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