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   verifyFormat("#if A\n"
12258                "#else\n"
12259                "int aaaaaaaa = 12;\n"
12260                "#endif\n"
12261                "#if B\n"
12262                "#else\n"
12263                "int a = 12;\n"
12264                "#endif\n",
12265                Alignment);
12266   verifyFormat("enum foo {\n"
12267                "#if A\n"
12268                "#else\n"
12269                "  aaaaaaaa = 12;\n"
12270                "#endif\n"
12271                "#if B\n"
12272                "#else\n"
12273                "  a = 12;\n"
12274                "#endif\n"
12275                "};\n",
12276                Alignment);
12277 
12278   EXPECT_EQ("int a = 5;\n"
12279             "\n"
12280             "int oneTwoThree = 123;",
12281             format("int a       = 5;\n"
12282                    "\n"
12283                    "int oneTwoThree= 123;",
12284                    Alignment));
12285   EXPECT_EQ("int a   = 5;\n"
12286             "int one = 1;\n"
12287             "\n"
12288             "int oneTwoThree = 123;",
12289             format("int a = 5;\n"
12290                    "int one = 1;\n"
12291                    "\n"
12292                    "int oneTwoThree = 123;",
12293                    Alignment));
12294   EXPECT_EQ("int a   = 5;\n"
12295             "int one = 1;\n"
12296             "\n"
12297             "int oneTwoThree = 123;\n"
12298             "int oneTwo      = 12;",
12299             format("int a = 5;\n"
12300                    "int one = 1;\n"
12301                    "\n"
12302                    "int oneTwoThree = 123;\n"
12303                    "int oneTwo = 12;",
12304                    Alignment));
12305   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12306   verifyFormat("#define A \\\n"
12307                "  int aaaa       = 12; \\\n"
12308                "  int b          = 23; \\\n"
12309                "  int ccc        = 234; \\\n"
12310                "  int dddddddddd = 2345;",
12311                Alignment);
12312   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12313   verifyFormat("#define A               \\\n"
12314                "  int aaaa       = 12;  \\\n"
12315                "  int b          = 23;  \\\n"
12316                "  int ccc        = 234; \\\n"
12317                "  int dddddddddd = 2345;",
12318                Alignment);
12319   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12320   verifyFormat("#define A                                                      "
12321                "                \\\n"
12322                "  int aaaa       = 12;                                         "
12323                "                \\\n"
12324                "  int b          = 23;                                         "
12325                "                \\\n"
12326                "  int ccc        = 234;                                        "
12327                "                \\\n"
12328                "  int dddddddddd = 2345;",
12329                Alignment);
12330   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12331                "k = 4, int l = 5,\n"
12332                "                  int m = 6) {\n"
12333                "  int j      = 10;\n"
12334                "  otherThing = 1;\n"
12335                "}",
12336                Alignment);
12337   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12338                "  int i   = 1;\n"
12339                "  int j   = 2;\n"
12340                "  int big = 10000;\n"
12341                "}",
12342                Alignment);
12343   verifyFormat("class C {\n"
12344                "public:\n"
12345                "  int i            = 1;\n"
12346                "  virtual void f() = 0;\n"
12347                "};",
12348                Alignment);
12349   verifyFormat("int i = 1;\n"
12350                "if (SomeType t = getSomething()) {\n"
12351                "}\n"
12352                "int j   = 2;\n"
12353                "int big = 10000;",
12354                Alignment);
12355   verifyFormat("int j = 7;\n"
12356                "for (int k = 0; k < N; ++k) {\n"
12357                "}\n"
12358                "int j   = 2;\n"
12359                "int big = 10000;\n"
12360                "}",
12361                Alignment);
12362   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12363   verifyFormat("int i = 1;\n"
12364                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12365                "    = someLooooooooooooooooongFunction();\n"
12366                "int j = 2;",
12367                Alignment);
12368   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12369   verifyFormat("int i = 1;\n"
12370                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12371                "    someLooooooooooooooooongFunction();\n"
12372                "int j = 2;",
12373                Alignment);
12374 
12375   verifyFormat("auto lambda = []() {\n"
12376                "  auto i = 0;\n"
12377                "  return 0;\n"
12378                "};\n"
12379                "int i  = 0;\n"
12380                "auto v = type{\n"
12381                "    i = 1,   //\n"
12382                "    (i = 2), //\n"
12383                "    i = 3    //\n"
12384                "};",
12385                Alignment);
12386 
12387   verifyFormat(
12388       "int i      = 1;\n"
12389       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12390       "                          loooooooooooooooooooooongParameterB);\n"
12391       "int j      = 2;",
12392       Alignment);
12393 
12394   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12395                "          typename B   = very_long_type_name_1,\n"
12396                "          typename T_2 = very_long_type_name_2>\n"
12397                "auto foo() {}\n",
12398                Alignment);
12399   verifyFormat("int a, b = 1;\n"
12400                "int c  = 2;\n"
12401                "int dd = 3;\n",
12402                Alignment);
12403   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12404                "float b[1][] = {{3.f}};\n",
12405                Alignment);
12406   verifyFormat("for (int i = 0; i < 1; i++)\n"
12407                "  int x = 1;\n",
12408                Alignment);
12409   verifyFormat("for (i = 0; i < 1; i++)\n"
12410                "  x = 1;\n"
12411                "y = 1;\n",
12412                Alignment);
12413 
12414   Alignment.ReflowComments = true;
12415   Alignment.ColumnLimit = 50;
12416   EXPECT_EQ("int x   = 0;\n"
12417             "int yy  = 1; /// specificlennospace\n"
12418             "int zzz = 2;\n",
12419             format("int x   = 0;\n"
12420                    "int yy  = 1; ///specificlennospace\n"
12421                    "int zzz = 2;\n",
12422                    Alignment));
12423 }
12424 
12425 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12426   FormatStyle Alignment = getLLVMStyle();
12427   Alignment.AlignConsecutiveBitFields = true;
12428   verifyFormat("int const a     : 5;\n"
12429                "int oneTwoThree : 23;",
12430                Alignment);
12431 
12432   // Initializers are allowed starting with c++2a
12433   verifyFormat("int const a     : 5 = 1;\n"
12434                "int oneTwoThree : 23 = 0;",
12435                Alignment);
12436 
12437   Alignment.AlignConsecutiveDeclarations = true;
12438   verifyFormat("int const a           : 5;\n"
12439                "int       oneTwoThree : 23;",
12440                Alignment);
12441 
12442   verifyFormat("int const a           : 5;  // comment\n"
12443                "int       oneTwoThree : 23; // comment",
12444                Alignment);
12445 
12446   verifyFormat("int const a           : 5 = 1;\n"
12447                "int       oneTwoThree : 23 = 0;",
12448                Alignment);
12449 
12450   Alignment.AlignConsecutiveAssignments = true;
12451   verifyFormat("int const a           : 5  = 1;\n"
12452                "int       oneTwoThree : 23 = 0;",
12453                Alignment);
12454   verifyFormat("int const a           : 5  = {1};\n"
12455                "int       oneTwoThree : 23 = 0;",
12456                Alignment);
12457 
12458   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_None;
12459   verifyFormat("int const a          :5;\n"
12460                "int       oneTwoThree:23;",
12461                Alignment);
12462 
12463   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_Before;
12464   verifyFormat("int const a           :5;\n"
12465                "int       oneTwoThree :23;",
12466                Alignment);
12467 
12468   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_After;
12469   verifyFormat("int const a          : 5;\n"
12470                "int       oneTwoThree: 23;",
12471                Alignment);
12472 
12473   // Known limitations: ':' is only recognized as a bitfield colon when
12474   // followed by a number.
12475   /*
12476   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12477                "int a           : 5;",
12478                Alignment);
12479   */
12480 }
12481 
12482 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12483   FormatStyle Alignment = getLLVMStyle();
12484   Alignment.AlignConsecutiveMacros = true;
12485   Alignment.AlignConsecutiveDeclarations = false;
12486   verifyFormat("float const a = 5;\n"
12487                "int oneTwoThree = 123;",
12488                Alignment);
12489   verifyFormat("int a = 5;\n"
12490                "float const oneTwoThree = 123;",
12491                Alignment);
12492 
12493   Alignment.AlignConsecutiveDeclarations = true;
12494   verifyFormat("float const a = 5;\n"
12495                "int         oneTwoThree = 123;",
12496                Alignment);
12497   verifyFormat("int         a = method();\n"
12498                "float const oneTwoThree = 133;",
12499                Alignment);
12500   verifyFormat("int i = 1, j = 10;\n"
12501                "something = 2000;",
12502                Alignment);
12503   verifyFormat("something = 2000;\n"
12504                "int i = 1, j = 10;\n",
12505                Alignment);
12506   verifyFormat("float      something = 2000;\n"
12507                "double     another = 911;\n"
12508                "int        i = 1, j = 10;\n"
12509                "const int *oneMore = 1;\n"
12510                "unsigned   i = 2;",
12511                Alignment);
12512   verifyFormat("float a = 5;\n"
12513                "int   one = 1;\n"
12514                "method();\n"
12515                "const double       oneTwoThree = 123;\n"
12516                "const unsigned int oneTwo = 12;",
12517                Alignment);
12518   verifyFormat("int      oneTwoThree{0}; // comment\n"
12519                "unsigned oneTwo;         // comment",
12520                Alignment);
12521   EXPECT_EQ("float const a = 5;\n"
12522             "\n"
12523             "int oneTwoThree = 123;",
12524             format("float const   a = 5;\n"
12525                    "\n"
12526                    "int           oneTwoThree= 123;",
12527                    Alignment));
12528   EXPECT_EQ("float a = 5;\n"
12529             "int   one = 1;\n"
12530             "\n"
12531             "unsigned oneTwoThree = 123;",
12532             format("float    a = 5;\n"
12533                    "int      one = 1;\n"
12534                    "\n"
12535                    "unsigned oneTwoThree = 123;",
12536                    Alignment));
12537   EXPECT_EQ("float a = 5;\n"
12538             "int   one = 1;\n"
12539             "\n"
12540             "unsigned oneTwoThree = 123;\n"
12541             "int      oneTwo = 12;",
12542             format("float    a = 5;\n"
12543                    "int one = 1;\n"
12544                    "\n"
12545                    "unsigned oneTwoThree = 123;\n"
12546                    "int oneTwo = 12;",
12547                    Alignment));
12548   // Function prototype alignment
12549   verifyFormat("int    a();\n"
12550                "double b();",
12551                Alignment);
12552   verifyFormat("int    a(int x);\n"
12553                "double b();",
12554                Alignment);
12555   unsigned OldColumnLimit = Alignment.ColumnLimit;
12556   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12557   // otherwise the function parameters will be re-flowed onto a single line.
12558   Alignment.ColumnLimit = 0;
12559   EXPECT_EQ("int    a(int   x,\n"
12560             "         float y);\n"
12561             "double b(int    x,\n"
12562             "         double y);",
12563             format("int a(int x,\n"
12564                    " float y);\n"
12565                    "double b(int x,\n"
12566                    " double y);",
12567                    Alignment));
12568   // This ensures that function parameters of function declarations are
12569   // correctly indented when their owning functions are indented.
12570   // The failure case here is for 'double y' to not be indented enough.
12571   EXPECT_EQ("double a(int x);\n"
12572             "int    b(int    y,\n"
12573             "         double z);",
12574             format("double a(int x);\n"
12575                    "int b(int y,\n"
12576                    " double z);",
12577                    Alignment));
12578   // Set ColumnLimit low so that we induce wrapping immediately after
12579   // the function name and opening paren.
12580   Alignment.ColumnLimit = 13;
12581   verifyFormat("int function(\n"
12582                "    int  x,\n"
12583                "    bool y);",
12584                Alignment);
12585   Alignment.ColumnLimit = OldColumnLimit;
12586   // Ensure function pointers don't screw up recursive alignment
12587   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12588                "double b();",
12589                Alignment);
12590   Alignment.AlignConsecutiveAssignments = true;
12591   // Ensure recursive alignment is broken by function braces, so that the
12592   // "a = 1" does not align with subsequent assignments inside the function
12593   // body.
12594   verifyFormat("int func(int a = 1) {\n"
12595                "  int b  = 2;\n"
12596                "  int cc = 3;\n"
12597                "}",
12598                Alignment);
12599   verifyFormat("float      something = 2000;\n"
12600                "double     another   = 911;\n"
12601                "int        i = 1, j = 10;\n"
12602                "const int *oneMore = 1;\n"
12603                "unsigned   i       = 2;",
12604                Alignment);
12605   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12606                "unsigned oneTwo      = 0;   // comment",
12607                Alignment);
12608   // Make sure that scope is correctly tracked, in the absence of braces
12609   verifyFormat("for (int i = 0; i < n; i++)\n"
12610                "  j = i;\n"
12611                "double x = 1;\n",
12612                Alignment);
12613   verifyFormat("if (int i = 0)\n"
12614                "  j = i;\n"
12615                "double x = 1;\n",
12616                Alignment);
12617   // Ensure operator[] and operator() are comprehended
12618   verifyFormat("struct test {\n"
12619                "  long long int foo();\n"
12620                "  int           operator[](int a);\n"
12621                "  double        bar();\n"
12622                "};\n",
12623                Alignment);
12624   verifyFormat("struct test {\n"
12625                "  long long int foo();\n"
12626                "  int           operator()(int a);\n"
12627                "  double        bar();\n"
12628                "};\n",
12629                Alignment);
12630   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12631             "  int const i   = 1;\n"
12632             "  int *     j   = 2;\n"
12633             "  int       big = 10000;\n"
12634             "\n"
12635             "  unsigned oneTwoThree = 123;\n"
12636             "  int      oneTwo      = 12;\n"
12637             "  method();\n"
12638             "  float k  = 2;\n"
12639             "  int   ll = 10000;\n"
12640             "}",
12641             format("void SomeFunction(int parameter= 0) {\n"
12642                    " int const  i= 1;\n"
12643                    "  int *j=2;\n"
12644                    " int big  =  10000;\n"
12645                    "\n"
12646                    "unsigned oneTwoThree  =123;\n"
12647                    "int oneTwo = 12;\n"
12648                    "  method();\n"
12649                    "float k= 2;\n"
12650                    "int ll=10000;\n"
12651                    "}",
12652                    Alignment));
12653   Alignment.AlignConsecutiveAssignments = false;
12654   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12655   verifyFormat("#define A \\\n"
12656                "  int       aaaa = 12; \\\n"
12657                "  float     b = 23; \\\n"
12658                "  const int ccc = 234; \\\n"
12659                "  unsigned  dddddddddd = 2345;",
12660                Alignment);
12661   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12662   verifyFormat("#define A              \\\n"
12663                "  int       aaaa = 12; \\\n"
12664                "  float     b = 23;    \\\n"
12665                "  const int ccc = 234; \\\n"
12666                "  unsigned  dddddddddd = 2345;",
12667                Alignment);
12668   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12669   Alignment.ColumnLimit = 30;
12670   verifyFormat("#define A                    \\\n"
12671                "  int       aaaa = 12;       \\\n"
12672                "  float     b = 23;          \\\n"
12673                "  const int ccc = 234;       \\\n"
12674                "  int       dddddddddd = 2345;",
12675                Alignment);
12676   Alignment.ColumnLimit = 80;
12677   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12678                "k = 4, int l = 5,\n"
12679                "                  int m = 6) {\n"
12680                "  const int j = 10;\n"
12681                "  otherThing = 1;\n"
12682                "}",
12683                Alignment);
12684   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12685                "  int const i = 1;\n"
12686                "  int *     j = 2;\n"
12687                "  int       big = 10000;\n"
12688                "}",
12689                Alignment);
12690   verifyFormat("class C {\n"
12691                "public:\n"
12692                "  int          i = 1;\n"
12693                "  virtual void f() = 0;\n"
12694                "};",
12695                Alignment);
12696   verifyFormat("float i = 1;\n"
12697                "if (SomeType t = getSomething()) {\n"
12698                "}\n"
12699                "const unsigned j = 2;\n"
12700                "int            big = 10000;",
12701                Alignment);
12702   verifyFormat("float j = 7;\n"
12703                "for (int k = 0; k < N; ++k) {\n"
12704                "}\n"
12705                "unsigned j = 2;\n"
12706                "int      big = 10000;\n"
12707                "}",
12708                Alignment);
12709   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12710   verifyFormat("float              i = 1;\n"
12711                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12712                "    = someLooooooooooooooooongFunction();\n"
12713                "int j = 2;",
12714                Alignment);
12715   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12716   verifyFormat("int                i = 1;\n"
12717                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12718                "    someLooooooooooooooooongFunction();\n"
12719                "int j = 2;",
12720                Alignment);
12721 
12722   Alignment.AlignConsecutiveAssignments = true;
12723   verifyFormat("auto lambda = []() {\n"
12724                "  auto  ii = 0;\n"
12725                "  float j  = 0;\n"
12726                "  return 0;\n"
12727                "};\n"
12728                "int   i  = 0;\n"
12729                "float i2 = 0;\n"
12730                "auto  v  = type{\n"
12731                "    i = 1,   //\n"
12732                "    (i = 2), //\n"
12733                "    i = 3    //\n"
12734                "};",
12735                Alignment);
12736   Alignment.AlignConsecutiveAssignments = false;
12737 
12738   verifyFormat(
12739       "int      i = 1;\n"
12740       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12741       "                          loooooooooooooooooooooongParameterB);\n"
12742       "int      j = 2;",
12743       Alignment);
12744 
12745   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12746   // We expect declarations and assignments to align, as long as it doesn't
12747   // exceed the column limit, starting a new alignment sequence whenever it
12748   // happens.
12749   Alignment.AlignConsecutiveAssignments = true;
12750   Alignment.ColumnLimit = 30;
12751   verifyFormat("float    ii              = 1;\n"
12752                "unsigned j               = 2;\n"
12753                "int someVerylongVariable = 1;\n"
12754                "AnotherLongType  ll = 123456;\n"
12755                "VeryVeryLongType k  = 2;\n"
12756                "int              myvar = 1;",
12757                Alignment);
12758   Alignment.ColumnLimit = 80;
12759   Alignment.AlignConsecutiveAssignments = false;
12760 
12761   verifyFormat(
12762       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12763       "          typename LongType, typename B>\n"
12764       "auto foo() {}\n",
12765       Alignment);
12766   verifyFormat("float a, b = 1;\n"
12767                "int   c = 2;\n"
12768                "int   dd = 3;\n",
12769                Alignment);
12770   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12771                "float b[1][] = {{3.f}};\n",
12772                Alignment);
12773   Alignment.AlignConsecutiveAssignments = true;
12774   verifyFormat("float a, b = 1;\n"
12775                "int   c  = 2;\n"
12776                "int   dd = 3;\n",
12777                Alignment);
12778   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12779                "float b[1][] = {{3.f}};\n",
12780                Alignment);
12781   Alignment.AlignConsecutiveAssignments = false;
12782 
12783   Alignment.ColumnLimit = 30;
12784   Alignment.BinPackParameters = false;
12785   verifyFormat("void foo(float     a,\n"
12786                "         float     b,\n"
12787                "         int       c,\n"
12788                "         uint32_t *d) {\n"
12789                "  int *  e = 0;\n"
12790                "  float  f = 0;\n"
12791                "  double g = 0;\n"
12792                "}\n"
12793                "void bar(ino_t     a,\n"
12794                "         int       b,\n"
12795                "         uint32_t *c,\n"
12796                "         bool      d) {}\n",
12797                Alignment);
12798   Alignment.BinPackParameters = true;
12799   Alignment.ColumnLimit = 80;
12800 
12801   // Bug 33507
12802   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12803   verifyFormat(
12804       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12805       "  static const Version verVs2017;\n"
12806       "  return true;\n"
12807       "});\n",
12808       Alignment);
12809   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12810 
12811   // See llvm.org/PR35641
12812   Alignment.AlignConsecutiveDeclarations = true;
12813   verifyFormat("int func() { //\n"
12814                "  int      b;\n"
12815                "  unsigned c;\n"
12816                "}",
12817                Alignment);
12818 
12819   // See PR37175
12820   FormatStyle Style = getMozillaStyle();
12821   Style.AlignConsecutiveDeclarations = true;
12822   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12823             "foo(int a);",
12824             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12825 }
12826 
12827 TEST_F(FormatTest, LinuxBraceBreaking) {
12828   FormatStyle LinuxBraceStyle = getLLVMStyle();
12829   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12830   verifyFormat("namespace a\n"
12831                "{\n"
12832                "class A\n"
12833                "{\n"
12834                "  void f()\n"
12835                "  {\n"
12836                "    if (true) {\n"
12837                "      a();\n"
12838                "      b();\n"
12839                "    } else {\n"
12840                "      a();\n"
12841                "    }\n"
12842                "  }\n"
12843                "  void g() { return; }\n"
12844                "};\n"
12845                "struct B {\n"
12846                "  int x;\n"
12847                "};\n"
12848                "} // namespace a\n",
12849                LinuxBraceStyle);
12850   verifyFormat("enum X {\n"
12851                "  Y = 0,\n"
12852                "}\n",
12853                LinuxBraceStyle);
12854   verifyFormat("struct S {\n"
12855                "  int Type;\n"
12856                "  union {\n"
12857                "    int x;\n"
12858                "    double y;\n"
12859                "  } Value;\n"
12860                "  class C\n"
12861                "  {\n"
12862                "    MyFavoriteType Value;\n"
12863                "  } Class;\n"
12864                "}\n",
12865                LinuxBraceStyle);
12866 }
12867 
12868 TEST_F(FormatTest, MozillaBraceBreaking) {
12869   FormatStyle MozillaBraceStyle = getLLVMStyle();
12870   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
12871   MozillaBraceStyle.FixNamespaceComments = false;
12872   verifyFormat("namespace a {\n"
12873                "class A\n"
12874                "{\n"
12875                "  void f()\n"
12876                "  {\n"
12877                "    if (true) {\n"
12878                "      a();\n"
12879                "      b();\n"
12880                "    }\n"
12881                "  }\n"
12882                "  void g() { return; }\n"
12883                "};\n"
12884                "enum E\n"
12885                "{\n"
12886                "  A,\n"
12887                "  // foo\n"
12888                "  B,\n"
12889                "  C\n"
12890                "};\n"
12891                "struct B\n"
12892                "{\n"
12893                "  int x;\n"
12894                "};\n"
12895                "}\n",
12896                MozillaBraceStyle);
12897   verifyFormat("struct S\n"
12898                "{\n"
12899                "  int Type;\n"
12900                "  union\n"
12901                "  {\n"
12902                "    int x;\n"
12903                "    double y;\n"
12904                "  } Value;\n"
12905                "  class C\n"
12906                "  {\n"
12907                "    MyFavoriteType Value;\n"
12908                "  } Class;\n"
12909                "}\n",
12910                MozillaBraceStyle);
12911 }
12912 
12913 TEST_F(FormatTest, StroustrupBraceBreaking) {
12914   FormatStyle StroustrupBraceStyle = getLLVMStyle();
12915   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12916   verifyFormat("namespace a {\n"
12917                "class A {\n"
12918                "  void f()\n"
12919                "  {\n"
12920                "    if (true) {\n"
12921                "      a();\n"
12922                "      b();\n"
12923                "    }\n"
12924                "  }\n"
12925                "  void g() { return; }\n"
12926                "};\n"
12927                "struct B {\n"
12928                "  int x;\n"
12929                "};\n"
12930                "} // namespace a\n",
12931                StroustrupBraceStyle);
12932 
12933   verifyFormat("void foo()\n"
12934                "{\n"
12935                "  if (a) {\n"
12936                "    a();\n"
12937                "  }\n"
12938                "  else {\n"
12939                "    b();\n"
12940                "  }\n"
12941                "}\n",
12942                StroustrupBraceStyle);
12943 
12944   verifyFormat("#ifdef _DEBUG\n"
12945                "int foo(int i = 0)\n"
12946                "#else\n"
12947                "int foo(int i = 5)\n"
12948                "#endif\n"
12949                "{\n"
12950                "  return i;\n"
12951                "}",
12952                StroustrupBraceStyle);
12953 
12954   verifyFormat("void foo() {}\n"
12955                "void bar()\n"
12956                "#ifdef _DEBUG\n"
12957                "{\n"
12958                "  foo();\n"
12959                "}\n"
12960                "#else\n"
12961                "{\n"
12962                "}\n"
12963                "#endif",
12964                StroustrupBraceStyle);
12965 
12966   verifyFormat("void foobar() { int i = 5; }\n"
12967                "#ifdef _DEBUG\n"
12968                "void bar() {}\n"
12969                "#else\n"
12970                "void bar() { foobar(); }\n"
12971                "#endif",
12972                StroustrupBraceStyle);
12973 }
12974 
12975 TEST_F(FormatTest, AllmanBraceBreaking) {
12976   FormatStyle AllmanBraceStyle = getLLVMStyle();
12977   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
12978 
12979   EXPECT_EQ("namespace a\n"
12980             "{\n"
12981             "void f();\n"
12982             "void g();\n"
12983             "} // namespace a\n",
12984             format("namespace a\n"
12985                    "{\n"
12986                    "void f();\n"
12987                    "void g();\n"
12988                    "}\n",
12989                    AllmanBraceStyle));
12990 
12991   verifyFormat("namespace a\n"
12992                "{\n"
12993                "class A\n"
12994                "{\n"
12995                "  void f()\n"
12996                "  {\n"
12997                "    if (true)\n"
12998                "    {\n"
12999                "      a();\n"
13000                "      b();\n"
13001                "    }\n"
13002                "  }\n"
13003                "  void g() { return; }\n"
13004                "};\n"
13005                "struct B\n"
13006                "{\n"
13007                "  int x;\n"
13008                "};\n"
13009                "union C\n"
13010                "{\n"
13011                "};\n"
13012                "} // namespace a",
13013                AllmanBraceStyle);
13014 
13015   verifyFormat("void f()\n"
13016                "{\n"
13017                "  if (true)\n"
13018                "  {\n"
13019                "    a();\n"
13020                "  }\n"
13021                "  else if (false)\n"
13022                "  {\n"
13023                "    b();\n"
13024                "  }\n"
13025                "  else\n"
13026                "  {\n"
13027                "    c();\n"
13028                "  }\n"
13029                "}\n",
13030                AllmanBraceStyle);
13031 
13032   verifyFormat("void f()\n"
13033                "{\n"
13034                "  for (int i = 0; i < 10; ++i)\n"
13035                "  {\n"
13036                "    a();\n"
13037                "  }\n"
13038                "  while (false)\n"
13039                "  {\n"
13040                "    b();\n"
13041                "  }\n"
13042                "  do\n"
13043                "  {\n"
13044                "    c();\n"
13045                "  } while (false)\n"
13046                "}\n",
13047                AllmanBraceStyle);
13048 
13049   verifyFormat("void f(int a)\n"
13050                "{\n"
13051                "  switch (a)\n"
13052                "  {\n"
13053                "  case 0:\n"
13054                "    break;\n"
13055                "  case 1:\n"
13056                "  {\n"
13057                "    break;\n"
13058                "  }\n"
13059                "  case 2:\n"
13060                "  {\n"
13061                "  }\n"
13062                "  break;\n"
13063                "  default:\n"
13064                "    break;\n"
13065                "  }\n"
13066                "}\n",
13067                AllmanBraceStyle);
13068 
13069   verifyFormat("enum X\n"
13070                "{\n"
13071                "  Y = 0,\n"
13072                "}\n",
13073                AllmanBraceStyle);
13074   verifyFormat("enum X\n"
13075                "{\n"
13076                "  Y = 0\n"
13077                "}\n",
13078                AllmanBraceStyle);
13079 
13080   verifyFormat("@interface BSApplicationController ()\n"
13081                "{\n"
13082                "@private\n"
13083                "  id _extraIvar;\n"
13084                "}\n"
13085                "@end\n",
13086                AllmanBraceStyle);
13087 
13088   verifyFormat("#ifdef _DEBUG\n"
13089                "int foo(int i = 0)\n"
13090                "#else\n"
13091                "int foo(int i = 5)\n"
13092                "#endif\n"
13093                "{\n"
13094                "  return i;\n"
13095                "}",
13096                AllmanBraceStyle);
13097 
13098   verifyFormat("void foo() {}\n"
13099                "void bar()\n"
13100                "#ifdef _DEBUG\n"
13101                "{\n"
13102                "  foo();\n"
13103                "}\n"
13104                "#else\n"
13105                "{\n"
13106                "}\n"
13107                "#endif",
13108                AllmanBraceStyle);
13109 
13110   verifyFormat("void foobar() { int i = 5; }\n"
13111                "#ifdef _DEBUG\n"
13112                "void bar() {}\n"
13113                "#else\n"
13114                "void bar() { foobar(); }\n"
13115                "#endif",
13116                AllmanBraceStyle);
13117 
13118   // This shouldn't affect ObjC blocks..
13119   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13120                "  // ...\n"
13121                "  int i;\n"
13122                "}];",
13123                AllmanBraceStyle);
13124   verifyFormat("void (^block)(void) = ^{\n"
13125                "  // ...\n"
13126                "  int i;\n"
13127                "};",
13128                AllmanBraceStyle);
13129   // .. or dict literals.
13130   verifyFormat("void f()\n"
13131                "{\n"
13132                "  // ...\n"
13133                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13134                "}",
13135                AllmanBraceStyle);
13136   verifyFormat("void f()\n"
13137                "{\n"
13138                "  // ...\n"
13139                "  [object someMethod:@{a : @\"b\"}];\n"
13140                "}",
13141                AllmanBraceStyle);
13142   verifyFormat("int f()\n"
13143                "{ // comment\n"
13144                "  return 42;\n"
13145                "}",
13146                AllmanBraceStyle);
13147 
13148   AllmanBraceStyle.ColumnLimit = 19;
13149   verifyFormat("void f() { int i; }", AllmanBraceStyle);
13150   AllmanBraceStyle.ColumnLimit = 18;
13151   verifyFormat("void f()\n"
13152                "{\n"
13153                "  int i;\n"
13154                "}",
13155                AllmanBraceStyle);
13156   AllmanBraceStyle.ColumnLimit = 80;
13157 
13158   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
13159   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13160       FormatStyle::SIS_WithoutElse;
13161   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13162   verifyFormat("void f(bool b)\n"
13163                "{\n"
13164                "  if (b)\n"
13165                "  {\n"
13166                "    return;\n"
13167                "  }\n"
13168                "}\n",
13169                BreakBeforeBraceShortIfs);
13170   verifyFormat("void f(bool b)\n"
13171                "{\n"
13172                "  if constexpr (b)\n"
13173                "  {\n"
13174                "    return;\n"
13175                "  }\n"
13176                "}\n",
13177                BreakBeforeBraceShortIfs);
13178   verifyFormat("void f(bool b)\n"
13179                "{\n"
13180                "  if CONSTEXPR (b)\n"
13181                "  {\n"
13182                "    return;\n"
13183                "  }\n"
13184                "}\n",
13185                BreakBeforeBraceShortIfs);
13186   verifyFormat("void f(bool b)\n"
13187                "{\n"
13188                "  if (b) return;\n"
13189                "}\n",
13190                BreakBeforeBraceShortIfs);
13191   verifyFormat("void f(bool b)\n"
13192                "{\n"
13193                "  if constexpr (b) return;\n"
13194                "}\n",
13195                BreakBeforeBraceShortIfs);
13196   verifyFormat("void f(bool b)\n"
13197                "{\n"
13198                "  if CONSTEXPR (b) return;\n"
13199                "}\n",
13200                BreakBeforeBraceShortIfs);
13201   verifyFormat("void f(bool b)\n"
13202                "{\n"
13203                "  while (b)\n"
13204                "  {\n"
13205                "    return;\n"
13206                "  }\n"
13207                "}\n",
13208                BreakBeforeBraceShortIfs);
13209 }
13210 
13211 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
13212   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
13213   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
13214 
13215   // Make a few changes to the style for testing purposes
13216   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
13217       FormatStyle::SFS_Empty;
13218   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
13219   WhitesmithsBraceStyle.ColumnLimit = 0;
13220 
13221   // FIXME: this test case can't decide whether there should be a blank line
13222   // after the ~D() line or not. It adds one if one doesn't exist in the test
13223   // and it removes the line if one exists.
13224   /*
13225   verifyFormat("class A;\n"
13226                "namespace B\n"
13227                "  {\n"
13228                "class C;\n"
13229                "// Comment\n"
13230                "class D\n"
13231                "  {\n"
13232                "public:\n"
13233                "  D();\n"
13234                "  ~D() {}\n"
13235                "private:\n"
13236                "  enum E\n"
13237                "    {\n"
13238                "    F\n"
13239                "    }\n"
13240                "  };\n"
13241                "  } // namespace B\n",
13242                WhitesmithsBraceStyle);
13243   */
13244 
13245   verifyFormat("namespace a\n"
13246                "  {\n"
13247                "class A\n"
13248                "  {\n"
13249                "  void f()\n"
13250                "    {\n"
13251                "    if (true)\n"
13252                "      {\n"
13253                "      a();\n"
13254                "      b();\n"
13255                "      }\n"
13256                "    }\n"
13257                "  void g()\n"
13258                "    {\n"
13259                "    return;\n"
13260                "    }\n"
13261                "  };\n"
13262                "struct B\n"
13263                "  {\n"
13264                "  int x;\n"
13265                "  };\n"
13266                "  } // namespace a",
13267                WhitesmithsBraceStyle);
13268 
13269   verifyFormat("void f()\n"
13270                "  {\n"
13271                "  if (true)\n"
13272                "    {\n"
13273                "    a();\n"
13274                "    }\n"
13275                "  else if (false)\n"
13276                "    {\n"
13277                "    b();\n"
13278                "    }\n"
13279                "  else\n"
13280                "    {\n"
13281                "    c();\n"
13282                "    }\n"
13283                "  }\n",
13284                WhitesmithsBraceStyle);
13285 
13286   verifyFormat("void f()\n"
13287                "  {\n"
13288                "  for (int i = 0; i < 10; ++i)\n"
13289                "    {\n"
13290                "    a();\n"
13291                "    }\n"
13292                "  while (false)\n"
13293                "    {\n"
13294                "    b();\n"
13295                "    }\n"
13296                "  do\n"
13297                "    {\n"
13298                "    c();\n"
13299                "    } while (false)\n"
13300                "  }\n",
13301                WhitesmithsBraceStyle);
13302 
13303   WhitesmithsBraceStyle.IndentCaseBlocks = true;
13304   verifyFormat("void switchTest1(int a)\n"
13305                "  {\n"
13306                "  switch (a)\n"
13307                "    {\n"
13308                "    case 2:\n"
13309                "      {\n"
13310                "      }\n"
13311                "    break;\n"
13312                "    }\n"
13313                "  }\n",
13314                WhitesmithsBraceStyle);
13315 
13316   verifyFormat("void switchTest2(int a)\n"
13317                "  {\n"
13318                "  switch (a)\n"
13319                "    {\n"
13320                "    case 0:\n"
13321                "    break;\n"
13322                "    case 1:\n"
13323                "      {\n"
13324                "      break;\n"
13325                "      }\n"
13326                "    case 2:\n"
13327                "      {\n"
13328                "      }\n"
13329                "    break;\n"
13330                "    default:\n"
13331                "    break;\n"
13332                "    }\n"
13333                "  }\n",
13334                WhitesmithsBraceStyle);
13335 
13336   verifyFormat("void switchTest3(int a)\n"
13337                "  {\n"
13338                "  switch (a)\n"
13339                "    {\n"
13340                "    case 0:\n"
13341                "      {\n"
13342                "      foo(x);\n"
13343                "      }\n"
13344                "    break;\n"
13345                "    default:\n"
13346                "      {\n"
13347                "      foo(1);\n"
13348                "      }\n"
13349                "    break;\n"
13350                "    }\n"
13351                "  }\n",
13352                WhitesmithsBraceStyle);
13353 
13354   WhitesmithsBraceStyle.IndentCaseBlocks = false;
13355 
13356   verifyFormat("void switchTest4(int a)\n"
13357                "  {\n"
13358                "  switch (a)\n"
13359                "    {\n"
13360                "    case 2:\n"
13361                "    {\n"
13362                "    }\n"
13363                "    break;\n"
13364                "    }\n"
13365                "  }\n",
13366                WhitesmithsBraceStyle);
13367 
13368   verifyFormat("void switchTest5(int a)\n"
13369                "  {\n"
13370                "  switch (a)\n"
13371                "    {\n"
13372                "    case 0:\n"
13373                "    break;\n"
13374                "    case 1:\n"
13375                "    {\n"
13376                "    foo();\n"
13377                "    break;\n"
13378                "    }\n"
13379                "    case 2:\n"
13380                "    {\n"
13381                "    }\n"
13382                "    break;\n"
13383                "    default:\n"
13384                "    break;\n"
13385                "    }\n"
13386                "  }\n",
13387                WhitesmithsBraceStyle);
13388 
13389   verifyFormat("void switchTest6(int a)\n"
13390                "  {\n"
13391                "  switch (a)\n"
13392                "    {\n"
13393                "    case 0:\n"
13394                "    {\n"
13395                "    foo(x);\n"
13396                "    }\n"
13397                "    break;\n"
13398                "    default:\n"
13399                "    {\n"
13400                "    foo(1);\n"
13401                "    }\n"
13402                "    break;\n"
13403                "    }\n"
13404                "  }\n",
13405                WhitesmithsBraceStyle);
13406 
13407   verifyFormat("enum X\n"
13408                "  {\n"
13409                "  Y = 0, // testing\n"
13410                "  }\n",
13411                WhitesmithsBraceStyle);
13412 
13413   verifyFormat("enum X\n"
13414                "  {\n"
13415                "  Y = 0\n"
13416                "  }\n",
13417                WhitesmithsBraceStyle);
13418   verifyFormat("enum X\n"
13419                "  {\n"
13420                "  Y = 0,\n"
13421                "  Z = 1\n"
13422                "  };\n",
13423                WhitesmithsBraceStyle);
13424 
13425   verifyFormat("@interface BSApplicationController ()\n"
13426                "  {\n"
13427                "@private\n"
13428                "  id _extraIvar;\n"
13429                "  }\n"
13430                "@end\n",
13431                WhitesmithsBraceStyle);
13432 
13433   verifyFormat("#ifdef _DEBUG\n"
13434                "int foo(int i = 0)\n"
13435                "#else\n"
13436                "int foo(int i = 5)\n"
13437                "#endif\n"
13438                "  {\n"
13439                "  return i;\n"
13440                "  }",
13441                WhitesmithsBraceStyle);
13442 
13443   verifyFormat("void foo() {}\n"
13444                "void bar()\n"
13445                "#ifdef _DEBUG\n"
13446                "  {\n"
13447                "  foo();\n"
13448                "  }\n"
13449                "#else\n"
13450                "  {\n"
13451                "  }\n"
13452                "#endif",
13453                WhitesmithsBraceStyle);
13454 
13455   verifyFormat("void foobar()\n"
13456                "  {\n"
13457                "  int i = 5;\n"
13458                "  }\n"
13459                "#ifdef _DEBUG\n"
13460                "void bar()\n"
13461                "  {\n"
13462                "  }\n"
13463                "#else\n"
13464                "void bar()\n"
13465                "  {\n"
13466                "  foobar();\n"
13467                "  }\n"
13468                "#endif",
13469                WhitesmithsBraceStyle);
13470 
13471   // This shouldn't affect ObjC blocks..
13472   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13473                "  // ...\n"
13474                "  int i;\n"
13475                "}];",
13476                WhitesmithsBraceStyle);
13477   verifyFormat("void (^block)(void) = ^{\n"
13478                "  // ...\n"
13479                "  int i;\n"
13480                "};",
13481                WhitesmithsBraceStyle);
13482   // .. or dict literals.
13483   verifyFormat("void f()\n"
13484                "  {\n"
13485                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13486                "  }",
13487                WhitesmithsBraceStyle);
13488 
13489   verifyFormat("int f()\n"
13490                "  { // comment\n"
13491                "  return 42;\n"
13492                "  }",
13493                WhitesmithsBraceStyle);
13494 
13495   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13496   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13497       FormatStyle::SIS_Always;
13498   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13499   verifyFormat("void f(bool b)\n"
13500                "  {\n"
13501                "  if (b)\n"
13502                "    {\n"
13503                "    return;\n"
13504                "    }\n"
13505                "  }\n",
13506                BreakBeforeBraceShortIfs);
13507   verifyFormat("void f(bool b)\n"
13508                "  {\n"
13509                "  if (b) return;\n"
13510                "  }\n",
13511                BreakBeforeBraceShortIfs);
13512   verifyFormat("void f(bool b)\n"
13513                "  {\n"
13514                "  while (b)\n"
13515                "    {\n"
13516                "    return;\n"
13517                "    }\n"
13518                "  }\n",
13519                BreakBeforeBraceShortIfs);
13520 }
13521 
13522 TEST_F(FormatTest, GNUBraceBreaking) {
13523   FormatStyle GNUBraceStyle = getLLVMStyle();
13524   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13525   verifyFormat("namespace a\n"
13526                "{\n"
13527                "class A\n"
13528                "{\n"
13529                "  void f()\n"
13530                "  {\n"
13531                "    int a;\n"
13532                "    {\n"
13533                "      int b;\n"
13534                "    }\n"
13535                "    if (true)\n"
13536                "      {\n"
13537                "        a();\n"
13538                "        b();\n"
13539                "      }\n"
13540                "  }\n"
13541                "  void g() { return; }\n"
13542                "}\n"
13543                "} // namespace a",
13544                GNUBraceStyle);
13545 
13546   verifyFormat("void f()\n"
13547                "{\n"
13548                "  if (true)\n"
13549                "    {\n"
13550                "      a();\n"
13551                "    }\n"
13552                "  else if (false)\n"
13553                "    {\n"
13554                "      b();\n"
13555                "    }\n"
13556                "  else\n"
13557                "    {\n"
13558                "      c();\n"
13559                "    }\n"
13560                "}\n",
13561                GNUBraceStyle);
13562 
13563   verifyFormat("void f()\n"
13564                "{\n"
13565                "  for (int i = 0; i < 10; ++i)\n"
13566                "    {\n"
13567                "      a();\n"
13568                "    }\n"
13569                "  while (false)\n"
13570                "    {\n"
13571                "      b();\n"
13572                "    }\n"
13573                "  do\n"
13574                "    {\n"
13575                "      c();\n"
13576                "    }\n"
13577                "  while (false);\n"
13578                "}\n",
13579                GNUBraceStyle);
13580 
13581   verifyFormat("void f(int a)\n"
13582                "{\n"
13583                "  switch (a)\n"
13584                "    {\n"
13585                "    case 0:\n"
13586                "      break;\n"
13587                "    case 1:\n"
13588                "      {\n"
13589                "        break;\n"
13590                "      }\n"
13591                "    case 2:\n"
13592                "      {\n"
13593                "      }\n"
13594                "      break;\n"
13595                "    default:\n"
13596                "      break;\n"
13597                "    }\n"
13598                "}\n",
13599                GNUBraceStyle);
13600 
13601   verifyFormat("enum X\n"
13602                "{\n"
13603                "  Y = 0,\n"
13604                "}\n",
13605                GNUBraceStyle);
13606 
13607   verifyFormat("@interface BSApplicationController ()\n"
13608                "{\n"
13609                "@private\n"
13610                "  id _extraIvar;\n"
13611                "}\n"
13612                "@end\n",
13613                GNUBraceStyle);
13614 
13615   verifyFormat("#ifdef _DEBUG\n"
13616                "int foo(int i = 0)\n"
13617                "#else\n"
13618                "int foo(int i = 5)\n"
13619                "#endif\n"
13620                "{\n"
13621                "  return i;\n"
13622                "}",
13623                GNUBraceStyle);
13624 
13625   verifyFormat("void foo() {}\n"
13626                "void bar()\n"
13627                "#ifdef _DEBUG\n"
13628                "{\n"
13629                "  foo();\n"
13630                "}\n"
13631                "#else\n"
13632                "{\n"
13633                "}\n"
13634                "#endif",
13635                GNUBraceStyle);
13636 
13637   verifyFormat("void foobar() { int i = 5; }\n"
13638                "#ifdef _DEBUG\n"
13639                "void bar() {}\n"
13640                "#else\n"
13641                "void bar() { foobar(); }\n"
13642                "#endif",
13643                GNUBraceStyle);
13644 }
13645 
13646 TEST_F(FormatTest, WebKitBraceBreaking) {
13647   FormatStyle WebKitBraceStyle = getLLVMStyle();
13648   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13649   WebKitBraceStyle.FixNamespaceComments = false;
13650   verifyFormat("namespace a {\n"
13651                "class A {\n"
13652                "  void f()\n"
13653                "  {\n"
13654                "    if (true) {\n"
13655                "      a();\n"
13656                "      b();\n"
13657                "    }\n"
13658                "  }\n"
13659                "  void g() { return; }\n"
13660                "};\n"
13661                "enum E {\n"
13662                "  A,\n"
13663                "  // foo\n"
13664                "  B,\n"
13665                "  C\n"
13666                "};\n"
13667                "struct B {\n"
13668                "  int x;\n"
13669                "};\n"
13670                "}\n",
13671                WebKitBraceStyle);
13672   verifyFormat("struct S {\n"
13673                "  int Type;\n"
13674                "  union {\n"
13675                "    int x;\n"
13676                "    double y;\n"
13677                "  } Value;\n"
13678                "  class C {\n"
13679                "    MyFavoriteType Value;\n"
13680                "  } Class;\n"
13681                "};\n",
13682                WebKitBraceStyle);
13683 }
13684 
13685 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13686   verifyFormat("void f() {\n"
13687                "  try {\n"
13688                "  } catch (const Exception &e) {\n"
13689                "  }\n"
13690                "}\n",
13691                getLLVMStyle());
13692 }
13693 
13694 TEST_F(FormatTest, UnderstandsPragmas) {
13695   verifyFormat("#pragma omp reduction(| : var)");
13696   verifyFormat("#pragma omp reduction(+ : var)");
13697 
13698   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13699             "(including parentheses).",
13700             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13701                    "(including parentheses)."));
13702 }
13703 
13704 TEST_F(FormatTest, UnderstandPragmaOption) {
13705   verifyFormat("#pragma option -C -A");
13706 
13707   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13708 }
13709 
13710 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13711   FormatStyle Style = getLLVMStyle();
13712   Style.ColumnLimit = 20;
13713 
13714   // See PR41213
13715   EXPECT_EQ("/*\n"
13716             " *\t9012345\n"
13717             " * /8901\n"
13718             " */",
13719             format("/*\n"
13720                    " *\t9012345 /8901\n"
13721                    " */",
13722                    Style));
13723   EXPECT_EQ("/*\n"
13724             " *345678\n"
13725             " *\t/8901\n"
13726             " */",
13727             format("/*\n"
13728                    " *345678\t/8901\n"
13729                    " */",
13730                    Style));
13731 
13732   verifyFormat("int a; // the\n"
13733                "       // comment",
13734                Style);
13735   EXPECT_EQ("int a; /* first line\n"
13736             "        * second\n"
13737             "        * line third\n"
13738             "        * line\n"
13739             "        */",
13740             format("int a; /* first line\n"
13741                    "        * second\n"
13742                    "        * line third\n"
13743                    "        * line\n"
13744                    "        */",
13745                    Style));
13746   EXPECT_EQ("int a; // first line\n"
13747             "       // second\n"
13748             "       // line third\n"
13749             "       // line",
13750             format("int a; // first line\n"
13751                    "       // second line\n"
13752                    "       // third line",
13753                    Style));
13754 
13755   Style.PenaltyExcessCharacter = 90;
13756   verifyFormat("int a; // the comment", Style);
13757   EXPECT_EQ("int a; // the comment\n"
13758             "       // aaa",
13759             format("int a; // the comment aaa", Style));
13760   EXPECT_EQ("int a; /* first line\n"
13761             "        * second line\n"
13762             "        * third line\n"
13763             "        */",
13764             format("int a; /* first line\n"
13765                    "        * second line\n"
13766                    "        * third line\n"
13767                    "        */",
13768                    Style));
13769   EXPECT_EQ("int a; // first line\n"
13770             "       // second line\n"
13771             "       // third line",
13772             format("int a; // first line\n"
13773                    "       // second line\n"
13774                    "       // third line",
13775                    Style));
13776   // FIXME: Investigate why this is not getting the same layout as the test
13777   // above.
13778   EXPECT_EQ("int a; /* first line\n"
13779             "        * second line\n"
13780             "        * third line\n"
13781             "        */",
13782             format("int a; /* first line second line third line"
13783                    "\n*/",
13784                    Style));
13785 
13786   EXPECT_EQ("// foo bar baz bazfoo\n"
13787             "// foo bar foo bar\n",
13788             format("// foo bar baz bazfoo\n"
13789                    "// foo bar foo           bar\n",
13790                    Style));
13791   EXPECT_EQ("// foo bar baz bazfoo\n"
13792             "// foo bar foo bar\n",
13793             format("// foo bar baz      bazfoo\n"
13794                    "// foo            bar foo bar\n",
13795                    Style));
13796 
13797   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13798   // next one.
13799   EXPECT_EQ("// foo bar baz bazfoo\n"
13800             "// bar foo bar\n",
13801             format("// foo bar baz      bazfoo bar\n"
13802                    "// foo            bar\n",
13803                    Style));
13804 
13805   EXPECT_EQ("// foo bar baz bazfoo\n"
13806             "// foo bar baz bazfoo\n"
13807             "// bar foo bar\n",
13808             format("// foo bar baz      bazfoo\n"
13809                    "// foo bar baz      bazfoo bar\n"
13810                    "// foo bar\n",
13811                    Style));
13812 
13813   EXPECT_EQ("// foo bar baz bazfoo\n"
13814             "// foo bar baz bazfoo\n"
13815             "// bar foo bar\n",
13816             format("// foo bar baz      bazfoo\n"
13817                    "// foo bar baz      bazfoo bar\n"
13818                    "// foo           bar\n",
13819                    Style));
13820 
13821   // Make sure we do not keep protruding characters if strict mode reflow is
13822   // cheaper than keeping protruding characters.
13823   Style.ColumnLimit = 21;
13824   EXPECT_EQ(
13825       "// foo foo foo foo\n"
13826       "// foo foo foo foo\n"
13827       "// foo foo foo foo\n",
13828       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13829 
13830   EXPECT_EQ("int a = /* long block\n"
13831             "           comment */\n"
13832             "    42;",
13833             format("int a = /* long block comment */ 42;", Style));
13834 }
13835 
13836 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13837   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13838   EXPECT_EQ(Styles[0], Styles[i])                                              \
13839       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13840 
13841 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13842   SmallVector<FormatStyle, 3> Styles;
13843   Styles.resize(3);
13844 
13845   Styles[0] = getLLVMStyle();
13846   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13847   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13848   EXPECT_ALL_STYLES_EQUAL(Styles);
13849 
13850   Styles[0] = getGoogleStyle();
13851   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13852   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13853   EXPECT_ALL_STYLES_EQUAL(Styles);
13854 
13855   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13856   EXPECT_TRUE(
13857       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13858   EXPECT_TRUE(
13859       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13860   EXPECT_ALL_STYLES_EQUAL(Styles);
13861 
13862   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13863   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13864   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
13865   EXPECT_ALL_STYLES_EQUAL(Styles);
13866 
13867   Styles[0] = getMozillaStyle();
13868   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
13869   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
13870   EXPECT_ALL_STYLES_EQUAL(Styles);
13871 
13872   Styles[0] = getWebKitStyle();
13873   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
13874   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
13875   EXPECT_ALL_STYLES_EQUAL(Styles);
13876 
13877   Styles[0] = getGNUStyle();
13878   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
13879   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
13880   EXPECT_ALL_STYLES_EQUAL(Styles);
13881 
13882   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
13883 }
13884 
13885 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
13886   SmallVector<FormatStyle, 8> Styles;
13887   Styles.resize(2);
13888 
13889   Styles[0] = getGoogleStyle();
13890   Styles[1] = getLLVMStyle();
13891   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13892   EXPECT_ALL_STYLES_EQUAL(Styles);
13893 
13894   Styles.resize(5);
13895   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13896   Styles[1] = getLLVMStyle();
13897   Styles[1].Language = FormatStyle::LK_JavaScript;
13898   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13899 
13900   Styles[2] = getLLVMStyle();
13901   Styles[2].Language = FormatStyle::LK_JavaScript;
13902   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
13903                                   "BasedOnStyle: Google",
13904                                   &Styles[2])
13905                    .value());
13906 
13907   Styles[3] = getLLVMStyle();
13908   Styles[3].Language = FormatStyle::LK_JavaScript;
13909   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
13910                                   "Language: JavaScript",
13911                                   &Styles[3])
13912                    .value());
13913 
13914   Styles[4] = getLLVMStyle();
13915   Styles[4].Language = FormatStyle::LK_JavaScript;
13916   EXPECT_EQ(0, parseConfiguration("---\n"
13917                                   "BasedOnStyle: LLVM\n"
13918                                   "IndentWidth: 123\n"
13919                                   "---\n"
13920                                   "BasedOnStyle: Google\n"
13921                                   "Language: JavaScript",
13922                                   &Styles[4])
13923                    .value());
13924   EXPECT_ALL_STYLES_EQUAL(Styles);
13925 }
13926 
13927 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
13928   Style.FIELD = false;                                                         \
13929   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
13930   EXPECT_TRUE(Style.FIELD);                                                    \
13931   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
13932   EXPECT_FALSE(Style.FIELD);
13933 
13934 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
13935 
13936 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
13937   Style.STRUCT.FIELD = false;                                                  \
13938   EXPECT_EQ(0,                                                                 \
13939             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
13940                 .value());                                                     \
13941   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
13942   EXPECT_EQ(0,                                                                 \
13943             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
13944                 .value());                                                     \
13945   EXPECT_FALSE(Style.STRUCT.FIELD);
13946 
13947 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
13948   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
13949 
13950 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
13951   EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!";          \
13952   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
13953   EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
13954 
13955 TEST_F(FormatTest, ParsesConfigurationBools) {
13956   FormatStyle Style = {};
13957   Style.Language = FormatStyle::LK_Cpp;
13958   CHECK_PARSE_BOOL(AlignTrailingComments);
13959   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
13960   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
13961   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
13962   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
13963   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
13964   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
13965   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
13966   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
13967   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
13968   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
13969   CHECK_PARSE_BOOL(BinPackArguments);
13970   CHECK_PARSE_BOOL(BinPackParameters);
13971   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
13972   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
13973   CHECK_PARSE_BOOL(BreakStringLiterals);
13974   CHECK_PARSE_BOOL(CompactNamespaces);
13975   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
13976   CHECK_PARSE_BOOL(DeriveLineEnding);
13977   CHECK_PARSE_BOOL(DerivePointerAlignment);
13978   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
13979   CHECK_PARSE_BOOL(DisableFormat);
13980   CHECK_PARSE_BOOL(IndentCaseLabels);
13981   CHECK_PARSE_BOOL(IndentCaseBlocks);
13982   CHECK_PARSE_BOOL(IndentGotoLabels);
13983   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
13984   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
13985   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
13986   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
13987   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
13988   CHECK_PARSE_BOOL(ReflowComments);
13989   CHECK_PARSE_BOOL(SortIncludes);
13990   CHECK_PARSE_BOOL(SortUsingDeclarations);
13991   CHECK_PARSE_BOOL(SpacesInParentheses);
13992   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
13993   CHECK_PARSE_BOOL(SpacesInAngles);
13994   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
13995   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
13996   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
13997   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
13998   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
13999   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
14000   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
14001   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
14002   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
14003   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
14004   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
14005   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
14006   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
14007   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
14008   CHECK_PARSE_BOOL(UseCRLF);
14009 
14010   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
14011   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
14012   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
14013   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
14014   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
14015   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
14016   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
14017   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
14018   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
14019   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
14020   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
14021   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
14022   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
14023   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
14024   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
14025   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
14026   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
14027 }
14028 
14029 #undef CHECK_PARSE_BOOL
14030 
14031 TEST_F(FormatTest, ParsesConfiguration) {
14032   FormatStyle Style = {};
14033   Style.Language = FormatStyle::LK_Cpp;
14034   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
14035   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
14036               ConstructorInitializerIndentWidth, 1234u);
14037   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
14038   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
14039   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
14040   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
14041   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
14042               PenaltyBreakBeforeFirstCallParameter, 1234u);
14043   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
14044               PenaltyBreakTemplateDeclaration, 1234u);
14045   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
14046   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
14047               PenaltyReturnTypeOnItsOwnLine, 1234u);
14048   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
14049               SpacesBeforeTrailingComments, 1234u);
14050   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
14051   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
14052   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
14053 
14054   Style.PointerAlignment = FormatStyle::PAS_Middle;
14055   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
14056               FormatStyle::PAS_Left);
14057   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
14058               FormatStyle::PAS_Right);
14059   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
14060               FormatStyle::PAS_Middle);
14061   // For backward compatibility:
14062   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
14063               FormatStyle::PAS_Left);
14064   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
14065               FormatStyle::PAS_Right);
14066   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
14067               FormatStyle::PAS_Middle);
14068 
14069   Style.Standard = FormatStyle::LS_Auto;
14070   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
14071   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
14072   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
14073   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
14074   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
14075   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
14076   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
14077   // Legacy aliases:
14078   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
14079   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
14080   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
14081   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
14082 
14083   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
14084   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
14085               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
14086   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
14087               FormatStyle::BOS_None);
14088   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
14089               FormatStyle::BOS_All);
14090   // For backward compatibility:
14091   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
14092               FormatStyle::BOS_None);
14093   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
14094               FormatStyle::BOS_All);
14095 
14096   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
14097   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
14098               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14099   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
14100               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
14101   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
14102               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
14103   // For backward compatibility:
14104   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
14105               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14106 
14107   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
14108   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
14109               FormatStyle::BILS_BeforeComma);
14110   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
14111               FormatStyle::BILS_AfterColon);
14112   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
14113               FormatStyle::BILS_BeforeColon);
14114   // For backward compatibility:
14115   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
14116               FormatStyle::BILS_BeforeComma);
14117 
14118   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14119   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
14120               FormatStyle::BAS_Align);
14121   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
14122               FormatStyle::BAS_DontAlign);
14123   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
14124               FormatStyle::BAS_AlwaysBreak);
14125   // For backward compatibility:
14126   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
14127               FormatStyle::BAS_DontAlign);
14128   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
14129               FormatStyle::BAS_Align);
14130 
14131   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
14132   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
14133               FormatStyle::ENAS_DontAlign);
14134   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
14135               FormatStyle::ENAS_Left);
14136   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
14137               FormatStyle::ENAS_Right);
14138   // For backward compatibility:
14139   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
14140               FormatStyle::ENAS_Left);
14141   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
14142               FormatStyle::ENAS_Right);
14143 
14144   Style.AlignOperands = FormatStyle::OAS_Align;
14145   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
14146               FormatStyle::OAS_DontAlign);
14147   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
14148   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
14149               FormatStyle::OAS_AlignAfterOperator);
14150   // For backward compatibility:
14151   CHECK_PARSE("AlignOperands: false", AlignOperands,
14152               FormatStyle::OAS_DontAlign);
14153   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
14154 
14155   Style.UseTab = FormatStyle::UT_ForIndentation;
14156   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
14157   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
14158   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
14159   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
14160               FormatStyle::UT_ForContinuationAndIndentation);
14161   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
14162               FormatStyle::UT_AlignWithSpaces);
14163   // For backward compatibility:
14164   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
14165   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
14166 
14167   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
14168   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
14169               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14170   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
14171               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
14172   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
14173               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14174   // For backward compatibility:
14175   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
14176               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14177   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
14178               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14179 
14180   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
14181   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
14182               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14183   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
14184               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
14185   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
14186               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
14187   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
14188               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14189   // For backward compatibility:
14190   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
14191               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14192   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
14193               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14194 
14195   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
14196   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
14197               FormatStyle::SBPO_Never);
14198   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
14199               FormatStyle::SBPO_Always);
14200   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
14201               FormatStyle::SBPO_ControlStatements);
14202   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
14203               FormatStyle::SBPO_NonEmptyParentheses);
14204   // For backward compatibility:
14205   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
14206               FormatStyle::SBPO_Never);
14207   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
14208               FormatStyle::SBPO_ControlStatements);
14209 
14210   Style.ColumnLimit = 123;
14211   FormatStyle BaseStyle = getLLVMStyle();
14212   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
14213   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
14214 
14215   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
14216   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
14217               FormatStyle::BS_Attach);
14218   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
14219               FormatStyle::BS_Linux);
14220   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
14221               FormatStyle::BS_Mozilla);
14222   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
14223               FormatStyle::BS_Stroustrup);
14224   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
14225               FormatStyle::BS_Allman);
14226   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
14227               FormatStyle::BS_Whitesmiths);
14228   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
14229   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
14230               FormatStyle::BS_WebKit);
14231   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
14232               FormatStyle::BS_Custom);
14233 
14234   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
14235   CHECK_PARSE("BraceWrapping:\n"
14236               "  AfterControlStatement: MultiLine",
14237               BraceWrapping.AfterControlStatement,
14238               FormatStyle::BWACS_MultiLine);
14239   CHECK_PARSE("BraceWrapping:\n"
14240               "  AfterControlStatement: Always",
14241               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14242   CHECK_PARSE("BraceWrapping:\n"
14243               "  AfterControlStatement: Never",
14244               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14245   // For backward compatibility:
14246   CHECK_PARSE("BraceWrapping:\n"
14247               "  AfterControlStatement: true",
14248               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14249   CHECK_PARSE("BraceWrapping:\n"
14250               "  AfterControlStatement: false",
14251               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14252 
14253   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
14254   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
14255               FormatStyle::RTBS_None);
14256   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
14257               FormatStyle::RTBS_All);
14258   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
14259               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
14260   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
14261               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
14262   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
14263               AlwaysBreakAfterReturnType,
14264               FormatStyle::RTBS_TopLevelDefinitions);
14265 
14266   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
14267   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
14268               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
14269   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
14270               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14271   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
14272               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14273   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
14274               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14275   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
14276               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14277 
14278   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
14279   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
14280               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
14281   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
14282               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
14283   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
14284               AlwaysBreakAfterDefinitionReturnType,
14285               FormatStyle::DRTBS_TopLevel);
14286 
14287   Style.NamespaceIndentation = FormatStyle::NI_All;
14288   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
14289               FormatStyle::NI_None);
14290   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
14291               FormatStyle::NI_Inner);
14292   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
14293               FormatStyle::NI_All);
14294 
14295   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
14296   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
14297               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14298   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
14299               AllowShortIfStatementsOnASingleLine,
14300               FormatStyle::SIS_WithoutElse);
14301   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
14302               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
14303   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
14304               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14305   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
14306               AllowShortIfStatementsOnASingleLine,
14307               FormatStyle::SIS_WithoutElse);
14308 
14309   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
14310   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
14311               FormatStyle::IEBS_AfterExternBlock);
14312   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
14313               FormatStyle::IEBS_Indent);
14314   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
14315               FormatStyle::IEBS_NoIndent);
14316   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
14317               FormatStyle::IEBS_Indent);
14318   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
14319               FormatStyle::IEBS_NoIndent);
14320 
14321   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
14322   CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
14323               FormatStyle::BFCS_Both);
14324   CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
14325               FormatStyle::BFCS_None);
14326   CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
14327               FormatStyle::BFCS_Before);
14328   CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
14329               FormatStyle::BFCS_After);
14330 
14331   Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
14332   CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
14333               FormatStyle::SJSIO_After);
14334   CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
14335               FormatStyle::SJSIO_Before);
14336 
14337   // FIXME: This is required because parsing a configuration simply overwrites
14338   // the first N elements of the list instead of resetting it.
14339   Style.ForEachMacros.clear();
14340   std::vector<std::string> BoostForeach;
14341   BoostForeach.push_back("BOOST_FOREACH");
14342   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
14343   std::vector<std::string> BoostAndQForeach;
14344   BoostAndQForeach.push_back("BOOST_FOREACH");
14345   BoostAndQForeach.push_back("Q_FOREACH");
14346   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
14347               BoostAndQForeach);
14348 
14349   Style.AttributeMacros.clear();
14350   CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
14351               std::vector<std::string>{"__capability"});
14352   CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
14353               std::vector<std::string>({"attr1", "attr2"}));
14354 
14355   Style.StatementMacros.clear();
14356   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
14357               std::vector<std::string>{"QUNUSED"});
14358   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
14359               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
14360 
14361   Style.NamespaceMacros.clear();
14362   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
14363               std::vector<std::string>{"TESTSUITE"});
14364   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
14365               std::vector<std::string>({"TESTSUITE", "SUITE"}));
14366 
14367   Style.WhitespaceSensitiveMacros.clear();
14368   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
14369               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14370   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
14371               WhitespaceSensitiveMacros,
14372               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14373   Style.WhitespaceSensitiveMacros.clear();
14374   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
14375               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14376   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
14377               WhitespaceSensitiveMacros,
14378               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14379 
14380   Style.IncludeStyle.IncludeCategories.clear();
14381   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
14382       {"abc/.*", 2, 0}, {".*", 1, 0}};
14383   CHECK_PARSE("IncludeCategories:\n"
14384               "  - Regex: abc/.*\n"
14385               "    Priority: 2\n"
14386               "  - Regex: .*\n"
14387               "    Priority: 1",
14388               IncludeStyle.IncludeCategories, ExpectedCategories);
14389   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
14390               "abc$");
14391   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
14392               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
14393 
14394   Style.RawStringFormats.clear();
14395   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
14396       {
14397           FormatStyle::LK_TextProto,
14398           {"pb", "proto"},
14399           {"PARSE_TEXT_PROTO"},
14400           /*CanonicalDelimiter=*/"",
14401           "llvm",
14402       },
14403       {
14404           FormatStyle::LK_Cpp,
14405           {"cc", "cpp"},
14406           {"C_CODEBLOCK", "CPPEVAL"},
14407           /*CanonicalDelimiter=*/"cc",
14408           /*BasedOnStyle=*/"",
14409       },
14410   };
14411 
14412   CHECK_PARSE("RawStringFormats:\n"
14413               "  - Language: TextProto\n"
14414               "    Delimiters:\n"
14415               "      - 'pb'\n"
14416               "      - 'proto'\n"
14417               "    EnclosingFunctions:\n"
14418               "      - 'PARSE_TEXT_PROTO'\n"
14419               "    BasedOnStyle: llvm\n"
14420               "  - Language: Cpp\n"
14421               "    Delimiters:\n"
14422               "      - 'cc'\n"
14423               "      - 'cpp'\n"
14424               "    EnclosingFunctions:\n"
14425               "      - 'C_CODEBLOCK'\n"
14426               "      - 'CPPEVAL'\n"
14427               "    CanonicalDelimiter: 'cc'",
14428               RawStringFormats, ExpectedRawStringFormats);
14429 }
14430 
14431 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
14432   FormatStyle Style = {};
14433   Style.Language = FormatStyle::LK_Cpp;
14434   CHECK_PARSE("Language: Cpp\n"
14435               "IndentWidth: 12",
14436               IndentWidth, 12u);
14437   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
14438                                "IndentWidth: 34",
14439                                &Style),
14440             ParseError::Unsuitable);
14441   FormatStyle BinPackedTCS = {};
14442   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
14443   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
14444                                "InsertTrailingCommas: Wrapped",
14445                                &BinPackedTCS),
14446             ParseError::BinPackTrailingCommaConflict);
14447   EXPECT_EQ(12u, Style.IndentWidth);
14448   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14449   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14450 
14451   Style.Language = FormatStyle::LK_JavaScript;
14452   CHECK_PARSE("Language: JavaScript\n"
14453               "IndentWidth: 12",
14454               IndentWidth, 12u);
14455   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14456   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14457                                "IndentWidth: 34",
14458                                &Style),
14459             ParseError::Unsuitable);
14460   EXPECT_EQ(23u, Style.IndentWidth);
14461   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14462   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14463 
14464   CHECK_PARSE("BasedOnStyle: LLVM\n"
14465               "IndentWidth: 67",
14466               IndentWidth, 67u);
14467 
14468   CHECK_PARSE("---\n"
14469               "Language: JavaScript\n"
14470               "IndentWidth: 12\n"
14471               "---\n"
14472               "Language: Cpp\n"
14473               "IndentWidth: 34\n"
14474               "...\n",
14475               IndentWidth, 12u);
14476 
14477   Style.Language = FormatStyle::LK_Cpp;
14478   CHECK_PARSE("---\n"
14479               "Language: JavaScript\n"
14480               "IndentWidth: 12\n"
14481               "---\n"
14482               "Language: Cpp\n"
14483               "IndentWidth: 34\n"
14484               "...\n",
14485               IndentWidth, 34u);
14486   CHECK_PARSE("---\n"
14487               "IndentWidth: 78\n"
14488               "---\n"
14489               "Language: JavaScript\n"
14490               "IndentWidth: 56\n"
14491               "...\n",
14492               IndentWidth, 78u);
14493 
14494   Style.ColumnLimit = 123;
14495   Style.IndentWidth = 234;
14496   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14497   Style.TabWidth = 345;
14498   EXPECT_FALSE(parseConfiguration("---\n"
14499                                   "IndentWidth: 456\n"
14500                                   "BreakBeforeBraces: Allman\n"
14501                                   "---\n"
14502                                   "Language: JavaScript\n"
14503                                   "IndentWidth: 111\n"
14504                                   "TabWidth: 111\n"
14505                                   "---\n"
14506                                   "Language: Cpp\n"
14507                                   "BreakBeforeBraces: Stroustrup\n"
14508                                   "TabWidth: 789\n"
14509                                   "...\n",
14510                                   &Style));
14511   EXPECT_EQ(123u, Style.ColumnLimit);
14512   EXPECT_EQ(456u, Style.IndentWidth);
14513   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14514   EXPECT_EQ(789u, Style.TabWidth);
14515 
14516   EXPECT_EQ(parseConfiguration("---\n"
14517                                "Language: JavaScript\n"
14518                                "IndentWidth: 56\n"
14519                                "---\n"
14520                                "IndentWidth: 78\n"
14521                                "...\n",
14522                                &Style),
14523             ParseError::Error);
14524   EXPECT_EQ(parseConfiguration("---\n"
14525                                "Language: JavaScript\n"
14526                                "IndentWidth: 56\n"
14527                                "---\n"
14528                                "Language: JavaScript\n"
14529                                "IndentWidth: 78\n"
14530                                "...\n",
14531                                &Style),
14532             ParseError::Error);
14533 
14534   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14535 }
14536 
14537 #undef CHECK_PARSE
14538 
14539 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14540   FormatStyle Style = {};
14541   Style.Language = FormatStyle::LK_JavaScript;
14542   Style.BreakBeforeTernaryOperators = true;
14543   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14544   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14545 
14546   Style.BreakBeforeTernaryOperators = true;
14547   EXPECT_EQ(0, parseConfiguration("---\n"
14548                                   "BasedOnStyle: Google\n"
14549                                   "---\n"
14550                                   "Language: JavaScript\n"
14551                                   "IndentWidth: 76\n"
14552                                   "...\n",
14553                                   &Style)
14554                    .value());
14555   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14556   EXPECT_EQ(76u, Style.IndentWidth);
14557   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14558 }
14559 
14560 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14561   FormatStyle Style = getLLVMStyle();
14562   std::string YAML = configurationAsText(Style);
14563   FormatStyle ParsedStyle = {};
14564   ParsedStyle.Language = FormatStyle::LK_Cpp;
14565   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14566   EXPECT_EQ(Style, ParsedStyle);
14567 }
14568 
14569 TEST_F(FormatTest, WorksFor8bitEncodings) {
14570   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14571             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14572             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14573             "\"\xef\xee\xf0\xf3...\"",
14574             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14575                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14576                    "\xef\xee\xf0\xf3...\"",
14577                    getLLVMStyleWithColumns(12)));
14578 }
14579 
14580 TEST_F(FormatTest, HandlesUTF8BOM) {
14581   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14582   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14583             format("\xef\xbb\xbf#include <iostream>"));
14584   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14585             format("\xef\xbb\xbf\n#include <iostream>"));
14586 }
14587 
14588 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14589 #if !defined(_MSC_VER)
14590 
14591 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14592   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14593                getLLVMStyleWithColumns(35));
14594   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14595                getLLVMStyleWithColumns(31));
14596   verifyFormat("// Однажды в студёную зимнюю пору...",
14597                getLLVMStyleWithColumns(36));
14598   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14599   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14600                getLLVMStyleWithColumns(39));
14601   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14602                getLLVMStyleWithColumns(35));
14603 }
14604 
14605 TEST_F(FormatTest, SplitsUTF8Strings) {
14606   // Non-printable characters' width is currently considered to be the length in
14607   // bytes in UTF8. The characters can be displayed in very different manner
14608   // (zero-width, single width with a substitution glyph, expanded to their code
14609   // (e.g. "<8d>"), so there's no single correct way to handle them.
14610   EXPECT_EQ("\"aaaaÄ\"\n"
14611             "\"\xc2\x8d\";",
14612             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14613   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14614             "\"\xc2\x8d\";",
14615             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14616   EXPECT_EQ("\"Однажды, в \"\n"
14617             "\"студёную \"\n"
14618             "\"зимнюю \"\n"
14619             "\"пору,\"",
14620             format("\"Однажды, в студёную зимнюю пору,\"",
14621                    getLLVMStyleWithColumns(13)));
14622   EXPECT_EQ(
14623       "\"一 二 三 \"\n"
14624       "\"四 五六 \"\n"
14625       "\"七 八 九 \"\n"
14626       "\"十\"",
14627       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14628   EXPECT_EQ("\"一\t\"\n"
14629             "\"二 \t\"\n"
14630             "\"三 四 \"\n"
14631             "\"五\t\"\n"
14632             "\"六 \t\"\n"
14633             "\"七 \"\n"
14634             "\"八九十\tqq\"",
14635             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14636                    getLLVMStyleWithColumns(11)));
14637 
14638   // UTF8 character in an escape sequence.
14639   EXPECT_EQ("\"aaaaaa\"\n"
14640             "\"\\\xC2\x8D\"",
14641             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14642 }
14643 
14644 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14645   EXPECT_EQ("const char *sssss =\n"
14646             "    \"一二三四五六七八\\\n"
14647             " 九 十\";",
14648             format("const char *sssss = \"一二三四五六七八\\\n"
14649                    " 九 十\";",
14650                    getLLVMStyleWithColumns(30)));
14651 }
14652 
14653 TEST_F(FormatTest, SplitsUTF8LineComments) {
14654   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14655             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14656   EXPECT_EQ("// Я из лесу\n"
14657             "// вышел; был\n"
14658             "// сильный\n"
14659             "// мороз.",
14660             format("// Я из лесу вышел; был сильный мороз.",
14661                    getLLVMStyleWithColumns(13)));
14662   EXPECT_EQ("// 一二三\n"
14663             "// 四五六七\n"
14664             "// 八  九\n"
14665             "// 十",
14666             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14667 }
14668 
14669 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14670   EXPECT_EQ("/* Гляжу,\n"
14671             " * поднимается\n"
14672             " * медленно в\n"
14673             " * гору\n"
14674             " * Лошадка,\n"
14675             " * везущая\n"
14676             " * хворосту\n"
14677             " * воз. */",
14678             format("/* Гляжу, поднимается медленно в гору\n"
14679                    " * Лошадка, везущая хворосту воз. */",
14680                    getLLVMStyleWithColumns(13)));
14681   EXPECT_EQ(
14682       "/* 一二三\n"
14683       " * 四五六七\n"
14684       " * 八  九\n"
14685       " * 十  */",
14686       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14687   EXPECT_EQ("/* �������� ��������\n"
14688             " * ��������\n"
14689             " * ������-�� */",
14690             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14691 }
14692 
14693 #endif // _MSC_VER
14694 
14695 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14696   FormatStyle Style = getLLVMStyle();
14697 
14698   Style.ConstructorInitializerIndentWidth = 4;
14699   verifyFormat(
14700       "SomeClass::Constructor()\n"
14701       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14702       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14703       Style);
14704 
14705   Style.ConstructorInitializerIndentWidth = 2;
14706   verifyFormat(
14707       "SomeClass::Constructor()\n"
14708       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14709       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14710       Style);
14711 
14712   Style.ConstructorInitializerIndentWidth = 0;
14713   verifyFormat(
14714       "SomeClass::Constructor()\n"
14715       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14716       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14717       Style);
14718   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14719   verifyFormat(
14720       "SomeLongTemplateVariableName<\n"
14721       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14722       Style);
14723   verifyFormat("bool smaller = 1 < "
14724                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14725                "                       "
14726                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14727                Style);
14728 
14729   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14730   verifyFormat("SomeClass::Constructor() :\n"
14731                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14732                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14733                Style);
14734 }
14735 
14736 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14737   FormatStyle Style = getLLVMStyle();
14738   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14739   Style.ConstructorInitializerIndentWidth = 4;
14740   verifyFormat("SomeClass::Constructor()\n"
14741                "    : a(a)\n"
14742                "    , b(b)\n"
14743                "    , c(c) {}",
14744                Style);
14745   verifyFormat("SomeClass::Constructor()\n"
14746                "    : a(a) {}",
14747                Style);
14748 
14749   Style.ColumnLimit = 0;
14750   verifyFormat("SomeClass::Constructor()\n"
14751                "    : a(a) {}",
14752                Style);
14753   verifyFormat("SomeClass::Constructor() noexcept\n"
14754                "    : a(a) {}",
14755                Style);
14756   verifyFormat("SomeClass::Constructor()\n"
14757                "    : a(a)\n"
14758                "    , b(b)\n"
14759                "    , c(c) {}",
14760                Style);
14761   verifyFormat("SomeClass::Constructor()\n"
14762                "    : a(a) {\n"
14763                "  foo();\n"
14764                "  bar();\n"
14765                "}",
14766                Style);
14767 
14768   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14769   verifyFormat("SomeClass::Constructor()\n"
14770                "    : a(a)\n"
14771                "    , b(b)\n"
14772                "    , c(c) {\n}",
14773                Style);
14774   verifyFormat("SomeClass::Constructor()\n"
14775                "    : a(a) {\n}",
14776                Style);
14777 
14778   Style.ColumnLimit = 80;
14779   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14780   Style.ConstructorInitializerIndentWidth = 2;
14781   verifyFormat("SomeClass::Constructor()\n"
14782                "  : a(a)\n"
14783                "  , b(b)\n"
14784                "  , c(c) {}",
14785                Style);
14786 
14787   Style.ConstructorInitializerIndentWidth = 0;
14788   verifyFormat("SomeClass::Constructor()\n"
14789                ": a(a)\n"
14790                ", b(b)\n"
14791                ", c(c) {}",
14792                Style);
14793 
14794   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14795   Style.ConstructorInitializerIndentWidth = 4;
14796   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14797   verifyFormat(
14798       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14799       Style);
14800   verifyFormat(
14801       "SomeClass::Constructor()\n"
14802       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14803       Style);
14804   Style.ConstructorInitializerIndentWidth = 4;
14805   Style.ColumnLimit = 60;
14806   verifyFormat("SomeClass::Constructor()\n"
14807                "    : aaaaaaaa(aaaaaaaa)\n"
14808                "    , aaaaaaaa(aaaaaaaa)\n"
14809                "    , aaaaaaaa(aaaaaaaa) {}",
14810                Style);
14811 }
14812 
14813 TEST_F(FormatTest, Destructors) {
14814   verifyFormat("void F(int &i) { i.~int(); }");
14815   verifyFormat("void F(int &i) { i->~int(); }");
14816 }
14817 
14818 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14819   FormatStyle Style = getWebKitStyle();
14820 
14821   // Don't indent in outer namespaces.
14822   verifyFormat("namespace outer {\n"
14823                "int i;\n"
14824                "namespace inner {\n"
14825                "    int i;\n"
14826                "} // namespace inner\n"
14827                "} // namespace outer\n"
14828                "namespace other_outer {\n"
14829                "int i;\n"
14830                "}",
14831                Style);
14832 
14833   // Don't indent case labels.
14834   verifyFormat("switch (variable) {\n"
14835                "case 1:\n"
14836                "case 2:\n"
14837                "    doSomething();\n"
14838                "    break;\n"
14839                "default:\n"
14840                "    ++variable;\n"
14841                "}",
14842                Style);
14843 
14844   // Wrap before binary operators.
14845   EXPECT_EQ("void f()\n"
14846             "{\n"
14847             "    if (aaaaaaaaaaaaaaaa\n"
14848             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14849             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14850             "        return;\n"
14851             "}",
14852             format("void f() {\n"
14853                    "if (aaaaaaaaaaaaaaaa\n"
14854                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
14855                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14856                    "return;\n"
14857                    "}",
14858                    Style));
14859 
14860   // Allow functions on a single line.
14861   verifyFormat("void f() { return; }", Style);
14862 
14863   // Allow empty blocks on a single line and insert a space in empty blocks.
14864   EXPECT_EQ("void f() { }", format("void f() {}", Style));
14865   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
14866   // However, don't merge non-empty short loops.
14867   EXPECT_EQ("while (true) {\n"
14868             "    continue;\n"
14869             "}",
14870             format("while (true) { continue; }", Style));
14871 
14872   // Constructor initializers are formatted one per line with the "," on the
14873   // new line.
14874   verifyFormat("Constructor()\n"
14875                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
14876                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
14877                "          aaaaaaaaaaaaaa)\n"
14878                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
14879                "{\n"
14880                "}",
14881                Style);
14882   verifyFormat("SomeClass::Constructor()\n"
14883                "    : a(a)\n"
14884                "{\n"
14885                "}",
14886                Style);
14887   EXPECT_EQ("SomeClass::Constructor()\n"
14888             "    : a(a)\n"
14889             "{\n"
14890             "}",
14891             format("SomeClass::Constructor():a(a){}", Style));
14892   verifyFormat("SomeClass::Constructor()\n"
14893                "    : a(a)\n"
14894                "    , b(b)\n"
14895                "    , c(c)\n"
14896                "{\n"
14897                "}",
14898                Style);
14899   verifyFormat("SomeClass::Constructor()\n"
14900                "    : a(a)\n"
14901                "{\n"
14902                "    foo();\n"
14903                "    bar();\n"
14904                "}",
14905                Style);
14906 
14907   // Access specifiers should be aligned left.
14908   verifyFormat("class C {\n"
14909                "public:\n"
14910                "    int i;\n"
14911                "};",
14912                Style);
14913 
14914   // Do not align comments.
14915   verifyFormat("int a; // Do not\n"
14916                "double b; // align comments.",
14917                Style);
14918 
14919   // Do not align operands.
14920   EXPECT_EQ("ASSERT(aaaa\n"
14921             "    || bbbb);",
14922             format("ASSERT ( aaaa\n||bbbb);", Style));
14923 
14924   // Accept input's line breaks.
14925   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
14926             "    || bbbbbbbbbbbbbbb) {\n"
14927             "    i++;\n"
14928             "}",
14929             format("if (aaaaaaaaaaaaaaa\n"
14930                    "|| bbbbbbbbbbbbbbb) { i++; }",
14931                    Style));
14932   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
14933             "    i++;\n"
14934             "}",
14935             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
14936 
14937   // Don't automatically break all macro definitions (llvm.org/PR17842).
14938   verifyFormat("#define aNumber 10", Style);
14939   // However, generally keep the line breaks that the user authored.
14940   EXPECT_EQ("#define aNumber \\\n"
14941             "    10",
14942             format("#define aNumber \\\n"
14943                    " 10",
14944                    Style));
14945 
14946   // Keep empty and one-element array literals on a single line.
14947   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
14948             "                                  copyItems:YES];",
14949             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
14950                    "copyItems:YES];",
14951                    Style));
14952   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
14953             "                                  copyItems:YES];",
14954             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
14955                    "             copyItems:YES];",
14956                    Style));
14957   // FIXME: This does not seem right, there should be more indentation before
14958   // the array literal's entries. Nested blocks have the same problem.
14959   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14960             "    @\"a\",\n"
14961             "    @\"a\"\n"
14962             "]\n"
14963             "                                  copyItems:YES];",
14964             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14965                    "     @\"a\",\n"
14966                    "     @\"a\"\n"
14967                    "     ]\n"
14968                    "       copyItems:YES];",
14969                    Style));
14970   EXPECT_EQ(
14971       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14972       "                                  copyItems:YES];",
14973       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14974              "   copyItems:YES];",
14975              Style));
14976 
14977   verifyFormat("[self.a b:c c:d];", Style);
14978   EXPECT_EQ("[self.a b:c\n"
14979             "        c:d];",
14980             format("[self.a b:c\n"
14981                    "c:d];",
14982                    Style));
14983 }
14984 
14985 TEST_F(FormatTest, FormatsLambdas) {
14986   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
14987   verifyFormat(
14988       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
14989   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
14990   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
14991   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
14992   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
14993   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
14994   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
14995   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
14996   verifyFormat("int x = f(*+[] {});");
14997   verifyFormat("void f() {\n"
14998                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
14999                "}\n");
15000   verifyFormat("void f() {\n"
15001                "  other(x.begin(), //\n"
15002                "        x.end(),   //\n"
15003                "        [&](int, int) { return 1; });\n"
15004                "}\n");
15005   verifyFormat("void f() {\n"
15006                "  other.other.other.other.other(\n"
15007                "      x.begin(), x.end(),\n"
15008                "      [something, rather](int, int, int, int, int, int, int) { "
15009                "return 1; });\n"
15010                "}\n");
15011   verifyFormat(
15012       "void f() {\n"
15013       "  other.other.other.other.other(\n"
15014       "      x.begin(), x.end(),\n"
15015       "      [something, rather](int, int, int, int, int, int, int) {\n"
15016       "        //\n"
15017       "      });\n"
15018       "}\n");
15019   verifyFormat("SomeFunction([]() { // A cool function...\n"
15020                "  return 43;\n"
15021                "});");
15022   EXPECT_EQ("SomeFunction([]() {\n"
15023             "#define A a\n"
15024             "  return 43;\n"
15025             "});",
15026             format("SomeFunction([](){\n"
15027                    "#define A a\n"
15028                    "return 43;\n"
15029                    "});"));
15030   verifyFormat("void f() {\n"
15031                "  SomeFunction([](decltype(x), A *a) {});\n"
15032                "  SomeFunction([](typeof(x), A *a) {});\n"
15033                "  SomeFunction([](_Atomic(x), A *a) {});\n"
15034                "  SomeFunction([](__underlying_type(x), A *a) {});\n"
15035                "}");
15036   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15037                "    [](const aaaaaaaaaa &a) { return a; });");
15038   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
15039                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
15040                "});");
15041   verifyFormat("Constructor()\n"
15042                "    : Field([] { // comment\n"
15043                "        int i;\n"
15044                "      }) {}");
15045   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
15046                "  return some_parameter.size();\n"
15047                "};");
15048   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
15049                "    [](const string &s) { return s; };");
15050   verifyFormat("int i = aaaaaa ? 1 //\n"
15051                "               : [] {\n"
15052                "                   return 2; //\n"
15053                "                 }();");
15054   verifyFormat("llvm::errs() << \"number of twos is \"\n"
15055                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
15056                "                  return x == 2; // force break\n"
15057                "                });");
15058   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15059                "    [=](int iiiiiiiiiiii) {\n"
15060                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
15061                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
15062                "    });",
15063                getLLVMStyleWithColumns(60));
15064   verifyFormat("SomeFunction({[&] {\n"
15065                "                // comment\n"
15066                "              },\n"
15067                "              [&] {\n"
15068                "                // comment\n"
15069                "              }});");
15070   verifyFormat("SomeFunction({[&] {\n"
15071                "  // comment\n"
15072                "}});");
15073   verifyFormat(
15074       "virtual aaaaaaaaaaaaaaaa(\n"
15075       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
15076       "    aaaaa aaaaaaaaa);");
15077 
15078   // Lambdas with return types.
15079   verifyFormat("int c = []() -> int { return 2; }();\n");
15080   verifyFormat("int c = []() -> int * { return 2; }();\n");
15081   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
15082   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
15083   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
15084   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
15085   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
15086   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
15087   verifyFormat("[a, a]() -> a<1> {};");
15088   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
15089   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
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> { return {}; };");
15095   verifyFormat("[]() -> foo<~5> { return {}; };");
15096   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
15097   verifyFormat("[]() -> foo<5 || 2> { 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<2 ? 1 : 0> { return {}; };");
15106   verifyFormat("namespace bar {\n"
15107                "// broken:\n"
15108                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
15109                "} // namespace bar");
15110   verifyFormat("namespace bar {\n"
15111                "// broken:\n"
15112                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
15113                "} // namespace bar");
15114   verifyFormat("namespace bar {\n"
15115                "// broken:\n"
15116                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
15117                "} // namespace bar");
15118   verifyFormat("namespace bar {\n"
15119                "// broken:\n"
15120                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
15121                "} // namespace bar");
15122   verifyFormat("namespace bar {\n"
15123                "// broken:\n"
15124                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
15125                "} // namespace bar");
15126   verifyFormat("namespace bar {\n"
15127                "// broken:\n"
15128                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
15129                "} // namespace bar");
15130   verifyFormat("namespace bar {\n"
15131                "// broken:\n"
15132                "auto foo{[]() -> foo<!5> { return {}; }};\n"
15133                "} // namespace bar");
15134   verifyFormat("namespace bar {\n"
15135                "// broken:\n"
15136                "auto foo{[]() -> foo<~5> { return {}; }};\n"
15137                "} // namespace bar");
15138   verifyFormat("namespace bar {\n"
15139                "// broken:\n"
15140                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
15141                "} // namespace bar");
15142   verifyFormat("namespace bar {\n"
15143                "// broken:\n"
15144                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
15145                "} // namespace bar");
15146   verifyFormat("namespace bar {\n"
15147                "// broken:\n"
15148                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
15149                "} // namespace bar");
15150   verifyFormat("namespace bar {\n"
15151                "// broken:\n"
15152                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
15153                "} // namespace bar");
15154   verifyFormat("namespace bar {\n"
15155                "// broken:\n"
15156                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
15157                "} // namespace bar");
15158   verifyFormat("namespace bar {\n"
15159                "// broken:\n"
15160                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
15161                "} // namespace bar");
15162   verifyFormat("namespace bar {\n"
15163                "// broken:\n"
15164                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
15165                "} // namespace bar");
15166   verifyFormat("namespace bar {\n"
15167                "// broken:\n"
15168                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
15169                "} // namespace bar");
15170   verifyFormat("namespace bar {\n"
15171                "// broken:\n"
15172                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
15173                "} // namespace bar");
15174   verifyFormat("namespace bar {\n"
15175                "// broken:\n"
15176                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
15177                "} // namespace bar");
15178   verifyFormat("[]() -> a<1> {};");
15179   verifyFormat("[]() -> a<1> { ; };");
15180   verifyFormat("[]() -> a<1> { ; }();");
15181   verifyFormat("[a, a]() -> a<true> {};");
15182   verifyFormat("[]() -> a<true> {};");
15183   verifyFormat("[]() -> a<true> { ; };");
15184   verifyFormat("[]() -> a<true> { ; }();");
15185   verifyFormat("[a, a]() -> a<false> {};");
15186   verifyFormat("[]() -> a<false> {};");
15187   verifyFormat("[]() -> a<false> { ; };");
15188   verifyFormat("[]() -> a<false> { ; }();");
15189   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
15190   verifyFormat("namespace bar {\n"
15191                "auto foo{[]() -> foo<false> { ; }};\n"
15192                "} // namespace bar");
15193   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
15194                "                   int j) -> int {\n"
15195                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
15196                "};");
15197   verifyFormat(
15198       "aaaaaaaaaaaaaaaaaaaaaa(\n"
15199       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
15200       "      return aaaaaaaaaaaaaaaaa;\n"
15201       "    });",
15202       getLLVMStyleWithColumns(70));
15203   verifyFormat("[]() //\n"
15204                "    -> int {\n"
15205                "  return 1; //\n"
15206                "};");
15207   verifyFormat("[]() -> Void<T...> {};");
15208   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
15209 
15210   // Lambdas with explicit template argument lists.
15211   verifyFormat(
15212       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
15213 
15214   // Multiple lambdas in the same parentheses change indentation rules. These
15215   // lambdas are forced to start on new lines.
15216   verifyFormat("SomeFunction(\n"
15217                "    []() {\n"
15218                "      //\n"
15219                "    },\n"
15220                "    []() {\n"
15221                "      //\n"
15222                "    });");
15223 
15224   // A lambda passed as arg0 is always pushed to the next line.
15225   verifyFormat("SomeFunction(\n"
15226                "    [this] {\n"
15227                "      //\n"
15228                "    },\n"
15229                "    1);\n");
15230 
15231   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
15232   // the arg0 case above.
15233   auto Style = getGoogleStyle();
15234   Style.BinPackArguments = false;
15235   verifyFormat("SomeFunction(\n"
15236                "    a,\n"
15237                "    [this] {\n"
15238                "      //\n"
15239                "    },\n"
15240                "    b);\n",
15241                Style);
15242   verifyFormat("SomeFunction(\n"
15243                "    a,\n"
15244                "    [this] {\n"
15245                "      //\n"
15246                "    },\n"
15247                "    b);\n");
15248 
15249   // A lambda with a very long line forces arg0 to be pushed out irrespective of
15250   // the BinPackArguments value (as long as the code is wide enough).
15251   verifyFormat(
15252       "something->SomeFunction(\n"
15253       "    a,\n"
15254       "    [this] {\n"
15255       "      "
15256       "D0000000000000000000000000000000000000000000000000000000000001();\n"
15257       "    },\n"
15258       "    b);\n");
15259 
15260   // A multi-line lambda is pulled up as long as the introducer fits on the
15261   // previous line and there are no further args.
15262   verifyFormat("function(1, [this, that] {\n"
15263                "  //\n"
15264                "});\n");
15265   verifyFormat("function([this, that] {\n"
15266                "  //\n"
15267                "});\n");
15268   // FIXME: this format is not ideal and we should consider forcing the first
15269   // arg onto its own line.
15270   verifyFormat("function(a, b, c, //\n"
15271                "         d, [this, that] {\n"
15272                "           //\n"
15273                "         });\n");
15274 
15275   // Multiple lambdas are treated correctly even when there is a short arg0.
15276   verifyFormat("SomeFunction(\n"
15277                "    1,\n"
15278                "    [this] {\n"
15279                "      //\n"
15280                "    },\n"
15281                "    [this] {\n"
15282                "      //\n"
15283                "    },\n"
15284                "    1);\n");
15285 
15286   // More complex introducers.
15287   verifyFormat("return [i, args...] {};");
15288 
15289   // Not lambdas.
15290   verifyFormat("constexpr char hello[]{\"hello\"};");
15291   verifyFormat("double &operator[](int i) { return 0; }\n"
15292                "int i;");
15293   verifyFormat("std::unique_ptr<int[]> foo() {}");
15294   verifyFormat("int i = a[a][a]->f();");
15295   verifyFormat("int i = (*b)[a]->f();");
15296 
15297   // Other corner cases.
15298   verifyFormat("void f() {\n"
15299                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
15300                "  );\n"
15301                "}");
15302 
15303   // Lambdas created through weird macros.
15304   verifyFormat("void f() {\n"
15305                "  MACRO((const AA &a) { return 1; });\n"
15306                "  MACRO((AA &a) { return 1; });\n"
15307                "}");
15308 
15309   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
15310                "      doo_dah();\n"
15311                "      doo_dah();\n"
15312                "    })) {\n"
15313                "}");
15314   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
15315                "                doo_dah();\n"
15316                "                doo_dah();\n"
15317                "              })) {\n"
15318                "}");
15319   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
15320                "                doo_dah();\n"
15321                "                doo_dah();\n"
15322                "              })) {\n"
15323                "}");
15324   verifyFormat("auto lambda = []() {\n"
15325                "  int a = 2\n"
15326                "#if A\n"
15327                "          + 2\n"
15328                "#endif\n"
15329                "      ;\n"
15330                "};");
15331 
15332   // Lambdas with complex multiline introducers.
15333   verifyFormat(
15334       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15335       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
15336       "        -> ::std::unordered_set<\n"
15337       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
15338       "      //\n"
15339       "    });");
15340 
15341   FormatStyle DoNotMerge = getLLVMStyle();
15342   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
15343   verifyFormat("auto c = []() {\n"
15344                "  return b;\n"
15345                "};",
15346                "auto c = []() { return b; };", DoNotMerge);
15347   verifyFormat("auto c = []() {\n"
15348                "};",
15349                " auto c = []() {};", DoNotMerge);
15350 
15351   FormatStyle MergeEmptyOnly = getLLVMStyle();
15352   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
15353   verifyFormat("auto c = []() {\n"
15354                "  return b;\n"
15355                "};",
15356                "auto c = []() {\n"
15357                "  return b;\n"
15358                " };",
15359                MergeEmptyOnly);
15360   verifyFormat("auto c = []() {};",
15361                "auto c = []() {\n"
15362                "};",
15363                MergeEmptyOnly);
15364 
15365   FormatStyle MergeInline = getLLVMStyle();
15366   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
15367   verifyFormat("auto c = []() {\n"
15368                "  return b;\n"
15369                "};",
15370                "auto c = []() { return b; };", MergeInline);
15371   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
15372                MergeInline);
15373   verifyFormat("function([]() { return b; }, a)",
15374                "function([]() { return b; }, a)", MergeInline);
15375   verifyFormat("function(a, []() { return b; })",
15376                "function(a, []() { return b; })", MergeInline);
15377 
15378   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
15379   // AllowShortLambdasOnASingleLine
15380   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15381   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15382   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15383   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15384       FormatStyle::ShortLambdaStyle::SLS_None;
15385   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
15386                "    []()\n"
15387                "    {\n"
15388                "      return 17;\n"
15389                "    });",
15390                LLVMWithBeforeLambdaBody);
15391   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
15392                "    []()\n"
15393                "    {\n"
15394                "    });",
15395                LLVMWithBeforeLambdaBody);
15396   verifyFormat("auto fct_SLS_None = []()\n"
15397                "{\n"
15398                "  return 17;\n"
15399                "};",
15400                LLVMWithBeforeLambdaBody);
15401   verifyFormat("TwoNestedLambdas_SLS_None(\n"
15402                "    []()\n"
15403                "    {\n"
15404                "      return Call(\n"
15405                "          []()\n"
15406                "          {\n"
15407                "            return 17;\n"
15408                "          });\n"
15409                "    });",
15410                LLVMWithBeforeLambdaBody);
15411   verifyFormat("void Fct()\n"
15412                "{\n"
15413                "  return {[]()\n"
15414                "          {\n"
15415                "            return 17;\n"
15416                "          }};\n"
15417                "}",
15418                LLVMWithBeforeLambdaBody);
15419 
15420   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15421       FormatStyle::ShortLambdaStyle::SLS_Empty;
15422   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
15423                "    []()\n"
15424                "    {\n"
15425                "      return 17;\n"
15426                "    });",
15427                LLVMWithBeforeLambdaBody);
15428   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
15429                LLVMWithBeforeLambdaBody);
15430   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
15431                "ongFunctionName_SLS_Empty(\n"
15432                "    []() {});",
15433                LLVMWithBeforeLambdaBody);
15434   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
15435                "                                []()\n"
15436                "                                {\n"
15437                "                                  return 17;\n"
15438                "                                });",
15439                LLVMWithBeforeLambdaBody);
15440   verifyFormat("auto fct_SLS_Empty = []()\n"
15441                "{\n"
15442                "  return 17;\n"
15443                "};",
15444                LLVMWithBeforeLambdaBody);
15445   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
15446                "    []()\n"
15447                "    {\n"
15448                "      return Call([]() {});\n"
15449                "    });",
15450                LLVMWithBeforeLambdaBody);
15451   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15452                "                           []()\n"
15453                "                           {\n"
15454                "                             return Call([]() {});\n"
15455                "                           });",
15456                LLVMWithBeforeLambdaBody);
15457   verifyFormat(
15458       "FctWithLongLineInLambda_SLS_Empty(\n"
15459       "    []()\n"
15460       "    {\n"
15461       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15462       "                               AndShouldNotBeConsiderAsInline,\n"
15463       "                               LambdaBodyMustBeBreak);\n"
15464       "    });",
15465       LLVMWithBeforeLambdaBody);
15466 
15467   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15468       FormatStyle::ShortLambdaStyle::SLS_Inline;
15469   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15470                LLVMWithBeforeLambdaBody);
15471   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15472                LLVMWithBeforeLambdaBody);
15473   verifyFormat("auto fct_SLS_Inline = []()\n"
15474                "{\n"
15475                "  return 17;\n"
15476                "};",
15477                LLVMWithBeforeLambdaBody);
15478   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15479                "17; }); });",
15480                LLVMWithBeforeLambdaBody);
15481   verifyFormat(
15482       "FctWithLongLineInLambda_SLS_Inline(\n"
15483       "    []()\n"
15484       "    {\n"
15485       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15486       "                               AndShouldNotBeConsiderAsInline,\n"
15487       "                               LambdaBodyMustBeBreak);\n"
15488       "    });",
15489       LLVMWithBeforeLambdaBody);
15490   verifyFormat("FctWithMultipleParams_SLS_Inline("
15491                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15492                "                                 []() { return 17; });",
15493                LLVMWithBeforeLambdaBody);
15494   verifyFormat(
15495       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15496       LLVMWithBeforeLambdaBody);
15497 
15498   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15499       FormatStyle::ShortLambdaStyle::SLS_All;
15500   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15501                LLVMWithBeforeLambdaBody);
15502   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15503                LLVMWithBeforeLambdaBody);
15504   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15505                LLVMWithBeforeLambdaBody);
15506   verifyFormat("FctWithOneParam_SLS_All(\n"
15507                "    []()\n"
15508                "    {\n"
15509                "      // A cool function...\n"
15510                "      return 43;\n"
15511                "    });",
15512                LLVMWithBeforeLambdaBody);
15513   verifyFormat("FctWithMultipleParams_SLS_All("
15514                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15515                "                              []() { return 17; });",
15516                LLVMWithBeforeLambdaBody);
15517   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15518                LLVMWithBeforeLambdaBody);
15519   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15520                LLVMWithBeforeLambdaBody);
15521   verifyFormat(
15522       "FctWithLongLineInLambda_SLS_All(\n"
15523       "    []()\n"
15524       "    {\n"
15525       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15526       "                               AndShouldNotBeConsiderAsInline,\n"
15527       "                               LambdaBodyMustBeBreak);\n"
15528       "    });",
15529       LLVMWithBeforeLambdaBody);
15530   verifyFormat(
15531       "auto fct_SLS_All = []()\n"
15532       "{\n"
15533       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15534       "                           AndShouldNotBeConsiderAsInline,\n"
15535       "                           LambdaBodyMustBeBreak);\n"
15536       "};",
15537       LLVMWithBeforeLambdaBody);
15538   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15539   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15540                LLVMWithBeforeLambdaBody);
15541   verifyFormat(
15542       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15543       "                                FirstParam,\n"
15544       "                                SecondParam,\n"
15545       "                                ThirdParam,\n"
15546       "                                FourthParam);",
15547       LLVMWithBeforeLambdaBody);
15548   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15549                "    []() { return "
15550                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15551                "    FirstParam,\n"
15552                "    SecondParam,\n"
15553                "    ThirdParam,\n"
15554                "    FourthParam);",
15555                LLVMWithBeforeLambdaBody);
15556   verifyFormat(
15557       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15558       "                                SecondParam,\n"
15559       "                                ThirdParam,\n"
15560       "                                FourthParam,\n"
15561       "                                []() { return SomeValueNotSoLong; });",
15562       LLVMWithBeforeLambdaBody);
15563   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15564                "    []()\n"
15565                "    {\n"
15566                "      return "
15567                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15568                "eConsiderAsInline;\n"
15569                "    });",
15570                LLVMWithBeforeLambdaBody);
15571   verifyFormat(
15572       "FctWithLongLineInLambda_SLS_All(\n"
15573       "    []()\n"
15574       "    {\n"
15575       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15576       "                               AndShouldNotBeConsiderAsInline,\n"
15577       "                               LambdaBodyMustBeBreak);\n"
15578       "    });",
15579       LLVMWithBeforeLambdaBody);
15580   verifyFormat("FctWithTwoParams_SLS_All(\n"
15581                "    []()\n"
15582                "    {\n"
15583                "      // A cool function...\n"
15584                "      return 43;\n"
15585                "    },\n"
15586                "    87);",
15587                LLVMWithBeforeLambdaBody);
15588   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15589                LLVMWithBeforeLambdaBody);
15590   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15591                LLVMWithBeforeLambdaBody);
15592   verifyFormat(
15593       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15594       LLVMWithBeforeLambdaBody);
15595   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15596                "}); }, x);",
15597                LLVMWithBeforeLambdaBody);
15598   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15599                "    []()\n"
15600                "    {\n"
15601                "      // A cool function...\n"
15602                "      return Call([]() { return 17; });\n"
15603                "    });",
15604                LLVMWithBeforeLambdaBody);
15605   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15606                "    []()\n"
15607                "    {\n"
15608                "      return Call(\n"
15609                "          []()\n"
15610                "          {\n"
15611                "            // A cool function...\n"
15612                "            return 17;\n"
15613                "          });\n"
15614                "    });",
15615                LLVMWithBeforeLambdaBody);
15616 }
15617 
15618 TEST_F(FormatTest, LambdaWithLineComments) {
15619   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15620   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15621   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15622   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15623       FormatStyle::ShortLambdaStyle::SLS_All;
15624 
15625   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15626   verifyFormat("auto k = []() // comment\n"
15627                "{ return; }",
15628                LLVMWithBeforeLambdaBody);
15629   verifyFormat("auto k = []() /* comment */ { return; }",
15630                LLVMWithBeforeLambdaBody);
15631   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15632                LLVMWithBeforeLambdaBody);
15633   verifyFormat("auto k = []() // X\n"
15634                "{ return; }",
15635                LLVMWithBeforeLambdaBody);
15636   verifyFormat(
15637       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15638       "{ return; }",
15639       LLVMWithBeforeLambdaBody);
15640 }
15641 
15642 TEST_F(FormatTest, EmptyLinesInLambdas) {
15643   verifyFormat("auto lambda = []() {\n"
15644                "  x(); //\n"
15645                "};",
15646                "auto lambda = []() {\n"
15647                "\n"
15648                "  x(); //\n"
15649                "\n"
15650                "};");
15651 }
15652 
15653 TEST_F(FormatTest, FormatsBlocks) {
15654   FormatStyle ShortBlocks = getLLVMStyle();
15655   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15656   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15657   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15658   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15659   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15660   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15661   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15662 
15663   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15664   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15665   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15666 
15667   verifyFormat("[operation setCompletionBlock:^{\n"
15668                "  [self onOperationDone];\n"
15669                "}];");
15670   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15671                "  [self onOperationDone];\n"
15672                "}]};");
15673   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15674                "  f();\n"
15675                "}];");
15676   verifyFormat("int a = [operation block:^int(int *i) {\n"
15677                "  return 1;\n"
15678                "}];");
15679   verifyFormat("[myObject doSomethingWith:arg1\n"
15680                "                      aaa:^int(int *a) {\n"
15681                "                        return 1;\n"
15682                "                      }\n"
15683                "                      bbb:f(a * bbbbbbbb)];");
15684 
15685   verifyFormat("[operation setCompletionBlock:^{\n"
15686                "  [self.delegate newDataAvailable];\n"
15687                "}];",
15688                getLLVMStyleWithColumns(60));
15689   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15690                "  NSString *path = [self sessionFilePath];\n"
15691                "  if (path) {\n"
15692                "    // ...\n"
15693                "  }\n"
15694                "});");
15695   verifyFormat("[[SessionService sharedService]\n"
15696                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15697                "      if (window) {\n"
15698                "        [self windowDidLoad:window];\n"
15699                "      } else {\n"
15700                "        [self errorLoadingWindow];\n"
15701                "      }\n"
15702                "    }];");
15703   verifyFormat("void (^largeBlock)(void) = ^{\n"
15704                "  // ...\n"
15705                "};\n",
15706                getLLVMStyleWithColumns(40));
15707   verifyFormat("[[SessionService sharedService]\n"
15708                "    loadWindowWithCompletionBlock: //\n"
15709                "        ^(SessionWindow *window) {\n"
15710                "          if (window) {\n"
15711                "            [self windowDidLoad:window];\n"
15712                "          } else {\n"
15713                "            [self errorLoadingWindow];\n"
15714                "          }\n"
15715                "        }];",
15716                getLLVMStyleWithColumns(60));
15717   verifyFormat("[myObject doSomethingWith:arg1\n"
15718                "    firstBlock:^(Foo *a) {\n"
15719                "      // ...\n"
15720                "      int i;\n"
15721                "    }\n"
15722                "    secondBlock:^(Bar *b) {\n"
15723                "      // ...\n"
15724                "      int i;\n"
15725                "    }\n"
15726                "    thirdBlock:^Foo(Bar *b) {\n"
15727                "      // ...\n"
15728                "      int i;\n"
15729                "    }];");
15730   verifyFormat("[myObject doSomethingWith:arg1\n"
15731                "               firstBlock:-1\n"
15732                "              secondBlock:^(Bar *b) {\n"
15733                "                // ...\n"
15734                "                int i;\n"
15735                "              }];");
15736 
15737   verifyFormat("f(^{\n"
15738                "  @autoreleasepool {\n"
15739                "    if (a) {\n"
15740                "      g();\n"
15741                "    }\n"
15742                "  }\n"
15743                "});");
15744   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15745   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15746                "};");
15747 
15748   FormatStyle FourIndent = getLLVMStyle();
15749   FourIndent.ObjCBlockIndentWidth = 4;
15750   verifyFormat("[operation setCompletionBlock:^{\n"
15751                "    [self onOperationDone];\n"
15752                "}];",
15753                FourIndent);
15754 }
15755 
15756 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15757   FormatStyle ZeroColumn = getLLVMStyle();
15758   ZeroColumn.ColumnLimit = 0;
15759 
15760   verifyFormat("[[SessionService sharedService] "
15761                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15762                "  if (window) {\n"
15763                "    [self windowDidLoad:window];\n"
15764                "  } else {\n"
15765                "    [self errorLoadingWindow];\n"
15766                "  }\n"
15767                "}];",
15768                ZeroColumn);
15769   EXPECT_EQ("[[SessionService sharedService]\n"
15770             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15771             "      if (window) {\n"
15772             "        [self windowDidLoad:window];\n"
15773             "      } else {\n"
15774             "        [self errorLoadingWindow];\n"
15775             "      }\n"
15776             "    }];",
15777             format("[[SessionService sharedService]\n"
15778                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15779                    "                if (window) {\n"
15780                    "    [self windowDidLoad:window];\n"
15781                    "  } else {\n"
15782                    "    [self errorLoadingWindow];\n"
15783                    "  }\n"
15784                    "}];",
15785                    ZeroColumn));
15786   verifyFormat("[myObject doSomethingWith:arg1\n"
15787                "    firstBlock:^(Foo *a) {\n"
15788                "      // ...\n"
15789                "      int i;\n"
15790                "    }\n"
15791                "    secondBlock:^(Bar *b) {\n"
15792                "      // ...\n"
15793                "      int i;\n"
15794                "    }\n"
15795                "    thirdBlock:^Foo(Bar *b) {\n"
15796                "      // ...\n"
15797                "      int i;\n"
15798                "    }];",
15799                ZeroColumn);
15800   verifyFormat("f(^{\n"
15801                "  @autoreleasepool {\n"
15802                "    if (a) {\n"
15803                "      g();\n"
15804                "    }\n"
15805                "  }\n"
15806                "});",
15807                ZeroColumn);
15808   verifyFormat("void (^largeBlock)(void) = ^{\n"
15809                "  // ...\n"
15810                "};",
15811                ZeroColumn);
15812 
15813   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15814   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15815             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15816   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15817   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15818             "  int i;\n"
15819             "};",
15820             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15821 }
15822 
15823 TEST_F(FormatTest, SupportsCRLF) {
15824   EXPECT_EQ("int a;\r\n"
15825             "int b;\r\n"
15826             "int c;\r\n",
15827             format("int a;\r\n"
15828                    "  int b;\r\n"
15829                    "    int c;\r\n",
15830                    getLLVMStyle()));
15831   EXPECT_EQ("int a;\r\n"
15832             "int b;\r\n"
15833             "int c;\r\n",
15834             format("int a;\r\n"
15835                    "  int b;\n"
15836                    "    int c;\r\n",
15837                    getLLVMStyle()));
15838   EXPECT_EQ("int a;\n"
15839             "int b;\n"
15840             "int c;\n",
15841             format("int a;\r\n"
15842                    "  int b;\n"
15843                    "    int c;\n",
15844                    getLLVMStyle()));
15845   EXPECT_EQ("\"aaaaaaa \"\r\n"
15846             "\"bbbbbbb\";\r\n",
15847             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15848   EXPECT_EQ("#define A \\\r\n"
15849             "  b;      \\\r\n"
15850             "  c;      \\\r\n"
15851             "  d;\r\n",
15852             format("#define A \\\r\n"
15853                    "  b; \\\r\n"
15854                    "  c; d; \r\n",
15855                    getGoogleStyle()));
15856 
15857   EXPECT_EQ("/*\r\n"
15858             "multi line block comments\r\n"
15859             "should not introduce\r\n"
15860             "an extra carriage return\r\n"
15861             "*/\r\n",
15862             format("/*\r\n"
15863                    "multi line block comments\r\n"
15864                    "should not introduce\r\n"
15865                    "an extra carriage return\r\n"
15866                    "*/\r\n"));
15867   EXPECT_EQ("/*\r\n"
15868             "\r\n"
15869             "*/",
15870             format("/*\r\n"
15871                    "    \r\r\r\n"
15872                    "*/"));
15873 
15874   FormatStyle style = getLLVMStyle();
15875 
15876   style.DeriveLineEnding = true;
15877   style.UseCRLF = false;
15878   EXPECT_EQ("union FooBarBazQux {\n"
15879             "  int foo;\n"
15880             "  int bar;\n"
15881             "  int baz;\n"
15882             "};",
15883             format("union FooBarBazQux {\r\n"
15884                    "  int foo;\n"
15885                    "  int bar;\r\n"
15886                    "  int baz;\n"
15887                    "};",
15888                    style));
15889   style.UseCRLF = true;
15890   EXPECT_EQ("union FooBarBazQux {\r\n"
15891             "  int foo;\r\n"
15892             "  int bar;\r\n"
15893             "  int baz;\r\n"
15894             "};",
15895             format("union FooBarBazQux {\r\n"
15896                    "  int foo;\n"
15897                    "  int bar;\r\n"
15898                    "  int baz;\n"
15899                    "};",
15900                    style));
15901 
15902   style.DeriveLineEnding = false;
15903   style.UseCRLF = false;
15904   EXPECT_EQ("union FooBarBazQux {\n"
15905             "  int foo;\n"
15906             "  int bar;\n"
15907             "  int baz;\n"
15908             "  int qux;\n"
15909             "};",
15910             format("union FooBarBazQux {\r\n"
15911                    "  int foo;\n"
15912                    "  int bar;\r\n"
15913                    "  int baz;\n"
15914                    "  int qux;\r\n"
15915                    "};",
15916                    style));
15917   style.UseCRLF = true;
15918   EXPECT_EQ("union FooBarBazQux {\r\n"
15919             "  int foo;\r\n"
15920             "  int bar;\r\n"
15921             "  int baz;\r\n"
15922             "  int qux;\r\n"
15923             "};",
15924             format("union FooBarBazQux {\r\n"
15925                    "  int foo;\n"
15926                    "  int bar;\r\n"
15927                    "  int baz;\n"
15928                    "  int qux;\n"
15929                    "};",
15930                    style));
15931 
15932   style.DeriveLineEnding = true;
15933   style.UseCRLF = false;
15934   EXPECT_EQ("union FooBarBazQux {\r\n"
15935             "  int foo;\r\n"
15936             "  int bar;\r\n"
15937             "  int baz;\r\n"
15938             "  int qux;\r\n"
15939             "};",
15940             format("union FooBarBazQux {\r\n"
15941                    "  int foo;\n"
15942                    "  int bar;\r\n"
15943                    "  int baz;\n"
15944                    "  int qux;\r\n"
15945                    "};",
15946                    style));
15947   style.UseCRLF = true;
15948   EXPECT_EQ("union FooBarBazQux {\n"
15949             "  int foo;\n"
15950             "  int bar;\n"
15951             "  int baz;\n"
15952             "  int qux;\n"
15953             "};",
15954             format("union FooBarBazQux {\r\n"
15955                    "  int foo;\n"
15956                    "  int bar;\r\n"
15957                    "  int baz;\n"
15958                    "  int qux;\n"
15959                    "};",
15960                    style));
15961 }
15962 
15963 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
15964   verifyFormat("MY_CLASS(C) {\n"
15965                "  int i;\n"
15966                "  int j;\n"
15967                "};");
15968 }
15969 
15970 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
15971   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
15972   TwoIndent.ContinuationIndentWidth = 2;
15973 
15974   EXPECT_EQ("int i =\n"
15975             "  longFunction(\n"
15976             "    arg);",
15977             format("int i = longFunction(arg);", TwoIndent));
15978 
15979   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
15980   SixIndent.ContinuationIndentWidth = 6;
15981 
15982   EXPECT_EQ("int i =\n"
15983             "      longFunction(\n"
15984             "            arg);",
15985             format("int i = longFunction(arg);", SixIndent));
15986 }
15987 
15988 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
15989   FormatStyle Style = getLLVMStyle();
15990   verifyFormat("int Foo::getter(\n"
15991                "    //\n"
15992                ") const {\n"
15993                "  return foo;\n"
15994                "}",
15995                Style);
15996   verifyFormat("void Foo::setter(\n"
15997                "    //\n"
15998                ") {\n"
15999                "  foo = 1;\n"
16000                "}",
16001                Style);
16002 }
16003 
16004 TEST_F(FormatTest, SpacesInAngles) {
16005   FormatStyle Spaces = getLLVMStyle();
16006   Spaces.SpacesInAngles = true;
16007 
16008   verifyFormat("static_cast< int >(arg);", Spaces);
16009   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
16010   verifyFormat("f< int, float >();", Spaces);
16011   verifyFormat("template <> g() {}", Spaces);
16012   verifyFormat("template < std::vector< int > > f() {}", Spaces);
16013   verifyFormat("std::function< void(int, int) > fct;", Spaces);
16014   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
16015                Spaces);
16016 
16017   Spaces.Standard = FormatStyle::LS_Cpp03;
16018   Spaces.SpacesInAngles = true;
16019   verifyFormat("A< A< int > >();", Spaces);
16020 
16021   Spaces.SpacesInAngles = false;
16022   verifyFormat("A<A<int> >();", Spaces);
16023 
16024   Spaces.Standard = FormatStyle::LS_Cpp11;
16025   Spaces.SpacesInAngles = true;
16026   verifyFormat("A< A< int > >();", Spaces);
16027 
16028   Spaces.SpacesInAngles = false;
16029   verifyFormat("A<A<int>>();", Spaces);
16030 }
16031 
16032 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
16033   FormatStyle Style = getLLVMStyle();
16034   Style.SpaceAfterTemplateKeyword = false;
16035   verifyFormat("template<int> void foo();", Style);
16036 }
16037 
16038 TEST_F(FormatTest, TripleAngleBrackets) {
16039   verifyFormat("f<<<1, 1>>>();");
16040   verifyFormat("f<<<1, 1, 1, s>>>();");
16041   verifyFormat("f<<<a, b, c, d>>>();");
16042   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
16043   verifyFormat("f<param><<<1, 1>>>();");
16044   verifyFormat("f<1><<<1, 1>>>();");
16045   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
16046   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16047                "aaaaaaaaaaa<<<\n    1, 1>>>();");
16048   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
16049                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
16050 }
16051 
16052 TEST_F(FormatTest, MergeLessLessAtEnd) {
16053   verifyFormat("<<");
16054   EXPECT_EQ("< < <", format("\\\n<<<"));
16055   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16056                "aaallvm::outs() <<");
16057   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16058                "aaaallvm::outs()\n    <<");
16059 }
16060 
16061 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
16062   std::string code = "#if A\n"
16063                      "#if B\n"
16064                      "a.\n"
16065                      "#endif\n"
16066                      "    a = 1;\n"
16067                      "#else\n"
16068                      "#endif\n"
16069                      "#if C\n"
16070                      "#else\n"
16071                      "#endif\n";
16072   EXPECT_EQ(code, format(code));
16073 }
16074 
16075 TEST_F(FormatTest, HandleConflictMarkers) {
16076   // Git/SVN conflict markers.
16077   EXPECT_EQ("int a;\n"
16078             "void f() {\n"
16079             "  callme(some(parameter1,\n"
16080             "<<<<<<< text by the vcs\n"
16081             "              parameter2),\n"
16082             "||||||| text by the vcs\n"
16083             "              parameter2),\n"
16084             "         parameter3,\n"
16085             "======= text by the vcs\n"
16086             "              parameter2, parameter3),\n"
16087             ">>>>>>> text by the vcs\n"
16088             "         otherparameter);\n",
16089             format("int a;\n"
16090                    "void f() {\n"
16091                    "  callme(some(parameter1,\n"
16092                    "<<<<<<< text by the vcs\n"
16093                    "  parameter2),\n"
16094                    "||||||| text by the vcs\n"
16095                    "  parameter2),\n"
16096                    "  parameter3,\n"
16097                    "======= text by the vcs\n"
16098                    "  parameter2,\n"
16099                    "  parameter3),\n"
16100                    ">>>>>>> text by the vcs\n"
16101                    "  otherparameter);\n"));
16102 
16103   // Perforce markers.
16104   EXPECT_EQ("void f() {\n"
16105             "  function(\n"
16106             ">>>> text by the vcs\n"
16107             "      parameter,\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             format("void f() {\n"
16115                    "  function(\n"
16116                    ">>>> text by the vcs\n"
16117                    "  parameter,\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 
16125   EXPECT_EQ("<<<<<<<\n"
16126             "|||||||\n"
16127             "=======\n"
16128             ">>>>>>>",
16129             format("<<<<<<<\n"
16130                    "|||||||\n"
16131                    "=======\n"
16132                    ">>>>>>>"));
16133 
16134   EXPECT_EQ("<<<<<<<\n"
16135             "|||||||\n"
16136             "int i;\n"
16137             "=======\n"
16138             ">>>>>>>",
16139             format("<<<<<<<\n"
16140                    "|||||||\n"
16141                    "int i;\n"
16142                    "=======\n"
16143                    ">>>>>>>"));
16144 
16145   // FIXME: Handle parsing of macros around conflict markers correctly:
16146   EXPECT_EQ("#define Macro \\\n"
16147             "<<<<<<<\n"
16148             "Something \\\n"
16149             "|||||||\n"
16150             "Else \\\n"
16151             "=======\n"
16152             "Other \\\n"
16153             ">>>>>>>\n"
16154             "    End int i;\n",
16155             format("#define Macro \\\n"
16156                    "<<<<<<<\n"
16157                    "  Something \\\n"
16158                    "|||||||\n"
16159                    "  Else \\\n"
16160                    "=======\n"
16161                    "  Other \\\n"
16162                    ">>>>>>>\n"
16163                    "  End\n"
16164                    "int i;\n"));
16165 }
16166 
16167 TEST_F(FormatTest, DisableRegions) {
16168   EXPECT_EQ("int i;\n"
16169             "// clang-format off\n"
16170             "  int j;\n"
16171             "// clang-format on\n"
16172             "int k;",
16173             format(" int  i;\n"
16174                    "   // clang-format off\n"
16175                    "  int j;\n"
16176                    " // clang-format on\n"
16177                    "   int   k;"));
16178   EXPECT_EQ("int i;\n"
16179             "/* clang-format off */\n"
16180             "  int j;\n"
16181             "/* clang-format on */\n"
16182             "int k;",
16183             format(" int  i;\n"
16184                    "   /* clang-format off */\n"
16185                    "  int j;\n"
16186                    " /* clang-format on */\n"
16187                    "   int   k;"));
16188 
16189   // Don't reflow comments within disabled regions.
16190   EXPECT_EQ("// clang-format off\n"
16191             "// long long long long long long line\n"
16192             "/* clang-format on */\n"
16193             "/* long long long\n"
16194             " * long long long\n"
16195             " * line */\n"
16196             "int i;\n"
16197             "/* clang-format off */\n"
16198             "/* long long long long long long line */\n",
16199             format("// clang-format off\n"
16200                    "// long long long long long long line\n"
16201                    "/* clang-format on */\n"
16202                    "/* long long long long long long line */\n"
16203                    "int i;\n"
16204                    "/* clang-format off */\n"
16205                    "/* long long long long long long line */\n",
16206                    getLLVMStyleWithColumns(20)));
16207 }
16208 
16209 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
16210   format("? ) =");
16211   verifyNoCrash("#define a\\\n /**/}");
16212 }
16213 
16214 TEST_F(FormatTest, FormatsTableGenCode) {
16215   FormatStyle Style = getLLVMStyle();
16216   Style.Language = FormatStyle::LK_TableGen;
16217   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
16218 }
16219 
16220 TEST_F(FormatTest, ArrayOfTemplates) {
16221   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
16222             format("auto a = new unique_ptr<int > [ 10];"));
16223 
16224   FormatStyle Spaces = getLLVMStyle();
16225   Spaces.SpacesInSquareBrackets = true;
16226   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
16227             format("auto a = new unique_ptr<int > [10];", Spaces));
16228 }
16229 
16230 TEST_F(FormatTest, ArrayAsTemplateType) {
16231   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
16232             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
16233 
16234   FormatStyle Spaces = getLLVMStyle();
16235   Spaces.SpacesInSquareBrackets = true;
16236   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
16237             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
16238 }
16239 
16240 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
16241 
16242 TEST(FormatStyle, GetStyleWithEmptyFileName) {
16243   llvm::vfs::InMemoryFileSystem FS;
16244   auto Style1 = getStyle("file", "", "Google", "", &FS);
16245   ASSERT_TRUE((bool)Style1);
16246   ASSERT_EQ(*Style1, getGoogleStyle());
16247 }
16248 
16249 TEST(FormatStyle, GetStyleOfFile) {
16250   llvm::vfs::InMemoryFileSystem FS;
16251   // Test 1: format file in the same directory.
16252   ASSERT_TRUE(
16253       FS.addFile("/a/.clang-format", 0,
16254                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
16255   ASSERT_TRUE(
16256       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16257   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
16258   ASSERT_TRUE((bool)Style1);
16259   ASSERT_EQ(*Style1, getLLVMStyle());
16260 
16261   // Test 2.1: fallback to default.
16262   ASSERT_TRUE(
16263       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16264   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
16265   ASSERT_TRUE((bool)Style2);
16266   ASSERT_EQ(*Style2, getMozillaStyle());
16267 
16268   // Test 2.2: no format on 'none' fallback style.
16269   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16270   ASSERT_TRUE((bool)Style2);
16271   ASSERT_EQ(*Style2, getNoStyle());
16272 
16273   // Test 2.3: format if config is found with no based style while fallback is
16274   // 'none'.
16275   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
16276                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
16277   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16278   ASSERT_TRUE((bool)Style2);
16279   ASSERT_EQ(*Style2, getLLVMStyle());
16280 
16281   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
16282   Style2 = getStyle("{}", "a.h", "none", "", &FS);
16283   ASSERT_TRUE((bool)Style2);
16284   ASSERT_EQ(*Style2, getLLVMStyle());
16285 
16286   // Test 3: format file in parent directory.
16287   ASSERT_TRUE(
16288       FS.addFile("/c/.clang-format", 0,
16289                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
16290   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
16291                          llvm::MemoryBuffer::getMemBuffer("int i;")));
16292   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
16293   ASSERT_TRUE((bool)Style3);
16294   ASSERT_EQ(*Style3, getGoogleStyle());
16295 
16296   // Test 4: error on invalid fallback style
16297   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
16298   ASSERT_FALSE((bool)Style4);
16299   llvm::consumeError(Style4.takeError());
16300 
16301   // Test 5: error on invalid yaml on command line
16302   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
16303   ASSERT_FALSE((bool)Style5);
16304   llvm::consumeError(Style5.takeError());
16305 
16306   // Test 6: error on invalid style
16307   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
16308   ASSERT_FALSE((bool)Style6);
16309   llvm::consumeError(Style6.takeError());
16310 
16311   // Test 7: found config file, error on parsing it
16312   ASSERT_TRUE(
16313       FS.addFile("/d/.clang-format", 0,
16314                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
16315                                                   "InvalidKey: InvalidValue")));
16316   ASSERT_TRUE(
16317       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16318   auto Style7a = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
16319   ASSERT_FALSE((bool)Style7a);
16320   llvm::consumeError(Style7a.takeError());
16321 
16322   auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
16323   ASSERT_TRUE((bool)Style7b);
16324 
16325   // Test 8: inferred per-language defaults apply.
16326   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
16327   ASSERT_TRUE((bool)StyleTd);
16328   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
16329 }
16330 
16331 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
16332   // Column limit is 20.
16333   std::string Code = "Type *a =\n"
16334                      "    new Type();\n"
16335                      "g(iiiii, 0, jjjjj,\n"
16336                      "  0, kkkkk, 0, mm);\n"
16337                      "int  bad     = format   ;";
16338   std::string Expected = "auto a = new Type();\n"
16339                          "g(iiiii, nullptr,\n"
16340                          "  jjjjj, nullptr,\n"
16341                          "  kkkkk, nullptr,\n"
16342                          "  mm);\n"
16343                          "int  bad     = format   ;";
16344   FileID ID = Context.createInMemoryFile("format.cpp", Code);
16345   tooling::Replacements Replaces = toReplacements(
16346       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
16347                             "auto "),
16348        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
16349                             "nullptr"),
16350        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
16351                             "nullptr"),
16352        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
16353                             "nullptr")});
16354 
16355   format::FormatStyle Style = format::getLLVMStyle();
16356   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
16357   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16358   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16359       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16360   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16361   EXPECT_TRUE(static_cast<bool>(Result));
16362   EXPECT_EQ(Expected, *Result);
16363 }
16364 
16365 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
16366   std::string Code = "#include \"a.h\"\n"
16367                      "#include \"c.h\"\n"
16368                      "\n"
16369                      "int main() {\n"
16370                      "  return 0;\n"
16371                      "}";
16372   std::string Expected = "#include \"a.h\"\n"
16373                          "#include \"b.h\"\n"
16374                          "#include \"c.h\"\n"
16375                          "\n"
16376                          "int main() {\n"
16377                          "  return 0;\n"
16378                          "}";
16379   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
16380   tooling::Replacements Replaces = toReplacements(
16381       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
16382                             "#include \"b.h\"\n")});
16383 
16384   format::FormatStyle Style = format::getLLVMStyle();
16385   Style.SortIncludes = true;
16386   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16387   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16388       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16389   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16390   EXPECT_TRUE(static_cast<bool>(Result));
16391   EXPECT_EQ(Expected, *Result);
16392 }
16393 
16394 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
16395   EXPECT_EQ("using std::cin;\n"
16396             "using std::cout;",
16397             format("using std::cout;\n"
16398                    "using std::cin;",
16399                    getGoogleStyle()));
16400 }
16401 
16402 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
16403   format::FormatStyle Style = format::getLLVMStyle();
16404   Style.Standard = FormatStyle::LS_Cpp03;
16405   // cpp03 recognize this string as identifier u8 and literal character 'a'
16406   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
16407 }
16408 
16409 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
16410   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
16411   // all modes, including C++11, C++14 and C++17
16412   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
16413 }
16414 
16415 TEST_F(FormatTest, DoNotFormatLikelyXml) {
16416   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
16417   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
16418 }
16419 
16420 TEST_F(FormatTest, StructuredBindings) {
16421   // Structured bindings is a C++17 feature.
16422   // all modes, including C++11, C++14 and C++17
16423   verifyFormat("auto [a, b] = f();");
16424   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
16425   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
16426   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
16427   EXPECT_EQ("auto const volatile [a, b] = f();",
16428             format("auto  const   volatile[a, b] = f();"));
16429   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
16430   EXPECT_EQ("auto &[a, b, c] = f();",
16431             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 const &[a, b] = f();", format("auto  const&[a, b] = f();"));
16435   EXPECT_EQ("auto const volatile &&[a, b] = f();",
16436             format("auto  const  volatile  &&[a, b] = f();"));
16437   EXPECT_EQ("auto const &&[a, b] = f();",
16438             format("auto  const   &&  [a, b] = f();"));
16439   EXPECT_EQ("const auto &[a, b] = f();",
16440             format("const  auto  &  [a, b] = f();"));
16441   EXPECT_EQ("const auto volatile &&[a, b] = f();",
16442             format("const  auto   volatile  &&[a, b] = f();"));
16443   EXPECT_EQ("volatile const auto &&[a, b] = f();",
16444             format("volatile  const  auto   &&[a, b] = f();"));
16445   EXPECT_EQ("const auto &&[a, b] = f();",
16446             format("const  auto  &&  [a, b] = f();"));
16447 
16448   // Make sure we don't mistake structured bindings for lambdas.
16449   FormatStyle PointerMiddle = getLLVMStyle();
16450   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16451   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16452   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16453   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16454   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16455   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16456   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16457   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16458   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16459   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16460   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16461   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16462   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16463 
16464   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16465             format("for (const auto   &&   [a, b] : some_range) {\n}"));
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("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16471   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16472   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16473   EXPECT_EQ("auto const &[x, y](expr);",
16474             format("auto  const  &  [x,y]  (expr);"));
16475   EXPECT_EQ("auto const &&[x, y](expr);",
16476             format("auto  const  &&  [x,y]  (expr);"));
16477   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16478   EXPECT_EQ("auto const &[x, y]{expr};",
16479             format("auto  const  &  [x,y]  {expr};"));
16480   EXPECT_EQ("auto const &&[x, y]{expr};",
16481             format("auto  const  &&  [x,y]  {expr};"));
16482 
16483   format::FormatStyle Spaces = format::getLLVMStyle();
16484   Spaces.SpacesInSquareBrackets = true;
16485   verifyFormat("auto [ a, b ] = f();", Spaces);
16486   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16487   verifyFormat("auto &[ a, b ] = f();", Spaces);
16488   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16489   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16490 }
16491 
16492 TEST_F(FormatTest, FileAndCode) {
16493   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16494   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16495   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16496   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16497   EXPECT_EQ(FormatStyle::LK_ObjC,
16498             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16499   EXPECT_EQ(
16500       FormatStyle::LK_ObjC,
16501       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16502   EXPECT_EQ(FormatStyle::LK_ObjC,
16503             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16504   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16505   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16506   EXPECT_EQ(FormatStyle::LK_ObjC,
16507             guessLanguage("foo", "@interface Foo\n@end\n"));
16508   EXPECT_EQ(FormatStyle::LK_ObjC,
16509             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16510   EXPECT_EQ(
16511       FormatStyle::LK_ObjC,
16512       guessLanguage("foo.h",
16513                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16514   EXPECT_EQ(
16515       FormatStyle::LK_Cpp,
16516       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16517 }
16518 
16519 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16520   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16521   EXPECT_EQ(FormatStyle::LK_ObjC,
16522             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16523   EXPECT_EQ(FormatStyle::LK_Cpp,
16524             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16525   EXPECT_EQ(
16526       FormatStyle::LK_Cpp,
16527       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16528   EXPECT_EQ(FormatStyle::LK_ObjC,
16529             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16530   EXPECT_EQ(FormatStyle::LK_Cpp,
16531             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16532   EXPECT_EQ(FormatStyle::LK_ObjC,
16533             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16534   EXPECT_EQ(FormatStyle::LK_Cpp,
16535             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16536   EXPECT_EQ(FormatStyle::LK_Cpp,
16537             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16538   EXPECT_EQ(FormatStyle::LK_ObjC,
16539             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16540   EXPECT_EQ(FormatStyle::LK_Cpp,
16541             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16542   EXPECT_EQ(
16543       FormatStyle::LK_Cpp,
16544       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16545   EXPECT_EQ(
16546       FormatStyle::LK_Cpp,
16547       guessLanguage("foo.h",
16548                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16549   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16550 }
16551 
16552 TEST_F(FormatTest, GuessLanguageWithCaret) {
16553   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16554   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16555   EXPECT_EQ(FormatStyle::LK_ObjC,
16556             guessLanguage("foo.h", "int(^)(char, float);"));
16557   EXPECT_EQ(FormatStyle::LK_ObjC,
16558             guessLanguage("foo.h", "int(^foo)(char, float);"));
16559   EXPECT_EQ(FormatStyle::LK_ObjC,
16560             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16561   EXPECT_EQ(FormatStyle::LK_ObjC,
16562             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16563   EXPECT_EQ(
16564       FormatStyle::LK_ObjC,
16565       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16566 }
16567 
16568 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16569   // ASM symbolic names are identifiers that must be surrounded by [] without
16570   // space in between:
16571   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16572 
16573   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16574   verifyFormat(R"(//
16575 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16576 )");
16577 
16578   // A list of several ASM symbolic names.
16579   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16580 
16581   // ASM symbolic names in inline ASM with inputs and outputs.
16582   verifyFormat(R"(//
16583 asm("cmoveq %1, %2, %[result]"
16584     : [result] "=r"(result)
16585     : "r"(test), "r"(new), "[result]"(old));
16586 )");
16587 
16588   // ASM symbolic names in inline ASM with no outputs.
16589   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16590 }
16591 
16592 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
16593   EXPECT_EQ(FormatStyle::LK_Cpp,
16594             guessLanguage("foo.h", "void f() {\n"
16595                                    "  asm (\"mov %[e], %[d]\"\n"
16596                                    "     : [d] \"=rm\" (d)\n"
16597                                    "       [e] \"rm\" (*e));\n"
16598                                    "}"));
16599   EXPECT_EQ(FormatStyle::LK_Cpp,
16600             guessLanguage("foo.h", "void f() {\n"
16601                                    "  _asm (\"mov %[e], %[d]\"\n"
16602                                    "     : [d] \"=rm\" (d)\n"
16603                                    "       [e] \"rm\" (*e));\n"
16604                                    "}"));
16605   EXPECT_EQ(FormatStyle::LK_Cpp,
16606             guessLanguage("foo.h", "void f() {\n"
16607                                    "  __asm (\"mov %[e], %[d]\"\n"
16608                                    "     : [d] \"=rm\" (d)\n"
16609                                    "       [e] \"rm\" (*e));\n"
16610                                    "}"));
16611   EXPECT_EQ(FormatStyle::LK_Cpp,
16612             guessLanguage("foo.h", "void f() {\n"
16613                                    "  __asm__ (\"mov %[e], %[d]\"\n"
16614                                    "     : [d] \"=rm\" (d)\n"
16615                                    "       [e] \"rm\" (*e));\n"
16616                                    "}"));
16617   EXPECT_EQ(FormatStyle::LK_Cpp,
16618             guessLanguage("foo.h", "void f() {\n"
16619                                    "  asm (\"mov %[e], %[d]\"\n"
16620                                    "     : [d] \"=rm\" (d),\n"
16621                                    "       [e] \"rm\" (*e));\n"
16622                                    "}"));
16623   EXPECT_EQ(FormatStyle::LK_Cpp,
16624             guessLanguage("foo.h", "void f() {\n"
16625                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16626                                    "     : [d] \"=rm\" (d)\n"
16627                                    "       [e] \"rm\" (*e));\n"
16628                                    "}"));
16629 }
16630 
16631 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16632   EXPECT_EQ(FormatStyle::LK_Cpp,
16633             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16634   EXPECT_EQ(FormatStyle::LK_ObjC,
16635             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16636   EXPECT_EQ(
16637       FormatStyle::LK_Cpp,
16638       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16639   EXPECT_EQ(
16640       FormatStyle::LK_ObjC,
16641       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16642 }
16643 
16644 TEST_F(FormatTest, TypenameMacros) {
16645   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16646 
16647   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16648   FormatStyle Google = getGoogleStyleWithColumns(0);
16649   Google.TypenameMacros = TypenameMacros;
16650   verifyFormat("struct foo {\n"
16651                "  int bar;\n"
16652                "  TAILQ_ENTRY(a) bleh;\n"
16653                "};",
16654                Google);
16655 
16656   FormatStyle Macros = getLLVMStyle();
16657   Macros.TypenameMacros = TypenameMacros;
16658 
16659   verifyFormat("STACK_OF(int) a;", Macros);
16660   verifyFormat("STACK_OF(int) *a;", Macros);
16661   verifyFormat("STACK_OF(int const *) *a;", Macros);
16662   verifyFormat("STACK_OF(int *const) *a;", Macros);
16663   verifyFormat("STACK_OF(int, string) a;", Macros);
16664   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16665   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16666   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16667   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16668   verifyFormat("vector<LIST(uint64_t) *attr> x;", Macros);
16669   verifyFormat("vector<LIST(uint64_t) *const> f(LIST(uint64_t) *arg);", Macros);
16670 
16671   Macros.PointerAlignment = FormatStyle::PAS_Left;
16672   verifyFormat("STACK_OF(int)* a;", Macros);
16673   verifyFormat("STACK_OF(int*)* a;", Macros);
16674   verifyFormat("x = (STACK_OF(uint64_t))*a;", Macros);
16675   verifyFormat("x = (STACK_OF(uint64_t))&a;", Macros);
16676   verifyFormat("vector<STACK_OF(uint64_t)* attr> x;", Macros);
16677 }
16678 
16679 TEST_F(FormatTest, AtomicQualifier) {
16680   // Check that we treate _Atomic as a type and not a function call
16681   FormatStyle Google = getGoogleStyleWithColumns(0);
16682   verifyFormat("struct foo {\n"
16683                "  int a1;\n"
16684                "  _Atomic(a) a2;\n"
16685                "  _Atomic(_Atomic(int) *const) a3;\n"
16686                "};",
16687                Google);
16688   verifyFormat("_Atomic(uint64_t) a;");
16689   verifyFormat("_Atomic(uint64_t) *a;");
16690   verifyFormat("_Atomic(uint64_t const *) *a;");
16691   verifyFormat("_Atomic(uint64_t *const) *a;");
16692   verifyFormat("_Atomic(const uint64_t *) *a;");
16693   verifyFormat("_Atomic(uint64_t) a;");
16694   verifyFormat("_Atomic(_Atomic(uint64_t)) a;");
16695   verifyFormat("_Atomic(_Atomic(uint64_t)) a, b;");
16696   verifyFormat("for (_Atomic(uint64_t) *a = NULL; a;) {\n}");
16697   verifyFormat("_Atomic(uint64_t) f(_Atomic(uint64_t) *arg);");
16698 
16699   verifyFormat("_Atomic(uint64_t) *s(InitValue);");
16700   verifyFormat("_Atomic(uint64_t) *s{InitValue};");
16701   FormatStyle Style = getLLVMStyle();
16702   Style.PointerAlignment = FormatStyle::PAS_Left;
16703   verifyFormat("_Atomic(uint64_t)* s(InitValue);", Style);
16704   verifyFormat("_Atomic(uint64_t)* s{InitValue};", Style);
16705   verifyFormat("_Atomic(int)* a;", Style);
16706   verifyFormat("_Atomic(int*)* a;", Style);
16707   verifyFormat("vector<_Atomic(uint64_t)* attr> x;", Style);
16708 
16709   Style.SpacesInCStyleCastParentheses = true;
16710   Style.SpacesInParentheses = false;
16711   verifyFormat("x = ( _Atomic(uint64_t) )*a;", Style);
16712   Style.SpacesInCStyleCastParentheses = false;
16713   Style.SpacesInParentheses = true;
16714   verifyFormat("x = (_Atomic( uint64_t ))*a;", Style);
16715   verifyFormat("x = (_Atomic( uint64_t ))&a;", Style);
16716 }
16717 
16718 TEST_F(FormatTest, AmbersandInLamda) {
16719   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16720   FormatStyle AlignStyle = getLLVMStyle();
16721   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16722   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16723   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16724   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16725 }
16726 
16727 TEST_F(FormatTest, SpacesInConditionalStatement) {
16728   FormatStyle Spaces = getLLVMStyle();
16729   Spaces.SpacesInConditionalStatement = true;
16730   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16731   verifyFormat("if ( !a )\n  return;", Spaces);
16732   verifyFormat("if ( a )\n  return;", Spaces);
16733   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16734   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16735   verifyFormat("while ( a )\n  return;", Spaces);
16736   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16737   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16738   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16739   // Check that space on the left of "::" is inserted as expected at beginning
16740   // of condition.
16741   verifyFormat("while ( ::func() )\n  return;", Spaces);
16742 }
16743 
16744 TEST_F(FormatTest, AlternativeOperators) {
16745   // Test case for ensuring alternate operators are not
16746   // combined with their right most neighbour.
16747   verifyFormat("int a and b;");
16748   verifyFormat("int a and_eq b;");
16749   verifyFormat("int a bitand b;");
16750   verifyFormat("int a bitor b;");
16751   verifyFormat("int a compl b;");
16752   verifyFormat("int a not b;");
16753   verifyFormat("int a not_eq b;");
16754   verifyFormat("int a or b;");
16755   verifyFormat("int a xor b;");
16756   verifyFormat("int a xor_eq b;");
16757   verifyFormat("return this not_eq bitand other;");
16758   verifyFormat("bool operator not_eq(const X bitand other)");
16759 
16760   verifyFormat("int a and 5;");
16761   verifyFormat("int a and_eq 5;");
16762   verifyFormat("int a bitand 5;");
16763   verifyFormat("int a bitor 5;");
16764   verifyFormat("int a compl 5;");
16765   verifyFormat("int a not 5;");
16766   verifyFormat("int a not_eq 5;");
16767   verifyFormat("int a or 5;");
16768   verifyFormat("int a xor 5;");
16769   verifyFormat("int a xor_eq 5;");
16770 
16771   verifyFormat("int a compl(5);");
16772   verifyFormat("int a not(5);");
16773 
16774   /* FIXME handle alternate tokens
16775    * https://en.cppreference.com/w/cpp/language/operator_alternative
16776   // alternative tokens
16777   verifyFormat("compl foo();");     //  ~foo();
16778   verifyFormat("foo() <%%>;");      // foo();
16779   verifyFormat("void foo() <%%>;"); // void foo(){}
16780   verifyFormat("int a <:1:>;");     // int a[1];[
16781   verifyFormat("%:define ABC abc"); // #define ABC abc
16782   verifyFormat("%:%:");             // ##
16783   */
16784 }
16785 
16786 TEST_F(FormatTest, STLWhileNotDefineChed) {
16787   verifyFormat("#if defined(while)\n"
16788                "#define while EMIT WARNING C4005\n"
16789                "#endif // while");
16790 }
16791 
16792 TEST_F(FormatTest, OperatorSpacing) {
16793   FormatStyle Style = getLLVMStyle();
16794   Style.PointerAlignment = FormatStyle::PAS_Right;
16795   verifyFormat("Foo::operator*();", Style);
16796   verifyFormat("Foo::operator void *();", Style);
16797   verifyFormat("Foo::operator void **();", 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*();", Style);
16803   verifyFormat("Foo::operator**();", Style);
16804   verifyFormat("Foo::operator&();", Style);
16805   verifyFormat("Foo::operator<int> *();", Style);
16806   verifyFormat("Foo::operator<Foo> *();", 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("operator*(int (*)(), class Foo);", Style);
16818 
16819   verifyFormat("Foo::operator&();", Style);
16820   verifyFormat("Foo::operator void &();", Style);
16821   verifyFormat("Foo::operator()(void &);", Style);
16822   verifyFormat("Foo::operator&(void &);", Style);
16823   verifyFormat("Foo::operator&();", Style);
16824   verifyFormat("operator&(int (&)(), class Foo);", Style);
16825 
16826   verifyFormat("Foo::operator&&();", Style);
16827   verifyFormat("Foo::operator**();", Style);
16828   verifyFormat("Foo::operator void &&();", Style);
16829   verifyFormat("Foo::operator()(void &&);", Style);
16830   verifyFormat("Foo::operator&&(void &&);", Style);
16831   verifyFormat("Foo::operator&&();", Style);
16832   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16833   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16834   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16835                Style);
16836   verifyFormat("operator void **()", Style);
16837   verifyFormat("operator const FooRight<Object> &()", Style);
16838   verifyFormat("operator const FooRight<Object> *()", Style);
16839   verifyFormat("operator const FooRight<Object> **()", Style);
16840   verifyFormat("operator const FooRight<Object> *&()", Style);
16841   verifyFormat("operator const FooRight<Object> *&&()", Style);
16842 
16843   Style.PointerAlignment = FormatStyle::PAS_Left;
16844   verifyFormat("Foo::operator*();", Style);
16845   verifyFormat("Foo::operator**();", Style);
16846   verifyFormat("Foo::operator void*();", Style);
16847   verifyFormat("Foo::operator void**();", Style);
16848   verifyFormat("Foo::operator void*&();", Style);
16849   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16850   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16851   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16852   verifyFormat("Foo::operator()(void*);", Style);
16853   verifyFormat("Foo::operator*(void*);", Style);
16854   verifyFormat("Foo::operator*();", Style);
16855   verifyFormat("Foo::operator<int>*();", Style);
16856   verifyFormat("Foo::operator<Foo>*();", Style);
16857   verifyFormat("Foo::operator<int>**();", Style);
16858   verifyFormat("Foo::operator<Foo>**();", Style);
16859   verifyFormat("Foo::operator<Foo>*&();", Style);
16860   verifyFormat("Foo::operator<int>&();", 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("operator*(int (*)(), class Foo);", Style);
16867 
16868   verifyFormat("Foo::operator&();", Style);
16869   verifyFormat("Foo::operator void&();", Style);
16870   verifyFormat("Foo::operator/*comment*/ void&();", Style);
16871   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
16872   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
16873   verifyFormat("Foo::operator()(void&);", Style);
16874   verifyFormat("Foo::operator&(void&);", Style);
16875   verifyFormat("Foo::operator&();", Style);
16876   verifyFormat("operator&(int (&)(), class Foo);", Style);
16877 
16878   verifyFormat("Foo::operator&&();", Style);
16879   verifyFormat("Foo::operator void&&();", Style);
16880   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
16881   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
16882   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
16883   verifyFormat("Foo::operator()(void&&);", Style);
16884   verifyFormat("Foo::operator&&(void&&);", Style);
16885   verifyFormat("Foo::operator&&();", Style);
16886   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16887   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
16888   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
16889                Style);
16890   verifyFormat("operator void**()", Style);
16891   verifyFormat("operator const FooLeft<Object>&()", Style);
16892   verifyFormat("operator const FooLeft<Object>*()", Style);
16893   verifyFormat("operator const FooLeft<Object>**()", Style);
16894   verifyFormat("operator const FooLeft<Object>*&()", Style);
16895   verifyFormat("operator const FooLeft<Object>*&&()", Style);
16896 
16897   // PR45107
16898   verifyFormat("operator Vector<String>&();", Style);
16899   verifyFormat("operator const Vector<String>&();", Style);
16900   verifyFormat("operator foo::Bar*();", Style);
16901   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
16902   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
16903                Style);
16904 
16905   Style.PointerAlignment = FormatStyle::PAS_Middle;
16906   verifyFormat("Foo::operator*();", Style);
16907   verifyFormat("Foo::operator void *();", Style);
16908   verifyFormat("Foo::operator()(void *);", Style);
16909   verifyFormat("Foo::operator*(void *);", Style);
16910   verifyFormat("Foo::operator*();", Style);
16911   verifyFormat("operator*(int (*)(), class Foo);", Style);
16912 
16913   verifyFormat("Foo::operator&();", Style);
16914   verifyFormat("Foo::operator void &();", Style);
16915   verifyFormat("Foo::operator()(void &);", Style);
16916   verifyFormat("Foo::operator&(void &);", Style);
16917   verifyFormat("Foo::operator&();", Style);
16918   verifyFormat("operator&(int (&)(), class Foo);", Style);
16919 
16920   verifyFormat("Foo::operator&&();", Style);
16921   verifyFormat("Foo::operator void &&();", Style);
16922   verifyFormat("Foo::operator()(void &&);", Style);
16923   verifyFormat("Foo::operator&&(void &&);", Style);
16924   verifyFormat("Foo::operator&&();", Style);
16925   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16926 }
16927 
16928 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
16929   FormatStyle Style = getLLVMStyle();
16930   // PR46157
16931   verifyFormat("foo(operator+, -42);", Style);
16932   verifyFormat("foo(operator++, -42);", Style);
16933   verifyFormat("foo(operator--, -42);", Style);
16934   verifyFormat("foo(-42, operator--);", Style);
16935   verifyFormat("foo(-42, operator, );", Style);
16936   verifyFormat("foo(operator, , -42);", Style);
16937 }
16938 
16939 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
16940   FormatStyle Style = getLLVMStyle();
16941   Style.WhitespaceSensitiveMacros.push_back("FOO");
16942 
16943   // Don't use the helpers here, since 'mess up' will change the whitespace
16944   // and these are all whitespace sensitive by definition
16945   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
16946             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
16947   EXPECT_EQ(
16948       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
16949       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
16950   EXPECT_EQ("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,: :\n"
16953             "       Still=Intentional);",
16954             format("FOO(String-ized&Messy+But,: :\n"
16955                    "       Still=Intentional);",
16956                    Style));
16957   Style.AlignConsecutiveAssignments = true;
16958   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
16959             "       Still=Intentional);",
16960             format("FOO(String-ized=&Messy+But,: :\n"
16961                    "       Still=Intentional);",
16962                    Style));
16963 
16964   Style.ColumnLimit = 21;
16965   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
16966             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
16967 }
16968 
16969 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
16970   // These tests are not in NamespaceFixer because that doesn't
16971   // test its interaction with line wrapping
16972   FormatStyle Style = getLLVMStyle();
16973   Style.ColumnLimit = 80;
16974   verifyFormat("namespace {\n"
16975                "int i;\n"
16976                "int j;\n"
16977                "} // namespace",
16978                Style);
16979 
16980   verifyFormat("namespace AAA {\n"
16981                "int i;\n"
16982                "int j;\n"
16983                "} // namespace AAA",
16984                Style);
16985 
16986   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
16987             "int i;\n"
16988             "int j;\n"
16989             "} // namespace Averyveryveryverylongnamespace",
16990             format("namespace Averyveryveryverylongnamespace {\n"
16991                    "int i;\n"
16992                    "int j;\n"
16993                    "}",
16994                    Style));
16995 
16996   EXPECT_EQ(
16997       "namespace "
16998       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16999       "    went::mad::now {\n"
17000       "int i;\n"
17001       "int j;\n"
17002       "} // namespace\n"
17003       "  // "
17004       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
17005       "went::mad::now",
17006       format("namespace "
17007              "would::it::save::you::a::lot::of::time::if_::i::"
17008              "just::gave::up::and_::went::mad::now {\n"
17009              "int i;\n"
17010              "int j;\n"
17011              "}",
17012              Style));
17013 
17014   // This used to duplicate the comment again and again on subsequent runs
17015   EXPECT_EQ(
17016       "namespace "
17017       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
17018       "    went::mad::now {\n"
17019       "int i;\n"
17020       "int j;\n"
17021       "} // namespace\n"
17022       "  // "
17023       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
17024       "went::mad::now",
17025       format("namespace "
17026              "would::it::save::you::a::lot::of::time::if_::i::"
17027              "just::gave::up::and_::went::mad::now {\n"
17028              "int i;\n"
17029              "int j;\n"
17030              "} // namespace\n"
17031              "  // "
17032              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
17033              "and_::went::mad::now",
17034              Style));
17035 }
17036 
17037 TEST_F(FormatTest, LikelyUnlikely) {
17038   FormatStyle Style = getLLVMStyle();
17039 
17040   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17041                "  return 29;\n"
17042                "}",
17043                Style);
17044 
17045   verifyFormat("if (argc > 5) [[likely]] {\n"
17046                "  return 29;\n"
17047                "}",
17048                Style);
17049 
17050   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17051                "  return 29;\n"
17052                "} else [[likely]] {\n"
17053                "  return 42;\n"
17054                "}\n",
17055                Style);
17056 
17057   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17058                "  return 29;\n"
17059                "} else if (argc > 10) [[likely]] {\n"
17060                "  return 99;\n"
17061                "} else {\n"
17062                "  return 42;\n"
17063                "}\n",
17064                Style);
17065 
17066   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
17067                "  return 29;\n"
17068                "}",
17069                Style);
17070 }
17071 
17072 TEST_F(FormatTest, LLVMDefaultStyle) {
17073   FormatStyle Style = getLLVMStyle();
17074   verifyFormat("extern \"C\" {\n"
17075                "int foo();\n"
17076                "}",
17077                Style);
17078 }
17079 TEST_F(FormatTest, GNUDefaultStyle) {
17080   FormatStyle Style = getGNUStyle();
17081   verifyFormat("extern \"C\"\n"
17082                "{\n"
17083                "  int foo ();\n"
17084                "}",
17085                Style);
17086 }
17087 TEST_F(FormatTest, MozillaDefaultStyle) {
17088   FormatStyle Style = getMozillaStyle();
17089   verifyFormat("extern \"C\"\n"
17090                "{\n"
17091                "  int foo();\n"
17092                "}",
17093                Style);
17094 }
17095 TEST_F(FormatTest, GoogleDefaultStyle) {
17096   FormatStyle Style = getGoogleStyle();
17097   verifyFormat("extern \"C\" {\n"
17098                "int foo();\n"
17099                "}",
17100                Style);
17101 }
17102 TEST_F(FormatTest, ChromiumDefaultStyle) {
17103   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
17104   verifyFormat("extern \"C\" {\n"
17105                "int foo();\n"
17106                "}",
17107                Style);
17108 }
17109 TEST_F(FormatTest, MicrosoftDefaultStyle) {
17110   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
17111   verifyFormat("extern \"C\"\n"
17112                "{\n"
17113                "    int foo();\n"
17114                "}",
17115                Style);
17116 }
17117 TEST_F(FormatTest, WebKitDefaultStyle) {
17118   FormatStyle Style = getWebKitStyle();
17119   verifyFormat("extern \"C\" {\n"
17120                "int foo();\n"
17121                "}",
17122                Style);
17123 }
17124 } // namespace
17125 } // namespace format
17126 } // namespace clang
17127