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 
2748 TEST_F(FormatTest, FormatSEHTryCatch) {
2749   verifyFormat("__try {\n"
2750                "  int a = b * c;\n"
2751                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2752                "  // Do nothing.\n"
2753                "}");
2754 
2755   verifyFormat("__try {\n"
2756                "  int a = b * c;\n"
2757                "} __finally {\n"
2758                "  // Do nothing.\n"
2759                "}");
2760 
2761   verifyFormat("DEBUG({\n"
2762                "  __try {\n"
2763                "  } __finally {\n"
2764                "  }\n"
2765                "});\n");
2766 }
2767 
2768 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2769   verifyFormat("try {\n"
2770                "  f();\n"
2771                "} catch {\n"
2772                "  g();\n"
2773                "}");
2774   verifyFormat("try {\n"
2775                "  f();\n"
2776                "} catch (A a) MACRO(x) {\n"
2777                "  g();\n"
2778                "} catch (B b) MACRO(x) {\n"
2779                "  g();\n"
2780                "}");
2781 }
2782 
2783 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2784   FormatStyle Style = getLLVMStyle();
2785   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2786                           FormatStyle::BS_WebKit}) {
2787     Style.BreakBeforeBraces = BraceStyle;
2788     verifyFormat("try {\n"
2789                  "  // something\n"
2790                  "} catch (...) {\n"
2791                  "  // something\n"
2792                  "}",
2793                  Style);
2794   }
2795   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2796   verifyFormat("try {\n"
2797                "  // something\n"
2798                "}\n"
2799                "catch (...) {\n"
2800                "  // something\n"
2801                "}",
2802                Style);
2803   verifyFormat("__try {\n"
2804                "  // something\n"
2805                "}\n"
2806                "__finally {\n"
2807                "  // something\n"
2808                "}",
2809                Style);
2810   verifyFormat("@try {\n"
2811                "  // something\n"
2812                "}\n"
2813                "@finally {\n"
2814                "  // something\n"
2815                "}",
2816                Style);
2817   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2818   verifyFormat("try\n"
2819                "{\n"
2820                "  // something\n"
2821                "}\n"
2822                "catch (...)\n"
2823                "{\n"
2824                "  // something\n"
2825                "}",
2826                Style);
2827   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2828   verifyFormat("try\n"
2829                "  {\n"
2830                "  // something white\n"
2831                "  }\n"
2832                "catch (...)\n"
2833                "  {\n"
2834                "  // something white\n"
2835                "  }",
2836                Style);
2837   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2838   verifyFormat("try\n"
2839                "  {\n"
2840                "    // something\n"
2841                "  }\n"
2842                "catch (...)\n"
2843                "  {\n"
2844                "    // something\n"
2845                "  }",
2846                Style);
2847   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2848   Style.BraceWrapping.BeforeCatch = true;
2849   verifyFormat("try {\n"
2850                "  // something\n"
2851                "}\n"
2852                "catch (...) {\n"
2853                "  // something\n"
2854                "}",
2855                Style);
2856 }
2857 
2858 TEST_F(FormatTest, StaticInitializers) {
2859   verifyFormat("static SomeClass SC = {1, 'a'};");
2860 
2861   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2862                "    100000000, "
2863                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2864 
2865   // Here, everything other than the "}" would fit on a line.
2866   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2867                "    10000000000000000000000000};");
2868   EXPECT_EQ("S s = {a,\n"
2869             "\n"
2870             "       b};",
2871             format("S s = {\n"
2872                    "  a,\n"
2873                    "\n"
2874                    "  b\n"
2875                    "};"));
2876 
2877   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2878   // line. However, the formatting looks a bit off and this probably doesn't
2879   // happen often in practice.
2880   verifyFormat("static int Variable[1] = {\n"
2881                "    {1000000000000000000000000000000000000}};",
2882                getLLVMStyleWithColumns(40));
2883 }
2884 
2885 TEST_F(FormatTest, DesignatedInitializers) {
2886   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2887   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2888                "                    .bbbbbbbbbb = 2,\n"
2889                "                    .cccccccccc = 3,\n"
2890                "                    .dddddddddd = 4,\n"
2891                "                    .eeeeeeeeee = 5};");
2892   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2893                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2894                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2895                "    .ccccccccccccccccccccccccccc = 3,\n"
2896                "    .ddddddddddddddddddddddddddd = 4,\n"
2897                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2898 
2899   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2900 
2901   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2902   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2903                "                    [2] = bbbbbbbbbb,\n"
2904                "                    [3] = cccccccccc,\n"
2905                "                    [4] = dddddddddd,\n"
2906                "                    [5] = eeeeeeeeee};");
2907   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2908                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2909                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2910                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2911                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2912                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2913 }
2914 
2915 TEST_F(FormatTest, NestedStaticInitializers) {
2916   verifyFormat("static A x = {{{}}};\n");
2917   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2918                "               {init1, init2, init3, init4}}};",
2919                getLLVMStyleWithColumns(50));
2920 
2921   verifyFormat("somes Status::global_reps[3] = {\n"
2922                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2923                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2924                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2925                getLLVMStyleWithColumns(60));
2926   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2927                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2928                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2929                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2930   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2931                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
2932                "rect.fTop}};");
2933 
2934   verifyFormat(
2935       "SomeArrayOfSomeType a = {\n"
2936       "    {{1, 2, 3},\n"
2937       "     {1, 2, 3},\n"
2938       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
2939       "      333333333333333333333333333333},\n"
2940       "     {1, 2, 3},\n"
2941       "     {1, 2, 3}}};");
2942   verifyFormat(
2943       "SomeArrayOfSomeType a = {\n"
2944       "    {{1, 2, 3}},\n"
2945       "    {{1, 2, 3}},\n"
2946       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2947       "      333333333333333333333333333333}},\n"
2948       "    {{1, 2, 3}},\n"
2949       "    {{1, 2, 3}}};");
2950 
2951   verifyFormat("struct {\n"
2952                "  unsigned bit;\n"
2953                "  const char *const name;\n"
2954                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2955                "                 {kOsWin, \"Windows\"},\n"
2956                "                 {kOsLinux, \"Linux\"},\n"
2957                "                 {kOsCrOS, \"Chrome OS\"}};");
2958   verifyFormat("struct {\n"
2959                "  unsigned bit;\n"
2960                "  const char *const name;\n"
2961                "} kBitsToOs[] = {\n"
2962                "    {kOsMac, \"Mac\"},\n"
2963                "    {kOsWin, \"Windows\"},\n"
2964                "    {kOsLinux, \"Linux\"},\n"
2965                "    {kOsCrOS, \"Chrome OS\"},\n"
2966                "};");
2967 }
2968 
2969 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2970   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2971                "                      \\\n"
2972                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2973 }
2974 
2975 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
2976   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2977                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
2978 
2979   // Do break defaulted and deleted functions.
2980   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2981                "    default;",
2982                getLLVMStyleWithColumns(40));
2983   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2984                "    delete;",
2985                getLLVMStyleWithColumns(40));
2986 }
2987 
2988 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2989   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2990                getLLVMStyleWithColumns(40));
2991   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2992                getLLVMStyleWithColumns(40));
2993   EXPECT_EQ("#define Q                              \\\n"
2994             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
2995             "  \"aaaaaaaa.cpp\"",
2996             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2997                    getLLVMStyleWithColumns(40)));
2998 }
2999 
3000 TEST_F(FormatTest, UnderstandsLinePPDirective) {
3001   EXPECT_EQ("# 123 \"A string literal\"",
3002             format("   #     123    \"A string literal\""));
3003 }
3004 
3005 TEST_F(FormatTest, LayoutUnknownPPDirective) {
3006   EXPECT_EQ("#;", format("#;"));
3007   verifyFormat("#\n;\n;\n;");
3008 }
3009 
3010 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
3011   EXPECT_EQ("#line 42 \"test\"\n",
3012             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
3013   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
3014                                     getLLVMStyleWithColumns(12)));
3015 }
3016 
3017 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
3018   EXPECT_EQ("#line 42 \"test\"",
3019             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
3020   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
3021 }
3022 
3023 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
3024   verifyFormat("#define A \\x20");
3025   verifyFormat("#define A \\ x20");
3026   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
3027   verifyFormat("#define A ''");
3028   verifyFormat("#define A ''qqq");
3029   verifyFormat("#define A `qqq");
3030   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
3031   EXPECT_EQ("const char *c = STRINGIFY(\n"
3032             "\\na : b);",
3033             format("const char * c = STRINGIFY(\n"
3034                    "\\na : b);"));
3035 
3036   verifyFormat("a\r\\");
3037   verifyFormat("a\v\\");
3038   verifyFormat("a\f\\");
3039 }
3040 
3041 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
3042   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
3043   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
3044   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
3045   // FIXME: We never break before the macro name.
3046   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
3047 
3048   verifyFormat("#define A A\n#define A A");
3049   verifyFormat("#define A(X) A\n#define A A");
3050 
3051   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
3052   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
3053 }
3054 
3055 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
3056   EXPECT_EQ("// somecomment\n"
3057             "#include \"a.h\"\n"
3058             "#define A(  \\\n"
3059             "    A, B)\n"
3060             "#include \"b.h\"\n"
3061             "// somecomment\n",
3062             format("  // somecomment\n"
3063                    "  #include \"a.h\"\n"
3064                    "#define A(A,\\\n"
3065                    "    B)\n"
3066                    "    #include \"b.h\"\n"
3067                    " // somecomment\n",
3068                    getLLVMStyleWithColumns(13)));
3069 }
3070 
3071 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
3072 
3073 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
3074   EXPECT_EQ("#define A    \\\n"
3075             "  c;         \\\n"
3076             "  e;\n"
3077             "f;",
3078             format("#define A c; e;\n"
3079                    "f;",
3080                    getLLVMStyleWithColumns(14)));
3081 }
3082 
3083 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
3084 
3085 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
3086   EXPECT_EQ("int x,\n"
3087             "#define A\n"
3088             "    y;",
3089             format("int x,\n#define A\ny;"));
3090 }
3091 
3092 TEST_F(FormatTest, HashInMacroDefinition) {
3093   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
3094   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
3095   verifyFormat("#define A  \\\n"
3096                "  {        \\\n"
3097                "    f(#c); \\\n"
3098                "  }",
3099                getLLVMStyleWithColumns(11));
3100 
3101   verifyFormat("#define A(X)         \\\n"
3102                "  void function##X()",
3103                getLLVMStyleWithColumns(22));
3104 
3105   verifyFormat("#define A(a, b, c)   \\\n"
3106                "  void a##b##c()",
3107                getLLVMStyleWithColumns(22));
3108 
3109   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
3110 }
3111 
3112 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
3113   EXPECT_EQ("#define A (x)", format("#define A (x)"));
3114   EXPECT_EQ("#define A(x)", format("#define A(x)"));
3115 
3116   FormatStyle Style = getLLVMStyle();
3117   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
3118   verifyFormat("#define true ((foo)1)", Style);
3119   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
3120   verifyFormat("#define false((foo)0)", Style);
3121 }
3122 
3123 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
3124   EXPECT_EQ("#define A b;", format("#define A \\\n"
3125                                    "          \\\n"
3126                                    "  b;",
3127                                    getLLVMStyleWithColumns(25)));
3128   EXPECT_EQ("#define A \\\n"
3129             "          \\\n"
3130             "  a;      \\\n"
3131             "  b;",
3132             format("#define A \\\n"
3133                    "          \\\n"
3134                    "  a;      \\\n"
3135                    "  b;",
3136                    getLLVMStyleWithColumns(11)));
3137   EXPECT_EQ("#define A \\\n"
3138             "  a;      \\\n"
3139             "          \\\n"
3140             "  b;",
3141             format("#define A \\\n"
3142                    "  a;      \\\n"
3143                    "          \\\n"
3144                    "  b;",
3145                    getLLVMStyleWithColumns(11)));
3146 }
3147 
3148 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
3149   verifyIncompleteFormat("#define A :");
3150   verifyFormat("#define SOMECASES  \\\n"
3151                "  case 1:          \\\n"
3152                "  case 2\n",
3153                getLLVMStyleWithColumns(20));
3154   verifyFormat("#define MACRO(a) \\\n"
3155                "  if (a)         \\\n"
3156                "    f();         \\\n"
3157                "  else           \\\n"
3158                "    g()",
3159                getLLVMStyleWithColumns(18));
3160   verifyFormat("#define A template <typename T>");
3161   verifyIncompleteFormat("#define STR(x) #x\n"
3162                          "f(STR(this_is_a_string_literal{));");
3163   verifyFormat("#pragma omp threadprivate( \\\n"
3164                "    y)), // expected-warning",
3165                getLLVMStyleWithColumns(28));
3166   verifyFormat("#d, = };");
3167   verifyFormat("#if \"a");
3168   verifyIncompleteFormat("({\n"
3169                          "#define b     \\\n"
3170                          "  }           \\\n"
3171                          "  a\n"
3172                          "a",
3173                          getLLVMStyleWithColumns(15));
3174   verifyFormat("#define A     \\\n"
3175                "  {           \\\n"
3176                "    {\n"
3177                "#define B     \\\n"
3178                "  }           \\\n"
3179                "  }",
3180                getLLVMStyleWithColumns(15));
3181   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
3182   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
3183   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
3184   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
3185 }
3186 
3187 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
3188   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
3189   EXPECT_EQ("class A : public QObject {\n"
3190             "  Q_OBJECT\n"
3191             "\n"
3192             "  A() {}\n"
3193             "};",
3194             format("class A  :  public QObject {\n"
3195                    "     Q_OBJECT\n"
3196                    "\n"
3197                    "  A() {\n}\n"
3198                    "}  ;"));
3199   EXPECT_EQ("MACRO\n"
3200             "/*static*/ int i;",
3201             format("MACRO\n"
3202                    " /*static*/ int   i;"));
3203   EXPECT_EQ("SOME_MACRO\n"
3204             "namespace {\n"
3205             "void f();\n"
3206             "} // namespace",
3207             format("SOME_MACRO\n"
3208                    "  namespace    {\n"
3209                    "void   f(  );\n"
3210                    "} // namespace"));
3211   // Only if the identifier contains at least 5 characters.
3212   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
3213   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
3214   // Only if everything is upper case.
3215   EXPECT_EQ("class A : public QObject {\n"
3216             "  Q_Object A() {}\n"
3217             "};",
3218             format("class A  :  public QObject {\n"
3219                    "     Q_Object\n"
3220                    "  A() {\n}\n"
3221                    "}  ;"));
3222 
3223   // Only if the next line can actually start an unwrapped line.
3224   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
3225             format("SOME_WEIRD_LOG_MACRO\n"
3226                    "<< SomeThing;"));
3227 
3228   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3229                "(n, buffers))\n",
3230                getChromiumStyle(FormatStyle::LK_Cpp));
3231 
3232   // See PR41483
3233   EXPECT_EQ("/**/ FOO(a)\n"
3234             "FOO(b)",
3235             format("/**/ FOO(a)\n"
3236                    "FOO(b)"));
3237 }
3238 
3239 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
3240   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3241             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3242             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3243             "class X {};\n"
3244             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3245             "int *createScopDetectionPass() { return 0; }",
3246             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3247                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3248                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3249                    "  class X {};\n"
3250                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3251                    "  int *createScopDetectionPass() { return 0; }"));
3252   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
3253   // braces, so that inner block is indented one level more.
3254   EXPECT_EQ("int q() {\n"
3255             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3256             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3257             "  IPC_END_MESSAGE_MAP()\n"
3258             "}",
3259             format("int q() {\n"
3260                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3261                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3262                    "  IPC_END_MESSAGE_MAP()\n"
3263                    "}"));
3264 
3265   // Same inside macros.
3266   EXPECT_EQ("#define LIST(L) \\\n"
3267             "  L(A)          \\\n"
3268             "  L(B)          \\\n"
3269             "  L(C)",
3270             format("#define LIST(L) \\\n"
3271                    "  L(A) \\\n"
3272                    "  L(B) \\\n"
3273                    "  L(C)",
3274                    getGoogleStyle()));
3275 
3276   // These must not be recognized as macros.
3277   EXPECT_EQ("int q() {\n"
3278             "  f(x);\n"
3279             "  f(x) {}\n"
3280             "  f(x)->g();\n"
3281             "  f(x)->*g();\n"
3282             "  f(x).g();\n"
3283             "  f(x) = x;\n"
3284             "  f(x) += x;\n"
3285             "  f(x) -= x;\n"
3286             "  f(x) *= x;\n"
3287             "  f(x) /= x;\n"
3288             "  f(x) %= x;\n"
3289             "  f(x) &= x;\n"
3290             "  f(x) |= x;\n"
3291             "  f(x) ^= x;\n"
3292             "  f(x) >>= x;\n"
3293             "  f(x) <<= x;\n"
3294             "  f(x)[y].z();\n"
3295             "  LOG(INFO) << x;\n"
3296             "  ifstream(x) >> x;\n"
3297             "}\n",
3298             format("int q() {\n"
3299                    "  f(x)\n;\n"
3300                    "  f(x)\n {}\n"
3301                    "  f(x)\n->g();\n"
3302                    "  f(x)\n->*g();\n"
3303                    "  f(x)\n.g();\n"
3304                    "  f(x)\n = x;\n"
3305                    "  f(x)\n += x;\n"
3306                    "  f(x)\n -= x;\n"
3307                    "  f(x)\n *= x;\n"
3308                    "  f(x)\n /= x;\n"
3309                    "  f(x)\n %= x;\n"
3310                    "  f(x)\n &= x;\n"
3311                    "  f(x)\n |= x;\n"
3312                    "  f(x)\n ^= x;\n"
3313                    "  f(x)\n >>= x;\n"
3314                    "  f(x)\n <<= x;\n"
3315                    "  f(x)\n[y].z();\n"
3316                    "  LOG(INFO)\n << x;\n"
3317                    "  ifstream(x)\n >> x;\n"
3318                    "}\n"));
3319   EXPECT_EQ("int q() {\n"
3320             "  F(x)\n"
3321             "  if (1) {\n"
3322             "  }\n"
3323             "  F(x)\n"
3324             "  while (1) {\n"
3325             "  }\n"
3326             "  F(x)\n"
3327             "  G(x);\n"
3328             "  F(x)\n"
3329             "  try {\n"
3330             "    Q();\n"
3331             "  } catch (...) {\n"
3332             "  }\n"
3333             "}\n",
3334             format("int q() {\n"
3335                    "F(x)\n"
3336                    "if (1) {}\n"
3337                    "F(x)\n"
3338                    "while (1) {}\n"
3339                    "F(x)\n"
3340                    "G(x);\n"
3341                    "F(x)\n"
3342                    "try { Q(); } catch (...) {}\n"
3343                    "}\n"));
3344   EXPECT_EQ("class A {\n"
3345             "  A() : t(0) {}\n"
3346             "  A(int i) noexcept() : {}\n"
3347             "  A(X x)\n" // FIXME: function-level try blocks are broken.
3348             "  try : t(0) {\n"
3349             "  } catch (...) {\n"
3350             "  }\n"
3351             "};",
3352             format("class A {\n"
3353                    "  A()\n : t(0) {}\n"
3354                    "  A(int i)\n noexcept() : {}\n"
3355                    "  A(X x)\n"
3356                    "  try : t(0) {} catch (...) {}\n"
3357                    "};"));
3358   FormatStyle Style = getLLVMStyle();
3359   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3360   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3361   Style.BraceWrapping.AfterFunction = true;
3362   EXPECT_EQ("void f()\n"
3363             "try\n"
3364             "{\n"
3365             "}",
3366             format("void f() try {\n"
3367                    "}",
3368                    Style));
3369   EXPECT_EQ("class SomeClass {\n"
3370             "public:\n"
3371             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3372             "};",
3373             format("class SomeClass {\n"
3374                    "public:\n"
3375                    "  SomeClass()\n"
3376                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3377                    "};"));
3378   EXPECT_EQ("class SomeClass {\n"
3379             "public:\n"
3380             "  SomeClass()\n"
3381             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3382             "};",
3383             format("class SomeClass {\n"
3384                    "public:\n"
3385                    "  SomeClass()\n"
3386                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3387                    "};",
3388                    getLLVMStyleWithColumns(40)));
3389 
3390   verifyFormat("MACRO(>)");
3391 
3392   // Some macros contain an implicit semicolon.
3393   Style = getLLVMStyle();
3394   Style.StatementMacros.push_back("FOO");
3395   verifyFormat("FOO(a) int b = 0;");
3396   verifyFormat("FOO(a)\n"
3397                "int b = 0;",
3398                Style);
3399   verifyFormat("FOO(a);\n"
3400                "int b = 0;",
3401                Style);
3402   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3403                "int b = 0;",
3404                Style);
3405   verifyFormat("FOO()\n"
3406                "int b = 0;",
3407                Style);
3408   verifyFormat("FOO\n"
3409                "int b = 0;",
3410                Style);
3411   verifyFormat("void f() {\n"
3412                "  FOO(a)\n"
3413                "  return a;\n"
3414                "}",
3415                Style);
3416   verifyFormat("FOO(a)\n"
3417                "FOO(b)",
3418                Style);
3419   verifyFormat("int a = 0;\n"
3420                "FOO(b)\n"
3421                "int c = 0;",
3422                Style);
3423   verifyFormat("int a = 0;\n"
3424                "int x = FOO(a)\n"
3425                "int b = 0;",
3426                Style);
3427   verifyFormat("void foo(int a) { FOO(a) }\n"
3428                "uint32_t bar() {}",
3429                Style);
3430 }
3431 
3432 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3433   verifyFormat("#define A \\\n"
3434                "  f({     \\\n"
3435                "    g();  \\\n"
3436                "  });",
3437                getLLVMStyleWithColumns(11));
3438 }
3439 
3440 TEST_F(FormatTest, IndentPreprocessorDirectives) {
3441   FormatStyle Style = getLLVMStyle();
3442   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3443   Style.ColumnLimit = 40;
3444   verifyFormat("#ifdef _WIN32\n"
3445                "#define A 0\n"
3446                "#ifdef VAR2\n"
3447                "#define B 1\n"
3448                "#include <someheader.h>\n"
3449                "#define MACRO                          \\\n"
3450                "  some_very_long_func_aaaaaaaaaa();\n"
3451                "#endif\n"
3452                "#else\n"
3453                "#define A 1\n"
3454                "#endif",
3455                Style);
3456   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3457   verifyFormat("#ifdef _WIN32\n"
3458                "#  define A 0\n"
3459                "#  ifdef VAR2\n"
3460                "#    define B 1\n"
3461                "#    include <someheader.h>\n"
3462                "#    define MACRO                      \\\n"
3463                "      some_very_long_func_aaaaaaaaaa();\n"
3464                "#  endif\n"
3465                "#else\n"
3466                "#  define A 1\n"
3467                "#endif",
3468                Style);
3469   verifyFormat("#if A\n"
3470                "#  define MACRO                        \\\n"
3471                "    void a(int x) {                    \\\n"
3472                "      b();                             \\\n"
3473                "      c();                             \\\n"
3474                "      d();                             \\\n"
3475                "      e();                             \\\n"
3476                "      f();                             \\\n"
3477                "    }\n"
3478                "#endif",
3479                Style);
3480   // Comments before include guard.
3481   verifyFormat("// file comment\n"
3482                "// file comment\n"
3483                "#ifndef HEADER_H\n"
3484                "#define HEADER_H\n"
3485                "code();\n"
3486                "#endif",
3487                Style);
3488   // Test with include guards.
3489   verifyFormat("#ifndef HEADER_H\n"
3490                "#define HEADER_H\n"
3491                "code();\n"
3492                "#endif",
3493                Style);
3494   // Include guards must have a #define with the same variable immediately
3495   // after #ifndef.
3496   verifyFormat("#ifndef NOT_GUARD\n"
3497                "#  define FOO\n"
3498                "code();\n"
3499                "#endif",
3500                Style);
3501 
3502   // Include guards must cover the entire file.
3503   verifyFormat("code();\n"
3504                "code();\n"
3505                "#ifndef NOT_GUARD\n"
3506                "#  define NOT_GUARD\n"
3507                "code();\n"
3508                "#endif",
3509                Style);
3510   verifyFormat("#ifndef NOT_GUARD\n"
3511                "#  define NOT_GUARD\n"
3512                "code();\n"
3513                "#endif\n"
3514                "code();",
3515                Style);
3516   // Test with trailing blank lines.
3517   verifyFormat("#ifndef HEADER_H\n"
3518                "#define HEADER_H\n"
3519                "code();\n"
3520                "#endif\n",
3521                Style);
3522   // Include guards don't have #else.
3523   verifyFormat("#ifndef NOT_GUARD\n"
3524                "#  define NOT_GUARD\n"
3525                "code();\n"
3526                "#else\n"
3527                "#endif",
3528                Style);
3529   verifyFormat("#ifndef NOT_GUARD\n"
3530                "#  define NOT_GUARD\n"
3531                "code();\n"
3532                "#elif FOO\n"
3533                "#endif",
3534                Style);
3535   // Non-identifier #define after potential include guard.
3536   verifyFormat("#ifndef FOO\n"
3537                "#  define 1\n"
3538                "#endif\n",
3539                Style);
3540   // #if closes past last non-preprocessor line.
3541   verifyFormat("#ifndef FOO\n"
3542                "#define FOO\n"
3543                "#if 1\n"
3544                "int i;\n"
3545                "#  define A 0\n"
3546                "#endif\n"
3547                "#endif\n",
3548                Style);
3549   // Don't crash if there is an #elif directive without a condition.
3550   verifyFormat("#if 1\n"
3551                "int x;\n"
3552                "#elif\n"
3553                "int y;\n"
3554                "#else\n"
3555                "int z;\n"
3556                "#endif",
3557                Style);
3558   // FIXME: This doesn't handle the case where there's code between the
3559   // #ifndef and #define but all other conditions hold. This is because when
3560   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3561   // previous code line yet, so we can't detect it.
3562   EXPECT_EQ("#ifndef NOT_GUARD\n"
3563             "code();\n"
3564             "#define NOT_GUARD\n"
3565             "code();\n"
3566             "#endif",
3567             format("#ifndef NOT_GUARD\n"
3568                    "code();\n"
3569                    "#  define NOT_GUARD\n"
3570                    "code();\n"
3571                    "#endif",
3572                    Style));
3573   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3574   // be outside an include guard. Examples are #pragma once and
3575   // #pragma GCC diagnostic, or anything else that does not change the meaning
3576   // of the file if it's included multiple times.
3577   EXPECT_EQ("#ifdef WIN32\n"
3578             "#  pragma once\n"
3579             "#endif\n"
3580             "#ifndef HEADER_H\n"
3581             "#  define HEADER_H\n"
3582             "code();\n"
3583             "#endif",
3584             format("#ifdef WIN32\n"
3585                    "#  pragma once\n"
3586                    "#endif\n"
3587                    "#ifndef HEADER_H\n"
3588                    "#define HEADER_H\n"
3589                    "code();\n"
3590                    "#endif",
3591                    Style));
3592   // FIXME: This does not detect when there is a single non-preprocessor line
3593   // in front of an include-guard-like structure where other conditions hold
3594   // because ScopedLineState hides the line.
3595   EXPECT_EQ("code();\n"
3596             "#ifndef HEADER_H\n"
3597             "#define HEADER_H\n"
3598             "code();\n"
3599             "#endif",
3600             format("code();\n"
3601                    "#ifndef HEADER_H\n"
3602                    "#  define HEADER_H\n"
3603                    "code();\n"
3604                    "#endif",
3605                    Style));
3606   // Keep comments aligned with #, otherwise indent comments normally. These
3607   // tests cannot use verifyFormat because messUp manipulates leading
3608   // whitespace.
3609   {
3610     const char *Expected = ""
3611                            "void f() {\n"
3612                            "#if 1\n"
3613                            "// Preprocessor aligned.\n"
3614                            "#  define A 0\n"
3615                            "  // Code. Separated by blank line.\n"
3616                            "\n"
3617                            "#  define B 0\n"
3618                            "  // Code. Not aligned with #\n"
3619                            "#  define C 0\n"
3620                            "#endif";
3621     const char *ToFormat = ""
3622                            "void f() {\n"
3623                            "#if 1\n"
3624                            "// Preprocessor aligned.\n"
3625                            "#  define A 0\n"
3626                            "// Code. Separated by blank line.\n"
3627                            "\n"
3628                            "#  define B 0\n"
3629                            "   // Code. Not aligned with #\n"
3630                            "#  define C 0\n"
3631                            "#endif";
3632     EXPECT_EQ(Expected, format(ToFormat, Style));
3633     EXPECT_EQ(Expected, format(Expected, Style));
3634   }
3635   // Keep block quotes aligned.
3636   {
3637     const char *Expected = ""
3638                            "void f() {\n"
3639                            "#if 1\n"
3640                            "/* Preprocessor aligned. */\n"
3641                            "#  define A 0\n"
3642                            "  /* Code. Separated by blank line. */\n"
3643                            "\n"
3644                            "#  define B 0\n"
3645                            "  /* Code. Not aligned with # */\n"
3646                            "#  define C 0\n"
3647                            "#endif";
3648     const char *ToFormat = ""
3649                            "void f() {\n"
3650                            "#if 1\n"
3651                            "/* Preprocessor aligned. */\n"
3652                            "#  define A 0\n"
3653                            "/* Code. Separated by blank line. */\n"
3654                            "\n"
3655                            "#  define B 0\n"
3656                            "   /* Code. Not aligned with # */\n"
3657                            "#  define C 0\n"
3658                            "#endif";
3659     EXPECT_EQ(Expected, format(ToFormat, Style));
3660     EXPECT_EQ(Expected, format(Expected, Style));
3661   }
3662   // Keep comments aligned with un-indented directives.
3663   {
3664     const char *Expected = ""
3665                            "void f() {\n"
3666                            "// Preprocessor aligned.\n"
3667                            "#define A 0\n"
3668                            "  // Code. Separated by blank line.\n"
3669                            "\n"
3670                            "#define B 0\n"
3671                            "  // Code. Not aligned with #\n"
3672                            "#define C 0\n";
3673     const char *ToFormat = ""
3674                            "void f() {\n"
3675                            "// Preprocessor aligned.\n"
3676                            "#define A 0\n"
3677                            "// Code. Separated by blank line.\n"
3678                            "\n"
3679                            "#define B 0\n"
3680                            "   // Code. Not aligned with #\n"
3681                            "#define C 0\n";
3682     EXPECT_EQ(Expected, format(ToFormat, Style));
3683     EXPECT_EQ(Expected, format(Expected, Style));
3684   }
3685   // Test AfterHash with tabs.
3686   {
3687     FormatStyle Tabbed = Style;
3688     Tabbed.UseTab = FormatStyle::UT_Always;
3689     Tabbed.IndentWidth = 8;
3690     Tabbed.TabWidth = 8;
3691     verifyFormat("#ifdef _WIN32\n"
3692                  "#\tdefine A 0\n"
3693                  "#\tifdef VAR2\n"
3694                  "#\t\tdefine B 1\n"
3695                  "#\t\tinclude <someheader.h>\n"
3696                  "#\t\tdefine MACRO          \\\n"
3697                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3698                  "#\tendif\n"
3699                  "#else\n"
3700                  "#\tdefine A 1\n"
3701                  "#endif",
3702                  Tabbed);
3703   }
3704 
3705   // Regression test: Multiline-macro inside include guards.
3706   verifyFormat("#ifndef HEADER_H\n"
3707                "#define HEADER_H\n"
3708                "#define A()        \\\n"
3709                "  int i;           \\\n"
3710                "  int j;\n"
3711                "#endif // HEADER_H",
3712                getLLVMStyleWithColumns(20));
3713 
3714   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3715   // Basic before hash indent tests
3716   verifyFormat("#ifdef _WIN32\n"
3717                "  #define A 0\n"
3718                "  #ifdef VAR2\n"
3719                "    #define B 1\n"
3720                "    #include <someheader.h>\n"
3721                "    #define MACRO                      \\\n"
3722                "      some_very_long_func_aaaaaaaaaa();\n"
3723                "  #endif\n"
3724                "#else\n"
3725                "  #define A 1\n"
3726                "#endif",
3727                Style);
3728   verifyFormat("#if A\n"
3729                "  #define MACRO                        \\\n"
3730                "    void a(int x) {                    \\\n"
3731                "      b();                             \\\n"
3732                "      c();                             \\\n"
3733                "      d();                             \\\n"
3734                "      e();                             \\\n"
3735                "      f();                             \\\n"
3736                "    }\n"
3737                "#endif",
3738                Style);
3739   // Keep comments aligned with indented directives. These
3740   // tests cannot use verifyFormat because messUp manipulates leading
3741   // whitespace.
3742   {
3743     const char *Expected = "void f() {\n"
3744                            "// Aligned to preprocessor.\n"
3745                            "#if 1\n"
3746                            "  // Aligned to code.\n"
3747                            "  int a;\n"
3748                            "  #if 1\n"
3749                            "    // Aligned to preprocessor.\n"
3750                            "    #define A 0\n"
3751                            "  // Aligned to code.\n"
3752                            "  int b;\n"
3753                            "  #endif\n"
3754                            "#endif\n"
3755                            "}";
3756     const char *ToFormat = "void f() {\n"
3757                            "// Aligned to preprocessor.\n"
3758                            "#if 1\n"
3759                            "// Aligned to code.\n"
3760                            "int a;\n"
3761                            "#if 1\n"
3762                            "// Aligned to preprocessor.\n"
3763                            "#define A 0\n"
3764                            "// Aligned to code.\n"
3765                            "int b;\n"
3766                            "#endif\n"
3767                            "#endif\n"
3768                            "}";
3769     EXPECT_EQ(Expected, format(ToFormat, Style));
3770     EXPECT_EQ(Expected, format(Expected, Style));
3771   }
3772   {
3773     const char *Expected = "void f() {\n"
3774                            "/* Aligned to preprocessor. */\n"
3775                            "#if 1\n"
3776                            "  /* Aligned to code. */\n"
3777                            "  int a;\n"
3778                            "  #if 1\n"
3779                            "    /* Aligned to preprocessor. */\n"
3780                            "    #define A 0\n"
3781                            "  /* Aligned to code. */\n"
3782                            "  int b;\n"
3783                            "  #endif\n"
3784                            "#endif\n"
3785                            "}";
3786     const char *ToFormat = "void f() {\n"
3787                            "/* Aligned to preprocessor. */\n"
3788                            "#if 1\n"
3789                            "/* Aligned to code. */\n"
3790                            "int a;\n"
3791                            "#if 1\n"
3792                            "/* Aligned to preprocessor. */\n"
3793                            "#define A 0\n"
3794                            "/* Aligned to code. */\n"
3795                            "int b;\n"
3796                            "#endif\n"
3797                            "#endif\n"
3798                            "}";
3799     EXPECT_EQ(Expected, format(ToFormat, Style));
3800     EXPECT_EQ(Expected, format(Expected, Style));
3801   }
3802 
3803   // Test single comment before preprocessor
3804   verifyFormat("// Comment\n"
3805                "\n"
3806                "#if 1\n"
3807                "#endif",
3808                Style);
3809 }
3810 
3811 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3812   verifyFormat("{\n  { a #c; }\n}");
3813 }
3814 
3815 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3816   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
3817             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3818   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
3819             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3820 }
3821 
3822 TEST_F(FormatTest, EscapedNewlines) {
3823   FormatStyle Narrow = getLLVMStyleWithColumns(11);
3824   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
3825             format("#define A \\\nint i;\\\n  int j;", Narrow));
3826   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3827   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3828   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
3829   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3830 
3831   FormatStyle AlignLeft = getLLVMStyle();
3832   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3833   EXPECT_EQ("#define MACRO(x) \\\n"
3834             "private:         \\\n"
3835             "  int x(int a);\n",
3836             format("#define MACRO(x) \\\n"
3837                    "private:         \\\n"
3838                    "  int x(int a);\n",
3839                    AlignLeft));
3840 
3841   // CRLF line endings
3842   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
3843             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
3844   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3845   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3846   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
3847   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3848   EXPECT_EQ("#define MACRO(x) \\\r\n"
3849             "private:         \\\r\n"
3850             "  int x(int a);\r\n",
3851             format("#define MACRO(x) \\\r\n"
3852                    "private:         \\\r\n"
3853                    "  int x(int a);\r\n",
3854                    AlignLeft));
3855 
3856   FormatStyle DontAlign = getLLVMStyle();
3857   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3858   DontAlign.MaxEmptyLinesToKeep = 3;
3859   // FIXME: can't use verifyFormat here because the newline before
3860   // "public:" is not inserted the first time it's reformatted
3861   EXPECT_EQ("#define A \\\n"
3862             "  class Foo { \\\n"
3863             "    void bar(); \\\n"
3864             "\\\n"
3865             "\\\n"
3866             "\\\n"
3867             "  public: \\\n"
3868             "    void baz(); \\\n"
3869             "  };",
3870             format("#define A \\\n"
3871                    "  class Foo { \\\n"
3872                    "    void bar(); \\\n"
3873                    "\\\n"
3874                    "\\\n"
3875                    "\\\n"
3876                    "  public: \\\n"
3877                    "    void baz(); \\\n"
3878                    "  };",
3879                    DontAlign));
3880 }
3881 
3882 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3883   verifyFormat("#define A \\\n"
3884                "  int v(  \\\n"
3885                "      a); \\\n"
3886                "  int i;",
3887                getLLVMStyleWithColumns(11));
3888 }
3889 
3890 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3891   EXPECT_EQ(
3892       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3893       "                      \\\n"
3894       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3895       "\n"
3896       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3897       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3898       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
3899              "\\\n"
3900              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3901              "  \n"
3902              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3903              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3904 }
3905 
3906 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3907   EXPECT_EQ("int\n"
3908             "#define A\n"
3909             "    a;",
3910             format("int\n#define A\na;"));
3911   verifyFormat("functionCallTo(\n"
3912                "    someOtherFunction(\n"
3913                "        withSomeParameters, whichInSequence,\n"
3914                "        areLongerThanALine(andAnotherCall,\n"
3915                "#define A B\n"
3916                "                           withMoreParamters,\n"
3917                "                           whichStronglyInfluenceTheLayout),\n"
3918                "        andMoreParameters),\n"
3919                "    trailing);",
3920                getLLVMStyleWithColumns(69));
3921   verifyFormat("Foo::Foo()\n"
3922                "#ifdef BAR\n"
3923                "    : baz(0)\n"
3924                "#endif\n"
3925                "{\n"
3926                "}");
3927   verifyFormat("void f() {\n"
3928                "  if (true)\n"
3929                "#ifdef A\n"
3930                "    f(42);\n"
3931                "  x();\n"
3932                "#else\n"
3933                "    g();\n"
3934                "  x();\n"
3935                "#endif\n"
3936                "}");
3937   verifyFormat("void f(param1, param2,\n"
3938                "       param3,\n"
3939                "#ifdef A\n"
3940                "       param4(param5,\n"
3941                "#ifdef A1\n"
3942                "              param6,\n"
3943                "#ifdef A2\n"
3944                "              param7),\n"
3945                "#else\n"
3946                "              param8),\n"
3947                "       param9,\n"
3948                "#endif\n"
3949                "       param10,\n"
3950                "#endif\n"
3951                "       param11)\n"
3952                "#else\n"
3953                "       param12)\n"
3954                "#endif\n"
3955                "{\n"
3956                "  x();\n"
3957                "}",
3958                getLLVMStyleWithColumns(28));
3959   verifyFormat("#if 1\n"
3960                "int i;");
3961   verifyFormat("#if 1\n"
3962                "#endif\n"
3963                "#if 1\n"
3964                "#else\n"
3965                "#endif\n");
3966   verifyFormat("DEBUG({\n"
3967                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3968                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
3969                "});\n"
3970                "#if a\n"
3971                "#else\n"
3972                "#endif");
3973 
3974   verifyIncompleteFormat("void f(\n"
3975                          "#if A\n"
3976                          ");\n"
3977                          "#else\n"
3978                          "#endif");
3979 }
3980 
3981 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
3982   verifyFormat("#endif\n"
3983                "#if B");
3984 }
3985 
3986 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
3987   FormatStyle SingleLine = getLLVMStyle();
3988   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
3989   verifyFormat("#if 0\n"
3990                "#elif 1\n"
3991                "#endif\n"
3992                "void foo() {\n"
3993                "  if (test) foo2();\n"
3994                "}",
3995                SingleLine);
3996 }
3997 
3998 TEST_F(FormatTest, LayoutBlockInsideParens) {
3999   verifyFormat("functionCall({ int i; });");
4000   verifyFormat("functionCall({\n"
4001                "  int i;\n"
4002                "  int j;\n"
4003                "});");
4004   verifyFormat("functionCall(\n"
4005                "    {\n"
4006                "      int i;\n"
4007                "      int j;\n"
4008                "    },\n"
4009                "    aaaa, bbbb, cccc);");
4010   verifyFormat("functionA(functionB({\n"
4011                "            int i;\n"
4012                "            int j;\n"
4013                "          }),\n"
4014                "          aaaa, bbbb, cccc);");
4015   verifyFormat("functionCall(\n"
4016                "    {\n"
4017                "      int i;\n"
4018                "      int j;\n"
4019                "    },\n"
4020                "    aaaa, bbbb, // comment\n"
4021                "    cccc);");
4022   verifyFormat("functionA(functionB({\n"
4023                "            int i;\n"
4024                "            int j;\n"
4025                "          }),\n"
4026                "          aaaa, bbbb, // comment\n"
4027                "          cccc);");
4028   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
4029   verifyFormat("functionCall(aaaa, bbbb, {\n"
4030                "  int i;\n"
4031                "  int j;\n"
4032                "});");
4033   verifyFormat(
4034       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
4035       "    {\n"
4036       "      int i; // break\n"
4037       "    },\n"
4038       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
4039       "                                     ccccccccccccccccc));");
4040   verifyFormat("DEBUG({\n"
4041                "  if (a)\n"
4042                "    f();\n"
4043                "});");
4044 }
4045 
4046 TEST_F(FormatTest, LayoutBlockInsideStatement) {
4047   EXPECT_EQ("SOME_MACRO { int i; }\n"
4048             "int i;",
4049             format("  SOME_MACRO  {int i;}  int i;"));
4050 }
4051 
4052 TEST_F(FormatTest, LayoutNestedBlocks) {
4053   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
4054                "  struct s {\n"
4055                "    int i;\n"
4056                "  };\n"
4057                "  s kBitsToOs[] = {{10}};\n"
4058                "  for (int i = 0; i < 10; ++i)\n"
4059                "    return;\n"
4060                "}");
4061   verifyFormat("call(parameter, {\n"
4062                "  something();\n"
4063                "  // Comment using all columns.\n"
4064                "  somethingelse();\n"
4065                "});",
4066                getLLVMStyleWithColumns(40));
4067   verifyFormat("DEBUG( //\n"
4068                "    { f(); }, a);");
4069   verifyFormat("DEBUG( //\n"
4070                "    {\n"
4071                "      f(); //\n"
4072                "    },\n"
4073                "    a);");
4074 
4075   EXPECT_EQ("call(parameter, {\n"
4076             "  something();\n"
4077             "  // Comment too\n"
4078             "  // looooooooooong.\n"
4079             "  somethingElse();\n"
4080             "});",
4081             format("call(parameter, {\n"
4082                    "  something();\n"
4083                    "  // Comment too looooooooooong.\n"
4084                    "  somethingElse();\n"
4085                    "});",
4086                    getLLVMStyleWithColumns(29)));
4087   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
4088   EXPECT_EQ("DEBUG({ // comment\n"
4089             "  int i;\n"
4090             "});",
4091             format("DEBUG({ // comment\n"
4092                    "int  i;\n"
4093                    "});"));
4094   EXPECT_EQ("DEBUG({\n"
4095             "  int i;\n"
4096             "\n"
4097             "  // comment\n"
4098             "  int j;\n"
4099             "});",
4100             format("DEBUG({\n"
4101                    "  int  i;\n"
4102                    "\n"
4103                    "  // comment\n"
4104                    "  int  j;\n"
4105                    "});"));
4106 
4107   verifyFormat("DEBUG({\n"
4108                "  if (a)\n"
4109                "    return;\n"
4110                "});");
4111   verifyGoogleFormat("DEBUG({\n"
4112                      "  if (a) return;\n"
4113                      "});");
4114   FormatStyle Style = getGoogleStyle();
4115   Style.ColumnLimit = 45;
4116   verifyFormat("Debug(\n"
4117                "    aaaaa,\n"
4118                "    {\n"
4119                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
4120                "    },\n"
4121                "    a);",
4122                Style);
4123 
4124   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
4125 
4126   verifyNoCrash("^{v^{a}}");
4127 }
4128 
4129 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
4130   EXPECT_EQ("#define MACRO()                     \\\n"
4131             "  Debug(aaa, /* force line break */ \\\n"
4132             "        {                           \\\n"
4133             "          int i;                    \\\n"
4134             "          int j;                    \\\n"
4135             "        })",
4136             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
4137                    "          {  int   i;  int  j;   })",
4138                    getGoogleStyle()));
4139 
4140   EXPECT_EQ("#define A                                       \\\n"
4141             "  [] {                                          \\\n"
4142             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
4143             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
4144             "  }",
4145             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4146                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
4147                    getGoogleStyle()));
4148 }
4149 
4150 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
4151   EXPECT_EQ("{}", format("{}"));
4152   verifyFormat("enum E {};");
4153   verifyFormat("enum E {}");
4154   FormatStyle Style = getLLVMStyle();
4155   Style.SpaceInEmptyBlock = true;
4156   EXPECT_EQ("void f() { }", format("void f() {}", Style));
4157   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
4158   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4159 }
4160 
4161 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
4162   FormatStyle Style = getLLVMStyle();
4163   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
4164   Style.MacroBlockEnd = "^[A-Z_]+_END$";
4165   verifyFormat("FOO_BEGIN\n"
4166                "  FOO_ENTRY\n"
4167                "FOO_END",
4168                Style);
4169   verifyFormat("FOO_BEGIN\n"
4170                "  NESTED_FOO_BEGIN\n"
4171                "    NESTED_FOO_ENTRY\n"
4172                "  NESTED_FOO_END\n"
4173                "FOO_END",
4174                Style);
4175   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
4176                "  int x;\n"
4177                "  x = 1;\n"
4178                "FOO_END(Baz)",
4179                Style);
4180 }
4181 
4182 //===----------------------------------------------------------------------===//
4183 // Line break tests.
4184 //===----------------------------------------------------------------------===//
4185 
4186 TEST_F(FormatTest, PreventConfusingIndents) {
4187   verifyFormat(
4188       "void f() {\n"
4189       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
4190       "                         parameter, parameter, parameter)),\n"
4191       "                     SecondLongCall(parameter));\n"
4192       "}");
4193   verifyFormat(
4194       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4195       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4196       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4197       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
4198   verifyFormat(
4199       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4200       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
4201       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4202       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
4203   verifyFormat(
4204       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
4205       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
4206       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
4207       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
4208   verifyFormat("int a = bbbb && ccc &&\n"
4209                "        fffff(\n"
4210                "#define A Just forcing a new line\n"
4211                "            ddd);");
4212 }
4213 
4214 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
4215   verifyFormat(
4216       "bool aaaaaaa =\n"
4217       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
4218       "    bbbbbbbb();");
4219   verifyFormat(
4220       "bool aaaaaaa =\n"
4221       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
4222       "    bbbbbbbb();");
4223 
4224   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4225                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
4226                "    ccccccccc == ddddddddddd;");
4227   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4228                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
4229                "    ccccccccc == ddddddddddd;");
4230   verifyFormat(
4231       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
4232       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
4233       "    ccccccccc == ddddddddddd;");
4234 
4235   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4236                "                 aaaaaa) &&\n"
4237                "         bbbbbb && cccccc;");
4238   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4239                "                 aaaaaa) >>\n"
4240                "         bbbbbb;");
4241   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
4242                "    SourceMgr.getSpellingColumnNumber(\n"
4243                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
4244                "    1);");
4245 
4246   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4247                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
4248                "    cccccc) {\n}");
4249   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4250                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4251                "              cccccc) {\n}");
4252   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4253                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4254                "              cccccc) {\n}");
4255   verifyFormat("b = a &&\n"
4256                "    // Comment\n"
4257                "    b.c && d;");
4258 
4259   // If the LHS of a comparison is not a binary expression itself, the
4260   // additional linebreak confuses many people.
4261   verifyFormat(
4262       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4263       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
4264       "}");
4265   verifyFormat(
4266       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4267       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4268       "}");
4269   verifyFormat(
4270       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
4271       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4272       "}");
4273   verifyFormat(
4274       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4275       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
4276       "}");
4277   // Even explicit parentheses stress the precedence enough to make the
4278   // additional break unnecessary.
4279   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4280                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4281                "}");
4282   // This cases is borderline, but with the indentation it is still readable.
4283   verifyFormat(
4284       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4285       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4286       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4287       "}",
4288       getLLVMStyleWithColumns(75));
4289 
4290   // If the LHS is a binary expression, we should still use the additional break
4291   // as otherwise the formatting hides the operator precedence.
4292   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4293                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4294                "    5) {\n"
4295                "}");
4296   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4297                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4298                "    5) {\n"
4299                "}");
4300 
4301   FormatStyle OnePerLine = getLLVMStyle();
4302   OnePerLine.BinPackParameters = false;
4303   verifyFormat(
4304       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4305       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4306       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4307       OnePerLine);
4308 
4309   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4310                "                .aaa(aaaaaaaaaaaaa) *\n"
4311                "            aaaaaaa +\n"
4312                "        aaaaaaa;",
4313                getLLVMStyleWithColumns(40));
4314 }
4315 
4316 TEST_F(FormatTest, ExpressionIndentation) {
4317   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4318                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4319                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4320                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4321                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4322                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4323                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4324                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4325                "                 ccccccccccccccccccccccccccccccccccccccccc;");
4326   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4327                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4328                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4329                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4330   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4331                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4332                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4333                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4334   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4335                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4336                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4337                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4338   verifyFormat("if () {\n"
4339                "} else if (aaaaa && bbbbb > // break\n"
4340                "                        ccccc) {\n"
4341                "}");
4342   verifyFormat("if () {\n"
4343                "} else if constexpr (aaaaa && bbbbb > // break\n"
4344                "                                  ccccc) {\n"
4345                "}");
4346   verifyFormat("if () {\n"
4347                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4348                "                                  ccccc) {\n"
4349                "}");
4350   verifyFormat("if () {\n"
4351                "} else if (aaaaa &&\n"
4352                "           bbbbb > // break\n"
4353                "               ccccc &&\n"
4354                "           ddddd) {\n"
4355                "}");
4356 
4357   // Presence of a trailing comment used to change indentation of b.
4358   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4359                "       b;\n"
4360                "return aaaaaaaaaaaaaaaaaaa +\n"
4361                "       b; //",
4362                getLLVMStyleWithColumns(30));
4363 }
4364 
4365 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4366   // Not sure what the best system is here. Like this, the LHS can be found
4367   // immediately above an operator (everything with the same or a higher
4368   // indent). The RHS is aligned right of the operator and so compasses
4369   // everything until something with the same indent as the operator is found.
4370   // FIXME: Is this a good system?
4371   FormatStyle Style = getLLVMStyle();
4372   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4373   verifyFormat(
4374       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4375       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4376       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4377       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4378       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4379       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4380       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4381       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4382       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
4383       Style);
4384   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4385                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4386                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4387                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4388                Style);
4389   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4390                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4391                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4392                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4393                Style);
4394   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4395                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4396                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4397                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4398                Style);
4399   verifyFormat("if () {\n"
4400                "} else if (aaaaa\n"
4401                "           && bbbbb // break\n"
4402                "                  > ccccc) {\n"
4403                "}",
4404                Style);
4405   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4406                "       && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4407                Style);
4408   verifyFormat("return (a)\n"
4409                "       // comment\n"
4410                "       + b;",
4411                Style);
4412   verifyFormat(
4413       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4414       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4415       "             + cc;",
4416       Style);
4417 
4418   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4419                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4420                Style);
4421 
4422   // Forced by comments.
4423   verifyFormat(
4424       "unsigned ContentSize =\n"
4425       "    sizeof(int16_t)   // DWARF ARange version number\n"
4426       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4427       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4428       "    + sizeof(int8_t); // Segment Size (in bytes)");
4429 
4430   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4431                "       == boost::fusion::at_c<1>(iiii).second;",
4432                Style);
4433 
4434   Style.ColumnLimit = 60;
4435   verifyFormat("zzzzzzzzzz\n"
4436                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4437                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4438                Style);
4439 
4440   Style.ColumnLimit = 80;
4441   Style.IndentWidth = 4;
4442   Style.TabWidth = 4;
4443   Style.UseTab = FormatStyle::UT_Always;
4444   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4445   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4446   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4447             "\t&& (someOtherLongishConditionPart1\n"
4448             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4449             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4450                    "(someOtherLongishConditionPart1 || "
4451                    "someOtherEvenLongerNestedConditionPart2);",
4452                    Style));
4453 }
4454 
4455 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
4456   FormatStyle Style = getLLVMStyle();
4457   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4458   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
4459 
4460   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4461                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4462                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4463                "              == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4464                "                         * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4465                "                     + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4466                "          && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4467                "                     * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4468                "                 > ccccccccccccccccccccccccccccccccccccccccc;",
4469                Style);
4470   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4471                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4472                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4473                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4474                Style);
4475   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4476                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4477                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4478                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4479                Style);
4480   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4481                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4482                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4483                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4484                Style);
4485   verifyFormat("if () {\n"
4486                "} else if (aaaaa\n"
4487                "           && bbbbb // break\n"
4488                "                  > ccccc) {\n"
4489                "}",
4490                Style);
4491   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4492                "    && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4493                Style);
4494   verifyFormat("return (a)\n"
4495                "     // comment\n"
4496                "     + b;",
4497                Style);
4498   verifyFormat(
4499       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4500       "               * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4501       "           + cc;",
4502       Style);
4503   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
4504                "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4505                "                        : 3333333333333333;",
4506                Style);
4507   verifyFormat(
4508       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
4509       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
4510       "                                             : eeeeeeeeeeeeeeeeee)\n"
4511       "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4512       "                        : 3333333333333333;",
4513       Style);
4514   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4515                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4516                Style);
4517 
4518   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4519                "    == boost::fusion::at_c<1>(iiii).second;",
4520                Style);
4521 
4522   Style.ColumnLimit = 60;
4523   verifyFormat("zzzzzzzzzzzzz\n"
4524                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4525                "   >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4526                Style);
4527 
4528   // Forced by comments.
4529   Style.ColumnLimit = 80;
4530   verifyFormat(
4531       "unsigned ContentSize\n"
4532       "    = sizeof(int16_t) // DWARF ARange version number\n"
4533       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4534       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4535       "    + sizeof(int8_t); // Segment Size (in bytes)",
4536       Style);
4537 
4538   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4539   verifyFormat(
4540       "unsigned ContentSize =\n"
4541       "    sizeof(int16_t)   // DWARF ARange version number\n"
4542       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4543       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4544       "    + sizeof(int8_t); // Segment Size (in bytes)",
4545       Style);
4546 
4547   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4548   verifyFormat(
4549       "unsigned ContentSize =\n"
4550       "    sizeof(int16_t)   // DWARF ARange version number\n"
4551       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4552       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4553       "    + sizeof(int8_t); // Segment Size (in bytes)",
4554       Style);
4555 }
4556 
4557 TEST_F(FormatTest, EnforcedOperatorWraps) {
4558   // Here we'd like to wrap after the || operators, but a comment is forcing an
4559   // earlier wrap.
4560   verifyFormat("bool x = aaaaa //\n"
4561                "         || bbbbb\n"
4562                "         //\n"
4563                "         || cccc;");
4564 }
4565 
4566 TEST_F(FormatTest, NoOperandAlignment) {
4567   FormatStyle Style = getLLVMStyle();
4568   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4569   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4570                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4571                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4572                Style);
4573   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4574   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4575                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4576                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4577                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4578                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4579                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4580                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4581                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4582                "        > ccccccccccccccccccccccccccccccccccccccccc;",
4583                Style);
4584 
4585   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4586                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4587                "    + cc;",
4588                Style);
4589   verifyFormat("int a = aa\n"
4590                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4591                "        * cccccccccccccccccccccccccccccccccccc;\n",
4592                Style);
4593 
4594   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4595   verifyFormat("return (a > b\n"
4596                "    // comment1\n"
4597                "    // comment2\n"
4598                "    || c);",
4599                Style);
4600 }
4601 
4602 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4603   FormatStyle Style = getLLVMStyle();
4604   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4605   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4606                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4607                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4608                Style);
4609 }
4610 
4611 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4612   FormatStyle Style = getLLVMStyle();
4613   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4614   Style.BinPackArguments = false;
4615   Style.ColumnLimit = 40;
4616   verifyFormat("void test() {\n"
4617                "  someFunction(\n"
4618                "      this + argument + is + quite\n"
4619                "      + long + so + it + gets + wrapped\n"
4620                "      + but + remains + bin - packed);\n"
4621                "}",
4622                Style);
4623   verifyFormat("void test() {\n"
4624                "  someFunction(arg1,\n"
4625                "               this + argument + is\n"
4626                "                   + quite + long + so\n"
4627                "                   + it + gets + wrapped\n"
4628                "                   + but + remains + bin\n"
4629                "                   - packed,\n"
4630                "               arg3);\n"
4631                "}",
4632                Style);
4633   verifyFormat("void test() {\n"
4634                "  someFunction(\n"
4635                "      arg1,\n"
4636                "      this + argument + has\n"
4637                "          + anotherFunc(nested,\n"
4638                "                        calls + whose\n"
4639                "                            + arguments\n"
4640                "                            + are + also\n"
4641                "                            + wrapped,\n"
4642                "                        in + addition)\n"
4643                "          + to + being + bin - packed,\n"
4644                "      arg3);\n"
4645                "}",
4646                Style);
4647 
4648   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4649   verifyFormat("void test() {\n"
4650                "  someFunction(\n"
4651                "      arg1,\n"
4652                "      this + argument + has +\n"
4653                "          anotherFunc(nested,\n"
4654                "                      calls + whose +\n"
4655                "                          arguments +\n"
4656                "                          are + also +\n"
4657                "                          wrapped,\n"
4658                "                      in + addition) +\n"
4659                "          to + being + bin - packed,\n"
4660                "      arg3);\n"
4661                "}",
4662                Style);
4663 }
4664 
4665 TEST_F(FormatTest, ConstructorInitializers) {
4666   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4667   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4668                getLLVMStyleWithColumns(45));
4669   verifyFormat("Constructor()\n"
4670                "    : Inttializer(FitsOnTheLine) {}",
4671                getLLVMStyleWithColumns(44));
4672   verifyFormat("Constructor()\n"
4673                "    : Inttializer(FitsOnTheLine) {}",
4674                getLLVMStyleWithColumns(43));
4675 
4676   verifyFormat("template <typename T>\n"
4677                "Constructor() : Initializer(FitsOnTheLine) {}",
4678                getLLVMStyleWithColumns(45));
4679 
4680   verifyFormat(
4681       "SomeClass::Constructor()\n"
4682       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4683 
4684   verifyFormat(
4685       "SomeClass::Constructor()\n"
4686       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4687       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4688   verifyFormat(
4689       "SomeClass::Constructor()\n"
4690       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4691       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4692   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4693                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4694                "    : aaaaaaaaaa(aaaaaa) {}");
4695 
4696   verifyFormat("Constructor()\n"
4697                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4698                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4699                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4700                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
4701 
4702   verifyFormat("Constructor()\n"
4703                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4704                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4705 
4706   verifyFormat("Constructor(int Parameter = 0)\n"
4707                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4708                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4709   verifyFormat("Constructor()\n"
4710                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4711                "}",
4712                getLLVMStyleWithColumns(60));
4713   verifyFormat("Constructor()\n"
4714                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4715                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4716 
4717   // Here a line could be saved by splitting the second initializer onto two
4718   // lines, but that is not desirable.
4719   verifyFormat("Constructor()\n"
4720                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4721                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
4722                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4723 
4724   FormatStyle OnePerLine = getLLVMStyle();
4725   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4726   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4727   verifyFormat("SomeClass::Constructor()\n"
4728                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4729                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4730                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4731                OnePerLine);
4732   verifyFormat("SomeClass::Constructor()\n"
4733                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4734                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4735                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4736                OnePerLine);
4737   verifyFormat("MyClass::MyClass(int var)\n"
4738                "    : some_var_(var),            // 4 space indent\n"
4739                "      some_other_var_(var + 1) { // lined up\n"
4740                "}",
4741                OnePerLine);
4742   verifyFormat("Constructor()\n"
4743                "    : aaaaa(aaaaaa),\n"
4744                "      aaaaa(aaaaaa),\n"
4745                "      aaaaa(aaaaaa),\n"
4746                "      aaaaa(aaaaaa),\n"
4747                "      aaaaa(aaaaaa) {}",
4748                OnePerLine);
4749   verifyFormat("Constructor()\n"
4750                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4751                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
4752                OnePerLine);
4753   OnePerLine.BinPackParameters = false;
4754   verifyFormat(
4755       "Constructor()\n"
4756       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4757       "          aaaaaaaaaaa().aaa(),\n"
4758       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4759       OnePerLine);
4760   OnePerLine.ColumnLimit = 60;
4761   verifyFormat("Constructor()\n"
4762                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4763                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4764                OnePerLine);
4765 
4766   EXPECT_EQ("Constructor()\n"
4767             "    : // Comment forcing unwanted break.\n"
4768             "      aaaa(aaaa) {}",
4769             format("Constructor() :\n"
4770                    "    // Comment forcing unwanted break.\n"
4771                    "    aaaa(aaaa) {}"));
4772 }
4773 
4774 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4775   FormatStyle Style = getLLVMStyle();
4776   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4777   Style.ColumnLimit = 60;
4778   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4779   Style.AllowAllConstructorInitializersOnNextLine = true;
4780   Style.BinPackParameters = false;
4781 
4782   for (int i = 0; i < 4; ++i) {
4783     // Test all combinations of parameters that should not have an effect.
4784     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4785     Style.AllowAllArgumentsOnNextLine = i & 2;
4786 
4787     Style.AllowAllConstructorInitializersOnNextLine = true;
4788     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4789     verifyFormat("Constructor()\n"
4790                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4791                  Style);
4792     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4793 
4794     Style.AllowAllConstructorInitializersOnNextLine = false;
4795     verifyFormat("Constructor()\n"
4796                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4797                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4798                  Style);
4799     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4800 
4801     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4802     Style.AllowAllConstructorInitializersOnNextLine = true;
4803     verifyFormat("Constructor()\n"
4804                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4805                  Style);
4806 
4807     Style.AllowAllConstructorInitializersOnNextLine = false;
4808     verifyFormat("Constructor()\n"
4809                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4810                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4811                  Style);
4812 
4813     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4814     Style.AllowAllConstructorInitializersOnNextLine = true;
4815     verifyFormat("Constructor() :\n"
4816                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4817                  Style);
4818 
4819     Style.AllowAllConstructorInitializersOnNextLine = false;
4820     verifyFormat("Constructor() :\n"
4821                  "    aaaaaaaaaaaaaaaaaa(a),\n"
4822                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4823                  Style);
4824   }
4825 
4826   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4827   // AllowAllConstructorInitializersOnNextLine in all
4828   // BreakConstructorInitializers modes
4829   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4830   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4831   Style.AllowAllConstructorInitializersOnNextLine = false;
4832   verifyFormat("SomeClassWithALongName::Constructor(\n"
4833                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4834                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4835                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4836                Style);
4837 
4838   Style.AllowAllConstructorInitializersOnNextLine = true;
4839   verifyFormat("SomeClassWithALongName::Constructor(\n"
4840                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4841                "    int bbbbbbbbbbbbb,\n"
4842                "    int cccccccccccccccc)\n"
4843                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4844                Style);
4845 
4846   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4847   Style.AllowAllConstructorInitializersOnNextLine = false;
4848   verifyFormat("SomeClassWithALongName::Constructor(\n"
4849                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4850                "    int bbbbbbbbbbbbb)\n"
4851                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4852                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4853                Style);
4854 
4855   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4856 
4857   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4858   verifyFormat("SomeClassWithALongName::Constructor(\n"
4859                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4860                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4861                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4862                Style);
4863 
4864   Style.AllowAllConstructorInitializersOnNextLine = true;
4865   verifyFormat("SomeClassWithALongName::Constructor(\n"
4866                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4867                "    int bbbbbbbbbbbbb,\n"
4868                "    int cccccccccccccccc)\n"
4869                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4870                Style);
4871 
4872   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4873   Style.AllowAllConstructorInitializersOnNextLine = false;
4874   verifyFormat("SomeClassWithALongName::Constructor(\n"
4875                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4876                "    int bbbbbbbbbbbbb)\n"
4877                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4878                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4879                Style);
4880 
4881   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4882   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4883   verifyFormat("SomeClassWithALongName::Constructor(\n"
4884                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4885                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4886                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4887                Style);
4888 
4889   Style.AllowAllConstructorInitializersOnNextLine = true;
4890   verifyFormat("SomeClassWithALongName::Constructor(\n"
4891                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4892                "    int bbbbbbbbbbbbb,\n"
4893                "    int cccccccccccccccc) :\n"
4894                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4895                Style);
4896 
4897   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4898   Style.AllowAllConstructorInitializersOnNextLine = false;
4899   verifyFormat("SomeClassWithALongName::Constructor(\n"
4900                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4901                "    int bbbbbbbbbbbbb) :\n"
4902                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4903                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4904                Style);
4905 }
4906 
4907 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4908   FormatStyle Style = getLLVMStyle();
4909   Style.ColumnLimit = 60;
4910   Style.BinPackArguments = false;
4911   for (int i = 0; i < 4; ++i) {
4912     // Test all combinations of parameters that should not have an effect.
4913     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4914     Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4915 
4916     Style.AllowAllArgumentsOnNextLine = true;
4917     verifyFormat("void foo() {\n"
4918                  "  FunctionCallWithReallyLongName(\n"
4919                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4920                  "}",
4921                  Style);
4922     Style.AllowAllArgumentsOnNextLine = false;
4923     verifyFormat("void foo() {\n"
4924                  "  FunctionCallWithReallyLongName(\n"
4925                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4926                  "      bbbbbbbbbbbb);\n"
4927                  "}",
4928                  Style);
4929 
4930     Style.AllowAllArgumentsOnNextLine = true;
4931     verifyFormat("void foo() {\n"
4932                  "  auto VariableWithReallyLongName = {\n"
4933                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4934                  "}",
4935                  Style);
4936     Style.AllowAllArgumentsOnNextLine = false;
4937     verifyFormat("void foo() {\n"
4938                  "  auto VariableWithReallyLongName = {\n"
4939                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4940                  "      bbbbbbbbbbbb};\n"
4941                  "}",
4942                  Style);
4943   }
4944 
4945   // This parameter should not affect declarations.
4946   Style.BinPackParameters = false;
4947   Style.AllowAllArgumentsOnNextLine = false;
4948   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4949   verifyFormat("void FunctionCallWithReallyLongName(\n"
4950                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
4951                Style);
4952   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4953   verifyFormat("void FunctionCallWithReallyLongName(\n"
4954                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
4955                "    int bbbbbbbbbbbb);",
4956                Style);
4957 }
4958 
4959 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
4960   FormatStyle Style = getLLVMStyle();
4961   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4962 
4963   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4964   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
4965                getStyleWithColumns(Style, 45));
4966   verifyFormat("Constructor() :\n"
4967                "    Initializer(FitsOnTheLine) {}",
4968                getStyleWithColumns(Style, 44));
4969   verifyFormat("Constructor() :\n"
4970                "    Initializer(FitsOnTheLine) {}",
4971                getStyleWithColumns(Style, 43));
4972 
4973   verifyFormat("template <typename T>\n"
4974                "Constructor() : Initializer(FitsOnTheLine) {}",
4975                getStyleWithColumns(Style, 50));
4976   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4977   verifyFormat(
4978       "SomeClass::Constructor() :\n"
4979       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4980       Style);
4981 
4982   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
4983   verifyFormat(
4984       "SomeClass::Constructor() :\n"
4985       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4986       Style);
4987 
4988   verifyFormat(
4989       "SomeClass::Constructor() :\n"
4990       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4991       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4992       Style);
4993   verifyFormat(
4994       "SomeClass::Constructor() :\n"
4995       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4996       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4997       Style);
4998   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4999                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
5000                "    aaaaaaaaaa(aaaaaa) {}",
5001                Style);
5002 
5003   verifyFormat("Constructor() :\n"
5004                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5005                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5006                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5007                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
5008                Style);
5009 
5010   verifyFormat("Constructor() :\n"
5011                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5012                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5013                Style);
5014 
5015   verifyFormat("Constructor(int Parameter = 0) :\n"
5016                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
5017                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
5018                Style);
5019   verifyFormat("Constructor() :\n"
5020                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
5021                "}",
5022                getStyleWithColumns(Style, 60));
5023   verifyFormat("Constructor() :\n"
5024                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5025                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
5026                Style);
5027 
5028   // Here a line could be saved by splitting the second initializer onto two
5029   // lines, but that is not desirable.
5030   verifyFormat("Constructor() :\n"
5031                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
5032                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
5033                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5034                Style);
5035 
5036   FormatStyle OnePerLine = Style;
5037   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5038   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
5039   verifyFormat("SomeClass::Constructor() :\n"
5040                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5041                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5042                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5043                OnePerLine);
5044   verifyFormat("SomeClass::Constructor() :\n"
5045                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
5046                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5047                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5048                OnePerLine);
5049   verifyFormat("MyClass::MyClass(int var) :\n"
5050                "    some_var_(var),            // 4 space indent\n"
5051                "    some_other_var_(var + 1) { // lined up\n"
5052                "}",
5053                OnePerLine);
5054   verifyFormat("Constructor() :\n"
5055                "    aaaaa(aaaaaa),\n"
5056                "    aaaaa(aaaaaa),\n"
5057                "    aaaaa(aaaaaa),\n"
5058                "    aaaaa(aaaaaa),\n"
5059                "    aaaaa(aaaaaa) {}",
5060                OnePerLine);
5061   verifyFormat("Constructor() :\n"
5062                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5063                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
5064                OnePerLine);
5065   OnePerLine.BinPackParameters = false;
5066   verifyFormat("Constructor() :\n"
5067                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5068                "        aaaaaaaaaaa().aaa(),\n"
5069                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5070                OnePerLine);
5071   OnePerLine.ColumnLimit = 60;
5072   verifyFormat("Constructor() :\n"
5073                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
5074                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
5075                OnePerLine);
5076 
5077   EXPECT_EQ("Constructor() :\n"
5078             "    // Comment forcing unwanted break.\n"
5079             "    aaaa(aaaa) {}",
5080             format("Constructor() :\n"
5081                    "    // Comment forcing unwanted break.\n"
5082                    "    aaaa(aaaa) {}",
5083                    Style));
5084 
5085   Style.ColumnLimit = 0;
5086   verifyFormat("SomeClass::Constructor() :\n"
5087                "    a(a) {}",
5088                Style);
5089   verifyFormat("SomeClass::Constructor() noexcept :\n"
5090                "    a(a) {}",
5091                Style);
5092   verifyFormat("SomeClass::Constructor() :\n"
5093                "    a(a), b(b), c(c) {}",
5094                Style);
5095   verifyFormat("SomeClass::Constructor() :\n"
5096                "    a(a) {\n"
5097                "  foo();\n"
5098                "  bar();\n"
5099                "}",
5100                Style);
5101 
5102   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5103   verifyFormat("SomeClass::Constructor() :\n"
5104                "    a(a), b(b), c(c) {\n"
5105                "}",
5106                Style);
5107   verifyFormat("SomeClass::Constructor() :\n"
5108                "    a(a) {\n"
5109                "}",
5110                Style);
5111 
5112   Style.ColumnLimit = 80;
5113   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5114   Style.ConstructorInitializerIndentWidth = 2;
5115   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5116   verifyFormat("SomeClass::Constructor() :\n"
5117                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5118                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5119                Style);
5120 
5121   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5122   // well
5123   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5124   verifyFormat(
5125       "class SomeClass\n"
5126       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5127       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5128       Style);
5129   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5130   verifyFormat(
5131       "class SomeClass\n"
5132       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5133       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5134       Style);
5135   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5136   verifyFormat(
5137       "class SomeClass :\n"
5138       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5139       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5140       Style);
5141 }
5142 
5143 #ifndef EXPENSIVE_CHECKS
5144 // Expensive checks enables libstdc++ checking which includes validating the
5145 // state of ranges used in std::priority_queue - this blows out the
5146 // runtime/scalability of the function and makes this test unacceptably slow.
5147 TEST_F(FormatTest, MemoizationTests) {
5148   // This breaks if the memoization lookup does not take \c Indent and
5149   // \c LastSpace into account.
5150   verifyFormat(
5151       "extern CFRunLoopTimerRef\n"
5152       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5153       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
5154       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
5155       "                     CFRunLoopTimerContext *context) {}");
5156 
5157   // Deep nesting somewhat works around our memoization.
5158   verifyFormat(
5159       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5160       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5161       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5162       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5163       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
5164       getLLVMStyleWithColumns(65));
5165   verifyFormat(
5166       "aaaaa(\n"
5167       "    aaaaa,\n"
5168       "    aaaaa(\n"
5169       "        aaaaa,\n"
5170       "        aaaaa(\n"
5171       "            aaaaa,\n"
5172       "            aaaaa(\n"
5173       "                aaaaa,\n"
5174       "                aaaaa(\n"
5175       "                    aaaaa,\n"
5176       "                    aaaaa(\n"
5177       "                        aaaaa,\n"
5178       "                        aaaaa(\n"
5179       "                            aaaaa,\n"
5180       "                            aaaaa(\n"
5181       "                                aaaaa,\n"
5182       "                                aaaaa(\n"
5183       "                                    aaaaa,\n"
5184       "                                    aaaaa(\n"
5185       "                                        aaaaa,\n"
5186       "                                        aaaaa(\n"
5187       "                                            aaaaa,\n"
5188       "                                            aaaaa(\n"
5189       "                                                aaaaa,\n"
5190       "                                                aaaaa))))))))))));",
5191       getLLVMStyleWithColumns(65));
5192   verifyFormat(
5193       "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"
5194       "                                  a),\n"
5195       "                                a),\n"
5196       "                              a),\n"
5197       "                            a),\n"
5198       "                          a),\n"
5199       "                        a),\n"
5200       "                      a),\n"
5201       "                    a),\n"
5202       "                  a),\n"
5203       "                a),\n"
5204       "              a),\n"
5205       "            a),\n"
5206       "          a),\n"
5207       "        a),\n"
5208       "      a),\n"
5209       "    a),\n"
5210       "  a)",
5211       getLLVMStyleWithColumns(65));
5212 
5213   // This test takes VERY long when memoization is broken.
5214   FormatStyle OnePerLine = getLLVMStyle();
5215   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5216   OnePerLine.BinPackParameters = false;
5217   std::string input = "Constructor()\n"
5218                       "    : aaaa(a,\n";
5219   for (unsigned i = 0, e = 80; i != e; ++i) {
5220     input += "           a,\n";
5221   }
5222   input += "           a) {}";
5223   verifyFormat(input, OnePerLine);
5224 }
5225 #endif
5226 
5227 TEST_F(FormatTest, BreaksAsHighAsPossible) {
5228   verifyFormat(
5229       "void f() {\n"
5230       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5231       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5232       "    f();\n"
5233       "}");
5234   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5235                "    Intervals[i - 1].getRange().getLast()) {\n}");
5236 }
5237 
5238 TEST_F(FormatTest, BreaksFunctionDeclarations) {
5239   // Principially, we break function declarations in a certain order:
5240   // 1) break amongst arguments.
5241   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5242                "                              Cccccccccccccc cccccccccccccc);");
5243   verifyFormat("template <class TemplateIt>\n"
5244                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5245                "                            TemplateIt *stop) {}");
5246 
5247   // 2) break after return type.
5248   verifyFormat(
5249       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5250       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5251       getGoogleStyle());
5252 
5253   // 3) break after (.
5254   verifyFormat(
5255       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5256       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5257       getGoogleStyle());
5258 
5259   // 4) break before after nested name specifiers.
5260   verifyFormat(
5261       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5262       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5263       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5264       getGoogleStyle());
5265 
5266   // However, there are exceptions, if a sufficient amount of lines can be
5267   // saved.
5268   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5269   // more adjusting.
5270   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5271                "                                  Cccccccccccccc cccccccccc,\n"
5272                "                                  Cccccccccccccc cccccccccc,\n"
5273                "                                  Cccccccccccccc cccccccccc,\n"
5274                "                                  Cccccccccccccc cccccccccc);");
5275   verifyFormat(
5276       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5277       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5278       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5279       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5280       getGoogleStyle());
5281   verifyFormat(
5282       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5283       "                                          Cccccccccccccc cccccccccc,\n"
5284       "                                          Cccccccccccccc cccccccccc,\n"
5285       "                                          Cccccccccccccc cccccccccc,\n"
5286       "                                          Cccccccccccccc cccccccccc,\n"
5287       "                                          Cccccccccccccc cccccccccc,\n"
5288       "                                          Cccccccccccccc cccccccccc);");
5289   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5290                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5291                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5292                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5293                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5294 
5295   // Break after multi-line parameters.
5296   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5297                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5298                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5299                "    bbbb bbbb);");
5300   verifyFormat("void SomeLoooooooooooongFunction(\n"
5301                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5302                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5303                "    int bbbbbbbbbbbbb);");
5304 
5305   // Treat overloaded operators like other functions.
5306   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5307                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5308   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5309                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5310   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5311                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5312   verifyGoogleFormat(
5313       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5314       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5315   verifyGoogleFormat(
5316       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5317       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5318   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5319                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5320   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5321                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5322   verifyGoogleFormat(
5323       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5324       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5325       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5326   verifyGoogleFormat("template <typename T>\n"
5327                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5328                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5329                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5330 
5331   FormatStyle Style = getLLVMStyle();
5332   Style.PointerAlignment = FormatStyle::PAS_Left;
5333   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5334                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5335                Style);
5336   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5337                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5338                Style);
5339 }
5340 
5341 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5342   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5343   // Prefer keeping `::` followed by `operator` together.
5344   EXPECT_EQ("const aaaa::bbbbbbb &\n"
5345             "ccccccccc::operator++() {\n"
5346             "  stuff();\n"
5347             "}",
5348             format("const aaaa::bbbbbbb\n"
5349                    "&ccccccccc::operator++() { stuff(); }",
5350                    getLLVMStyleWithColumns(40)));
5351 }
5352 
5353 TEST_F(FormatTest, TrailingReturnType) {
5354   verifyFormat("auto foo() -> int;\n");
5355   // correct trailing return type spacing
5356   verifyFormat("auto operator->() -> int;\n");
5357   verifyFormat("auto operator++(int) -> int;\n");
5358 
5359   verifyFormat("struct S {\n"
5360                "  auto bar() const -> int;\n"
5361                "};");
5362   verifyFormat("template <size_t Order, typename T>\n"
5363                "auto load_img(const std::string &filename)\n"
5364                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
5365   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5366                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5367   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5368   verifyFormat("template <typename T>\n"
5369                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5370                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5371 
5372   // Not trailing return types.
5373   verifyFormat("void f() { auto a = b->c(); }");
5374 }
5375 
5376 TEST_F(FormatTest, DeductionGuides) {
5377   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5378   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5379   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5380   verifyFormat(
5381       "template <class... T>\n"
5382       "array(T &&...t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5383   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5384   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5385   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5386   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5387   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5388   verifyFormat("template <class T> x() -> x<1>;");
5389   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5390 
5391   // Ensure not deduction guides.
5392   verifyFormat("c()->f<int>();");
5393   verifyFormat("x()->foo<1>;");
5394   verifyFormat("x = p->foo<3>();");
5395   verifyFormat("x()->x<1>();");
5396   verifyFormat("x()->x<1>;");
5397 }
5398 
5399 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5400   // Avoid breaking before trailing 'const' or other trailing annotations, if
5401   // they are not function-like.
5402   FormatStyle Style = getGoogleStyle();
5403   Style.ColumnLimit = 47;
5404   verifyFormat("void someLongFunction(\n"
5405                "    int someLoooooooooooooongParameter) const {\n}",
5406                getLLVMStyleWithColumns(47));
5407   verifyFormat("LoooooongReturnType\n"
5408                "someLoooooooongFunction() const {}",
5409                getLLVMStyleWithColumns(47));
5410   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5411                "    const {}",
5412                Style);
5413   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5414                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5415   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5416                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5417   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5418                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5419   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5420                "                   aaaaaaaaaaa aaaaa) const override;");
5421   verifyGoogleFormat(
5422       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5423       "    const override;");
5424 
5425   // Even if the first parameter has to be wrapped.
5426   verifyFormat("void someLongFunction(\n"
5427                "    int someLongParameter) const {}",
5428                getLLVMStyleWithColumns(46));
5429   verifyFormat("void someLongFunction(\n"
5430                "    int someLongParameter) const {}",
5431                Style);
5432   verifyFormat("void someLongFunction(\n"
5433                "    int someLongParameter) override {}",
5434                Style);
5435   verifyFormat("void someLongFunction(\n"
5436                "    int someLongParameter) OVERRIDE {}",
5437                Style);
5438   verifyFormat("void someLongFunction(\n"
5439                "    int someLongParameter) final {}",
5440                Style);
5441   verifyFormat("void someLongFunction(\n"
5442                "    int someLongParameter) FINAL {}",
5443                Style);
5444   verifyFormat("void someLongFunction(\n"
5445                "    int parameter) const override {}",
5446                Style);
5447 
5448   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5449   verifyFormat("void someLongFunction(\n"
5450                "    int someLongParameter) const\n"
5451                "{\n"
5452                "}",
5453                Style);
5454 
5455   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5456   verifyFormat("void someLongFunction(\n"
5457                "    int someLongParameter) const\n"
5458                "  {\n"
5459                "  }",
5460                Style);
5461 
5462   // Unless these are unknown annotations.
5463   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5464                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5465                "    LONG_AND_UGLY_ANNOTATION;");
5466 
5467   // Breaking before function-like trailing annotations is fine to keep them
5468   // close to their arguments.
5469   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5470                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5471   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5472                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5473   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5474                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5475   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5476                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5477   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5478 
5479   verifyFormat(
5480       "void aaaaaaaaaaaaaaaaaa()\n"
5481       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5482       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5483   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5484                "    __attribute__((unused));");
5485   verifyGoogleFormat(
5486       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5487       "    GUARDED_BY(aaaaaaaaaaaa);");
5488   verifyGoogleFormat(
5489       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5490       "    GUARDED_BY(aaaaaaaaaaaa);");
5491   verifyGoogleFormat(
5492       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5493       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5494   verifyGoogleFormat(
5495       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5496       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5497 }
5498 
5499 TEST_F(FormatTest, FunctionAnnotations) {
5500   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5501                "int OldFunction(const string &parameter) {}");
5502   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5503                "string OldFunction(const string &parameter) {}");
5504   verifyFormat("template <typename T>\n"
5505                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5506                "string OldFunction(const string &parameter) {}");
5507 
5508   // Not function annotations.
5509   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5510                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5511   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5512                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5513   verifyFormat("MACRO(abc).function() // wrap\n"
5514                "    << abc;");
5515   verifyFormat("MACRO(abc)->function() // wrap\n"
5516                "    << abc;");
5517   verifyFormat("MACRO(abc)::function() // wrap\n"
5518                "    << abc;");
5519 }
5520 
5521 TEST_F(FormatTest, BreaksDesireably) {
5522   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5523                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5524                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5525   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5526                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5527                "}");
5528 
5529   verifyFormat(
5530       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5531       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5532 
5533   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5534                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5535                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5536 
5537   verifyFormat(
5538       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5539       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5540       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5541       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5542       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5543 
5544   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5545                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5546 
5547   verifyFormat(
5548       "void f() {\n"
5549       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5550       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5551       "}");
5552   verifyFormat(
5553       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5554       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5555   verifyFormat(
5556       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5557       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5558   verifyFormat(
5559       "aaaaaa(aaa,\n"
5560       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5561       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5562       "       aaaa);");
5563   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5564                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5565                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5566 
5567   // Indent consistently independent of call expression and unary operator.
5568   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5569                "    dddddddddddddddddddddddddddddd));");
5570   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5571                "    dddddddddddddddddddddddddddddd));");
5572   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5573                "    dddddddddddddddddddddddddddddd));");
5574 
5575   // This test case breaks on an incorrect memoization, i.e. an optimization not
5576   // taking into account the StopAt value.
5577   verifyFormat(
5578       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5579       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5580       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5581       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5582 
5583   verifyFormat("{\n  {\n    {\n"
5584                "      Annotation.SpaceRequiredBefore =\n"
5585                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5586                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5587                "    }\n  }\n}");
5588 
5589   // Break on an outer level if there was a break on an inner level.
5590   EXPECT_EQ("f(g(h(a, // comment\n"
5591             "      b, c),\n"
5592             "    d, e),\n"
5593             "  x, y);",
5594             format("f(g(h(a, // comment\n"
5595                    "    b, c), d, e), x, y);"));
5596 
5597   // Prefer breaking similar line breaks.
5598   verifyFormat(
5599       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5600       "                             NSTrackingMouseEnteredAndExited |\n"
5601       "                             NSTrackingActiveAlways;");
5602 }
5603 
5604 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5605   FormatStyle NoBinPacking = getGoogleStyle();
5606   NoBinPacking.BinPackParameters = false;
5607   NoBinPacking.BinPackArguments = true;
5608   verifyFormat("void f() {\n"
5609                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5610                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5611                "}",
5612                NoBinPacking);
5613   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5614                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5615                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5616                NoBinPacking);
5617 
5618   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5619   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5620                "                        vector<int> bbbbbbbbbbbbbbb);",
5621                NoBinPacking);
5622   // FIXME: This behavior difference is probably not wanted. However, currently
5623   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5624   // template arguments from BreakBeforeParameter being set because of the
5625   // one-per-line formatting.
5626   verifyFormat(
5627       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5628       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5629       NoBinPacking);
5630   verifyFormat(
5631       "void fffffffffff(\n"
5632       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5633       "        aaaaaaaaaa);");
5634 }
5635 
5636 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5637   FormatStyle NoBinPacking = getGoogleStyle();
5638   NoBinPacking.BinPackParameters = false;
5639   NoBinPacking.BinPackArguments = false;
5640   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5641                "  aaaaaaaaaaaaaaaaaaaa,\n"
5642                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5643                NoBinPacking);
5644   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5645                "        aaaaaaaaaaaaa,\n"
5646                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5647                NoBinPacking);
5648   verifyFormat(
5649       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5650       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5651       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5652       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5653       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5654       NoBinPacking);
5655   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5656                "    .aaaaaaaaaaaaaaaaaa();",
5657                NoBinPacking);
5658   verifyFormat("void f() {\n"
5659                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5660                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5661                "}",
5662                NoBinPacking);
5663 
5664   verifyFormat(
5665       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5666       "             aaaaaaaaaaaa,\n"
5667       "             aaaaaaaaaaaa);",
5668       NoBinPacking);
5669   verifyFormat(
5670       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5671       "                               ddddddddddddddddddddddddddddd),\n"
5672       "             test);",
5673       NoBinPacking);
5674 
5675   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5676                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5677                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5678                "    aaaaaaaaaaaaaaaaaa;",
5679                NoBinPacking);
5680   verifyFormat("a(\"a\"\n"
5681                "  \"a\",\n"
5682                "  a);");
5683 
5684   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5685   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5686                "                aaaaaaaaa,\n"
5687                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5688                NoBinPacking);
5689   verifyFormat(
5690       "void f() {\n"
5691       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5692       "      .aaaaaaa();\n"
5693       "}",
5694       NoBinPacking);
5695   verifyFormat(
5696       "template <class SomeType, class SomeOtherType>\n"
5697       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5698       NoBinPacking);
5699 }
5700 
5701 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5702   FormatStyle Style = getLLVMStyleWithColumns(15);
5703   Style.ExperimentalAutoDetectBinPacking = true;
5704   EXPECT_EQ("aaa(aaaa,\n"
5705             "    aaaa,\n"
5706             "    aaaa);\n"
5707             "aaa(aaaa,\n"
5708             "    aaaa,\n"
5709             "    aaaa);",
5710             format("aaa(aaaa,\n" // one-per-line
5711                    "  aaaa,\n"
5712                    "    aaaa  );\n"
5713                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5714                    Style));
5715   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5716             "    aaaa);\n"
5717             "aaa(aaaa, aaaa,\n"
5718             "    aaaa);",
5719             format("aaa(aaaa,  aaaa,\n" // bin-packed
5720                    "    aaaa  );\n"
5721                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5722                    Style));
5723 }
5724 
5725 TEST_F(FormatTest, FormatsBuilderPattern) {
5726   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5727                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5728                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5729                "    .StartsWith(\".init\", ORDER_INIT)\n"
5730                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5731                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5732                "    .Default(ORDER_TEXT);\n");
5733 
5734   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5735                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5736   verifyFormat("aaaaaaa->aaaaaaa\n"
5737                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5738                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5739                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5740   verifyFormat(
5741       "aaaaaaa->aaaaaaa\n"
5742       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5743       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5744   verifyFormat(
5745       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5746       "    aaaaaaaaaaaaaa);");
5747   verifyFormat(
5748       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5749       "    aaaaaa->aaaaaaaaaaaa()\n"
5750       "        ->aaaaaaaaaaaaaaaa(\n"
5751       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5752       "        ->aaaaaaaaaaaaaaaaa();");
5753   verifyGoogleFormat(
5754       "void f() {\n"
5755       "  someo->Add((new util::filetools::Handler(dir))\n"
5756       "                 ->OnEvent1(NewPermanentCallback(\n"
5757       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5758       "                 ->OnEvent2(NewPermanentCallback(\n"
5759       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5760       "                 ->OnEvent3(NewPermanentCallback(\n"
5761       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5762       "                 ->OnEvent5(NewPermanentCallback(\n"
5763       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5764       "                 ->OnEvent6(NewPermanentCallback(\n"
5765       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5766       "}");
5767 
5768   verifyFormat(
5769       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5770   verifyFormat("aaaaaaaaaaaaaaa()\n"
5771                "    .aaaaaaaaaaaaaaa()\n"
5772                "    .aaaaaaaaaaaaaaa()\n"
5773                "    .aaaaaaaaaaaaaaa()\n"
5774                "    .aaaaaaaaaaaaaaa();");
5775   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5776                "    .aaaaaaaaaaaaaaa()\n"
5777                "    .aaaaaaaaaaaaaaa()\n"
5778                "    .aaaaaaaaaaaaaaa();");
5779   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5780                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5781                "    .aaaaaaaaaaaaaaa();");
5782   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5783                "    ->aaaaaaaaaaaaaae(0)\n"
5784                "    ->aaaaaaaaaaaaaaa();");
5785 
5786   // Don't linewrap after very short segments.
5787   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5788                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5789                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5790   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5791                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5792                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5793   verifyFormat("aaa()\n"
5794                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5795                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5796                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5797 
5798   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5799                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5800                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5801   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5802                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5803                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5804 
5805   // Prefer not to break after empty parentheses.
5806   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5807                "    First->LastNewlineOffset);");
5808 
5809   // Prefer not to create "hanging" indents.
5810   verifyFormat(
5811       "return !soooooooooooooome_map\n"
5812       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5813       "            .second;");
5814   verifyFormat(
5815       "return aaaaaaaaaaaaaaaa\n"
5816       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5817       "    .aaaa(aaaaaaaaaaaaaa);");
5818   // No hanging indent here.
5819   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5820                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5821   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5822                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5823   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5824                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5825                getLLVMStyleWithColumns(60));
5826   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5827                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5828                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5829                getLLVMStyleWithColumns(59));
5830   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5831                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5832                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5833 
5834   // Dont break if only closing statements before member call
5835   verifyFormat("test() {\n"
5836                "  ([]() -> {\n"
5837                "    int b = 32;\n"
5838                "    return 3;\n"
5839                "  }).foo();\n"
5840                "}");
5841   verifyFormat("test() {\n"
5842                "  (\n"
5843                "      []() -> {\n"
5844                "        int b = 32;\n"
5845                "        return 3;\n"
5846                "      },\n"
5847                "      foo, bar)\n"
5848                "      .foo();\n"
5849                "}");
5850   verifyFormat("test() {\n"
5851                "  ([]() -> {\n"
5852                "    int b = 32;\n"
5853                "    return 3;\n"
5854                "  })\n"
5855                "      .foo()\n"
5856                "      .bar();\n"
5857                "}");
5858   verifyFormat("test() {\n"
5859                "  ([]() -> {\n"
5860                "    int b = 32;\n"
5861                "    return 3;\n"
5862                "  })\n"
5863                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5864                "           \"bbbb\");\n"
5865                "}",
5866                getLLVMStyleWithColumns(30));
5867 }
5868 
5869 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5870   verifyFormat(
5871       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5872       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5873   verifyFormat(
5874       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5875       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5876 
5877   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5878                "    ccccccccccccccccccccccccc) {\n}");
5879   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5880                "    ccccccccccccccccccccccccc) {\n}");
5881 
5882   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5883                "    ccccccccccccccccccccccccc) {\n}");
5884   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5885                "    ccccccccccccccccccccccccc) {\n}");
5886 
5887   verifyFormat(
5888       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
5889       "    ccccccccccccccccccccccccc) {\n}");
5890   verifyFormat(
5891       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
5892       "    ccccccccccccccccccccccccc) {\n}");
5893 
5894   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5895                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
5896                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
5897                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5898   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5899                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
5900                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
5901                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5902 
5903   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5904                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
5905                "    aaaaaaaaaaaaaaa != aa) {\n}");
5906   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5907                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
5908                "    aaaaaaaaaaaaaaa != aa) {\n}");
5909 }
5910 
5911 TEST_F(FormatTest, BreaksAfterAssignments) {
5912   verifyFormat(
5913       "unsigned Cost =\n"
5914       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
5915       "                        SI->getPointerAddressSpaceee());\n");
5916   verifyFormat(
5917       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
5918       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
5919 
5920   verifyFormat(
5921       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
5922       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
5923   verifyFormat("unsigned OriginalStartColumn =\n"
5924                "    SourceMgr.getSpellingColumnNumber(\n"
5925                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
5926                "    1;");
5927 }
5928 
5929 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
5930   FormatStyle Style = getLLVMStyle();
5931   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5932                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
5933                Style);
5934 
5935   Style.PenaltyBreakAssignment = 20;
5936   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5937                "                                 cccccccccccccccccccccccccc;",
5938                Style);
5939 }
5940 
5941 TEST_F(FormatTest, AlignsAfterAssignments) {
5942   verifyFormat(
5943       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5944       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
5945   verifyFormat(
5946       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5947       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
5948   verifyFormat(
5949       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5950       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
5951   verifyFormat(
5952       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5953       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
5954   verifyFormat(
5955       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5956       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5957       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
5958 }
5959 
5960 TEST_F(FormatTest, AlignsAfterReturn) {
5961   verifyFormat(
5962       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5963       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
5964   verifyFormat(
5965       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5966       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
5967   verifyFormat(
5968       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5969       "       aaaaaaaaaaaaaaaaaaaaaa();");
5970   verifyFormat(
5971       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5972       "        aaaaaaaaaaaaaaaaaaaaaa());");
5973   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5974                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5975   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5976                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
5977                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5978   verifyFormat("return\n"
5979                "    // true if code is one of a or b.\n"
5980                "    code == a || code == b;");
5981 }
5982 
5983 TEST_F(FormatTest, AlignsAfterOpenBracket) {
5984   verifyFormat(
5985       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5986       "                                                aaaaaaaaa aaaaaaa) {}");
5987   verifyFormat(
5988       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5989       "                                               aaaaaaaaaaa aaaaaaaaa);");
5990   verifyFormat(
5991       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5992       "                                             aaaaaaaaaaaaaaaaaaaaa));");
5993   FormatStyle Style = getLLVMStyle();
5994   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5995   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5996                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
5997                Style);
5998   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5999                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
6000                Style);
6001   verifyFormat("SomeLongVariableName->someFunction(\n"
6002                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
6003                Style);
6004   verifyFormat(
6005       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
6006       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6007       Style);
6008   verifyFormat(
6009       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
6010       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6011       Style);
6012   verifyFormat(
6013       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6014       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6015       Style);
6016 
6017   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
6018                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
6019                "        b));",
6020                Style);
6021 
6022   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6023   Style.BinPackArguments = false;
6024   Style.BinPackParameters = false;
6025   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6026                "    aaaaaaaaaaa aaaaaaaa,\n"
6027                "    aaaaaaaaa aaaaaaa,\n"
6028                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6029                Style);
6030   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6031                "    aaaaaaaaaaa aaaaaaaaa,\n"
6032                "    aaaaaaaaaaa aaaaaaaaa,\n"
6033                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6034                Style);
6035   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
6036                "    aaaaaaaaaaaaaaa,\n"
6037                "    aaaaaaaaaaaaaaaaaaaaa,\n"
6038                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6039                Style);
6040   verifyFormat(
6041       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
6042       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6043       Style);
6044   verifyFormat(
6045       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
6046       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6047       Style);
6048   verifyFormat(
6049       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6050       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6051       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
6052       "    aaaaaaaaaaaaaaaa);",
6053       Style);
6054   verifyFormat(
6055       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6056       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6057       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
6058       "    aaaaaaaaaaaaaaaa);",
6059       Style);
6060 }
6061 
6062 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
6063   FormatStyle Style = getLLVMStyleWithColumns(40);
6064   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6065                "          bbbbbbbbbbbbbbbbbbbbbb);",
6066                Style);
6067   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6068   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6069   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6070                "          bbbbbbbbbbbbbbbbbbbbbb);",
6071                Style);
6072   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6073   Style.AlignOperands = FormatStyle::OAS_Align;
6074   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6075                "          bbbbbbbbbbbbbbbbbbbbbb);",
6076                Style);
6077   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6078   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6079   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6080                "    bbbbbbbbbbbbbbbbbbbbbb);",
6081                Style);
6082 }
6083 
6084 TEST_F(FormatTest, BreaksConditionalExpressions) {
6085   verifyFormat(
6086       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6087       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6088       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6089   verifyFormat(
6090       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6091       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6092       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6093   verifyFormat(
6094       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6095       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6096   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6097                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6098                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6099   verifyFormat(
6100       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6101       "                                                    : aaaaaaaaaaaaa);");
6102   verifyFormat(
6103       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6104       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6105       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6106       "                   aaaaaaaaaaaaa);");
6107   verifyFormat(
6108       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6109       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6110       "                   aaaaaaaaaaaaa);");
6111   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6112                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6113                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6114                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6115                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6116   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6117                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6118                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6119                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6120                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6121                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6122                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6123   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6124                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6125                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6126                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6127                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6128   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6129                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6130                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6131   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6132                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6133                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6134                "        : aaaaaaaaaaaaaaaa;");
6135   verifyFormat(
6136       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6137       "    ? aaaaaaaaaaaaaaa\n"
6138       "    : aaaaaaaaaaaaaaa;");
6139   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6140                "          aaaaaaaaa\n"
6141                "      ? b\n"
6142                "      : c);");
6143   verifyFormat("return aaaa == bbbb\n"
6144                "           // comment\n"
6145                "           ? aaaa\n"
6146                "           : bbbb;");
6147   verifyFormat("unsigned Indent =\n"
6148                "    format(TheLine.First,\n"
6149                "           IndentForLevel[TheLine.Level] >= 0\n"
6150                "               ? IndentForLevel[TheLine.Level]\n"
6151                "               : TheLine * 2,\n"
6152                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6153                getLLVMStyleWithColumns(60));
6154   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6155                "                  ? aaaaaaaaaaaaaaa\n"
6156                "                  : bbbbbbbbbbbbbbb //\n"
6157                "                        ? ccccccccccccccc\n"
6158                "                        : ddddddddddddddd;");
6159   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6160                "                  ? aaaaaaaaaaaaaaa\n"
6161                "                  : (bbbbbbbbbbbbbbb //\n"
6162                "                         ? ccccccccccccccc\n"
6163                "                         : ddddddddddddddd);");
6164   verifyFormat(
6165       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6166       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6167       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
6168       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
6169       "                                      : aaaaaaaaaa;");
6170   verifyFormat(
6171       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6172       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
6173       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6174 
6175   FormatStyle NoBinPacking = getLLVMStyle();
6176   NoBinPacking.BinPackArguments = false;
6177   verifyFormat(
6178       "void f() {\n"
6179       "  g(aaa,\n"
6180       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6181       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6182       "        ? aaaaaaaaaaaaaaa\n"
6183       "        : aaaaaaaaaaaaaaa);\n"
6184       "}",
6185       NoBinPacking);
6186   verifyFormat(
6187       "void f() {\n"
6188       "  g(aaa,\n"
6189       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6190       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6191       "        ?: aaaaaaaaaaaaaaa);\n"
6192       "}",
6193       NoBinPacking);
6194 
6195   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6196                "             // comment.\n"
6197                "             ccccccccccccccccccccccccccccccccccccccc\n"
6198                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6199                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6200 
6201   // Assignments in conditional expressions. Apparently not uncommon :-(.
6202   verifyFormat("return a != b\n"
6203                "           // comment\n"
6204                "           ? a = b\n"
6205                "           : a = b;");
6206   verifyFormat("return a != b\n"
6207                "           // comment\n"
6208                "           ? a = a != b\n"
6209                "                     // comment\n"
6210                "                     ? a = b\n"
6211                "                     : a\n"
6212                "           : a;\n");
6213   verifyFormat("return a != b\n"
6214                "           // comment\n"
6215                "           ? a\n"
6216                "           : a = a != b\n"
6217                "                     // comment\n"
6218                "                     ? a = b\n"
6219                "                     : a;");
6220 
6221   // Chained conditionals
6222   FormatStyle Style = getLLVMStyle();
6223   Style.ColumnLimit = 70;
6224   Style.AlignOperands = FormatStyle::OAS_Align;
6225   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6226                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6227                "                        : 3333333333333333;",
6228                Style);
6229   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6230                "       : bbbbbbbbbb     ? 2222222222222222\n"
6231                "                        : 3333333333333333;",
6232                Style);
6233   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
6234                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6235                "                          : 3333333333333333;",
6236                Style);
6237   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6238                "       : bbbbbbbbbbbbbb ? 222222\n"
6239                "                        : 333333;",
6240                Style);
6241   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6242                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6243                "       : cccccccccccccc ? 3333333333333333\n"
6244                "                        : 4444444444444444;",
6245                Style);
6246   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6247                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6248                "                        : 3333333333333333;",
6249                Style);
6250   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6251                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6252                "                        : (aaa ? bbb : ccc);",
6253                Style);
6254   verifyFormat(
6255       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6256       "                                             : cccccccccccccccccc)\n"
6257       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6258       "                        : 3333333333333333;",
6259       Style);
6260   verifyFormat(
6261       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6262       "                                             : cccccccccccccccccc)\n"
6263       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6264       "                        : 3333333333333333;",
6265       Style);
6266   verifyFormat(
6267       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6268       "                                             : dddddddddddddddddd)\n"
6269       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6270       "                        : 3333333333333333;",
6271       Style);
6272   verifyFormat(
6273       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6274       "                                             : dddddddddddddddddd)\n"
6275       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6276       "                        : 3333333333333333;",
6277       Style);
6278   verifyFormat(
6279       "return aaaaaaaaa        ? 1111111111111111\n"
6280       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6281       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6282       "                                             : dddddddddddddddddd)\n",
6283       Style);
6284   verifyFormat(
6285       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6286       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6287       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6288       "                                             : cccccccccccccccccc);",
6289       Style);
6290   verifyFormat(
6291       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6292       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6293       "                                             : eeeeeeeeeeeeeeeeee)\n"
6294       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6295       "                        : 3333333333333333;",
6296       Style);
6297   verifyFormat(
6298       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
6299       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6300       "                                             : eeeeeeeeeeeeeeeeee)\n"
6301       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6302       "                        : 3333333333333333;",
6303       Style);
6304   verifyFormat(
6305       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6306       "                           : cccccccccccc    ? dddddddddddddddddd\n"
6307       "                                             : eeeeeeeeeeeeeeeeee)\n"
6308       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6309       "                        : 3333333333333333;",
6310       Style);
6311   verifyFormat(
6312       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6313       "                                             : cccccccccccccccccc\n"
6314       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6315       "                        : 3333333333333333;",
6316       Style);
6317   verifyFormat(
6318       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6319       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
6320       "                                             : eeeeeeeeeeeeeeeeee\n"
6321       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6322       "                        : 3333333333333333;",
6323       Style);
6324   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6325                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
6326                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
6327                "                                   : eeeeeeeeeeeeeeeeee)\n"
6328                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6329                "                             : 3333333333333333;",
6330                Style);
6331   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6332                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6333                "             : cccccccccccccccc ? dddddddddddddddddd\n"
6334                "                                : eeeeeeeeeeeeeeeeee\n"
6335                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6336                "                                 : 3333333333333333;",
6337                Style);
6338 
6339   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6340   Style.BreakBeforeTernaryOperators = false;
6341   // FIXME: Aligning the question marks is weird given DontAlign.
6342   // Consider disabling this alignment in this case. Also check whether this
6343   // will render the adjustment from https://reviews.llvm.org/D82199
6344   // unnecessary.
6345   verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
6346                "    bbbb                ? cccccccccccccccccc :\n"
6347                "                          ddddd;\n",
6348                Style);
6349 }
6350 
6351 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6352   FormatStyle Style = getLLVMStyle();
6353   Style.BreakBeforeTernaryOperators = false;
6354   Style.ColumnLimit = 70;
6355   verifyFormat(
6356       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6357       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6358       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6359       Style);
6360   verifyFormat(
6361       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6362       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6363       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6364       Style);
6365   verifyFormat(
6366       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6367       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6368       Style);
6369   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6370                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6371                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6372                Style);
6373   verifyFormat(
6374       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6375       "                                                      aaaaaaaaaaaaa);",
6376       Style);
6377   verifyFormat(
6378       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6379       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6380       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6381       "                   aaaaaaaaaaaaa);",
6382       Style);
6383   verifyFormat(
6384       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6385       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6386       "                   aaaaaaaaaaaaa);",
6387       Style);
6388   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6389                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6390                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6391                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6392                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6393                Style);
6394   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6395                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6396                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6397                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6398                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6399                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6400                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6401                Style);
6402   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6403                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6404                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6405                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6406                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6407                Style);
6408   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6409                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6410                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6411                Style);
6412   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6413                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6414                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6415                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6416                Style);
6417   verifyFormat(
6418       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6419       "    aaaaaaaaaaaaaaa :\n"
6420       "    aaaaaaaaaaaaaaa;",
6421       Style);
6422   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6423                "          aaaaaaaaa ?\n"
6424                "      b :\n"
6425                "      c);",
6426                Style);
6427   verifyFormat("unsigned Indent =\n"
6428                "    format(TheLine.First,\n"
6429                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
6430                "               IndentForLevel[TheLine.Level] :\n"
6431                "               TheLine * 2,\n"
6432                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6433                Style);
6434   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6435                "                  aaaaaaaaaaaaaaa :\n"
6436                "                  bbbbbbbbbbbbbbb ? //\n"
6437                "                      ccccccccccccccc :\n"
6438                "                      ddddddddddddddd;",
6439                Style);
6440   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6441                "                  aaaaaaaaaaaaaaa :\n"
6442                "                  (bbbbbbbbbbbbbbb ? //\n"
6443                "                       ccccccccccccccc :\n"
6444                "                       ddddddddddddddd);",
6445                Style);
6446   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6447                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6448                "            ccccccccccccccccccccccccccc;",
6449                Style);
6450   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6451                "           aaaaa :\n"
6452                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
6453                Style);
6454 
6455   // Chained conditionals
6456   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6457                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6458                "                          3333333333333333;",
6459                Style);
6460   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6461                "       bbbbbbbbbb       ? 2222222222222222 :\n"
6462                "                          3333333333333333;",
6463                Style);
6464   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
6465                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6466                "                          3333333333333333;",
6467                Style);
6468   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6469                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
6470                "                          333333;",
6471                Style);
6472   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6473                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6474                "       cccccccccccccccc ? 3333333333333333 :\n"
6475                "                          4444444444444444;",
6476                Style);
6477   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6478                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6479                "                          3333333333333333;",
6480                Style);
6481   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6482                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6483                "                          (aaa ? bbb : ccc);",
6484                Style);
6485   verifyFormat(
6486       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6487       "                                               cccccccccccccccccc) :\n"
6488       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6489       "                          3333333333333333;",
6490       Style);
6491   verifyFormat(
6492       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6493       "                                               cccccccccccccccccc) :\n"
6494       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6495       "                          3333333333333333;",
6496       Style);
6497   verifyFormat(
6498       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6499       "                                               dddddddddddddddddd) :\n"
6500       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6501       "                          3333333333333333;",
6502       Style);
6503   verifyFormat(
6504       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6505       "                                               dddddddddddddddddd) :\n"
6506       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6507       "                          3333333333333333;",
6508       Style);
6509   verifyFormat(
6510       "return aaaaaaaaa        ? 1111111111111111 :\n"
6511       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6512       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6513       "                                               dddddddddddddddddd)\n",
6514       Style);
6515   verifyFormat(
6516       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6517       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6518       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6519       "                                               cccccccccccccccccc);",
6520       Style);
6521   verifyFormat(
6522       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6523       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6524       "                                               eeeeeeeeeeeeeeeeee) :\n"
6525       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6526       "                          3333333333333333;",
6527       Style);
6528   verifyFormat(
6529       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6530       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
6531       "                                               eeeeeeeeeeeeeeeeee) :\n"
6532       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6533       "                          3333333333333333;",
6534       Style);
6535   verifyFormat(
6536       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
6537       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6538       "                                               eeeeeeeeeeeeeeeeee) :\n"
6539       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6540       "                          3333333333333333;",
6541       Style);
6542   verifyFormat(
6543       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6544       "                                               cccccccccccccccccc :\n"
6545       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6546       "                          3333333333333333;",
6547       Style);
6548   verifyFormat(
6549       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6550       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
6551       "                                               eeeeeeeeeeeeeeeeee :\n"
6552       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6553       "                          3333333333333333;",
6554       Style);
6555   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6556                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6557                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
6558                "                                 eeeeeeeeeeeeeeeeee) :\n"
6559                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6560                "                               3333333333333333;",
6561                Style);
6562   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6563                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6564                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
6565                "                                  eeeeeeeeeeeeeeeeee :\n"
6566                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6567                "                               3333333333333333;",
6568                Style);
6569 }
6570 
6571 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6572   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6573                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6574   verifyFormat("bool a = true, b = false;");
6575 
6576   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6577                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6578                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6579                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6580   verifyFormat(
6581       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6582       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6583       "     d = e && f;");
6584   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6585                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6586   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6587                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6588   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6589                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6590 
6591   FormatStyle Style = getGoogleStyle();
6592   Style.PointerAlignment = FormatStyle::PAS_Left;
6593   Style.DerivePointerAlignment = false;
6594   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6595                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6596                "    *b = bbbbbbbbbbbbbbbbbbb;",
6597                Style);
6598   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6599                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6600                Style);
6601   verifyFormat("vector<int*> a, b;", Style);
6602   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6603 }
6604 
6605 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6606   verifyFormat("arr[foo ? bar : baz];");
6607   verifyFormat("f()[foo ? bar : baz];");
6608   verifyFormat("(a + b)[foo ? bar : baz];");
6609   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6610 }
6611 
6612 TEST_F(FormatTest, AlignsStringLiterals) {
6613   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6614                "                                      \"short literal\");");
6615   verifyFormat(
6616       "looooooooooooooooooooooooongFunction(\n"
6617       "    \"short literal\"\n"
6618       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6619   verifyFormat("someFunction(\"Always break between multi-line\"\n"
6620                "             \" string literals\",\n"
6621                "             and, other, parameters);");
6622   EXPECT_EQ("fun + \"1243\" /* comment */\n"
6623             "      \"5678\";",
6624             format("fun + \"1243\" /* comment */\n"
6625                    "    \"5678\";",
6626                    getLLVMStyleWithColumns(28)));
6627   EXPECT_EQ(
6628       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6629       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6630       "         \"aaaaaaaaaaaaaaaa\";",
6631       format("aaaaaa ="
6632              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6633              "aaaaaaaaaaaaaaaaaaaaa\" "
6634              "\"aaaaaaaaaaaaaaaa\";"));
6635   verifyFormat("a = a + \"a\"\n"
6636                "        \"a\"\n"
6637                "        \"a\";");
6638   verifyFormat("f(\"a\", \"b\"\n"
6639                "       \"c\");");
6640 
6641   verifyFormat(
6642       "#define LL_FORMAT \"ll\"\n"
6643       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6644       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6645 
6646   verifyFormat("#define A(X)          \\\n"
6647                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
6648                "  \"ccccc\"",
6649                getLLVMStyleWithColumns(23));
6650   verifyFormat("#define A \"def\"\n"
6651                "f(\"abc\" A \"ghi\"\n"
6652                "  \"jkl\");");
6653 
6654   verifyFormat("f(L\"a\"\n"
6655                "  L\"b\");");
6656   verifyFormat("#define A(X)            \\\n"
6657                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6658                "  L\"ccccc\"",
6659                getLLVMStyleWithColumns(25));
6660 
6661   verifyFormat("f(@\"a\"\n"
6662                "  @\"b\");");
6663   verifyFormat("NSString s = @\"a\"\n"
6664                "             @\"b\"\n"
6665                "             @\"c\";");
6666   verifyFormat("NSString s = @\"a\"\n"
6667                "              \"b\"\n"
6668                "              \"c\";");
6669 }
6670 
6671 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6672   FormatStyle Style = getLLVMStyle();
6673   // No declarations or definitions should be moved to own line.
6674   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6675   verifyFormat("class A {\n"
6676                "  int f() { return 1; }\n"
6677                "  int g();\n"
6678                "};\n"
6679                "int f() { return 1; }\n"
6680                "int g();\n",
6681                Style);
6682 
6683   // All declarations and definitions should have the return type moved to its
6684   // own line.
6685   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6686   Style.TypenameMacros = {"LIST"};
6687   verifyFormat("SomeType\n"
6688                "funcdecl(LIST(uint64_t));",
6689                Style);
6690   verifyFormat("class E {\n"
6691                "  int\n"
6692                "  f() {\n"
6693                "    return 1;\n"
6694                "  }\n"
6695                "  int\n"
6696                "  g();\n"
6697                "};\n"
6698                "int\n"
6699                "f() {\n"
6700                "  return 1;\n"
6701                "}\n"
6702                "int\n"
6703                "g();\n",
6704                Style);
6705 
6706   // Top-level definitions, and no kinds of declarations should have the
6707   // return type moved to its own line.
6708   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6709   verifyFormat("class B {\n"
6710                "  int f() { return 1; }\n"
6711                "  int g();\n"
6712                "};\n"
6713                "int\n"
6714                "f() {\n"
6715                "  return 1;\n"
6716                "}\n"
6717                "int g();\n",
6718                Style);
6719 
6720   // Top-level definitions and declarations should have the return type moved
6721   // to its own line.
6722   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6723   verifyFormat("class C {\n"
6724                "  int f() { return 1; }\n"
6725                "  int g();\n"
6726                "};\n"
6727                "int\n"
6728                "f() {\n"
6729                "  return 1;\n"
6730                "}\n"
6731                "int\n"
6732                "g();\n",
6733                Style);
6734 
6735   // All definitions should have the return type moved to its own line, but no
6736   // kinds of declarations.
6737   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6738   verifyFormat("class D {\n"
6739                "  int\n"
6740                "  f() {\n"
6741                "    return 1;\n"
6742                "  }\n"
6743                "  int g();\n"
6744                "};\n"
6745                "int\n"
6746                "f() {\n"
6747                "  return 1;\n"
6748                "}\n"
6749                "int g();\n",
6750                Style);
6751   verifyFormat("const char *\n"
6752                "f(void) {\n" // Break here.
6753                "  return \"\";\n"
6754                "}\n"
6755                "const char *bar(void);\n", // No break here.
6756                Style);
6757   verifyFormat("template <class T>\n"
6758                "T *\n"
6759                "f(T &c) {\n" // Break here.
6760                "  return NULL;\n"
6761                "}\n"
6762                "template <class T> T *f(T &c);\n", // No break here.
6763                Style);
6764   verifyFormat("class C {\n"
6765                "  int\n"
6766                "  operator+() {\n"
6767                "    return 1;\n"
6768                "  }\n"
6769                "  int\n"
6770                "  operator()() {\n"
6771                "    return 1;\n"
6772                "  }\n"
6773                "};\n",
6774                Style);
6775   verifyFormat("void\n"
6776                "A::operator()() {}\n"
6777                "void\n"
6778                "A::operator>>() {}\n"
6779                "void\n"
6780                "A::operator+() {}\n"
6781                "void\n"
6782                "A::operator*() {}\n"
6783                "void\n"
6784                "A::operator->() {}\n"
6785                "void\n"
6786                "A::operator void *() {}\n"
6787                "void\n"
6788                "A::operator void &() {}\n"
6789                "void\n"
6790                "A::operator void &&() {}\n"
6791                "void\n"
6792                "A::operator char *() {}\n"
6793                "void\n"
6794                "A::operator[]() {}\n"
6795                "void\n"
6796                "A::operator!() {}\n"
6797                "void\n"
6798                "A::operator**() {}\n"
6799                "void\n"
6800                "A::operator<Foo> *() {}\n"
6801                "void\n"
6802                "A::operator<Foo> **() {}\n"
6803                "void\n"
6804                "A::operator<Foo> &() {}\n"
6805                "void\n"
6806                "A::operator void **() {}\n",
6807                Style);
6808   verifyFormat("constexpr auto\n"
6809                "operator()() const -> reference {}\n"
6810                "constexpr auto\n"
6811                "operator>>() const -> reference {}\n"
6812                "constexpr auto\n"
6813                "operator+() const -> reference {}\n"
6814                "constexpr auto\n"
6815                "operator*() const -> reference {}\n"
6816                "constexpr auto\n"
6817                "operator->() const -> reference {}\n"
6818                "constexpr auto\n"
6819                "operator++() const -> reference {}\n"
6820                "constexpr auto\n"
6821                "operator void *() const -> reference {}\n"
6822                "constexpr auto\n"
6823                "operator void **() const -> reference {}\n"
6824                "constexpr auto\n"
6825                "operator void *() const -> reference {}\n"
6826                "constexpr auto\n"
6827                "operator void &() const -> reference {}\n"
6828                "constexpr auto\n"
6829                "operator void &&() const -> reference {}\n"
6830                "constexpr auto\n"
6831                "operator char *() const -> reference {}\n"
6832                "constexpr auto\n"
6833                "operator!() const -> reference {}\n"
6834                "constexpr auto\n"
6835                "operator[]() const -> reference {}\n",
6836                Style);
6837   verifyFormat("void *operator new(std::size_t s);", // No break here.
6838                Style);
6839   verifyFormat("void *\n"
6840                "operator new(std::size_t s) {}",
6841                Style);
6842   verifyFormat("void *\n"
6843                "operator delete[](void *ptr) {}",
6844                Style);
6845   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6846   verifyFormat("const char *\n"
6847                "f(void)\n" // Break here.
6848                "{\n"
6849                "  return \"\";\n"
6850                "}\n"
6851                "const char *bar(void);\n", // No break here.
6852                Style);
6853   verifyFormat("template <class T>\n"
6854                "T *\n"     // Problem here: no line break
6855                "f(T &c)\n" // Break here.
6856                "{\n"
6857                "  return NULL;\n"
6858                "}\n"
6859                "template <class T> T *f(T &c);\n", // No break here.
6860                Style);
6861   verifyFormat("int\n"
6862                "foo(A<bool> a)\n"
6863                "{\n"
6864                "  return a;\n"
6865                "}\n",
6866                Style);
6867   verifyFormat("int\n"
6868                "foo(A<8> a)\n"
6869                "{\n"
6870                "  return a;\n"
6871                "}\n",
6872                Style);
6873   verifyFormat("int\n"
6874                "foo(A<B<bool>, 8> a)\n"
6875                "{\n"
6876                "  return a;\n"
6877                "}\n",
6878                Style);
6879   verifyFormat("int\n"
6880                "foo(A<B<8>, bool> a)\n"
6881                "{\n"
6882                "  return a;\n"
6883                "}\n",
6884                Style);
6885   verifyFormat("int\n"
6886                "foo(A<B<bool>, bool> a)\n"
6887                "{\n"
6888                "  return a;\n"
6889                "}\n",
6890                Style);
6891   verifyFormat("int\n"
6892                "foo(A<B<8>, 8> a)\n"
6893                "{\n"
6894                "  return a;\n"
6895                "}\n",
6896                Style);
6897 
6898   Style = getGNUStyle();
6899 
6900   // Test for comments at the end of function declarations.
6901   verifyFormat("void\n"
6902                "foo (int a, /*abc*/ int b) // def\n"
6903                "{\n"
6904                "}\n",
6905                Style);
6906 
6907   verifyFormat("void\n"
6908                "foo (int a, /* abc */ int b) /* def */\n"
6909                "{\n"
6910                "}\n",
6911                Style);
6912 
6913   // Definitions that should not break after return type
6914   verifyFormat("void foo (int a, int b); // def\n", Style);
6915   verifyFormat("void foo (int a, int b); /* def */\n", Style);
6916   verifyFormat("void foo (int a, int b);\n", Style);
6917 }
6918 
6919 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
6920   FormatStyle NoBreak = getLLVMStyle();
6921   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
6922   FormatStyle Break = getLLVMStyle();
6923   Break.AlwaysBreakBeforeMultilineStrings = true;
6924   verifyFormat("aaaa = \"bbbb\"\n"
6925                "       \"cccc\";",
6926                NoBreak);
6927   verifyFormat("aaaa =\n"
6928                "    \"bbbb\"\n"
6929                "    \"cccc\";",
6930                Break);
6931   verifyFormat("aaaa(\"bbbb\"\n"
6932                "     \"cccc\");",
6933                NoBreak);
6934   verifyFormat("aaaa(\n"
6935                "    \"bbbb\"\n"
6936                "    \"cccc\");",
6937                Break);
6938   verifyFormat("aaaa(qqq, \"bbbb\"\n"
6939                "          \"cccc\");",
6940                NoBreak);
6941   verifyFormat("aaaa(qqq,\n"
6942                "     \"bbbb\"\n"
6943                "     \"cccc\");",
6944                Break);
6945   verifyFormat("aaaa(qqq,\n"
6946                "     L\"bbbb\"\n"
6947                "     L\"cccc\");",
6948                Break);
6949   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
6950                "                      \"bbbb\"));",
6951                Break);
6952   verifyFormat("string s = someFunction(\n"
6953                "    \"abc\"\n"
6954                "    \"abc\");",
6955                Break);
6956 
6957   // As we break before unary operators, breaking right after them is bad.
6958   verifyFormat("string foo = abc ? \"x\"\n"
6959                "                   \"blah blah blah blah blah blah\"\n"
6960                "                 : \"y\";",
6961                Break);
6962 
6963   // Don't break if there is no column gain.
6964   verifyFormat("f(\"aaaa\"\n"
6965                "  \"bbbb\");",
6966                Break);
6967 
6968   // Treat literals with escaped newlines like multi-line string literals.
6969   EXPECT_EQ("x = \"a\\\n"
6970             "b\\\n"
6971             "c\";",
6972             format("x = \"a\\\n"
6973                    "b\\\n"
6974                    "c\";",
6975                    NoBreak));
6976   EXPECT_EQ("xxxx =\n"
6977             "    \"a\\\n"
6978             "b\\\n"
6979             "c\";",
6980             format("xxxx = \"a\\\n"
6981                    "b\\\n"
6982                    "c\";",
6983                    Break));
6984 
6985   EXPECT_EQ("NSString *const kString =\n"
6986             "    @\"aaaa\"\n"
6987             "    @\"bbbb\";",
6988             format("NSString *const kString = @\"aaaa\"\n"
6989                    "@\"bbbb\";",
6990                    Break));
6991 
6992   Break.ColumnLimit = 0;
6993   verifyFormat("const char *hello = \"hello llvm\";", Break);
6994 }
6995 
6996 TEST_F(FormatTest, AlignsPipes) {
6997   verifyFormat(
6998       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6999       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7000       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7001   verifyFormat(
7002       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
7003       "                     << aaaaaaaaaaaaaaaaaaaa;");
7004   verifyFormat(
7005       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7006       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7007   verifyFormat(
7008       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7009       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7010   verifyFormat(
7011       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
7012       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
7013       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
7014   verifyFormat(
7015       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7016       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7017       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7018   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7019                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7020                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7021                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7022   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
7023                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
7024   verifyFormat(
7025       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7026       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7027   verifyFormat(
7028       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
7029       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
7030 
7031   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
7032                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
7033   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7034                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7035                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
7036                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
7037   verifyFormat("LOG_IF(aaa == //\n"
7038                "       bbb)\n"
7039                "    << a << b;");
7040 
7041   // But sometimes, breaking before the first "<<" is desirable.
7042   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7043                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
7044   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
7045                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7046                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7047   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
7048                "    << BEF << IsTemplate << Description << E->getType();");
7049   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7050                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7051                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7052   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7053                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7054                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7055                "    << aaa;");
7056 
7057   verifyFormat(
7058       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7059       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7060 
7061   // Incomplete string literal.
7062   EXPECT_EQ("llvm::errs() << \"\n"
7063             "             << a;",
7064             format("llvm::errs() << \"\n<<a;"));
7065 
7066   verifyFormat("void f() {\n"
7067                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
7068                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
7069                "}");
7070 
7071   // Handle 'endl'.
7072   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
7073                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7074   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7075 
7076   // Handle '\n'.
7077   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
7078                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7079   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
7080                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
7081   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
7082                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
7083   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7084 }
7085 
7086 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
7087   verifyFormat("return out << \"somepacket = {\\n\"\n"
7088                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
7089                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
7090                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
7091                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
7092                "           << \"}\";");
7093 
7094   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7095                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7096                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7097   verifyFormat(
7098       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7099       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7100       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7101       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7102       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7103   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7104                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7105   verifyFormat(
7106       "void f() {\n"
7107       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7108       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7109       "}");
7110 
7111   // Breaking before the first "<<" is generally not desirable.
7112   verifyFormat(
7113       "llvm::errs()\n"
7114       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7115       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7116       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7117       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7118       getLLVMStyleWithColumns(70));
7119   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7120                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7121                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7122                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7123                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7124                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7125                getLLVMStyleWithColumns(70));
7126 
7127   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7128                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7129                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7130   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7131                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7132                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7133   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7134                "           (aaaa + aaaa);",
7135                getLLVMStyleWithColumns(40));
7136   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7137                "                  (aaaaaaa + aaaaa));",
7138                getLLVMStyleWithColumns(40));
7139   verifyFormat(
7140       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7141       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7142       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
7143 }
7144 
7145 TEST_F(FormatTest, UnderstandsEquals) {
7146   verifyFormat(
7147       "aaaaaaaaaaaaaaaaa =\n"
7148       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7149   verifyFormat(
7150       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7151       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7152   verifyFormat(
7153       "if (a) {\n"
7154       "  f();\n"
7155       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7156       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7157       "}");
7158 
7159   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7160                "        100000000 + 10000000) {\n}");
7161 }
7162 
7163 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7164   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7165                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
7166 
7167   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7168                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
7169 
7170   verifyFormat(
7171       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7172       "                                                          Parameter2);");
7173 
7174   verifyFormat(
7175       "ShortObject->shortFunction(\n"
7176       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7177       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7178 
7179   verifyFormat("loooooooooooooongFunction(\n"
7180                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
7181 
7182   verifyFormat(
7183       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7184       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7185 
7186   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7187                "    .WillRepeatedly(Return(SomeValue));");
7188   verifyFormat("void f() {\n"
7189                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7190                "      .Times(2)\n"
7191                "      .WillRepeatedly(Return(SomeValue));\n"
7192                "}");
7193   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7194                "    ccccccccccccccccccccccc);");
7195   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7196                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7197                "          .aaaaa(aaaaa),\n"
7198                "      aaaaaaaaaaaaaaaaaaaaa);");
7199   verifyFormat("void f() {\n"
7200                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7201                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7202                "}");
7203   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7204                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7205                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7206                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7207                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7208   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7209                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7210                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7211                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7212                "}");
7213 
7214   // Here, it is not necessary to wrap at "." or "->".
7215   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7216                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7217   verifyFormat(
7218       "aaaaaaaaaaa->aaaaaaaaa(\n"
7219       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7220       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7221 
7222   verifyFormat(
7223       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7224       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7225   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7226                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7227   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7228                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7229 
7230   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7231                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7232                "    .a();");
7233 
7234   FormatStyle NoBinPacking = getLLVMStyle();
7235   NoBinPacking.BinPackParameters = false;
7236   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7237                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7238                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7239                "                         aaaaaaaaaaaaaaaaaaa,\n"
7240                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7241                NoBinPacking);
7242 
7243   // If there is a subsequent call, change to hanging indentation.
7244   verifyFormat(
7245       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7246       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7247       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7248   verifyFormat(
7249       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7250       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7251   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7252                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7253                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7254   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7255                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7256                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7257 }
7258 
7259 TEST_F(FormatTest, WrapsTemplateDeclarations) {
7260   verifyFormat("template <typename T>\n"
7261                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7262   verifyFormat("template <typename T>\n"
7263                "// T should be one of {A, B}.\n"
7264                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7265   verifyFormat(
7266       "template <typename T>\n"
7267       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7268   verifyFormat("template <typename T>\n"
7269                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7270                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7271   verifyFormat(
7272       "template <typename T>\n"
7273       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7274       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
7275   verifyFormat(
7276       "template <typename T>\n"
7277       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7278       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7279       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7280   verifyFormat("template <typename T>\n"
7281                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7282                "    int aaaaaaaaaaaaaaaaaaaaaa);");
7283   verifyFormat(
7284       "template <typename T1, typename T2 = char, typename T3 = char,\n"
7285       "          typename T4 = char>\n"
7286       "void f();");
7287   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7288                "          template <typename> class cccccccccccccccccccccc,\n"
7289                "          typename ddddddddddddd>\n"
7290                "class C {};");
7291   verifyFormat(
7292       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7293       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7294 
7295   verifyFormat("void f() {\n"
7296                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7297                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7298                "}");
7299 
7300   verifyFormat("template <typename T> class C {};");
7301   verifyFormat("template <typename T> void f();");
7302   verifyFormat("template <typename T> void f() {}");
7303   verifyFormat(
7304       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7305       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7306       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7307       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7308       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7309       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7310       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
7311       getLLVMStyleWithColumns(72));
7312   EXPECT_EQ("static_cast<A< //\n"
7313             "    B> *>(\n"
7314             "\n"
7315             ");",
7316             format("static_cast<A<//\n"
7317                    "    B>*>(\n"
7318                    "\n"
7319                    "    );"));
7320   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7321                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7322 
7323   FormatStyle AlwaysBreak = getLLVMStyle();
7324   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7325   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7326   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7327   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7328   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7329                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7330                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
7331   verifyFormat("template <template <typename> class Fooooooo,\n"
7332                "          template <typename> class Baaaaaaar>\n"
7333                "struct C {};",
7334                AlwaysBreak);
7335   verifyFormat("template <typename T> // T can be A, B or C.\n"
7336                "struct C {};",
7337                AlwaysBreak);
7338   verifyFormat("template <enum E> class A {\n"
7339                "public:\n"
7340                "  E *f();\n"
7341                "};");
7342 
7343   FormatStyle NeverBreak = getLLVMStyle();
7344   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7345   verifyFormat("template <typename T> class C {};", NeverBreak);
7346   verifyFormat("template <typename T> void f();", NeverBreak);
7347   verifyFormat("template <typename T> void f() {}", NeverBreak);
7348   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7349                "bbbbbbbbbbbbbbbbbbbb) {}",
7350                NeverBreak);
7351   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7352                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7353                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
7354                NeverBreak);
7355   verifyFormat("template <template <typename> class Fooooooo,\n"
7356                "          template <typename> class Baaaaaaar>\n"
7357                "struct C {};",
7358                NeverBreak);
7359   verifyFormat("template <typename T> // T can be A, B or C.\n"
7360                "struct C {};",
7361                NeverBreak);
7362   verifyFormat("template <enum E> class A {\n"
7363                "public:\n"
7364                "  E *f();\n"
7365                "};",
7366                NeverBreak);
7367   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7368   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7369                "bbbbbbbbbbbbbbbbbbbb) {}",
7370                NeverBreak);
7371 }
7372 
7373 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7374   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7375   Style.ColumnLimit = 60;
7376   EXPECT_EQ("// Baseline - no comments.\n"
7377             "template <\n"
7378             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7379             "void f() {}",
7380             format("// Baseline - no comments.\n"
7381                    "template <\n"
7382                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7383                    "void f() {}",
7384                    Style));
7385 
7386   EXPECT_EQ("template <\n"
7387             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7388             "void f() {}",
7389             format("template <\n"
7390                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7391                    "void f() {}",
7392                    Style));
7393 
7394   EXPECT_EQ(
7395       "template <\n"
7396       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7397       "void f() {}",
7398       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
7399              "void f() {}",
7400              Style));
7401 
7402   EXPECT_EQ(
7403       "template <\n"
7404       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7405       "                                               // multiline\n"
7406       "void f() {}",
7407       format("template <\n"
7408              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7409              "                                              // multiline\n"
7410              "void f() {}",
7411              Style));
7412 
7413   EXPECT_EQ(
7414       "template <typename aaaaaaaaaa<\n"
7415       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
7416       "void f() {}",
7417       format(
7418           "template <\n"
7419           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7420           "void f() {}",
7421           Style));
7422 }
7423 
7424 TEST_F(FormatTest, WrapsTemplateParameters) {
7425   FormatStyle Style = getLLVMStyle();
7426   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7427   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7428   verifyFormat(
7429       "template <typename... a> struct q {};\n"
7430       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7431       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7432       "    y;",
7433       Style);
7434   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7435   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7436   verifyFormat(
7437       "template <typename... a> struct r {};\n"
7438       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7439       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7440       "    y;",
7441       Style);
7442   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7443   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7444   verifyFormat("template <typename... a> struct s {};\n"
7445                "extern s<\n"
7446                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7447                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7448                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7449                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7450                "    y;",
7451                Style);
7452   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7453   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7454   verifyFormat("template <typename... a> struct t {};\n"
7455                "extern t<\n"
7456                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7457                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7458                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7459                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7460                "    y;",
7461                Style);
7462 }
7463 
7464 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7465   verifyFormat(
7466       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7467       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7468   verifyFormat(
7469       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7470       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7471       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7472 
7473   // FIXME: Should we have the extra indent after the second break?
7474   verifyFormat(
7475       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7476       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7477       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7478 
7479   verifyFormat(
7480       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7481       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
7482 
7483   // Breaking at nested name specifiers is generally not desirable.
7484   verifyFormat(
7485       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7486       "    aaaaaaaaaaaaaaaaaaaaaaa);");
7487 
7488   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7489                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7490                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7491                "                   aaaaaaaaaaaaaaaaaaaaa);",
7492                getLLVMStyleWithColumns(74));
7493 
7494   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7495                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7496                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7497 }
7498 
7499 TEST_F(FormatTest, UnderstandsTemplateParameters) {
7500   verifyFormat("A<int> a;");
7501   verifyFormat("A<A<A<int>>> a;");
7502   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7503   verifyFormat("bool x = a < 1 || 2 > a;");
7504   verifyFormat("bool x = 5 < f<int>();");
7505   verifyFormat("bool x = f<int>() > 5;");
7506   verifyFormat("bool x = 5 < a<int>::x;");
7507   verifyFormat("bool x = a < 4 ? a > 2 : false;");
7508   verifyFormat("bool x = f() ? a < 2 : a > 2;");
7509 
7510   verifyGoogleFormat("A<A<int>> a;");
7511   verifyGoogleFormat("A<A<A<int>>> a;");
7512   verifyGoogleFormat("A<A<A<A<int>>>> a;");
7513   verifyGoogleFormat("A<A<int> > a;");
7514   verifyGoogleFormat("A<A<A<int> > > a;");
7515   verifyGoogleFormat("A<A<A<A<int> > > > a;");
7516   verifyGoogleFormat("A<::A<int>> a;");
7517   verifyGoogleFormat("A<::A> a;");
7518   verifyGoogleFormat("A< ::A> a;");
7519   verifyGoogleFormat("A< ::A<int> > a;");
7520   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7521   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7522   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7523   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7524   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7525             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7526 
7527   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7528 
7529   // template closer followed by a token that starts with > or =
7530   verifyFormat("bool b = a<1> > 1;");
7531   verifyFormat("bool b = a<1> >= 1;");
7532   verifyFormat("int i = a<1> >> 1;");
7533   FormatStyle Style = getLLVMStyle();
7534   Style.SpaceBeforeAssignmentOperators = false;
7535   verifyFormat("bool b= a<1> == 1;", Style);
7536   verifyFormat("a<int> = 1;", Style);
7537   verifyFormat("a<int> >>= 1;", Style);
7538 
7539   verifyFormat("test >> a >> b;");
7540   verifyFormat("test << a >> b;");
7541 
7542   verifyFormat("f<int>();");
7543   verifyFormat("template <typename T> void f() {}");
7544   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7545   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7546                "sizeof(char)>::type>;");
7547   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7548   verifyFormat("f(a.operator()<A>());");
7549   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7550                "      .template operator()<A>());",
7551                getLLVMStyleWithColumns(35));
7552 
7553   // Not template parameters.
7554   verifyFormat("return a < b && c > d;");
7555   verifyFormat("void f() {\n"
7556                "  while (a < b && c > d) {\n"
7557                "  }\n"
7558                "}");
7559   verifyFormat("template <typename... Types>\n"
7560                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7561 
7562   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7563                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7564                getLLVMStyleWithColumns(60));
7565   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7566   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7567   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7568   verifyFormat("some_templated_type<decltype([](int i) { return i; })>");
7569 }
7570 
7571 TEST_F(FormatTest, UnderstandsShiftOperators) {
7572   verifyFormat("if (i < x >> 1)");
7573   verifyFormat("while (i < x >> 1)");
7574   verifyFormat("for (unsigned i = 0; i < i; ++i, v = v >> 1)");
7575   verifyFormat("for (unsigned i = 0; i < x >> 1; ++i, v = v >> 1)");
7576   verifyFormat(
7577       "for (std::vector<int>::iterator i = 0; i < x >> 1; ++i, v = v >> 1)");
7578   verifyFormat("Foo.call<Bar<Function>>()");
7579   verifyFormat("if (Foo.call<Bar<Function>>() == 0)");
7580   verifyFormat("for (std::vector<std::pair<int>>::iterator i = 0; i < x >> 1; "
7581                "++i, v = v >> 1)");
7582   verifyFormat("if (w<u<v<x>>, 1>::t)");
7583 }
7584 
7585 TEST_F(FormatTest, BitshiftOperatorWidth) {
7586   EXPECT_EQ("int a = 1 << 2; /* foo\n"
7587             "                   bar */",
7588             format("int    a=1<<2;  /* foo\n"
7589                    "                   bar */"));
7590 
7591   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7592             "                     bar */",
7593             format("int  b  =256>>1 ;  /* foo\n"
7594                    "                      bar */"));
7595 }
7596 
7597 TEST_F(FormatTest, UnderstandsBinaryOperators) {
7598   verifyFormat("COMPARE(a, ==, b);");
7599   verifyFormat("auto s = sizeof...(Ts) - 1;");
7600 }
7601 
7602 TEST_F(FormatTest, UnderstandsPointersToMembers) {
7603   verifyFormat("int A::*x;");
7604   verifyFormat("int (S::*func)(void *);");
7605   verifyFormat("void f() { int (S::*func)(void *); }");
7606   verifyFormat("typedef bool *(Class::*Member)() const;");
7607   verifyFormat("void f() {\n"
7608                "  (a->*f)();\n"
7609                "  a->*x;\n"
7610                "  (a.*f)();\n"
7611                "  ((*a).*f)();\n"
7612                "  a.*x;\n"
7613                "}");
7614   verifyFormat("void f() {\n"
7615                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7616                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7617                "}");
7618   verifyFormat(
7619       "(aaaaaaaaaa->*bbbbbbb)(\n"
7620       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7621   FormatStyle Style = getLLVMStyle();
7622   Style.PointerAlignment = FormatStyle::PAS_Left;
7623   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7624 }
7625 
7626 TEST_F(FormatTest, UnderstandsUnaryOperators) {
7627   verifyFormat("int a = -2;");
7628   verifyFormat("f(-1, -2, -3);");
7629   verifyFormat("a[-1] = 5;");
7630   verifyFormat("int a = 5 + -2;");
7631   verifyFormat("if (i == -1) {\n}");
7632   verifyFormat("if (i != -1) {\n}");
7633   verifyFormat("if (i > -1) {\n}");
7634   verifyFormat("if (i < -1) {\n}");
7635   verifyFormat("++(a->f());");
7636   verifyFormat("--(a->f());");
7637   verifyFormat("(a->f())++;");
7638   verifyFormat("a[42]++;");
7639   verifyFormat("if (!(a->f())) {\n}");
7640   verifyFormat("if (!+i) {\n}");
7641   verifyFormat("~&a;");
7642 
7643   verifyFormat("a-- > b;");
7644   verifyFormat("b ? -a : c;");
7645   verifyFormat("n * sizeof char16;");
7646   verifyFormat("n * alignof char16;", getGoogleStyle());
7647   verifyFormat("sizeof(char);");
7648   verifyFormat("alignof(char);", getGoogleStyle());
7649 
7650   verifyFormat("return -1;");
7651   verifyFormat("throw -1;");
7652   verifyFormat("switch (a) {\n"
7653                "case -1:\n"
7654                "  break;\n"
7655                "}");
7656   verifyFormat("#define X -1");
7657   verifyFormat("#define X -kConstant");
7658 
7659   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7660   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7661 
7662   verifyFormat("int a = /* confusing comment */ -1;");
7663   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7664   verifyFormat("int a = i /* confusing comment */++;");
7665 
7666   verifyFormat("co_yield -1;");
7667   verifyFormat("co_return -1;");
7668 }
7669 
7670 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7671   verifyFormat("if (!aaaaaaaaaa( // break\n"
7672                "        aaaaa)) {\n"
7673                "}");
7674   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7675                "    aaaaa));");
7676   verifyFormat("*aaa = aaaaaaa( // break\n"
7677                "    bbbbbb);");
7678 }
7679 
7680 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7681   verifyFormat("bool operator<();");
7682   verifyFormat("bool operator>();");
7683   verifyFormat("bool operator=();");
7684   verifyFormat("bool operator==();");
7685   verifyFormat("bool operator!=();");
7686   verifyFormat("int operator+();");
7687   verifyFormat("int operator++();");
7688   verifyFormat("int operator++(int) volatile noexcept;");
7689   verifyFormat("bool operator,();");
7690   verifyFormat("bool operator();");
7691   verifyFormat("bool operator()();");
7692   verifyFormat("bool operator[]();");
7693   verifyFormat("operator bool();");
7694   verifyFormat("operator int();");
7695   verifyFormat("operator void *();");
7696   verifyFormat("operator SomeType<int>();");
7697   verifyFormat("operator SomeType<int, int>();");
7698   verifyFormat("operator SomeType<SomeType<int>>();");
7699   verifyFormat("void *operator new(std::size_t size);");
7700   verifyFormat("void *operator new[](std::size_t size);");
7701   verifyFormat("void operator delete(void *ptr);");
7702   verifyFormat("void operator delete[](void *ptr);");
7703   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7704                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7705   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7706                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7707 
7708   verifyFormat(
7709       "ostream &operator<<(ostream &OutputStream,\n"
7710       "                    SomeReallyLongType WithSomeReallyLongValue);");
7711   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7712                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7713                "  return left.group < right.group;\n"
7714                "}");
7715   verifyFormat("SomeType &operator=(const SomeType &S);");
7716   verifyFormat("f.template operator()<int>();");
7717 
7718   verifyGoogleFormat("operator void*();");
7719   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7720   verifyGoogleFormat("operator ::A();");
7721 
7722   verifyFormat("using A::operator+;");
7723   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7724                "int i;");
7725 }
7726 
7727 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7728   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7729   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7730   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7731   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7732   verifyFormat("Deleted &operator=(const Deleted &) &;");
7733   verifyFormat("Deleted &operator=(const Deleted &) &&;");
7734   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7735   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7736   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7737   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7738   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7739   verifyFormat("void Fn(T const &) const &;");
7740   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7741   verifyFormat("template <typename T>\n"
7742                "void F(T) && = delete;",
7743                getGoogleStyle());
7744 
7745   FormatStyle AlignLeft = getLLVMStyle();
7746   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7747   verifyFormat("void A::b() && {}", AlignLeft);
7748   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7749   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7750                AlignLeft);
7751   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7752   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7753   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7754   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7755   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7756   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7757   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7758   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7759 
7760   FormatStyle Spaces = getLLVMStyle();
7761   Spaces.SpacesInCStyleCastParentheses = true;
7762   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7763   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7764   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7765   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7766 
7767   Spaces.SpacesInCStyleCastParentheses = false;
7768   Spaces.SpacesInParentheses = true;
7769   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7770   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7771                Spaces);
7772   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7773   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7774 
7775   FormatStyle BreakTemplate = getLLVMStyle();
7776   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7777 
7778   verifyFormat("struct f {\n"
7779                "  template <class T>\n"
7780                "  int &foo(const std::string &str) &noexcept {}\n"
7781                "};",
7782                BreakTemplate);
7783 
7784   verifyFormat("struct f {\n"
7785                "  template <class T>\n"
7786                "  int &foo(const std::string &str) &&noexcept {}\n"
7787                "};",
7788                BreakTemplate);
7789 
7790   verifyFormat("struct f {\n"
7791                "  template <class T>\n"
7792                "  int &foo(const std::string &str) const &noexcept {}\n"
7793                "};",
7794                BreakTemplate);
7795 
7796   verifyFormat("struct f {\n"
7797                "  template <class T>\n"
7798                "  int &foo(const std::string &str) const &noexcept {}\n"
7799                "};",
7800                BreakTemplate);
7801 
7802   verifyFormat("struct f {\n"
7803                "  template <class T>\n"
7804                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
7805                "};",
7806                BreakTemplate);
7807 
7808   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7809   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7810       FormatStyle::BTDS_Yes;
7811   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7812 
7813   verifyFormat("struct f {\n"
7814                "  template <class T>\n"
7815                "  int& foo(const std::string& str) & noexcept {}\n"
7816                "};",
7817                AlignLeftBreakTemplate);
7818 
7819   verifyFormat("struct f {\n"
7820                "  template <class T>\n"
7821                "  int& foo(const std::string& str) && noexcept {}\n"
7822                "};",
7823                AlignLeftBreakTemplate);
7824 
7825   verifyFormat("struct f {\n"
7826                "  template <class T>\n"
7827                "  int& foo(const std::string& str) const& noexcept {}\n"
7828                "};",
7829                AlignLeftBreakTemplate);
7830 
7831   verifyFormat("struct f {\n"
7832                "  template <class T>\n"
7833                "  int& foo(const std::string& str) const&& noexcept {}\n"
7834                "};",
7835                AlignLeftBreakTemplate);
7836 
7837   verifyFormat("struct f {\n"
7838                "  template <class T>\n"
7839                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7840                "};",
7841                AlignLeftBreakTemplate);
7842 
7843   // The `&` in `Type&` should not be confused with a trailing `&` of
7844   // DEPRECATED(reason) member function.
7845   verifyFormat("struct f {\n"
7846                "  template <class T>\n"
7847                "  DEPRECATED(reason)\n"
7848                "  Type &foo(arguments) {}\n"
7849                "};",
7850                BreakTemplate);
7851 
7852   verifyFormat("struct f {\n"
7853                "  template <class T>\n"
7854                "  DEPRECATED(reason)\n"
7855                "  Type& foo(arguments) {}\n"
7856                "};",
7857                AlignLeftBreakTemplate);
7858 
7859   verifyFormat("void (*foopt)(int) = &func;");
7860 }
7861 
7862 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7863   verifyFormat("void f() {\n"
7864                "  A *a = new A;\n"
7865                "  A *a = new (placement) A;\n"
7866                "  delete a;\n"
7867                "  delete (A *)a;\n"
7868                "}");
7869   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7870                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7871   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7872                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7873                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7874   verifyFormat("delete[] h->p;");
7875 }
7876 
7877 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
7878   verifyFormat("int *f(int *a) {}");
7879   verifyFormat("int main(int argc, char **argv) {}");
7880   verifyFormat("Test::Test(int b) : a(b * b) {}");
7881   verifyIndependentOfContext("f(a, *a);");
7882   verifyFormat("void g() { f(*a); }");
7883   verifyIndependentOfContext("int a = b * 10;");
7884   verifyIndependentOfContext("int a = 10 * b;");
7885   verifyIndependentOfContext("int a = b * c;");
7886   verifyIndependentOfContext("int a += b * c;");
7887   verifyIndependentOfContext("int a -= b * c;");
7888   verifyIndependentOfContext("int a *= b * c;");
7889   verifyIndependentOfContext("int a /= b * c;");
7890   verifyIndependentOfContext("int a = *b;");
7891   verifyIndependentOfContext("int a = *b * c;");
7892   verifyIndependentOfContext("int a = b * *c;");
7893   verifyIndependentOfContext("int a = b * (10);");
7894   verifyIndependentOfContext("S << b * (10);");
7895   verifyIndependentOfContext("return 10 * b;");
7896   verifyIndependentOfContext("return *b * *c;");
7897   verifyIndependentOfContext("return a & ~b;");
7898   verifyIndependentOfContext("f(b ? *c : *d);");
7899   verifyIndependentOfContext("int a = b ? *c : *d;");
7900   verifyIndependentOfContext("*b = a;");
7901   verifyIndependentOfContext("a * ~b;");
7902   verifyIndependentOfContext("a * !b;");
7903   verifyIndependentOfContext("a * +b;");
7904   verifyIndependentOfContext("a * -b;");
7905   verifyIndependentOfContext("a * ++b;");
7906   verifyIndependentOfContext("a * --b;");
7907   verifyIndependentOfContext("a[4] * b;");
7908   verifyIndependentOfContext("a[a * a] = 1;");
7909   verifyIndependentOfContext("f() * b;");
7910   verifyIndependentOfContext("a * [self dostuff];");
7911   verifyIndependentOfContext("int x = a * (a + b);");
7912   verifyIndependentOfContext("(a *)(a + b);");
7913   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
7914   verifyIndependentOfContext("int *pa = (int *)&a;");
7915   verifyIndependentOfContext("return sizeof(int **);");
7916   verifyIndependentOfContext("return sizeof(int ******);");
7917   verifyIndependentOfContext("return (int **&)a;");
7918   verifyIndependentOfContext("f((*PointerToArray)[10]);");
7919   verifyFormat("void f(Type (*parameter)[10]) {}");
7920   verifyFormat("void f(Type (&parameter)[10]) {}");
7921   verifyGoogleFormat("return sizeof(int**);");
7922   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
7923   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
7924   verifyFormat("auto a = [](int **&, int ***) {};");
7925   verifyFormat("auto PointerBinding = [](const char *S) {};");
7926   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
7927   verifyFormat("[](const decltype(*a) &value) {}");
7928   verifyFormat("[](const typeof(*a) &value) {}");
7929   verifyFormat("[](const _Atomic(a *) &value) {}");
7930   verifyFormat("[](const __underlying_type(a) &value) {}");
7931   verifyFormat("decltype(a * b) F();");
7932   verifyFormat("typeof(a * b) F();");
7933   verifyFormat("#define MACRO() [](A *a) { return 1; }");
7934   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
7935   verifyIndependentOfContext("typedef void (*f)(int *a);");
7936   verifyIndependentOfContext("int i{a * b};");
7937   verifyIndependentOfContext("aaa && aaa->f();");
7938   verifyIndependentOfContext("int x = ~*p;");
7939   verifyFormat("Constructor() : a(a), area(width * height) {}");
7940   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
7941   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
7942   verifyFormat("void f() { f(a, c * d); }");
7943   verifyFormat("void f() { f(new a(), c * d); }");
7944   verifyFormat("void f(const MyOverride &override);");
7945   verifyFormat("void f(const MyFinal &final);");
7946   verifyIndependentOfContext("bool a = f() && override.f();");
7947   verifyIndependentOfContext("bool a = f() && final.f();");
7948 
7949   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
7950 
7951   verifyIndependentOfContext("A<int *> a;");
7952   verifyIndependentOfContext("A<int **> a;");
7953   verifyIndependentOfContext("A<int *, int *> a;");
7954   verifyIndependentOfContext("A<int *[]> a;");
7955   verifyIndependentOfContext(
7956       "const char *const p = reinterpret_cast<const char *const>(q);");
7957   verifyIndependentOfContext("A<int **, int **> a;");
7958   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
7959   verifyFormat("for (char **a = b; *a; ++a) {\n}");
7960   verifyFormat("for (; a && b;) {\n}");
7961   verifyFormat("bool foo = true && [] { return false; }();");
7962 
7963   verifyFormat(
7964       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7965       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7966 
7967   verifyGoogleFormat("int const* a = &b;");
7968   verifyGoogleFormat("**outparam = 1;");
7969   verifyGoogleFormat("*outparam = a * b;");
7970   verifyGoogleFormat("int main(int argc, char** argv) {}");
7971   verifyGoogleFormat("A<int*> a;");
7972   verifyGoogleFormat("A<int**> a;");
7973   verifyGoogleFormat("A<int*, int*> a;");
7974   verifyGoogleFormat("A<int**, int**> a;");
7975   verifyGoogleFormat("f(b ? *c : *d);");
7976   verifyGoogleFormat("int a = b ? *c : *d;");
7977   verifyGoogleFormat("Type* t = **x;");
7978   verifyGoogleFormat("Type* t = *++*x;");
7979   verifyGoogleFormat("*++*x;");
7980   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
7981   verifyGoogleFormat("Type* t = x++ * y;");
7982   verifyGoogleFormat(
7983       "const char* const p = reinterpret_cast<const char* const>(q);");
7984   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
7985   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
7986   verifyGoogleFormat("template <typename T>\n"
7987                      "void f(int i = 0, SomeType** temps = NULL);");
7988 
7989   FormatStyle Left = getLLVMStyle();
7990   Left.PointerAlignment = FormatStyle::PAS_Left;
7991   verifyFormat("x = *a(x) = *a(y);", Left);
7992   verifyFormat("for (;; *a = b) {\n}", Left);
7993   verifyFormat("return *this += 1;", Left);
7994   verifyFormat("throw *x;", Left);
7995   verifyFormat("delete *x;", Left);
7996   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
7997   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
7998   verifyFormat("[](const typeof(*a)* ptr) {}", Left);
7999   verifyFormat("[](const _Atomic(a*)* ptr) {}", Left);
8000   verifyFormat("[](const __underlying_type(a)* ptr) {}", Left);
8001   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
8002   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
8003   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
8004   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
8005 
8006   verifyIndependentOfContext("a = *(x + y);");
8007   verifyIndependentOfContext("a = &(x + y);");
8008   verifyIndependentOfContext("*(x + y).call();");
8009   verifyIndependentOfContext("&(x + y)->call();");
8010   verifyFormat("void f() { &(*I).first; }");
8011 
8012   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
8013   verifyFormat(
8014       "int *MyValues = {\n"
8015       "    *A, // Operator detection might be confused by the '{'\n"
8016       "    *BB // Operator detection might be confused by previous comment\n"
8017       "};");
8018 
8019   verifyIndependentOfContext("if (int *a = &b)");
8020   verifyIndependentOfContext("if (int &a = *b)");
8021   verifyIndependentOfContext("if (a & b[i])");
8022   verifyIndependentOfContext("if constexpr (a & b[i])");
8023   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
8024   verifyIndependentOfContext("if (a * (b * c))");
8025   verifyIndependentOfContext("if constexpr (a * (b * c))");
8026   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
8027   verifyIndependentOfContext("if (a::b::c::d & b[i])");
8028   verifyIndependentOfContext("if (*b[i])");
8029   verifyIndependentOfContext("if (int *a = (&b))");
8030   verifyIndependentOfContext("while (int *a = &b)");
8031   verifyIndependentOfContext("while (a * (b * c))");
8032   verifyIndependentOfContext("size = sizeof *a;");
8033   verifyIndependentOfContext("if (a && (b = c))");
8034   verifyFormat("void f() {\n"
8035                "  for (const int &v : Values) {\n"
8036                "  }\n"
8037                "}");
8038   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
8039   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
8040   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
8041 
8042   verifyFormat("#define A (!a * b)");
8043   verifyFormat("#define MACRO     \\\n"
8044                "  int *i = a * b; \\\n"
8045                "  void f(a *b);",
8046                getLLVMStyleWithColumns(19));
8047 
8048   verifyIndependentOfContext("A = new SomeType *[Length];");
8049   verifyIndependentOfContext("A = new SomeType *[Length]();");
8050   verifyIndependentOfContext("T **t = new T *;");
8051   verifyIndependentOfContext("T **t = new T *();");
8052   verifyGoogleFormat("A = new SomeType*[Length]();");
8053   verifyGoogleFormat("A = new SomeType*[Length];");
8054   verifyGoogleFormat("T** t = new T*;");
8055   verifyGoogleFormat("T** t = new T*();");
8056 
8057   verifyFormat("STATIC_ASSERT((a & b) == 0);");
8058   verifyFormat("STATIC_ASSERT(0 == (a & b));");
8059   verifyFormat("template <bool a, bool b> "
8060                "typename t::if<x && y>::type f() {}");
8061   verifyFormat("template <int *y> f() {}");
8062   verifyFormat("vector<int *> v;");
8063   verifyFormat("vector<int *const> v;");
8064   verifyFormat("vector<int *const **const *> v;");
8065   verifyFormat("vector<int *volatile> v;");
8066   verifyFormat("vector<a *_Nonnull> v;");
8067   verifyFormat("vector<a *_Nullable> v;");
8068   verifyFormat("vector<a *_Null_unspecified> v;");
8069   verifyFormat("vector<a *__ptr32> v;");
8070   verifyFormat("vector<a *__ptr64> v;");
8071   verifyFormat("vector<a *__capability> v;");
8072   FormatStyle TypeMacros = getLLVMStyle();
8073   TypeMacros.TypenameMacros = {"LIST"};
8074   verifyFormat("vector<LIST(uint64_t)> v;", TypeMacros);
8075   verifyFormat("vector<LIST(uint64_t) *> v;", TypeMacros);
8076   verifyFormat("vector<LIST(uint64_t) **> v;", TypeMacros);
8077   verifyFormat("vector<LIST(uint64_t) *attr> v;", TypeMacros);
8078   verifyFormat("vector<A(uint64_t) * attr> v;", TypeMacros); // multiplication
8079 
8080   FormatStyle CustomQualifier = getLLVMStyle();
8081   // Add indentifers that should not be parsed as a qualifier by default.
8082   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8083   CustomQualifier.AttributeMacros.push_back("_My_qualifier");
8084   CustomQualifier.AttributeMacros.push_back("my_other_qualifier");
8085   verifyFormat("vector<a * __my_qualifier> parse_as_multiply;");
8086   verifyFormat("vector<a *__my_qualifier> v;", CustomQualifier);
8087   verifyFormat("vector<a * _My_qualifier> parse_as_multiply;");
8088   verifyFormat("vector<a *_My_qualifier> v;", CustomQualifier);
8089   verifyFormat("vector<a * my_other_qualifier> parse_as_multiply;");
8090   verifyFormat("vector<a *my_other_qualifier> v;", CustomQualifier);
8091   verifyFormat("vector<a * _NotAQualifier> v;");
8092   verifyFormat("vector<a * __not_a_qualifier> v;");
8093   verifyFormat("vector<a * b> v;");
8094   verifyFormat("foo<b && false>();");
8095   verifyFormat("foo<b & 1>();");
8096   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
8097   verifyFormat("typeof(*::std::declval<const T &>()) void F();");
8098   verifyFormat("_Atomic(*::std::declval<const T &>()) void F();");
8099   verifyFormat("__underlying_type(*::std::declval<const T &>()) void F();");
8100   verifyFormat(
8101       "template <class T, class = typename std::enable_if<\n"
8102       "                       std::is_integral<T>::value &&\n"
8103       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
8104       "void F();",
8105       getLLVMStyleWithColumns(70));
8106   verifyFormat("template <class T,\n"
8107                "          class = typename std::enable_if<\n"
8108                "              std::is_integral<T>::value &&\n"
8109                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
8110                "          class U>\n"
8111                "void F();",
8112                getLLVMStyleWithColumns(70));
8113   verifyFormat(
8114       "template <class T,\n"
8115       "          class = typename ::std::enable_if<\n"
8116       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
8117       "void F();",
8118       getGoogleStyleWithColumns(68));
8119 
8120   verifyIndependentOfContext("MACRO(int *i);");
8121   verifyIndependentOfContext("MACRO(auto *a);");
8122   verifyIndependentOfContext("MACRO(const A *a);");
8123   verifyIndependentOfContext("MACRO(_Atomic(A) *a);");
8124   verifyIndependentOfContext("MACRO(decltype(A) *a);");
8125   verifyIndependentOfContext("MACRO(typeof(A) *a);");
8126   verifyIndependentOfContext("MACRO(__underlying_type(A) *a);");
8127   verifyIndependentOfContext("MACRO(A *const a);");
8128   verifyIndependentOfContext("MACRO(A *restrict a);");
8129   verifyIndependentOfContext("MACRO(A *__restrict__ a);");
8130   verifyIndependentOfContext("MACRO(A *__restrict a);");
8131   verifyIndependentOfContext("MACRO(A *volatile a);");
8132   verifyIndependentOfContext("MACRO(A *__volatile a);");
8133   verifyIndependentOfContext("MACRO(A *__volatile__ a);");
8134   verifyIndependentOfContext("MACRO(A *_Nonnull a);");
8135   verifyIndependentOfContext("MACRO(A *_Nullable a);");
8136   verifyIndependentOfContext("MACRO(A *_Null_unspecified a);");
8137   verifyIndependentOfContext("MACRO(A *__attribute__((foo)) a);");
8138   verifyIndependentOfContext("MACRO(A *__attribute((foo)) a);");
8139   verifyIndependentOfContext("MACRO(A *[[clang::attr]] a);");
8140   verifyIndependentOfContext("MACRO(A *[[clang::attr(\"foo\")]] a);");
8141   verifyIndependentOfContext("MACRO(A *__ptr32 a);");
8142   verifyIndependentOfContext("MACRO(A *__ptr64 a);");
8143   verifyIndependentOfContext("MACRO(A *__capability);");
8144   verifyIndependentOfContext("MACRO(A &__capability);");
8145   verifyFormat("MACRO(A *__my_qualifier);");               // type declaration
8146   verifyFormat("void f() { MACRO(A * __my_qualifier); }"); // multiplication
8147   // If we add __my_qualifier to AttributeMacros it should always be parsed as
8148   // a type declaration:
8149   verifyFormat("MACRO(A *__my_qualifier);", CustomQualifier);
8150   verifyFormat("void f() { MACRO(A *__my_qualifier); }", CustomQualifier);
8151   // Also check that TypenameMacros prevents parsing it as multiplication:
8152   verifyIndependentOfContext("MACRO(LIST(uint64_t) * a);"); // multiplication
8153   verifyIndependentOfContext("MACRO(LIST(uint64_t) *a);", TypeMacros); // type
8154 
8155   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
8156   verifyFormat("void f() { f(float{1}, a * a); }");
8157   // FIXME: Is there a way to make this work?
8158   // verifyIndependentOfContext("MACRO(A *a);");
8159   verifyFormat("MACRO(A &B);");
8160   verifyFormat("MACRO(A *B);");
8161   verifyFormat("void f() { MACRO(A * B); }");
8162   verifyFormat("void f() { MACRO(A & B); }");
8163 
8164   verifyFormat("DatumHandle const *operator->() const { return input_; }");
8165   verifyFormat("return options != nullptr && operator==(*options);");
8166 
8167   EXPECT_EQ("#define OP(x)                                    \\\n"
8168             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
8169             "    return s << a.DebugString();                 \\\n"
8170             "  }",
8171             format("#define OP(x) \\\n"
8172                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
8173                    "    return s << a.DebugString(); \\\n"
8174                    "  }",
8175                    getLLVMStyleWithColumns(50)));
8176 
8177   // FIXME: We cannot handle this case yet; we might be able to figure out that
8178   // foo<x> d > v; doesn't make sense.
8179   verifyFormat("foo<a<b && c> d> v;");
8180 
8181   FormatStyle PointerMiddle = getLLVMStyle();
8182   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8183   verifyFormat("delete *x;", PointerMiddle);
8184   verifyFormat("int * x;", PointerMiddle);
8185   verifyFormat("int *[] x;", PointerMiddle);
8186   verifyFormat("template <int * y> f() {}", PointerMiddle);
8187   verifyFormat("int * f(int * a) {}", PointerMiddle);
8188   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8189   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8190   verifyFormat("A<int *> a;", PointerMiddle);
8191   verifyFormat("A<int **> a;", PointerMiddle);
8192   verifyFormat("A<int *, int *> a;", PointerMiddle);
8193   verifyFormat("A<int *[]> a;", PointerMiddle);
8194   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8195   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8196   verifyFormat("T ** t = new T *;", PointerMiddle);
8197 
8198   // Member function reference qualifiers aren't binary operators.
8199   verifyFormat("string // break\n"
8200                "operator()() & {}");
8201   verifyFormat("string // break\n"
8202                "operator()() && {}");
8203   verifyGoogleFormat("template <typename T>\n"
8204                      "auto x() & -> int {}");
8205 }
8206 
8207 TEST_F(FormatTest, UnderstandsAttributes) {
8208   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8209   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8210                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8211   FormatStyle AfterType = getLLVMStyle();
8212   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
8213   verifyFormat("__attribute__((nodebug)) void\n"
8214                "foo() {}\n",
8215                AfterType);
8216   verifyFormat("__unused void\n"
8217                "foo() {}",
8218                AfterType);
8219 
8220   FormatStyle CustomAttrs = getLLVMStyle();
8221   CustomAttrs.AttributeMacros.push_back("__unused");
8222   CustomAttrs.AttributeMacros.push_back("__attr1");
8223   CustomAttrs.AttributeMacros.push_back("__attr2");
8224   CustomAttrs.AttributeMacros.push_back("no_underscore_attr");
8225   verifyFormat("vector<SomeType *__attribute((foo))> v;");
8226   verifyFormat("vector<SomeType *__attribute__((foo))> v;");
8227   verifyFormat("vector<SomeType * __not_attribute__((foo))> v;");
8228   // Check that it is parsed as a multiplication without AttributeMacros and
8229   // as a pointer qualifier when we add __attr1/__attr2 to AttributeMacros.
8230   verifyFormat("vector<SomeType * __attr1> v;");
8231   verifyFormat("vector<SomeType __attr1 *> v;");
8232   verifyFormat("vector<SomeType __attr1 *const> v;");
8233   verifyFormat("vector<SomeType __attr1 * __attr2> v;");
8234   verifyFormat("vector<SomeType *__attr1> v;", CustomAttrs);
8235   verifyFormat("vector<SomeType *__attr2> v;", CustomAttrs);
8236   verifyFormat("vector<SomeType *no_underscore_attr> v;", CustomAttrs);
8237   verifyFormat("vector<SomeType __attr1 *> v;", CustomAttrs);
8238   verifyFormat("vector<SomeType __attr1 *const> v;", CustomAttrs);
8239   verifyFormat("vector<SomeType __attr1 *__attr2> v;", CustomAttrs);
8240   verifyFormat("vector<SomeType __attr1 *no_underscore_attr> v;", CustomAttrs);
8241 
8242   // Check that these are not parsed as function declarations:
8243   CustomAttrs.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8244   CustomAttrs.BreakBeforeBraces = FormatStyle::BS_Allman;
8245   verifyFormat("SomeType s(InitValue);", CustomAttrs);
8246   verifyFormat("SomeType s{InitValue};", CustomAttrs);
8247   verifyFormat("SomeType *__unused s(InitValue);", CustomAttrs);
8248   verifyFormat("SomeType *__unused s{InitValue};", CustomAttrs);
8249   verifyFormat("SomeType s __unused(InitValue);", CustomAttrs);
8250   verifyFormat("SomeType s __unused{InitValue};", CustomAttrs);
8251   verifyFormat("SomeType *__capability s(InitValue);", CustomAttrs);
8252   verifyFormat("SomeType *__capability s{InitValue};", CustomAttrs);
8253 }
8254 
8255 TEST_F(FormatTest, UnderstandsPointerQualifiersInCast) {
8256   // Check that qualifiers on pointers don't break parsing of casts.
8257   verifyFormat("x = (foo *const)*v;");
8258   verifyFormat("x = (foo *volatile)*v;");
8259   verifyFormat("x = (foo *restrict)*v;");
8260   verifyFormat("x = (foo *__attribute__((foo)))*v;");
8261   verifyFormat("x = (foo *_Nonnull)*v;");
8262   verifyFormat("x = (foo *_Nullable)*v;");
8263   verifyFormat("x = (foo *_Null_unspecified)*v;");
8264   verifyFormat("x = (foo *_Nonnull)*v;");
8265   verifyFormat("x = (foo *[[clang::attr]])*v;");
8266   verifyFormat("x = (foo *[[clang::attr(\"foo\")]])*v;");
8267   verifyFormat("x = (foo *__ptr32)*v;");
8268   verifyFormat("x = (foo *__ptr64)*v;");
8269   verifyFormat("x = (foo *__capability)*v;");
8270 
8271   // Check that we handle multiple trailing qualifiers and skip them all to
8272   // determine that the expression is a cast to a pointer type.
8273   FormatStyle LongPointerRight = getLLVMStyleWithColumns(999);
8274   FormatStyle LongPointerLeft = getLLVMStyleWithColumns(999);
8275   LongPointerLeft.PointerAlignment = FormatStyle::PAS_Left;
8276   StringRef AllQualifiers =
8277       "const volatile restrict __attribute__((foo)) _Nonnull _Null_unspecified "
8278       "_Nonnull [[clang::attr]] __ptr32 __ptr64 __capability";
8279   verifyFormat(("x = (foo *" + AllQualifiers + ")*v;").str(), LongPointerRight);
8280   verifyFormat(("x = (foo* " + AllQualifiers + ")*v;").str(), LongPointerLeft);
8281 
8282   // Also check that address-of is not parsed as a binary bitwise-and:
8283   verifyFormat("x = (foo *const)&v;");
8284   verifyFormat(("x = (foo *" + AllQualifiers + ")&v;").str(), LongPointerRight);
8285   verifyFormat(("x = (foo* " + AllQualifiers + ")&v;").str(), LongPointerLeft);
8286 
8287   // Check custom qualifiers:
8288   FormatStyle CustomQualifier = getLLVMStyleWithColumns(999);
8289   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8290   verifyFormat("x = (foo * __my_qualifier) * v;"); // not parsed as qualifier.
8291   verifyFormat("x = (foo *__my_qualifier)*v;", CustomQualifier);
8292   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)*v;").str(),
8293                CustomQualifier);
8294   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)&v;").str(),
8295                CustomQualifier);
8296 
8297   // Check that unknown identifiers result in binary operator parsing:
8298   verifyFormat("x = (foo * __unknown_qualifier) * v;");
8299   verifyFormat("x = (foo * __unknown_qualifier) & v;");
8300 }
8301 
8302 TEST_F(FormatTest, UnderstandsSquareAttributes) {
8303   verifyFormat("SomeType s [[unused]] (InitValue);");
8304   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8305   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8306   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8307   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8308   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8309                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8310   verifyFormat("[[nodiscard]] bool f() { return false; }");
8311   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
8312   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
8313   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
8314 
8315   // Make sure we do not mistake attributes for array subscripts.
8316   verifyFormat("int a() {}\n"
8317                "[[unused]] int b() {}\n");
8318   verifyFormat("NSArray *arr;\n"
8319                "arr[[Foo() bar]];");
8320 
8321   // On the other hand, we still need to correctly find array subscripts.
8322   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8323 
8324   // Make sure that we do not mistake Objective-C method inside array literals
8325   // as attributes, even if those method names are also keywords.
8326   verifyFormat("@[ [foo bar] ];");
8327   verifyFormat("@[ [NSArray class] ];");
8328   verifyFormat("@[ [foo enum] ];");
8329 
8330   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8331 
8332   // Make sure we do not parse attributes as lambda introducers.
8333   FormatStyle MultiLineFunctions = getLLVMStyle();
8334   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8335   verifyFormat("[[unused]] int b() {\n"
8336                "  return 42;\n"
8337                "}\n",
8338                MultiLineFunctions);
8339 }
8340 
8341 TEST_F(FormatTest, AttributeClass) {
8342   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8343   verifyFormat("class S {\n"
8344                "  S(S&&) = default;\n"
8345                "};",
8346                Style);
8347   verifyFormat("class [[nodiscard]] S {\n"
8348                "  S(S&&) = default;\n"
8349                "};",
8350                Style);
8351   verifyFormat("class __attribute((maybeunused)) S {\n"
8352                "  S(S&&) = default;\n"
8353                "};",
8354                Style);
8355   verifyFormat("struct S {\n"
8356                "  S(S&&) = default;\n"
8357                "};",
8358                Style);
8359   verifyFormat("struct [[nodiscard]] S {\n"
8360                "  S(S&&) = default;\n"
8361                "};",
8362                Style);
8363 }
8364 
8365 TEST_F(FormatTest, AttributesAfterMacro) {
8366   FormatStyle Style = getLLVMStyle();
8367   verifyFormat("MACRO;\n"
8368                "__attribute__((maybe_unused)) int foo() {\n"
8369                "  //...\n"
8370                "}");
8371 
8372   verifyFormat("MACRO;\n"
8373                "[[nodiscard]] int foo() {\n"
8374                "  //...\n"
8375                "}");
8376 
8377   EXPECT_EQ("MACRO\n\n"
8378             "__attribute__((maybe_unused)) int foo() {\n"
8379             "  //...\n"
8380             "}",
8381             format("MACRO\n\n"
8382                    "__attribute__((maybe_unused)) int foo() {\n"
8383                    "  //...\n"
8384                    "}"));
8385 
8386   EXPECT_EQ("MACRO\n\n"
8387             "[[nodiscard]] int foo() {\n"
8388             "  //...\n"
8389             "}",
8390             format("MACRO\n\n"
8391                    "[[nodiscard]] int foo() {\n"
8392                    "  //...\n"
8393                    "}"));
8394 }
8395 
8396 TEST_F(FormatTest, AttributePenaltyBreaking) {
8397   FormatStyle Style = getLLVMStyle();
8398   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8399                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8400                Style);
8401   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8402                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8403                Style);
8404   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8405                "shared_ptr<ALongTypeName> &C d) {\n}",
8406                Style);
8407 }
8408 
8409 TEST_F(FormatTest, UnderstandsEllipsis) {
8410   FormatStyle Style = getLLVMStyle();
8411   verifyFormat("int printf(const char *fmt, ...);");
8412   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8413   verifyFormat("template <class... Ts> void Foo(Ts *...ts) {}");
8414 
8415   verifyFormat("template <int *...PP> a;", Style);
8416 
8417   Style.PointerAlignment = FormatStyle::PAS_Left;
8418   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", Style);
8419 
8420   verifyFormat("template <int*... PP> a;", Style);
8421 
8422   Style.PointerAlignment = FormatStyle::PAS_Middle;
8423   verifyFormat("template <int *... PP> a;", Style);
8424 }
8425 
8426 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8427   EXPECT_EQ("int *a;\n"
8428             "int *a;\n"
8429             "int *a;",
8430             format("int *a;\n"
8431                    "int* a;\n"
8432                    "int *a;",
8433                    getGoogleStyle()));
8434   EXPECT_EQ("int* a;\n"
8435             "int* a;\n"
8436             "int* a;",
8437             format("int* a;\n"
8438                    "int* a;\n"
8439                    "int *a;",
8440                    getGoogleStyle()));
8441   EXPECT_EQ("int *a;\n"
8442             "int *a;\n"
8443             "int *a;",
8444             format("int *a;\n"
8445                    "int * a;\n"
8446                    "int *  a;",
8447                    getGoogleStyle()));
8448   EXPECT_EQ("auto x = [] {\n"
8449             "  int *a;\n"
8450             "  int *a;\n"
8451             "  int *a;\n"
8452             "};",
8453             format("auto x=[]{int *a;\n"
8454                    "int * a;\n"
8455                    "int *  a;};",
8456                    getGoogleStyle()));
8457 }
8458 
8459 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8460   verifyFormat("int f(int &&a) {}");
8461   verifyFormat("int f(int a, char &&b) {}");
8462   verifyFormat("void f() { int &&a = b; }");
8463   verifyGoogleFormat("int f(int a, char&& b) {}");
8464   verifyGoogleFormat("void f() { int&& a = b; }");
8465 
8466   verifyIndependentOfContext("A<int &&> a;");
8467   verifyIndependentOfContext("A<int &&, int &&> a;");
8468   verifyGoogleFormat("A<int&&> a;");
8469   verifyGoogleFormat("A<int&&, int&&> a;");
8470 
8471   // Not rvalue references:
8472   verifyFormat("template <bool B, bool C> class A {\n"
8473                "  static_assert(B && C, \"Something is wrong\");\n"
8474                "};");
8475   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8476   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8477   verifyFormat("#define A(a, b) (a && b)");
8478 }
8479 
8480 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8481   verifyFormat("void f() {\n"
8482                "  x[aaaaaaaaa -\n"
8483                "    b] = 23;\n"
8484                "}",
8485                getLLVMStyleWithColumns(15));
8486 }
8487 
8488 TEST_F(FormatTest, FormatsCasts) {
8489   verifyFormat("Type *A = static_cast<Type *>(P);");
8490   verifyFormat("Type *A = (Type *)P;");
8491   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8492   verifyFormat("int a = (int)(2.0f);");
8493   verifyFormat("int a = (int)2.0f;");
8494   verifyFormat("x[(int32)y];");
8495   verifyFormat("x = (int32)y;");
8496   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8497   verifyFormat("int a = (int)*b;");
8498   verifyFormat("int a = (int)2.0f;");
8499   verifyFormat("int a = (int)~0;");
8500   verifyFormat("int a = (int)++a;");
8501   verifyFormat("int a = (int)sizeof(int);");
8502   verifyFormat("int a = (int)+2;");
8503   verifyFormat("my_int a = (my_int)2.0f;");
8504   verifyFormat("my_int a = (my_int)sizeof(int);");
8505   verifyFormat("return (my_int)aaa;");
8506   verifyFormat("#define x ((int)-1)");
8507   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8508   verifyFormat("#define p(q) ((int *)&q)");
8509   verifyFormat("fn(a)(b) + 1;");
8510 
8511   verifyFormat("void f() { my_int a = (my_int)*b; }");
8512   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8513   verifyFormat("my_int a = (my_int)~0;");
8514   verifyFormat("my_int a = (my_int)++a;");
8515   verifyFormat("my_int a = (my_int)-2;");
8516   verifyFormat("my_int a = (my_int)1;");
8517   verifyFormat("my_int a = (my_int *)1;");
8518   verifyFormat("my_int a = (const my_int)-1;");
8519   verifyFormat("my_int a = (const my_int *)-1;");
8520   verifyFormat("my_int a = (my_int)(my_int)-1;");
8521   verifyFormat("my_int a = (ns::my_int)-2;");
8522   verifyFormat("case (my_int)ONE:");
8523   verifyFormat("auto x = (X)this;");
8524   // Casts in Obj-C style calls used to not be recognized as such.
8525   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8526 
8527   // FIXME: single value wrapped with paren will be treated as cast.
8528   verifyFormat("void f(int i = (kValue)*kMask) {}");
8529 
8530   verifyFormat("{ (void)F; }");
8531 
8532   // Don't break after a cast's
8533   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8534                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8535                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8536 
8537   // These are not casts.
8538   verifyFormat("void f(int *) {}");
8539   verifyFormat("f(foo)->b;");
8540   verifyFormat("f(foo).b;");
8541   verifyFormat("f(foo)(b);");
8542   verifyFormat("f(foo)[b];");
8543   verifyFormat("[](foo) { return 4; }(bar);");
8544   verifyFormat("(*funptr)(foo)[4];");
8545   verifyFormat("funptrs[4](foo)[4];");
8546   verifyFormat("void f(int *);");
8547   verifyFormat("void f(int *) = 0;");
8548   verifyFormat("void f(SmallVector<int>) {}");
8549   verifyFormat("void f(SmallVector<int>);");
8550   verifyFormat("void f(SmallVector<int>) = 0;");
8551   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8552   verifyFormat("int a = sizeof(int) * b;");
8553   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8554   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8555   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8556   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8557 
8558   // These are not casts, but at some point were confused with casts.
8559   verifyFormat("virtual void foo(int *) override;");
8560   verifyFormat("virtual void foo(char &) const;");
8561   verifyFormat("virtual void foo(int *a, char *) const;");
8562   verifyFormat("int a = sizeof(int *) + b;");
8563   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8564   verifyFormat("bool b = f(g<int>) && c;");
8565   verifyFormat("typedef void (*f)(int i) func;");
8566   verifyFormat("void operator++(int) noexcept;");
8567   verifyFormat("void operator++(int &) noexcept;");
8568   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8569                "&) noexcept;");
8570   verifyFormat(
8571       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8572   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8573   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8574   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8575   verifyFormat("void operator delete(foo &) noexcept;");
8576   verifyFormat("void operator delete(foo) noexcept;");
8577   verifyFormat("void operator delete(int) noexcept;");
8578   verifyFormat("void operator delete(int &) noexcept;");
8579   verifyFormat("void operator delete(int &) volatile noexcept;");
8580   verifyFormat("void operator delete(int &) const");
8581   verifyFormat("void operator delete(int &) = default");
8582   verifyFormat("void operator delete(int &) = delete");
8583   verifyFormat("void operator delete(int &) [[noreturn]]");
8584   verifyFormat("void operator delete(int &) throw();");
8585   verifyFormat("void operator delete(int &) throw(int);");
8586   verifyFormat("auto operator delete(int &) -> int;");
8587   verifyFormat("auto operator delete(int &) override");
8588   verifyFormat("auto operator delete(int &) final");
8589 
8590   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8591                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8592   // FIXME: The indentation here is not ideal.
8593   verifyFormat(
8594       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8595       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8596       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8597 }
8598 
8599 TEST_F(FormatTest, FormatsFunctionTypes) {
8600   verifyFormat("A<bool()> a;");
8601   verifyFormat("A<SomeType()> a;");
8602   verifyFormat("A<void (*)(int, std::string)> a;");
8603   verifyFormat("A<void *(int)>;");
8604   verifyFormat("void *(*a)(int *, SomeType *);");
8605   verifyFormat("int (*func)(void *);");
8606   verifyFormat("void f() { int (*func)(void *); }");
8607   verifyFormat("template <class CallbackClass>\n"
8608                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8609 
8610   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8611   verifyGoogleFormat("void* (*a)(int);");
8612   verifyGoogleFormat(
8613       "template <class CallbackClass>\n"
8614       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8615 
8616   // Other constructs can look somewhat like function types:
8617   verifyFormat("A<sizeof(*x)> a;");
8618   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8619   verifyFormat("some_var = function(*some_pointer_var)[0];");
8620   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8621   verifyFormat("int x = f(&h)();");
8622   verifyFormat("returnsFunction(&param1, &param2)(param);");
8623   verifyFormat("std::function<\n"
8624                "    LooooooooooongTemplatedType<\n"
8625                "        SomeType>*(\n"
8626                "        LooooooooooooooooongType type)>\n"
8627                "    function;",
8628                getGoogleStyleWithColumns(40));
8629 }
8630 
8631 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8632   verifyFormat("A (*foo_)[6];");
8633   verifyFormat("vector<int> (*foo_)[6];");
8634 }
8635 
8636 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8637   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8638                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8639   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8640                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8641   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8642                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8643 
8644   // Different ways of ()-initializiation.
8645   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8646                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8647   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8648                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8649   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8650                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8651   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8652                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8653 
8654   // Lambdas should not confuse the variable declaration heuristic.
8655   verifyFormat("LooooooooooooooooongType\n"
8656                "    variable(nullptr, [](A *a) {});",
8657                getLLVMStyleWithColumns(40));
8658 }
8659 
8660 TEST_F(FormatTest, BreaksLongDeclarations) {
8661   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8662                "    AnotherNameForTheLongType;");
8663   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8664                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8665   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8666                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8667   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8668                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8669   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8670                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8671   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8672                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8673   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8674                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8675   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8676                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8677   verifyFormat("typeof(LoooooooooooooooooooooooooooooooooooooooooongName)\n"
8678                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8679   verifyFormat("_Atomic(LooooooooooooooooooooooooooooooooooooooooongName)\n"
8680                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8681   verifyFormat("__underlying_type(LooooooooooooooooooooooooooooooongName)\n"
8682                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8683   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8684                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8685   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8686                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8687   FormatStyle Indented = getLLVMStyle();
8688   Indented.IndentWrappedFunctionNames = true;
8689   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8690                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8691                Indented);
8692   verifyFormat(
8693       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8694       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8695       Indented);
8696   verifyFormat(
8697       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8698       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8699       Indented);
8700   verifyFormat(
8701       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8702       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8703       Indented);
8704 
8705   // FIXME: Without the comment, this breaks after "(".
8706   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8707                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8708                getGoogleStyle());
8709 
8710   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8711                "                  int LoooooooooooooooooooongParam2) {}");
8712   verifyFormat(
8713       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8714       "                                   SourceLocation L, IdentifierIn *II,\n"
8715       "                                   Type *T) {}");
8716   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8717                "ReallyReaaallyLongFunctionName(\n"
8718                "    const std::string &SomeParameter,\n"
8719                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8720                "        &ReallyReallyLongParameterName,\n"
8721                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8722                "        &AnotherLongParameterName) {}");
8723   verifyFormat("template <typename A>\n"
8724                "SomeLoooooooooooooooooooooongType<\n"
8725                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8726                "Function() {}");
8727 
8728   verifyGoogleFormat(
8729       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8730       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8731   verifyGoogleFormat(
8732       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8733       "                                   SourceLocation L) {}");
8734   verifyGoogleFormat(
8735       "some_namespace::LongReturnType\n"
8736       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8737       "    int first_long_parameter, int second_parameter) {}");
8738 
8739   verifyGoogleFormat("template <typename T>\n"
8740                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8741                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8742   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8743                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8744 
8745   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8746                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8747                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8748   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8749                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8750                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8751   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8752                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8753                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8754                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8755 
8756   verifyFormat("template <typename T> // Templates on own line.\n"
8757                "static int            // Some comment.\n"
8758                "MyFunction(int a);",
8759                getLLVMStyle());
8760 }
8761 
8762 TEST_F(FormatTest, FormatsArrays) {
8763   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8764                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8765   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8766                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8767   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8768                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8769   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8770                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8771   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8772                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8773   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8774                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8775                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8776   verifyFormat(
8777       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8778       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8779       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8780   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8781                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8782 
8783   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8784                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8785   verifyFormat(
8786       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8787       "                                  .aaaaaaa[0]\n"
8788       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8789   verifyFormat("a[::b::c];");
8790 
8791   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8792 
8793   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8794   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8795 }
8796 
8797 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8798   verifyFormat("(a)->b();");
8799   verifyFormat("--a;");
8800 }
8801 
8802 TEST_F(FormatTest, HandlesIncludeDirectives) {
8803   verifyFormat("#include <string>\n"
8804                "#include <a/b/c.h>\n"
8805                "#include \"a/b/string\"\n"
8806                "#include \"string.h\"\n"
8807                "#include \"string.h\"\n"
8808                "#include <a-a>\n"
8809                "#include < path with space >\n"
8810                "#include_next <test.h>"
8811                "#include \"abc.h\" // this is included for ABC\n"
8812                "#include \"some long include\" // with a comment\n"
8813                "#include \"some very long include path\"\n"
8814                "#include <some/very/long/include/path>\n",
8815                getLLVMStyleWithColumns(35));
8816   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8817   EXPECT_EQ("#include <a>", format("#include<a>"));
8818 
8819   verifyFormat("#import <string>");
8820   verifyFormat("#import <a/b/c.h>");
8821   verifyFormat("#import \"a/b/string\"");
8822   verifyFormat("#import \"string.h\"");
8823   verifyFormat("#import \"string.h\"");
8824   verifyFormat("#if __has_include(<strstream>)\n"
8825                "#include <strstream>\n"
8826                "#endif");
8827 
8828   verifyFormat("#define MY_IMPORT <a/b>");
8829 
8830   verifyFormat("#if __has_include(<a/b>)");
8831   verifyFormat("#if __has_include_next(<a/b>)");
8832   verifyFormat("#define F __has_include(<a/b>)");
8833   verifyFormat("#define F __has_include_next(<a/b>)");
8834 
8835   // Protocol buffer definition or missing "#".
8836   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8837                getLLVMStyleWithColumns(30));
8838 
8839   FormatStyle Style = getLLVMStyle();
8840   Style.AlwaysBreakBeforeMultilineStrings = true;
8841   Style.ColumnLimit = 0;
8842   verifyFormat("#import \"abc.h\"", Style);
8843 
8844   // But 'import' might also be a regular C++ namespace.
8845   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8846                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8847 }
8848 
8849 //===----------------------------------------------------------------------===//
8850 // Error recovery tests.
8851 //===----------------------------------------------------------------------===//
8852 
8853 TEST_F(FormatTest, IncompleteParameterLists) {
8854   FormatStyle NoBinPacking = getLLVMStyle();
8855   NoBinPacking.BinPackParameters = false;
8856   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8857                "                        double *min_x,\n"
8858                "                        double *max_x,\n"
8859                "                        double *min_y,\n"
8860                "                        double *max_y,\n"
8861                "                        double *min_z,\n"
8862                "                        double *max_z, ) {}",
8863                NoBinPacking);
8864 }
8865 
8866 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8867   verifyFormat("void f() { return; }\n42");
8868   verifyFormat("void f() {\n"
8869                "  if (0)\n"
8870                "    return;\n"
8871                "}\n"
8872                "42");
8873   verifyFormat("void f() { return }\n42");
8874   verifyFormat("void f() {\n"
8875                "  if (0)\n"
8876                "    return\n"
8877                "}\n"
8878                "42");
8879 }
8880 
8881 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
8882   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
8883   EXPECT_EQ("void f() {\n"
8884             "  if (a)\n"
8885             "    return\n"
8886             "}",
8887             format("void  f  (  )  {  if  ( a )  return  }"));
8888   EXPECT_EQ("namespace N {\n"
8889             "void f()\n"
8890             "}",
8891             format("namespace  N  {  void f()  }"));
8892   EXPECT_EQ("namespace N {\n"
8893             "void f() {}\n"
8894             "void g()\n"
8895             "} // namespace N",
8896             format("namespace N  { void f( ) { } void g( ) }"));
8897 }
8898 
8899 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
8900   verifyFormat("int aaaaaaaa =\n"
8901                "    // Overlylongcomment\n"
8902                "    b;",
8903                getLLVMStyleWithColumns(20));
8904   verifyFormat("function(\n"
8905                "    ShortArgument,\n"
8906                "    LoooooooooooongArgument);\n",
8907                getLLVMStyleWithColumns(20));
8908 }
8909 
8910 TEST_F(FormatTest, IncorrectAccessSpecifier) {
8911   verifyFormat("public:");
8912   verifyFormat("class A {\n"
8913                "public\n"
8914                "  void f() {}\n"
8915                "};");
8916   verifyFormat("public\n"
8917                "int qwerty;");
8918   verifyFormat("public\n"
8919                "B {}");
8920   verifyFormat("public\n"
8921                "{}");
8922   verifyFormat("public\n"
8923                "B { int x; }");
8924 }
8925 
8926 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
8927   verifyFormat("{");
8928   verifyFormat("#})");
8929   verifyNoCrash("(/**/[:!] ?[).");
8930 }
8931 
8932 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
8933   // Found by oss-fuzz:
8934   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
8935   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
8936   Style.ColumnLimit = 60;
8937   verifyNoCrash(
8938       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
8939       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
8940       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
8941       Style);
8942 }
8943 
8944 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
8945   verifyFormat("do {\n}");
8946   verifyFormat("do {\n}\n"
8947                "f();");
8948   verifyFormat("do {\n}\n"
8949                "wheeee(fun);");
8950   verifyFormat("do {\n"
8951                "  f();\n"
8952                "}");
8953 }
8954 
8955 TEST_F(FormatTest, IncorrectCodeMissingParens) {
8956   verifyFormat("if {\n  foo;\n  foo();\n}");
8957   verifyFormat("switch {\n  foo;\n  foo();\n}");
8958   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
8959   verifyFormat("while {\n  foo;\n  foo();\n}");
8960   verifyFormat("do {\n  foo;\n  foo();\n} while;");
8961 }
8962 
8963 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
8964   verifyIncompleteFormat("namespace {\n"
8965                          "class Foo { Foo (\n"
8966                          "};\n"
8967                          "} // namespace");
8968 }
8969 
8970 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
8971   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
8972   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
8973   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
8974   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
8975 
8976   EXPECT_EQ("{\n"
8977             "  {\n"
8978             "    breakme(\n"
8979             "        qwe);\n"
8980             "  }\n",
8981             format("{\n"
8982                    "    {\n"
8983                    " breakme(qwe);\n"
8984                    "}\n",
8985                    getLLVMStyleWithColumns(10)));
8986 }
8987 
8988 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
8989   verifyFormat("int x = {\n"
8990                "    avariable,\n"
8991                "    b(alongervariable)};",
8992                getLLVMStyleWithColumns(25));
8993 }
8994 
8995 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
8996   verifyFormat("return (a)(b){1, 2, 3};");
8997 }
8998 
8999 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
9000   verifyFormat("vector<int> x{1, 2, 3, 4};");
9001   verifyFormat("vector<int> x{\n"
9002                "    1,\n"
9003                "    2,\n"
9004                "    3,\n"
9005                "    4,\n"
9006                "};");
9007   verifyFormat("vector<T> x{{}, {}, {}, {}};");
9008   verifyFormat("f({1, 2});");
9009   verifyFormat("auto v = Foo{-1};");
9010   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
9011   verifyFormat("Class::Class : member{1, 2, 3} {}");
9012   verifyFormat("new vector<int>{1, 2, 3};");
9013   verifyFormat("new int[3]{1, 2, 3};");
9014   verifyFormat("new int{1};");
9015   verifyFormat("return {arg1, arg2};");
9016   verifyFormat("return {arg1, SomeType{parameter}};");
9017   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
9018   verifyFormat("new T{arg1, arg2};");
9019   verifyFormat("f(MyMap[{composite, key}]);");
9020   verifyFormat("class Class {\n"
9021                "  T member = {arg1, arg2};\n"
9022                "};");
9023   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
9024   verifyFormat("const struct A a = {.a = 1, .b = 2};");
9025   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
9026   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
9027   verifyFormat("int a = std::is_integral<int>{} + 0;");
9028 
9029   verifyFormat("int foo(int i) { return fo1{}(i); }");
9030   verifyFormat("int foo(int i) { return fo1{}(i); }");
9031   verifyFormat("auto i = decltype(x){};");
9032   verifyFormat("auto i = typeof(x){};");
9033   verifyFormat("auto i = _Atomic(x){};");
9034   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
9035   verifyFormat("Node n{1, Node{1000}, //\n"
9036                "       2};");
9037   verifyFormat("Aaaa aaaaaaa{\n"
9038                "    {\n"
9039                "        aaaa,\n"
9040                "    },\n"
9041                "};");
9042   verifyFormat("class C : public D {\n"
9043                "  SomeClass SC{2};\n"
9044                "};");
9045   verifyFormat("class C : public A {\n"
9046                "  class D : public B {\n"
9047                "    void f() { int i{2}; }\n"
9048                "  };\n"
9049                "};");
9050   verifyFormat("#define A {a, a},");
9051 
9052   // Avoid breaking between equal sign and opening brace
9053   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
9054   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
9055   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
9056                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
9057                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
9058                "     {\"ccccccccccccccccccccc\", 2}};",
9059                AvoidBreakingFirstArgument);
9060 
9061   // Binpacking only if there is no trailing comma
9062   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
9063                "                      cccccccccc, dddddddddd};",
9064                getLLVMStyleWithColumns(50));
9065   verifyFormat("const Aaaaaa aaaaa = {\n"
9066                "    aaaaaaaaaaa,\n"
9067                "    bbbbbbbbbbb,\n"
9068                "    ccccccccccc,\n"
9069                "    ddddddddddd,\n"
9070                "};",
9071                getLLVMStyleWithColumns(50));
9072 
9073   // Cases where distinguising braced lists and blocks is hard.
9074   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
9075   verifyFormat("void f() {\n"
9076                "  return; // comment\n"
9077                "}\n"
9078                "SomeType t;");
9079   verifyFormat("void f() {\n"
9080                "  if (a) {\n"
9081                "    f();\n"
9082                "  }\n"
9083                "}\n"
9084                "SomeType t;");
9085 
9086   // In combination with BinPackArguments = false.
9087   FormatStyle NoBinPacking = getLLVMStyle();
9088   NoBinPacking.BinPackArguments = false;
9089   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
9090                "                      bbbbb,\n"
9091                "                      ccccc,\n"
9092                "                      ddddd,\n"
9093                "                      eeeee,\n"
9094                "                      ffffff,\n"
9095                "                      ggggg,\n"
9096                "                      hhhhhh,\n"
9097                "                      iiiiii,\n"
9098                "                      jjjjjj,\n"
9099                "                      kkkkkk};",
9100                NoBinPacking);
9101   verifyFormat("const Aaaaaa aaaaa = {\n"
9102                "    aaaaa,\n"
9103                "    bbbbb,\n"
9104                "    ccccc,\n"
9105                "    ddddd,\n"
9106                "    eeeee,\n"
9107                "    ffffff,\n"
9108                "    ggggg,\n"
9109                "    hhhhhh,\n"
9110                "    iiiiii,\n"
9111                "    jjjjjj,\n"
9112                "    kkkkkk,\n"
9113                "};",
9114                NoBinPacking);
9115   verifyFormat(
9116       "const Aaaaaa aaaaa = {\n"
9117       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
9118       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
9119       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
9120       "};",
9121       NoBinPacking);
9122 
9123   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
9124   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
9125             "    CDDDP83848_BMCR_REGISTER,\n"
9126             "    CDDDP83848_BMSR_REGISTER,\n"
9127             "    CDDDP83848_RBR_REGISTER};",
9128             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
9129                    "                                CDDDP83848_BMSR_REGISTER,\n"
9130                    "                                CDDDP83848_RBR_REGISTER};",
9131                    NoBinPacking));
9132 
9133   // FIXME: The alignment of these trailing comments might be bad. Then again,
9134   // this might be utterly useless in real code.
9135   verifyFormat("Constructor::Constructor()\n"
9136                "    : some_value{         //\n"
9137                "                 aaaaaaa, //\n"
9138                "                 bbbbbbb} {}");
9139 
9140   // In braced lists, the first comment is always assumed to belong to the
9141   // first element. Thus, it can be moved to the next or previous line as
9142   // appropriate.
9143   EXPECT_EQ("function({// First element:\n"
9144             "          1,\n"
9145             "          // Second element:\n"
9146             "          2});",
9147             format("function({\n"
9148                    "    // First element:\n"
9149                    "    1,\n"
9150                    "    // Second element:\n"
9151                    "    2});"));
9152   EXPECT_EQ("std::vector<int> MyNumbers{\n"
9153             "    // First element:\n"
9154             "    1,\n"
9155             "    // Second element:\n"
9156             "    2};",
9157             format("std::vector<int> MyNumbers{// First element:\n"
9158                    "                           1,\n"
9159                    "                           // Second element:\n"
9160                    "                           2};",
9161                    getLLVMStyleWithColumns(30)));
9162   // A trailing comma should still lead to an enforced line break and no
9163   // binpacking.
9164   EXPECT_EQ("vector<int> SomeVector = {\n"
9165             "    // aaa\n"
9166             "    1,\n"
9167             "    2,\n"
9168             "};",
9169             format("vector<int> SomeVector = { // aaa\n"
9170                    "    1, 2, };"));
9171 
9172   // C++11 brace initializer list l-braces should not be treated any differently
9173   // when breaking before lambda bodies is enabled
9174   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
9175   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
9176   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
9177   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
9178   verifyFormat(
9179       "std::runtime_error{\n"
9180       "    \"Long string which will force a break onto the next line...\"};",
9181       BreakBeforeLambdaBody);
9182 
9183   FormatStyle ExtraSpaces = getLLVMStyle();
9184   ExtraSpaces.Cpp11BracedListStyle = false;
9185   ExtraSpaces.ColumnLimit = 75;
9186   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
9187   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
9188   verifyFormat("f({ 1, 2 });", ExtraSpaces);
9189   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
9190   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
9191   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
9192   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
9193   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
9194   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
9195   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
9196   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
9197   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
9198   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
9199   verifyFormat("class Class {\n"
9200                "  T member = { arg1, arg2 };\n"
9201                "};",
9202                ExtraSpaces);
9203   verifyFormat(
9204       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9205       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
9206       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
9207       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
9208       ExtraSpaces);
9209   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
9210   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
9211                ExtraSpaces);
9212   verifyFormat(
9213       "someFunction(OtherParam,\n"
9214       "             BracedList{ // comment 1 (Forcing interesting break)\n"
9215       "                         param1, param2,\n"
9216       "                         // comment 2\n"
9217       "                         param3, param4 });",
9218       ExtraSpaces);
9219   verifyFormat(
9220       "std::this_thread::sleep_for(\n"
9221       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
9222       ExtraSpaces);
9223   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
9224                "    aaaaaaa,\n"
9225                "    aaaaaaaaaa,\n"
9226                "    aaaaa,\n"
9227                "    aaaaaaaaaaaaaaa,\n"
9228                "    aaa,\n"
9229                "    aaaaaaaaaa,\n"
9230                "    a,\n"
9231                "    aaaaaaaaaaaaaaaaaaaaa,\n"
9232                "    aaaaaaaaaaaa,\n"
9233                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
9234                "    aaaaaaa,\n"
9235                "    a};");
9236   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
9237   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
9238   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
9239 
9240   // Avoid breaking between initializer/equal sign and opening brace
9241   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
9242   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
9243                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9244                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9245                "  { \"ccccccccccccccccccccc\", 2 }\n"
9246                "};",
9247                ExtraSpaces);
9248   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
9249                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9250                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9251                "  { \"ccccccccccccccccccccc\", 2 }\n"
9252                "};",
9253                ExtraSpaces);
9254 
9255   FormatStyle SpaceBeforeBrace = getLLVMStyle();
9256   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9257   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9258   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9259 
9260   FormatStyle SpaceBetweenBraces = getLLVMStyle();
9261   SpaceBetweenBraces.SpacesInAngles = true;
9262   SpaceBetweenBraces.SpacesInParentheses = true;
9263   SpaceBetweenBraces.SpacesInSquareBrackets = true;
9264   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9265   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9266   verifyFormat("vector< int > x{ // comment 1\n"
9267                "                 1, 2, 3, 4 };",
9268                SpaceBetweenBraces);
9269   SpaceBetweenBraces.ColumnLimit = 20;
9270   EXPECT_EQ("vector< int > x{\n"
9271             "    1, 2, 3, 4 };",
9272             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9273   SpaceBetweenBraces.ColumnLimit = 24;
9274   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9275             "                 3, 4 };",
9276             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9277   EXPECT_EQ("vector< int > x{\n"
9278             "    1,\n"
9279             "    2,\n"
9280             "    3,\n"
9281             "    4,\n"
9282             "};",
9283             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9284   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9285   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9286   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9287 }
9288 
9289 TEST_F(FormatTest, FormatSpacesInAngles) {
9290   FormatStyle SpaceInAngles = getLLVMStyle();
9291   SpaceInAngles.SpacesInAngles = true;
9292   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9293   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9294   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9295 
9296   SpaceInAngles.SpacesInAngles = false;
9297   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9298   verifyFormat("vector<int> x5;", SpaceInAngles);
9299   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9300   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9301 }
9302 
9303 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9304   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9305                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9306                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9307                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9308                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9309                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9310   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9311                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9312                "                 1, 22, 333, 4444, 55555, //\n"
9313                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9314                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9315   verifyFormat(
9316       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9317       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9318       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9319       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9320       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9321       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9322       "                 7777777};");
9323   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9324                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9325                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9326   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9327                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9328                "    // Separating comment.\n"
9329                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9330   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9331                "    // Leading comment\n"
9332                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9333                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9334   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9335                "                 1, 1, 1, 1};",
9336                getLLVMStyleWithColumns(39));
9337   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9338                "                 1, 1, 1, 1};",
9339                getLLVMStyleWithColumns(38));
9340   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9341                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9342                getLLVMStyleWithColumns(43));
9343   verifyFormat(
9344       "static unsigned SomeValues[10][3] = {\n"
9345       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9346       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9347   verifyFormat("static auto fields = new vector<string>{\n"
9348                "    \"aaaaaaaaaaaaa\",\n"
9349                "    \"aaaaaaaaaaaaa\",\n"
9350                "    \"aaaaaaaaaaaa\",\n"
9351                "    \"aaaaaaaaaaaaaa\",\n"
9352                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9353                "    \"aaaaaaaaaaaa\",\n"
9354                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9355                "};");
9356   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9357   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9358                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9359                "                 3, cccccccccccccccccccccc};",
9360                getLLVMStyleWithColumns(60));
9361 
9362   // Trailing commas.
9363   verifyFormat("vector<int> x = {\n"
9364                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9365                "};",
9366                getLLVMStyleWithColumns(39));
9367   verifyFormat("vector<int> x = {\n"
9368                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9369                "};",
9370                getLLVMStyleWithColumns(39));
9371   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9372                "                 1, 1, 1, 1,\n"
9373                "                 /**/ /**/};",
9374                getLLVMStyleWithColumns(39));
9375 
9376   // Trailing comment in the first line.
9377   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9378                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9379                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9380                "    11111111,   22222222,   333333333,   44444444};");
9381   // Trailing comment in the last line.
9382   verifyFormat("int aaaaa[] = {\n"
9383                "    1, 2, 3, // comment\n"
9384                "    4, 5, 6  // comment\n"
9385                "};");
9386 
9387   // With nested lists, we should either format one item per line or all nested
9388   // lists one on line.
9389   // FIXME: For some nested lists, we can do better.
9390   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9391                "        {aaaaaaaaaaaaaaaaaaa},\n"
9392                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9393                "        {aaaaaaaaaaaaaaaaa}};",
9394                getLLVMStyleWithColumns(60));
9395   verifyFormat(
9396       "SomeStruct my_struct_array = {\n"
9397       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9398       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9399       "    {aaa, aaa},\n"
9400       "    {aaa, aaa},\n"
9401       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9402       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9403       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9404 
9405   // No column layout should be used here.
9406   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9407                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9408 
9409   verifyNoCrash("a<,");
9410 
9411   // No braced initializer here.
9412   verifyFormat("void f() {\n"
9413                "  struct Dummy {};\n"
9414                "  f(v);\n"
9415                "}");
9416 
9417   // Long lists should be formatted in columns even if they are nested.
9418   verifyFormat(
9419       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9420       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9421       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9422       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9423       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9424       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9425 
9426   // Allow "single-column" layout even if that violates the column limit. There
9427   // isn't going to be a better way.
9428   verifyFormat("std::vector<int> a = {\n"
9429                "    aaaaaaaa,\n"
9430                "    aaaaaaaa,\n"
9431                "    aaaaaaaa,\n"
9432                "    aaaaaaaa,\n"
9433                "    aaaaaaaaaa,\n"
9434                "    aaaaaaaa,\n"
9435                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9436                getLLVMStyleWithColumns(30));
9437   verifyFormat("vector<int> aaaa = {\n"
9438                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9439                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9440                "    aaaaaa.aaaaaaa,\n"
9441                "    aaaaaa.aaaaaaa,\n"
9442                "    aaaaaa.aaaaaaa,\n"
9443                "    aaaaaa.aaaaaaa,\n"
9444                "};");
9445 
9446   // Don't create hanging lists.
9447   verifyFormat("someFunction(Param, {List1, List2,\n"
9448                "                     List3});",
9449                getLLVMStyleWithColumns(35));
9450   verifyFormat("someFunction(Param, Param,\n"
9451                "             {List1, List2,\n"
9452                "              List3});",
9453                getLLVMStyleWithColumns(35));
9454   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9455                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9456 }
9457 
9458 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9459   FormatStyle DoNotMerge = getLLVMStyle();
9460   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9461 
9462   verifyFormat("void f() { return 42; }");
9463   verifyFormat("void f() {\n"
9464                "  return 42;\n"
9465                "}",
9466                DoNotMerge);
9467   verifyFormat("void f() {\n"
9468                "  // Comment\n"
9469                "}");
9470   verifyFormat("{\n"
9471                "#error {\n"
9472                "  int a;\n"
9473                "}");
9474   verifyFormat("{\n"
9475                "  int a;\n"
9476                "#error {\n"
9477                "}");
9478   verifyFormat("void f() {} // comment");
9479   verifyFormat("void f() { int a; } // comment");
9480   verifyFormat("void f() {\n"
9481                "} // comment",
9482                DoNotMerge);
9483   verifyFormat("void f() {\n"
9484                "  int a;\n"
9485                "} // comment",
9486                DoNotMerge);
9487   verifyFormat("void f() {\n"
9488                "} // comment",
9489                getLLVMStyleWithColumns(15));
9490 
9491   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9492   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9493 
9494   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9495   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9496   verifyFormat("class C {\n"
9497                "  C()\n"
9498                "      : iiiiiiii(nullptr),\n"
9499                "        kkkkkkk(nullptr),\n"
9500                "        mmmmmmm(nullptr),\n"
9501                "        nnnnnnn(nullptr) {}\n"
9502                "};",
9503                getGoogleStyle());
9504 
9505   FormatStyle NoColumnLimit = getLLVMStyle();
9506   NoColumnLimit.ColumnLimit = 0;
9507   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9508   EXPECT_EQ("class C {\n"
9509             "  A() : b(0) {}\n"
9510             "};",
9511             format("class C{A():b(0){}};", NoColumnLimit));
9512   EXPECT_EQ("A()\n"
9513             "    : b(0) {\n"
9514             "}",
9515             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9516 
9517   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9518   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9519       FormatStyle::SFS_None;
9520   EXPECT_EQ("A()\n"
9521             "    : b(0) {\n"
9522             "}",
9523             format("A():b(0){}", DoNotMergeNoColumnLimit));
9524   EXPECT_EQ("A()\n"
9525             "    : b(0) {\n"
9526             "}",
9527             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9528 
9529   verifyFormat("#define A          \\\n"
9530                "  void f() {       \\\n"
9531                "    int i;         \\\n"
9532                "  }",
9533                getLLVMStyleWithColumns(20));
9534   verifyFormat("#define A           \\\n"
9535                "  void f() { int i; }",
9536                getLLVMStyleWithColumns(21));
9537   verifyFormat("#define A            \\\n"
9538                "  void f() {         \\\n"
9539                "    int i;           \\\n"
9540                "  }                  \\\n"
9541                "  int j;",
9542                getLLVMStyleWithColumns(22));
9543   verifyFormat("#define A             \\\n"
9544                "  void f() { int i; } \\\n"
9545                "  int j;",
9546                getLLVMStyleWithColumns(23));
9547 }
9548 
9549 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9550   FormatStyle MergeEmptyOnly = getLLVMStyle();
9551   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9552   verifyFormat("class C {\n"
9553                "  int f() {}\n"
9554                "};",
9555                MergeEmptyOnly);
9556   verifyFormat("class C {\n"
9557                "  int f() {\n"
9558                "    return 42;\n"
9559                "  }\n"
9560                "};",
9561                MergeEmptyOnly);
9562   verifyFormat("int f() {}", MergeEmptyOnly);
9563   verifyFormat("int f() {\n"
9564                "  return 42;\n"
9565                "}",
9566                MergeEmptyOnly);
9567 
9568   // Also verify behavior when BraceWrapping.AfterFunction = true
9569   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9570   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9571   verifyFormat("int f() {}", MergeEmptyOnly);
9572   verifyFormat("class C {\n"
9573                "  int f() {}\n"
9574                "};",
9575                MergeEmptyOnly);
9576 }
9577 
9578 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9579   FormatStyle MergeInlineOnly = getLLVMStyle();
9580   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9581   verifyFormat("class C {\n"
9582                "  int f() { return 42; }\n"
9583                "};",
9584                MergeInlineOnly);
9585   verifyFormat("int f() {\n"
9586                "  return 42;\n"
9587                "}",
9588                MergeInlineOnly);
9589 
9590   // SFS_Inline implies SFS_Empty
9591   verifyFormat("class C {\n"
9592                "  int f() {}\n"
9593                "};",
9594                MergeInlineOnly);
9595   verifyFormat("int f() {}", MergeInlineOnly);
9596 
9597   // Also verify behavior when BraceWrapping.AfterFunction = true
9598   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9599   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9600   verifyFormat("class C {\n"
9601                "  int f() { return 42; }\n"
9602                "};",
9603                MergeInlineOnly);
9604   verifyFormat("int f()\n"
9605                "{\n"
9606                "  return 42;\n"
9607                "}",
9608                MergeInlineOnly);
9609 
9610   // SFS_Inline implies SFS_Empty
9611   verifyFormat("int f() {}", MergeInlineOnly);
9612   verifyFormat("class C {\n"
9613                "  int f() {}\n"
9614                "};",
9615                MergeInlineOnly);
9616 }
9617 
9618 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9619   FormatStyle MergeInlineOnly = getLLVMStyle();
9620   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9621       FormatStyle::SFS_InlineOnly;
9622   verifyFormat("class C {\n"
9623                "  int f() { return 42; }\n"
9624                "};",
9625                MergeInlineOnly);
9626   verifyFormat("int f() {\n"
9627                "  return 42;\n"
9628                "}",
9629                MergeInlineOnly);
9630 
9631   // SFS_InlineOnly does not imply SFS_Empty
9632   verifyFormat("class C {\n"
9633                "  int f() {}\n"
9634                "};",
9635                MergeInlineOnly);
9636   verifyFormat("int f() {\n"
9637                "}",
9638                MergeInlineOnly);
9639 
9640   // Also verify behavior when BraceWrapping.AfterFunction = true
9641   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9642   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9643   verifyFormat("class C {\n"
9644                "  int f() { return 42; }\n"
9645                "};",
9646                MergeInlineOnly);
9647   verifyFormat("int f()\n"
9648                "{\n"
9649                "  return 42;\n"
9650                "}",
9651                MergeInlineOnly);
9652 
9653   // SFS_InlineOnly does not imply SFS_Empty
9654   verifyFormat("int f()\n"
9655                "{\n"
9656                "}",
9657                MergeInlineOnly);
9658   verifyFormat("class C {\n"
9659                "  int f() {}\n"
9660                "};",
9661                MergeInlineOnly);
9662 }
9663 
9664 TEST_F(FormatTest, SplitEmptyFunction) {
9665   FormatStyle Style = getLLVMStyle();
9666   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9667   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9668   Style.BraceWrapping.AfterFunction = true;
9669   Style.BraceWrapping.SplitEmptyFunction = false;
9670   Style.ColumnLimit = 40;
9671 
9672   verifyFormat("int f()\n"
9673                "{}",
9674                Style);
9675   verifyFormat("int f()\n"
9676                "{\n"
9677                "  return 42;\n"
9678                "}",
9679                Style);
9680   verifyFormat("int f()\n"
9681                "{\n"
9682                "  // some comment\n"
9683                "}",
9684                Style);
9685 
9686   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9687   verifyFormat("int f() {}", Style);
9688   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9689                "{}",
9690                Style);
9691   verifyFormat("int f()\n"
9692                "{\n"
9693                "  return 0;\n"
9694                "}",
9695                Style);
9696 
9697   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9698   verifyFormat("class Foo {\n"
9699                "  int f() {}\n"
9700                "};\n",
9701                Style);
9702   verifyFormat("class Foo {\n"
9703                "  int f() { return 0; }\n"
9704                "};\n",
9705                Style);
9706   verifyFormat("class Foo {\n"
9707                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9708                "  {}\n"
9709                "};\n",
9710                Style);
9711   verifyFormat("class Foo {\n"
9712                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9713                "  {\n"
9714                "    return 0;\n"
9715                "  }\n"
9716                "};\n",
9717                Style);
9718 
9719   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9720   verifyFormat("int f() {}", Style);
9721   verifyFormat("int f() { return 0; }", Style);
9722   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9723                "{}",
9724                Style);
9725   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9726                "{\n"
9727                "  return 0;\n"
9728                "}",
9729                Style);
9730 }
9731 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9732   FormatStyle Style = getLLVMStyle();
9733   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9734   verifyFormat("#ifdef A\n"
9735                "int f() {}\n"
9736                "#else\n"
9737                "int g() {}\n"
9738                "#endif",
9739                Style);
9740 }
9741 
9742 TEST_F(FormatTest, SplitEmptyClass) {
9743   FormatStyle Style = getLLVMStyle();
9744   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9745   Style.BraceWrapping.AfterClass = true;
9746   Style.BraceWrapping.SplitEmptyRecord = false;
9747 
9748   verifyFormat("class Foo\n"
9749                "{};",
9750                Style);
9751   verifyFormat("/* something */ class Foo\n"
9752                "{};",
9753                Style);
9754   verifyFormat("template <typename X> class Foo\n"
9755                "{};",
9756                Style);
9757   verifyFormat("class Foo\n"
9758                "{\n"
9759                "  Foo();\n"
9760                "};",
9761                Style);
9762   verifyFormat("typedef class Foo\n"
9763                "{\n"
9764                "} Foo_t;",
9765                Style);
9766 }
9767 
9768 TEST_F(FormatTest, SplitEmptyStruct) {
9769   FormatStyle Style = getLLVMStyle();
9770   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9771   Style.BraceWrapping.AfterStruct = true;
9772   Style.BraceWrapping.SplitEmptyRecord = false;
9773 
9774   verifyFormat("struct Foo\n"
9775                "{};",
9776                Style);
9777   verifyFormat("/* something */ struct Foo\n"
9778                "{};",
9779                Style);
9780   verifyFormat("template <typename X> struct Foo\n"
9781                "{};",
9782                Style);
9783   verifyFormat("struct Foo\n"
9784                "{\n"
9785                "  Foo();\n"
9786                "};",
9787                Style);
9788   verifyFormat("typedef struct Foo\n"
9789                "{\n"
9790                "} Foo_t;",
9791                Style);
9792   // typedef struct Bar {} Bar_t;
9793 }
9794 
9795 TEST_F(FormatTest, SplitEmptyUnion) {
9796   FormatStyle Style = getLLVMStyle();
9797   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9798   Style.BraceWrapping.AfterUnion = true;
9799   Style.BraceWrapping.SplitEmptyRecord = false;
9800 
9801   verifyFormat("union Foo\n"
9802                "{};",
9803                Style);
9804   verifyFormat("/* something */ union Foo\n"
9805                "{};",
9806                Style);
9807   verifyFormat("union Foo\n"
9808                "{\n"
9809                "  A,\n"
9810                "};",
9811                Style);
9812   verifyFormat("typedef union Foo\n"
9813                "{\n"
9814                "} Foo_t;",
9815                Style);
9816 }
9817 
9818 TEST_F(FormatTest, SplitEmptyNamespace) {
9819   FormatStyle Style = getLLVMStyle();
9820   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9821   Style.BraceWrapping.AfterNamespace = true;
9822   Style.BraceWrapping.SplitEmptyNamespace = false;
9823 
9824   verifyFormat("namespace Foo\n"
9825                "{};",
9826                Style);
9827   verifyFormat("/* something */ namespace Foo\n"
9828                "{};",
9829                Style);
9830   verifyFormat("inline namespace Foo\n"
9831                "{};",
9832                Style);
9833   verifyFormat("/* something */ inline namespace Foo\n"
9834                "{};",
9835                Style);
9836   verifyFormat("export namespace Foo\n"
9837                "{};",
9838                Style);
9839   verifyFormat("namespace Foo\n"
9840                "{\n"
9841                "void Bar();\n"
9842                "};",
9843                Style);
9844 }
9845 
9846 TEST_F(FormatTest, NeverMergeShortRecords) {
9847   FormatStyle Style = getLLVMStyle();
9848 
9849   verifyFormat("class Foo {\n"
9850                "  Foo();\n"
9851                "};",
9852                Style);
9853   verifyFormat("typedef class Foo {\n"
9854                "  Foo();\n"
9855                "} Foo_t;",
9856                Style);
9857   verifyFormat("struct Foo {\n"
9858                "  Foo();\n"
9859                "};",
9860                Style);
9861   verifyFormat("typedef struct Foo {\n"
9862                "  Foo();\n"
9863                "} Foo_t;",
9864                Style);
9865   verifyFormat("union Foo {\n"
9866                "  A,\n"
9867                "};",
9868                Style);
9869   verifyFormat("typedef union Foo {\n"
9870                "  A,\n"
9871                "} Foo_t;",
9872                Style);
9873   verifyFormat("namespace Foo {\n"
9874                "void Bar();\n"
9875                "};",
9876                Style);
9877 
9878   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9879   Style.BraceWrapping.AfterClass = true;
9880   Style.BraceWrapping.AfterStruct = true;
9881   Style.BraceWrapping.AfterUnion = true;
9882   Style.BraceWrapping.AfterNamespace = true;
9883   verifyFormat("class Foo\n"
9884                "{\n"
9885                "  Foo();\n"
9886                "};",
9887                Style);
9888   verifyFormat("typedef class Foo\n"
9889                "{\n"
9890                "  Foo();\n"
9891                "} Foo_t;",
9892                Style);
9893   verifyFormat("struct Foo\n"
9894                "{\n"
9895                "  Foo();\n"
9896                "};",
9897                Style);
9898   verifyFormat("typedef struct Foo\n"
9899                "{\n"
9900                "  Foo();\n"
9901                "} Foo_t;",
9902                Style);
9903   verifyFormat("union Foo\n"
9904                "{\n"
9905                "  A,\n"
9906                "};",
9907                Style);
9908   verifyFormat("typedef union Foo\n"
9909                "{\n"
9910                "  A,\n"
9911                "} Foo_t;",
9912                Style);
9913   verifyFormat("namespace Foo\n"
9914                "{\n"
9915                "void Bar();\n"
9916                "};",
9917                Style);
9918 }
9919 
9920 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
9921   // Elaborate type variable declarations.
9922   verifyFormat("struct foo a = {bar};\nint n;");
9923   verifyFormat("class foo a = {bar};\nint n;");
9924   verifyFormat("union foo a = {bar};\nint n;");
9925 
9926   // Elaborate types inside function definitions.
9927   verifyFormat("struct foo f() {}\nint n;");
9928   verifyFormat("class foo f() {}\nint n;");
9929   verifyFormat("union foo f() {}\nint n;");
9930 
9931   // Templates.
9932   verifyFormat("template <class X> void f() {}\nint n;");
9933   verifyFormat("template <struct X> void f() {}\nint n;");
9934   verifyFormat("template <union X> void f() {}\nint n;");
9935 
9936   // Actual definitions...
9937   verifyFormat("struct {\n} n;");
9938   verifyFormat(
9939       "template <template <class T, class Y>, class Z> class X {\n} n;");
9940   verifyFormat("union Z {\n  int n;\n} x;");
9941   verifyFormat("class MACRO Z {\n} n;");
9942   verifyFormat("class MACRO(X) Z {\n} n;");
9943   verifyFormat("class __attribute__(X) Z {\n} n;");
9944   verifyFormat("class __declspec(X) Z {\n} n;");
9945   verifyFormat("class A##B##C {\n} n;");
9946   verifyFormat("class alignas(16) Z {\n} n;");
9947   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
9948   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
9949 
9950   // Redefinition from nested context:
9951   verifyFormat("class A::B::C {\n} n;");
9952 
9953   // Template definitions.
9954   verifyFormat(
9955       "template <typename F>\n"
9956       "Matcher(const Matcher<F> &Other,\n"
9957       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
9958       "                             !is_same<F, T>::value>::type * = 0)\n"
9959       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
9960 
9961   // FIXME: This is still incorrectly handled at the formatter side.
9962   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
9963   verifyFormat("int i = SomeFunction(a<b, a> b);");
9964 
9965   // FIXME:
9966   // This now gets parsed incorrectly as class definition.
9967   // verifyFormat("class A<int> f() {\n}\nint n;");
9968 
9969   // Elaborate types where incorrectly parsing the structural element would
9970   // break the indent.
9971   verifyFormat("if (true)\n"
9972                "  class X x;\n"
9973                "else\n"
9974                "  f();\n");
9975 
9976   // This is simply incomplete. Formatting is not important, but must not crash.
9977   verifyFormat("class A:");
9978 }
9979 
9980 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
9981   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
9982             format("#error Leave     all         white!!!!! space* alone!\n"));
9983   EXPECT_EQ(
9984       "#warning Leave     all         white!!!!! space* alone!\n",
9985       format("#warning Leave     all         white!!!!! space* alone!\n"));
9986   EXPECT_EQ("#error 1", format("  #  error   1"));
9987   EXPECT_EQ("#warning 1", format("  #  warning 1"));
9988 }
9989 
9990 TEST_F(FormatTest, FormatHashIfExpressions) {
9991   verifyFormat("#if AAAA && BBBB");
9992   verifyFormat("#if (AAAA && BBBB)");
9993   verifyFormat("#elif (AAAA && BBBB)");
9994   // FIXME: Come up with a better indentation for #elif.
9995   verifyFormat(
9996       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
9997       "    defined(BBBBBBBB)\n"
9998       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
9999       "    defined(BBBBBBBB)\n"
10000       "#endif",
10001       getLLVMStyleWithColumns(65));
10002 }
10003 
10004 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
10005   FormatStyle AllowsMergedIf = getGoogleStyle();
10006   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
10007       FormatStyle::SIS_WithoutElse;
10008   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
10009   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
10010   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
10011   EXPECT_EQ("if (true) return 42;",
10012             format("if (true)\nreturn 42;", AllowsMergedIf));
10013   FormatStyle ShortMergedIf = AllowsMergedIf;
10014   ShortMergedIf.ColumnLimit = 25;
10015   verifyFormat("#define A \\\n"
10016                "  if (true) return 42;",
10017                ShortMergedIf);
10018   verifyFormat("#define A \\\n"
10019                "  f();    \\\n"
10020                "  if (true)\n"
10021                "#define B",
10022                ShortMergedIf);
10023   verifyFormat("#define A \\\n"
10024                "  f();    \\\n"
10025                "  if (true)\n"
10026                "g();",
10027                ShortMergedIf);
10028   verifyFormat("{\n"
10029                "#ifdef A\n"
10030                "  // Comment\n"
10031                "  if (true) continue;\n"
10032                "#endif\n"
10033                "  // Comment\n"
10034                "  if (true) continue;\n"
10035                "}",
10036                ShortMergedIf);
10037   ShortMergedIf.ColumnLimit = 33;
10038   verifyFormat("#define A \\\n"
10039                "  if constexpr (true) return 42;",
10040                ShortMergedIf);
10041   verifyFormat("#define A \\\n"
10042                "  if CONSTEXPR (true) return 42;",
10043                ShortMergedIf);
10044   ShortMergedIf.ColumnLimit = 29;
10045   verifyFormat("#define A                   \\\n"
10046                "  if (aaaaaaaaaa) return 1; \\\n"
10047                "  return 2;",
10048                ShortMergedIf);
10049   ShortMergedIf.ColumnLimit = 28;
10050   verifyFormat("#define A         \\\n"
10051                "  if (aaaaaaaaaa) \\\n"
10052                "    return 1;     \\\n"
10053                "  return 2;",
10054                ShortMergedIf);
10055   verifyFormat("#define A                \\\n"
10056                "  if constexpr (aaaaaaa) \\\n"
10057                "    return 1;            \\\n"
10058                "  return 2;",
10059                ShortMergedIf);
10060   verifyFormat("#define A                \\\n"
10061                "  if CONSTEXPR (aaaaaaa) \\\n"
10062                "    return 1;            \\\n"
10063                "  return 2;",
10064                ShortMergedIf);
10065 }
10066 
10067 TEST_F(FormatTest, FormatStarDependingOnContext) {
10068   verifyFormat("void f(int *a);");
10069   verifyFormat("void f() { f(fint * b); }");
10070   verifyFormat("class A {\n  void f(int *a);\n};");
10071   verifyFormat("class A {\n  int *a;\n};");
10072   verifyFormat("namespace a {\n"
10073                "namespace b {\n"
10074                "class A {\n"
10075                "  void f() {}\n"
10076                "  int *a;\n"
10077                "};\n"
10078                "} // namespace b\n"
10079                "} // namespace a");
10080 }
10081 
10082 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
10083   verifyFormat("while");
10084   verifyFormat("operator");
10085 }
10086 
10087 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
10088   // This code would be painfully slow to format if we didn't skip it.
10089   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
10090                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10091                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10092                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10093                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10094                    "A(1, 1)\n"
10095                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
10096                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10097                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10098                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10099                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10100                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10101                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10102                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10103                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10104                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
10105   // Deeply nested part is untouched, rest is formatted.
10106   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
10107             format(std::string("int    i;\n") + Code + "int    j;\n",
10108                    getLLVMStyle(), SC_ExpectIncomplete));
10109 }
10110 
10111 //===----------------------------------------------------------------------===//
10112 // Objective-C tests.
10113 //===----------------------------------------------------------------------===//
10114 
10115 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
10116   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
10117   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
10118             format("-(NSUInteger)indexOfObject:(id)anObject;"));
10119   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
10120   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
10121   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
10122             format("-(NSInteger)Method3:(id)anObject;"));
10123   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
10124             format("-(NSInteger)Method4:(id)anObject;"));
10125   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
10126             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
10127   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
10128             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
10129   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10130             "forAllCells:(BOOL)flag;",
10131             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10132                    "forAllCells:(BOOL)flag;"));
10133 
10134   // Very long objectiveC method declaration.
10135   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
10136                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
10137   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
10138                "                    inRange:(NSRange)range\n"
10139                "                   outRange:(NSRange)out_range\n"
10140                "                  outRange1:(NSRange)out_range1\n"
10141                "                  outRange2:(NSRange)out_range2\n"
10142                "                  outRange3:(NSRange)out_range3\n"
10143                "                  outRange4:(NSRange)out_range4\n"
10144                "                  outRange5:(NSRange)out_range5\n"
10145                "                  outRange6:(NSRange)out_range6\n"
10146                "                  outRange7:(NSRange)out_range7\n"
10147                "                  outRange8:(NSRange)out_range8\n"
10148                "                  outRange9:(NSRange)out_range9;");
10149 
10150   // When the function name has to be wrapped.
10151   FormatStyle Style = getLLVMStyle();
10152   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
10153   // and always indents instead.
10154   Style.IndentWrappedFunctionNames = false;
10155   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10156                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
10157                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
10158                "}",
10159                Style);
10160   Style.IndentWrappedFunctionNames = true;
10161   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10162                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
10163                "               anotherName:(NSString)dddddddddddddd {\n"
10164                "}",
10165                Style);
10166 
10167   verifyFormat("- (int)sum:(vector<int>)numbers;");
10168   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
10169   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
10170   // protocol lists (but not for template classes):
10171   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
10172 
10173   verifyFormat("- (int (*)())foo:(int (*)())f;");
10174   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
10175 
10176   // If there's no return type (very rare in practice!), LLVM and Google style
10177   // agree.
10178   verifyFormat("- foo;");
10179   verifyFormat("- foo:(int)f;");
10180   verifyGoogleFormat("- foo:(int)foo;");
10181 }
10182 
10183 TEST_F(FormatTest, BreaksStringLiterals) {
10184   EXPECT_EQ("\"some text \"\n"
10185             "\"other\";",
10186             format("\"some text other\";", getLLVMStyleWithColumns(12)));
10187   EXPECT_EQ("\"some text \"\n"
10188             "\"other\";",
10189             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
10190   EXPECT_EQ(
10191       "#define A  \\\n"
10192       "  \"some \"  \\\n"
10193       "  \"text \"  \\\n"
10194       "  \"other\";",
10195       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
10196   EXPECT_EQ(
10197       "#define A  \\\n"
10198       "  \"so \"    \\\n"
10199       "  \"text \"  \\\n"
10200       "  \"other\";",
10201       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
10202 
10203   EXPECT_EQ("\"some text\"",
10204             format("\"some text\"", getLLVMStyleWithColumns(1)));
10205   EXPECT_EQ("\"some text\"",
10206             format("\"some text\"", getLLVMStyleWithColumns(11)));
10207   EXPECT_EQ("\"some \"\n"
10208             "\"text\"",
10209             format("\"some text\"", getLLVMStyleWithColumns(10)));
10210   EXPECT_EQ("\"some \"\n"
10211             "\"text\"",
10212             format("\"some text\"", getLLVMStyleWithColumns(7)));
10213   EXPECT_EQ("\"some\"\n"
10214             "\" tex\"\n"
10215             "\"t\"",
10216             format("\"some text\"", getLLVMStyleWithColumns(6)));
10217   EXPECT_EQ("\"some\"\n"
10218             "\" tex\"\n"
10219             "\" and\"",
10220             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
10221   EXPECT_EQ("\"some\"\n"
10222             "\"/tex\"\n"
10223             "\"/and\"",
10224             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
10225 
10226   EXPECT_EQ("variable =\n"
10227             "    \"long string \"\n"
10228             "    \"literal\";",
10229             format("variable = \"long string literal\";",
10230                    getLLVMStyleWithColumns(20)));
10231 
10232   EXPECT_EQ("variable = f(\n"
10233             "    \"long string \"\n"
10234             "    \"literal\",\n"
10235             "    short,\n"
10236             "    loooooooooooooooooooong);",
10237             format("variable = f(\"long string literal\", short, "
10238                    "loooooooooooooooooooong);",
10239                    getLLVMStyleWithColumns(20)));
10240 
10241   EXPECT_EQ(
10242       "f(g(\"long string \"\n"
10243       "    \"literal\"),\n"
10244       "  b);",
10245       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
10246   EXPECT_EQ("f(g(\"long string \"\n"
10247             "    \"literal\",\n"
10248             "    a),\n"
10249             "  b);",
10250             format("f(g(\"long string literal\", a), b);",
10251                    getLLVMStyleWithColumns(20)));
10252   EXPECT_EQ(
10253       "f(\"one two\".split(\n"
10254       "    variable));",
10255       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10256   EXPECT_EQ("f(\"one two three four five six \"\n"
10257             "  \"seven\".split(\n"
10258             "      really_looooong_variable));",
10259             format("f(\"one two three four five six seven\"."
10260                    "split(really_looooong_variable));",
10261                    getLLVMStyleWithColumns(33)));
10262 
10263   EXPECT_EQ("f(\"some \"\n"
10264             "  \"text\",\n"
10265             "  other);",
10266             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10267 
10268   // Only break as a last resort.
10269   verifyFormat(
10270       "aaaaaaaaaaaaaaaaaaaa(\n"
10271       "    aaaaaaaaaaaaaaaaaaaa,\n"
10272       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10273 
10274   EXPECT_EQ("\"splitmea\"\n"
10275             "\"trandomp\"\n"
10276             "\"oint\"",
10277             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10278 
10279   EXPECT_EQ("\"split/\"\n"
10280             "\"pathat/\"\n"
10281             "\"slashes\"",
10282             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10283 
10284   EXPECT_EQ("\"split/\"\n"
10285             "\"pathat/\"\n"
10286             "\"slashes\"",
10287             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10288   EXPECT_EQ("\"split at \"\n"
10289             "\"spaces/at/\"\n"
10290             "\"slashes.at.any$\"\n"
10291             "\"non-alphanumeric%\"\n"
10292             "\"1111111111characte\"\n"
10293             "\"rs\"",
10294             format("\"split at "
10295                    "spaces/at/"
10296                    "slashes.at."
10297                    "any$non-"
10298                    "alphanumeric%"
10299                    "1111111111characte"
10300                    "rs\"",
10301                    getLLVMStyleWithColumns(20)));
10302 
10303   // Verify that splitting the strings understands
10304   // Style::AlwaysBreakBeforeMultilineStrings.
10305   EXPECT_EQ("aaaaaaaaaaaa(\n"
10306             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10307             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10308             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10309                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10310                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10311                    getGoogleStyle()));
10312   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10313             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10314             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10315                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10316                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10317                    getGoogleStyle()));
10318   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10319             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10320             format("llvm::outs() << "
10321                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10322                    "aaaaaaaaaaaaaaaaaaa\";"));
10323   EXPECT_EQ("ffff(\n"
10324             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10325             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10326             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10327                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10328                    getGoogleStyle()));
10329 
10330   FormatStyle Style = getLLVMStyleWithColumns(12);
10331   Style.BreakStringLiterals = false;
10332   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10333 
10334   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10335   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10336   EXPECT_EQ("#define A \\\n"
10337             "  \"some \" \\\n"
10338             "  \"text \" \\\n"
10339             "  \"other\";",
10340             format("#define A \"some text other\";", AlignLeft));
10341 }
10342 
10343 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10344   EXPECT_EQ("C a = \"some more \"\n"
10345             "      \"text\";",
10346             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10347 }
10348 
10349 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10350   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10351   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10352   EXPECT_EQ("int i = a(b());",
10353             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10354 }
10355 
10356 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10357   EXPECT_EQ(
10358       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10359       "(\n"
10360       "    \"x\t\");",
10361       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10362              "aaaaaaa("
10363              "\"x\t\");"));
10364 }
10365 
10366 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10367   EXPECT_EQ(
10368       "u8\"utf8 string \"\n"
10369       "u8\"literal\";",
10370       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10371   EXPECT_EQ(
10372       "u\"utf16 string \"\n"
10373       "u\"literal\";",
10374       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10375   EXPECT_EQ(
10376       "U\"utf32 string \"\n"
10377       "U\"literal\";",
10378       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10379   EXPECT_EQ("L\"wide string \"\n"
10380             "L\"literal\";",
10381             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10382   EXPECT_EQ("@\"NSString \"\n"
10383             "@\"literal\";",
10384             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10385   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10386 
10387   // This input makes clang-format try to split the incomplete unicode escape
10388   // sequence, which used to lead to a crasher.
10389   verifyNoCrash(
10390       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10391       getLLVMStyleWithColumns(60));
10392 }
10393 
10394 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10395   FormatStyle Style = getGoogleStyleWithColumns(15);
10396   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10397   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10398   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10399   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10400   EXPECT_EQ("u8R\"x(raw literal)x\";",
10401             format("u8R\"x(raw literal)x\";", Style));
10402 }
10403 
10404 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10405   FormatStyle Style = getLLVMStyleWithColumns(20);
10406   EXPECT_EQ(
10407       "_T(\"aaaaaaaaaaaaaa\")\n"
10408       "_T(\"aaaaaaaaaaaaaa\")\n"
10409       "_T(\"aaaaaaaaaaaa\")",
10410       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10411   EXPECT_EQ("f(x,\n"
10412             "  _T(\"aaaaaaaaaaaa\")\n"
10413             "  _T(\"aaa\"),\n"
10414             "  z);",
10415             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10416 
10417   // FIXME: Handle embedded spaces in one iteration.
10418   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10419   //            "_T(\"aaaaaaaaaaaaa\")\n"
10420   //            "_T(\"aaaaaaaaaaaaa\")\n"
10421   //            "_T(\"a\")",
10422   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10423   //                   getLLVMStyleWithColumns(20)));
10424   EXPECT_EQ(
10425       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10426       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10427   EXPECT_EQ("f(\n"
10428             "#if !TEST\n"
10429             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10430             "#endif\n"
10431             ");",
10432             format("f(\n"
10433                    "#if !TEST\n"
10434                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10435                    "#endif\n"
10436                    ");"));
10437   EXPECT_EQ("f(\n"
10438             "\n"
10439             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10440             format("f(\n"
10441                    "\n"
10442                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10443 }
10444 
10445 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10446   // In a function call with two operands, the second can be broken with no line
10447   // break before it.
10448   EXPECT_EQ(
10449       "func(a, \"long long \"\n"
10450       "        \"long long\");",
10451       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10452   // In a function call with three operands, the second must be broken with a
10453   // line break before it.
10454   EXPECT_EQ("func(a,\n"
10455             "     \"long long long \"\n"
10456             "     \"long\",\n"
10457             "     c);",
10458             format("func(a, \"long long long long\", c);",
10459                    getLLVMStyleWithColumns(24)));
10460   // In a function call with three operands, the third must be broken with a
10461   // line break before it.
10462   EXPECT_EQ("func(a, b,\n"
10463             "     \"long long long \"\n"
10464             "     \"long\");",
10465             format("func(a, b, \"long long long long\");",
10466                    getLLVMStyleWithColumns(24)));
10467   // In a function call with three operands, both the second and the third must
10468   // be broken with a line break before them.
10469   EXPECT_EQ("func(a,\n"
10470             "     \"long long long \"\n"
10471             "     \"long\",\n"
10472             "     \"long long long \"\n"
10473             "     \"long\");",
10474             format("func(a, \"long long long long\", \"long long long long\");",
10475                    getLLVMStyleWithColumns(24)));
10476   // In a chain of << with two operands, the second can be broken with no line
10477   // break before it.
10478   EXPECT_EQ("a << \"line line \"\n"
10479             "     \"line\";",
10480             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10481   // In a chain of << with three operands, the second can be broken with no line
10482   // break before it.
10483   EXPECT_EQ(
10484       "abcde << \"line \"\n"
10485       "         \"line line\"\n"
10486       "      << c;",
10487       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10488   // In a chain of << with three operands, the third must be broken with a line
10489   // break before it.
10490   EXPECT_EQ(
10491       "a << b\n"
10492       "  << \"line line \"\n"
10493       "     \"line\";",
10494       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10495   // In a chain of << with three operands, the second can be broken with no line
10496   // break before it and the third must be broken with a line break before it.
10497   EXPECT_EQ("abcd << \"line line \"\n"
10498             "        \"line\"\n"
10499             "     << \"line line \"\n"
10500             "        \"line\";",
10501             format("abcd << \"line line line\" << \"line line line\";",
10502                    getLLVMStyleWithColumns(20)));
10503   // In a chain of binary operators with two operands, the second can be broken
10504   // with no line break before it.
10505   EXPECT_EQ(
10506       "abcd + \"line line \"\n"
10507       "       \"line line\";",
10508       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10509   // In a chain of binary operators with three operands, the second must be
10510   // broken with a line break before it.
10511   EXPECT_EQ("abcd +\n"
10512             "    \"line line \"\n"
10513             "    \"line line\" +\n"
10514             "    e;",
10515             format("abcd + \"line line line line\" + e;",
10516                    getLLVMStyleWithColumns(20)));
10517   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10518   // the first must be broken with a line break before it.
10519   FormatStyle Style = getLLVMStyleWithColumns(25);
10520   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10521   EXPECT_EQ("someFunction(\n"
10522             "    \"long long long \"\n"
10523             "    \"long\",\n"
10524             "    a);",
10525             format("someFunction(\"long long long long\", a);", Style));
10526 }
10527 
10528 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10529   EXPECT_EQ(
10530       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10531       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10532       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10533       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10534              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10535              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10536 }
10537 
10538 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10539   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10540             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10541   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10542             "multiline raw string literal xxxxxxxxxxxxxx\n"
10543             ")x\",\n"
10544             "              a),\n"
10545             "            b);",
10546             format("fffffffffff(g(R\"x(\n"
10547                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10548                    ")x\", a), b);",
10549                    getGoogleStyleWithColumns(20)));
10550   EXPECT_EQ("fffffffffff(\n"
10551             "    g(R\"x(qqq\n"
10552             "multiline raw string literal xxxxxxxxxxxxxx\n"
10553             ")x\",\n"
10554             "      a),\n"
10555             "    b);",
10556             format("fffffffffff(g(R\"x(qqq\n"
10557                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10558                    ")x\", a), b);",
10559                    getGoogleStyleWithColumns(20)));
10560 
10561   EXPECT_EQ("fffffffffff(R\"x(\n"
10562             "multiline raw string literal xxxxxxxxxxxxxx\n"
10563             ")x\");",
10564             format("fffffffffff(R\"x(\n"
10565                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10566                    ")x\");",
10567                    getGoogleStyleWithColumns(20)));
10568   EXPECT_EQ("fffffffffff(R\"x(\n"
10569             "multiline raw string literal xxxxxxxxxxxxxx\n"
10570             ")x\" + bbbbbb);",
10571             format("fffffffffff(R\"x(\n"
10572                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10573                    ")x\" +   bbbbbb);",
10574                    getGoogleStyleWithColumns(20)));
10575   EXPECT_EQ("fffffffffff(\n"
10576             "    R\"x(\n"
10577             "multiline raw string literal xxxxxxxxxxxxxx\n"
10578             ")x\" +\n"
10579             "    bbbbbb);",
10580             format("fffffffffff(\n"
10581                    " R\"x(\n"
10582                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10583                    ")x\" + bbbbbb);",
10584                    getGoogleStyleWithColumns(20)));
10585   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10586             format("fffffffffff(\n"
10587                    " R\"(single line raw string)\" + bbbbbb);"));
10588 }
10589 
10590 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10591   verifyFormat("string a = \"unterminated;");
10592   EXPECT_EQ("function(\"unterminated,\n"
10593             "         OtherParameter);",
10594             format("function(  \"unterminated,\n"
10595                    "    OtherParameter);"));
10596 }
10597 
10598 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10599   FormatStyle Style = getLLVMStyle();
10600   Style.Standard = FormatStyle::LS_Cpp03;
10601   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10602             format("#define x(_a) printf(\"foo\"_a);", Style));
10603 }
10604 
10605 TEST_F(FormatTest, CppLexVersion) {
10606   FormatStyle Style = getLLVMStyle();
10607   // Formatting of x * y differs if x is a type.
10608   verifyFormat("void foo() { MACRO(a * b); }", Style);
10609   verifyFormat("void foo() { MACRO(int *b); }", Style);
10610 
10611   // LLVM style uses latest lexer.
10612   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10613   Style.Standard = FormatStyle::LS_Cpp17;
10614   // But in c++17, char8_t isn't a keyword.
10615   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10616 }
10617 
10618 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10619 
10620 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10621   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10622             "             \"ddeeefff\");",
10623             format("someFunction(\"aaabbbcccdddeeefff\");",
10624                    getLLVMStyleWithColumns(25)));
10625   EXPECT_EQ("someFunction1234567890(\n"
10626             "    \"aaabbbcccdddeeefff\");",
10627             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10628                    getLLVMStyleWithColumns(26)));
10629   EXPECT_EQ("someFunction1234567890(\n"
10630             "    \"aaabbbcccdddeeeff\"\n"
10631             "    \"f\");",
10632             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10633                    getLLVMStyleWithColumns(25)));
10634   EXPECT_EQ("someFunction1234567890(\n"
10635             "    \"aaabbbcccdddeeeff\"\n"
10636             "    \"f\");",
10637             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10638                    getLLVMStyleWithColumns(24)));
10639   EXPECT_EQ("someFunction(\n"
10640             "    \"aaabbbcc ddde \"\n"
10641             "    \"efff\");",
10642             format("someFunction(\"aaabbbcc ddde efff\");",
10643                    getLLVMStyleWithColumns(25)));
10644   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10645             "             \"ddeeefff\");",
10646             format("someFunction(\"aaabbbccc ddeeefff\");",
10647                    getLLVMStyleWithColumns(25)));
10648   EXPECT_EQ("someFunction1234567890(\n"
10649             "    \"aaabb \"\n"
10650             "    \"cccdddeeefff\");",
10651             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10652                    getLLVMStyleWithColumns(25)));
10653   EXPECT_EQ("#define A          \\\n"
10654             "  string s =       \\\n"
10655             "      \"123456789\"  \\\n"
10656             "      \"0\";         \\\n"
10657             "  int i;",
10658             format("#define A string s = \"1234567890\"; int i;",
10659                    getLLVMStyleWithColumns(20)));
10660   EXPECT_EQ("someFunction(\n"
10661             "    \"aaabbbcc \"\n"
10662             "    \"dddeeefff\");",
10663             format("someFunction(\"aaabbbcc dddeeefff\");",
10664                    getLLVMStyleWithColumns(25)));
10665 }
10666 
10667 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10668   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10669   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10670   EXPECT_EQ("\"test\"\n"
10671             "\"\\n\"",
10672             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10673   EXPECT_EQ("\"tes\\\\\"\n"
10674             "\"n\"",
10675             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10676   EXPECT_EQ("\"\\\\\\\\\"\n"
10677             "\"\\n\"",
10678             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10679   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10680   EXPECT_EQ("\"\\uff01\"\n"
10681             "\"test\"",
10682             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10683   EXPECT_EQ("\"\\Uff01ff02\"",
10684             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10685   EXPECT_EQ("\"\\x000000000001\"\n"
10686             "\"next\"",
10687             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10688   EXPECT_EQ("\"\\x000000000001next\"",
10689             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10690   EXPECT_EQ("\"\\x000000000001\"",
10691             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10692   EXPECT_EQ("\"test\"\n"
10693             "\"\\000000\"\n"
10694             "\"000001\"",
10695             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10696   EXPECT_EQ("\"test\\000\"\n"
10697             "\"00000000\"\n"
10698             "\"1\"",
10699             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10700 }
10701 
10702 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10703   verifyFormat("void f() {\n"
10704                "  return g() {}\n"
10705                "  void h() {}");
10706   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10707                "g();\n"
10708                "}");
10709 }
10710 
10711 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10712   verifyFormat(
10713       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10714 }
10715 
10716 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10717   verifyFormat("class X {\n"
10718                "  void f() {\n"
10719                "  }\n"
10720                "};",
10721                getLLVMStyleWithColumns(12));
10722 }
10723 
10724 TEST_F(FormatTest, ConfigurableIndentWidth) {
10725   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10726   EightIndent.IndentWidth = 8;
10727   EightIndent.ContinuationIndentWidth = 8;
10728   verifyFormat("void f() {\n"
10729                "        someFunction();\n"
10730                "        if (true) {\n"
10731                "                f();\n"
10732                "        }\n"
10733                "}",
10734                EightIndent);
10735   verifyFormat("class X {\n"
10736                "        void f() {\n"
10737                "        }\n"
10738                "};",
10739                EightIndent);
10740   verifyFormat("int x[] = {\n"
10741                "        call(),\n"
10742                "        call()};",
10743                EightIndent);
10744 }
10745 
10746 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10747   verifyFormat("double\n"
10748                "f();",
10749                getLLVMStyleWithColumns(8));
10750 }
10751 
10752 TEST_F(FormatTest, ConfigurableUseOfTab) {
10753   FormatStyle Tab = getLLVMStyleWithColumns(42);
10754   Tab.IndentWidth = 8;
10755   Tab.UseTab = FormatStyle::UT_Always;
10756   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10757 
10758   EXPECT_EQ("if (aaaaaaaa && // q\n"
10759             "    bb)\t\t// w\n"
10760             "\t;",
10761             format("if (aaaaaaaa &&// q\n"
10762                    "bb)// w\n"
10763                    ";",
10764                    Tab));
10765   EXPECT_EQ("if (aaa && bbb) // w\n"
10766             "\t;",
10767             format("if(aaa&&bbb)// w\n"
10768                    ";",
10769                    Tab));
10770 
10771   verifyFormat("class X {\n"
10772                "\tvoid f() {\n"
10773                "\t\tsomeFunction(parameter1,\n"
10774                "\t\t\t     parameter2);\n"
10775                "\t}\n"
10776                "};",
10777                Tab);
10778   verifyFormat("#define A                        \\\n"
10779                "\tvoid f() {               \\\n"
10780                "\t\tsomeFunction(    \\\n"
10781                "\t\t    parameter1,  \\\n"
10782                "\t\t    parameter2); \\\n"
10783                "\t}",
10784                Tab);
10785   verifyFormat("int a;\t      // x\n"
10786                "int bbbbbbbb; // x\n",
10787                Tab);
10788 
10789   Tab.TabWidth = 4;
10790   Tab.IndentWidth = 8;
10791   verifyFormat("class TabWidth4Indent8 {\n"
10792                "\t\tvoid f() {\n"
10793                "\t\t\t\tsomeFunction(parameter1,\n"
10794                "\t\t\t\t\t\t\t parameter2);\n"
10795                "\t\t}\n"
10796                "};",
10797                Tab);
10798 
10799   Tab.TabWidth = 4;
10800   Tab.IndentWidth = 4;
10801   verifyFormat("class TabWidth4Indent4 {\n"
10802                "\tvoid f() {\n"
10803                "\t\tsomeFunction(parameter1,\n"
10804                "\t\t\t\t\t parameter2);\n"
10805                "\t}\n"
10806                "};",
10807                Tab);
10808 
10809   Tab.TabWidth = 8;
10810   Tab.IndentWidth = 4;
10811   verifyFormat("class TabWidth8Indent4 {\n"
10812                "    void f() {\n"
10813                "\tsomeFunction(parameter1,\n"
10814                "\t\t     parameter2);\n"
10815                "    }\n"
10816                "};",
10817                Tab);
10818 
10819   Tab.TabWidth = 8;
10820   Tab.IndentWidth = 8;
10821   EXPECT_EQ("/*\n"
10822             "\t      a\t\tcomment\n"
10823             "\t      in multiple lines\n"
10824             "       */",
10825             format("   /*\t \t \n"
10826                    " \t \t a\t\tcomment\t \t\n"
10827                    " \t \t in multiple lines\t\n"
10828                    " \t  */",
10829                    Tab));
10830 
10831   Tab.UseTab = FormatStyle::UT_ForIndentation;
10832   verifyFormat("{\n"
10833                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10834                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10835                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10836                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10837                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10838                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10839                "};",
10840                Tab);
10841   verifyFormat("enum AA {\n"
10842                "\ta1, // Force multiple lines\n"
10843                "\ta2,\n"
10844                "\ta3\n"
10845                "};",
10846                Tab);
10847   EXPECT_EQ("if (aaaaaaaa && // q\n"
10848             "    bb)         // w\n"
10849             "\t;",
10850             format("if (aaaaaaaa &&// q\n"
10851                    "bb)// w\n"
10852                    ";",
10853                    Tab));
10854   verifyFormat("class X {\n"
10855                "\tvoid f() {\n"
10856                "\t\tsomeFunction(parameter1,\n"
10857                "\t\t             parameter2);\n"
10858                "\t}\n"
10859                "};",
10860                Tab);
10861   verifyFormat("{\n"
10862                "\tQ(\n"
10863                "\t    {\n"
10864                "\t\t    int a;\n"
10865                "\t\t    someFunction(aaaaaaaa,\n"
10866                "\t\t                 bbbbbbb);\n"
10867                "\t    },\n"
10868                "\t    p);\n"
10869                "}",
10870                Tab);
10871   EXPECT_EQ("{\n"
10872             "\t/* aaaa\n"
10873             "\t   bbbb */\n"
10874             "}",
10875             format("{\n"
10876                    "/* aaaa\n"
10877                    "   bbbb */\n"
10878                    "}",
10879                    Tab));
10880   EXPECT_EQ("{\n"
10881             "\t/*\n"
10882             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10883             "\t  bbbbbbbbbbbbb\n"
10884             "\t*/\n"
10885             "}",
10886             format("{\n"
10887                    "/*\n"
10888                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10889                    "*/\n"
10890                    "}",
10891                    Tab));
10892   EXPECT_EQ("{\n"
10893             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10894             "\t// bbbbbbbbbbbbb\n"
10895             "}",
10896             format("{\n"
10897                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10898                    "}",
10899                    Tab));
10900   EXPECT_EQ("{\n"
10901             "\t/*\n"
10902             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10903             "\t  bbbbbbbbbbbbb\n"
10904             "\t*/\n"
10905             "}",
10906             format("{\n"
10907                    "\t/*\n"
10908                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10909                    "\t*/\n"
10910                    "}",
10911                    Tab));
10912   EXPECT_EQ("{\n"
10913             "\t/*\n"
10914             "\n"
10915             "\t*/\n"
10916             "}",
10917             format("{\n"
10918                    "\t/*\n"
10919                    "\n"
10920                    "\t*/\n"
10921                    "}",
10922                    Tab));
10923   EXPECT_EQ("{\n"
10924             "\t/*\n"
10925             " asdf\n"
10926             "\t*/\n"
10927             "}",
10928             format("{\n"
10929                    "\t/*\n"
10930                    " asdf\n"
10931                    "\t*/\n"
10932                    "}",
10933                    Tab));
10934 
10935   Tab.UseTab = FormatStyle::UT_Never;
10936   EXPECT_EQ("/*\n"
10937             "              a\t\tcomment\n"
10938             "              in multiple lines\n"
10939             "       */",
10940             format("   /*\t \t \n"
10941                    " \t \t a\t\tcomment\t \t\n"
10942                    " \t \t in multiple lines\t\n"
10943                    " \t  */",
10944                    Tab));
10945   EXPECT_EQ("/* some\n"
10946             "   comment */",
10947             format(" \t \t /* some\n"
10948                    " \t \t    comment */",
10949                    Tab));
10950   EXPECT_EQ("int a; /* some\n"
10951             "   comment */",
10952             format(" \t \t int a; /* some\n"
10953                    " \t \t    comment */",
10954                    Tab));
10955 
10956   EXPECT_EQ("int a; /* some\n"
10957             "comment */",
10958             format(" \t \t int\ta; /* some\n"
10959                    " \t \t    comment */",
10960                    Tab));
10961   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10962             "    comment */",
10963             format(" \t \t f(\"\t\t\"); /* some\n"
10964                    " \t \t    comment */",
10965                    Tab));
10966   EXPECT_EQ("{\n"
10967             "        /*\n"
10968             "         * Comment\n"
10969             "         */\n"
10970             "        int i;\n"
10971             "}",
10972             format("{\n"
10973                    "\t/*\n"
10974                    "\t * Comment\n"
10975                    "\t */\n"
10976                    "\t int i;\n"
10977                    "}",
10978                    Tab));
10979 
10980   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
10981   Tab.TabWidth = 8;
10982   Tab.IndentWidth = 8;
10983   EXPECT_EQ("if (aaaaaaaa && // q\n"
10984             "    bb)         // w\n"
10985             "\t;",
10986             format("if (aaaaaaaa &&// q\n"
10987                    "bb)// w\n"
10988                    ";",
10989                    Tab));
10990   EXPECT_EQ("if (aaa && bbb) // w\n"
10991             "\t;",
10992             format("if(aaa&&bbb)// w\n"
10993                    ";",
10994                    Tab));
10995   verifyFormat("class X {\n"
10996                "\tvoid f() {\n"
10997                "\t\tsomeFunction(parameter1,\n"
10998                "\t\t\t     parameter2);\n"
10999                "\t}\n"
11000                "};",
11001                Tab);
11002   verifyFormat("#define A                        \\\n"
11003                "\tvoid f() {               \\\n"
11004                "\t\tsomeFunction(    \\\n"
11005                "\t\t    parameter1,  \\\n"
11006                "\t\t    parameter2); \\\n"
11007                "\t}",
11008                Tab);
11009   Tab.TabWidth = 4;
11010   Tab.IndentWidth = 8;
11011   verifyFormat("class TabWidth4Indent8 {\n"
11012                "\t\tvoid f() {\n"
11013                "\t\t\t\tsomeFunction(parameter1,\n"
11014                "\t\t\t\t\t\t\t parameter2);\n"
11015                "\t\t}\n"
11016                "};",
11017                Tab);
11018   Tab.TabWidth = 4;
11019   Tab.IndentWidth = 4;
11020   verifyFormat("class TabWidth4Indent4 {\n"
11021                "\tvoid f() {\n"
11022                "\t\tsomeFunction(parameter1,\n"
11023                "\t\t\t\t\t parameter2);\n"
11024                "\t}\n"
11025                "};",
11026                Tab);
11027   Tab.TabWidth = 8;
11028   Tab.IndentWidth = 4;
11029   verifyFormat("class TabWidth8Indent4 {\n"
11030                "    void f() {\n"
11031                "\tsomeFunction(parameter1,\n"
11032                "\t\t     parameter2);\n"
11033                "    }\n"
11034                "};",
11035                Tab);
11036   Tab.TabWidth = 8;
11037   Tab.IndentWidth = 8;
11038   EXPECT_EQ("/*\n"
11039             "\t      a\t\tcomment\n"
11040             "\t      in multiple lines\n"
11041             "       */",
11042             format("   /*\t \t \n"
11043                    " \t \t a\t\tcomment\t \t\n"
11044                    " \t \t in multiple lines\t\n"
11045                    " \t  */",
11046                    Tab));
11047   verifyFormat("{\n"
11048                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11049                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11050                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11051                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11052                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11053                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11054                "};",
11055                Tab);
11056   verifyFormat("enum AA {\n"
11057                "\ta1, // Force multiple lines\n"
11058                "\ta2,\n"
11059                "\ta3\n"
11060                "};",
11061                Tab);
11062   EXPECT_EQ("if (aaaaaaaa && // q\n"
11063             "    bb)         // w\n"
11064             "\t;",
11065             format("if (aaaaaaaa &&// q\n"
11066                    "bb)// w\n"
11067                    ";",
11068                    Tab));
11069   verifyFormat("class X {\n"
11070                "\tvoid f() {\n"
11071                "\t\tsomeFunction(parameter1,\n"
11072                "\t\t\t     parameter2);\n"
11073                "\t}\n"
11074                "};",
11075                Tab);
11076   verifyFormat("{\n"
11077                "\tQ(\n"
11078                "\t    {\n"
11079                "\t\t    int a;\n"
11080                "\t\t    someFunction(aaaaaaaa,\n"
11081                "\t\t\t\t bbbbbbb);\n"
11082                "\t    },\n"
11083                "\t    p);\n"
11084                "}",
11085                Tab);
11086   EXPECT_EQ("{\n"
11087             "\t/* aaaa\n"
11088             "\t   bbbb */\n"
11089             "}",
11090             format("{\n"
11091                    "/* aaaa\n"
11092                    "   bbbb */\n"
11093                    "}",
11094                    Tab));
11095   EXPECT_EQ("{\n"
11096             "\t/*\n"
11097             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11098             "\t  bbbbbbbbbbbbb\n"
11099             "\t*/\n"
11100             "}",
11101             format("{\n"
11102                    "/*\n"
11103                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11104                    "*/\n"
11105                    "}",
11106                    Tab));
11107   EXPECT_EQ("{\n"
11108             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11109             "\t// bbbbbbbbbbbbb\n"
11110             "}",
11111             format("{\n"
11112                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11113                    "}",
11114                    Tab));
11115   EXPECT_EQ("{\n"
11116             "\t/*\n"
11117             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11118             "\t  bbbbbbbbbbbbb\n"
11119             "\t*/\n"
11120             "}",
11121             format("{\n"
11122                    "\t/*\n"
11123                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11124                    "\t*/\n"
11125                    "}",
11126                    Tab));
11127   EXPECT_EQ("{\n"
11128             "\t/*\n"
11129             "\n"
11130             "\t*/\n"
11131             "}",
11132             format("{\n"
11133                    "\t/*\n"
11134                    "\n"
11135                    "\t*/\n"
11136                    "}",
11137                    Tab));
11138   EXPECT_EQ("{\n"
11139             "\t/*\n"
11140             " asdf\n"
11141             "\t*/\n"
11142             "}",
11143             format("{\n"
11144                    "\t/*\n"
11145                    " asdf\n"
11146                    "\t*/\n"
11147                    "}",
11148                    Tab));
11149   EXPECT_EQ("/* some\n"
11150             "   comment */",
11151             format(" \t \t /* some\n"
11152                    " \t \t    comment */",
11153                    Tab));
11154   EXPECT_EQ("int a; /* some\n"
11155             "   comment */",
11156             format(" \t \t int a; /* some\n"
11157                    " \t \t    comment */",
11158                    Tab));
11159   EXPECT_EQ("int a; /* some\n"
11160             "comment */",
11161             format(" \t \t int\ta; /* some\n"
11162                    " \t \t    comment */",
11163                    Tab));
11164   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11165             "    comment */",
11166             format(" \t \t f(\"\t\t\"); /* some\n"
11167                    " \t \t    comment */",
11168                    Tab));
11169   EXPECT_EQ("{\n"
11170             "\t/*\n"
11171             "\t * Comment\n"
11172             "\t */\n"
11173             "\tint i;\n"
11174             "}",
11175             format("{\n"
11176                    "\t/*\n"
11177                    "\t * Comment\n"
11178                    "\t */\n"
11179                    "\t int i;\n"
11180                    "}",
11181                    Tab));
11182   Tab.TabWidth = 2;
11183   Tab.IndentWidth = 2;
11184   EXPECT_EQ("{\n"
11185             "\t/* aaaa\n"
11186             "\t\t bbbb */\n"
11187             "}",
11188             format("{\n"
11189                    "/* aaaa\n"
11190                    "\t bbbb */\n"
11191                    "}",
11192                    Tab));
11193   EXPECT_EQ("{\n"
11194             "\t/*\n"
11195             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11196             "\t\tbbbbbbbbbbbbb\n"
11197             "\t*/\n"
11198             "}",
11199             format("{\n"
11200                    "/*\n"
11201                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11202                    "*/\n"
11203                    "}",
11204                    Tab));
11205   Tab.AlignConsecutiveAssignments = true;
11206   Tab.AlignConsecutiveDeclarations = true;
11207   Tab.TabWidth = 4;
11208   Tab.IndentWidth = 4;
11209   verifyFormat("class Assign {\n"
11210                "\tvoid f() {\n"
11211                "\t\tint         x      = 123;\n"
11212                "\t\tint         random = 4;\n"
11213                "\t\tstd::string alphabet =\n"
11214                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11215                "\t}\n"
11216                "};",
11217                Tab);
11218 
11219   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11220   Tab.TabWidth = 8;
11221   Tab.IndentWidth = 8;
11222   EXPECT_EQ("if (aaaaaaaa && // q\n"
11223             "    bb)         // w\n"
11224             "\t;",
11225             format("if (aaaaaaaa &&// q\n"
11226                    "bb)// w\n"
11227                    ";",
11228                    Tab));
11229   EXPECT_EQ("if (aaa && bbb) // w\n"
11230             "\t;",
11231             format("if(aaa&&bbb)// w\n"
11232                    ";",
11233                    Tab));
11234   verifyFormat("class X {\n"
11235                "\tvoid f() {\n"
11236                "\t\tsomeFunction(parameter1,\n"
11237                "\t\t             parameter2);\n"
11238                "\t}\n"
11239                "};",
11240                Tab);
11241   verifyFormat("#define A                        \\\n"
11242                "\tvoid f() {               \\\n"
11243                "\t\tsomeFunction(    \\\n"
11244                "\t\t    parameter1,  \\\n"
11245                "\t\t    parameter2); \\\n"
11246                "\t}",
11247                Tab);
11248   Tab.TabWidth = 4;
11249   Tab.IndentWidth = 8;
11250   verifyFormat("class TabWidth4Indent8 {\n"
11251                "\t\tvoid f() {\n"
11252                "\t\t\t\tsomeFunction(parameter1,\n"
11253                "\t\t\t\t             parameter2);\n"
11254                "\t\t}\n"
11255                "};",
11256                Tab);
11257   Tab.TabWidth = 4;
11258   Tab.IndentWidth = 4;
11259   verifyFormat("class TabWidth4Indent4 {\n"
11260                "\tvoid f() {\n"
11261                "\t\tsomeFunction(parameter1,\n"
11262                "\t\t             parameter2);\n"
11263                "\t}\n"
11264                "};",
11265                Tab);
11266   Tab.TabWidth = 8;
11267   Tab.IndentWidth = 4;
11268   verifyFormat("class TabWidth8Indent4 {\n"
11269                "    void f() {\n"
11270                "\tsomeFunction(parameter1,\n"
11271                "\t             parameter2);\n"
11272                "    }\n"
11273                "};",
11274                Tab);
11275   Tab.TabWidth = 8;
11276   Tab.IndentWidth = 8;
11277   EXPECT_EQ("/*\n"
11278             "              a\t\tcomment\n"
11279             "              in multiple lines\n"
11280             "       */",
11281             format("   /*\t \t \n"
11282                    " \t \t a\t\tcomment\t \t\n"
11283                    " \t \t in multiple lines\t\n"
11284                    " \t  */",
11285                    Tab));
11286   verifyFormat("{\n"
11287                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11288                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11289                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11290                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11291                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11292                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11293                "};",
11294                Tab);
11295   verifyFormat("enum AA {\n"
11296                "\ta1, // Force multiple lines\n"
11297                "\ta2,\n"
11298                "\ta3\n"
11299                "};",
11300                Tab);
11301   EXPECT_EQ("if (aaaaaaaa && // q\n"
11302             "    bb)         // w\n"
11303             "\t;",
11304             format("if (aaaaaaaa &&// q\n"
11305                    "bb)// w\n"
11306                    ";",
11307                    Tab));
11308   verifyFormat("class X {\n"
11309                "\tvoid f() {\n"
11310                "\t\tsomeFunction(parameter1,\n"
11311                "\t\t             parameter2);\n"
11312                "\t}\n"
11313                "};",
11314                Tab);
11315   verifyFormat("{\n"
11316                "\tQ(\n"
11317                "\t    {\n"
11318                "\t\t    int a;\n"
11319                "\t\t    someFunction(aaaaaaaa,\n"
11320                "\t\t                 bbbbbbb);\n"
11321                "\t    },\n"
11322                "\t    p);\n"
11323                "}",
11324                Tab);
11325   EXPECT_EQ("{\n"
11326             "\t/* aaaa\n"
11327             "\t   bbbb */\n"
11328             "}",
11329             format("{\n"
11330                    "/* aaaa\n"
11331                    "   bbbb */\n"
11332                    "}",
11333                    Tab));
11334   EXPECT_EQ("{\n"
11335             "\t/*\n"
11336             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11337             "\t  bbbbbbbbbbbbb\n"
11338             "\t*/\n"
11339             "}",
11340             format("{\n"
11341                    "/*\n"
11342                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11343                    "*/\n"
11344                    "}",
11345                    Tab));
11346   EXPECT_EQ("{\n"
11347             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11348             "\t// bbbbbbbbbbbbb\n"
11349             "}",
11350             format("{\n"
11351                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11352                    "}",
11353                    Tab));
11354   EXPECT_EQ("{\n"
11355             "\t/*\n"
11356             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11357             "\t  bbbbbbbbbbbbb\n"
11358             "\t*/\n"
11359             "}",
11360             format("{\n"
11361                    "\t/*\n"
11362                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11363                    "\t*/\n"
11364                    "}",
11365                    Tab));
11366   EXPECT_EQ("{\n"
11367             "\t/*\n"
11368             "\n"
11369             "\t*/\n"
11370             "}",
11371             format("{\n"
11372                    "\t/*\n"
11373                    "\n"
11374                    "\t*/\n"
11375                    "}",
11376                    Tab));
11377   EXPECT_EQ("{\n"
11378             "\t/*\n"
11379             " asdf\n"
11380             "\t*/\n"
11381             "}",
11382             format("{\n"
11383                    "\t/*\n"
11384                    " asdf\n"
11385                    "\t*/\n"
11386                    "}",
11387                    Tab));
11388   EXPECT_EQ("/* some\n"
11389             "   comment */",
11390             format(" \t \t /* some\n"
11391                    " \t \t    comment */",
11392                    Tab));
11393   EXPECT_EQ("int a; /* some\n"
11394             "   comment */",
11395             format(" \t \t int a; /* some\n"
11396                    " \t \t    comment */",
11397                    Tab));
11398   EXPECT_EQ("int a; /* some\n"
11399             "comment */",
11400             format(" \t \t int\ta; /* some\n"
11401                    " \t \t    comment */",
11402                    Tab));
11403   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11404             "    comment */",
11405             format(" \t \t f(\"\t\t\"); /* some\n"
11406                    " \t \t    comment */",
11407                    Tab));
11408   EXPECT_EQ("{\n"
11409             "\t/*\n"
11410             "\t * Comment\n"
11411             "\t */\n"
11412             "\tint i;\n"
11413             "}",
11414             format("{\n"
11415                    "\t/*\n"
11416                    "\t * Comment\n"
11417                    "\t */\n"
11418                    "\t int i;\n"
11419                    "}",
11420                    Tab));
11421   Tab.TabWidth = 2;
11422   Tab.IndentWidth = 2;
11423   EXPECT_EQ("{\n"
11424             "\t/* aaaa\n"
11425             "\t   bbbb */\n"
11426             "}",
11427             format("{\n"
11428                    "/* aaaa\n"
11429                    "   bbbb */\n"
11430                    "}",
11431                    Tab));
11432   EXPECT_EQ("{\n"
11433             "\t/*\n"
11434             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11435             "\t  bbbbbbbbbbbbb\n"
11436             "\t*/\n"
11437             "}",
11438             format("{\n"
11439                    "/*\n"
11440                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11441                    "*/\n"
11442                    "}",
11443                    Tab));
11444   Tab.AlignConsecutiveAssignments = true;
11445   Tab.AlignConsecutiveDeclarations = true;
11446   Tab.TabWidth = 4;
11447   Tab.IndentWidth = 4;
11448   verifyFormat("class Assign {\n"
11449                "\tvoid f() {\n"
11450                "\t\tint         x      = 123;\n"
11451                "\t\tint         random = 4;\n"
11452                "\t\tstd::string alphabet =\n"
11453                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11454                "\t}\n"
11455                "};",
11456                Tab);
11457   Tab.AlignOperands = FormatStyle::OAS_Align;
11458   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb +\n"
11459                "                 cccccccccccccccccccc;",
11460                Tab);
11461   // no alignment
11462   verifyFormat("int aaaaaaaaaa =\n"
11463                "\tbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
11464                Tab);
11465   verifyFormat("return aaaaaaaaaaaaaaaa ? 111111111111111\n"
11466                "       : bbbbbbbbbbbbbb ? 222222222222222\n"
11467                "                        : 333333333333333;",
11468                Tab);
11469   Tab.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
11470   Tab.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
11471   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb\n"
11472                "               + cccccccccccccccccccc;",
11473                Tab);
11474 }
11475 
11476 TEST_F(FormatTest, ZeroTabWidth) {
11477   FormatStyle Tab = getLLVMStyleWithColumns(42);
11478   Tab.IndentWidth = 8;
11479   Tab.UseTab = FormatStyle::UT_Never;
11480   Tab.TabWidth = 0;
11481   EXPECT_EQ("void a(){\n"
11482             "    // line starts with '\t'\n"
11483             "};",
11484             format("void a(){\n"
11485                    "\t// line starts with '\t'\n"
11486                    "};",
11487                    Tab));
11488 
11489   EXPECT_EQ("void a(){\n"
11490             "    // line starts with '\t'\n"
11491             "};",
11492             format("void a(){\n"
11493                    "\t\t// line starts with '\t'\n"
11494                    "};",
11495                    Tab));
11496 
11497   Tab.UseTab = FormatStyle::UT_ForIndentation;
11498   EXPECT_EQ("void a(){\n"
11499             "    // line starts with '\t'\n"
11500             "};",
11501             format("void a(){\n"
11502                    "\t// line starts with '\t'\n"
11503                    "};",
11504                    Tab));
11505 
11506   EXPECT_EQ("void a(){\n"
11507             "    // line starts with '\t'\n"
11508             "};",
11509             format("void a(){\n"
11510                    "\t\t// line starts with '\t'\n"
11511                    "};",
11512                    Tab));
11513 
11514   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11515   EXPECT_EQ("void a(){\n"
11516             "    // line starts with '\t'\n"
11517             "};",
11518             format("void a(){\n"
11519                    "\t// line starts with '\t'\n"
11520                    "};",
11521                    Tab));
11522 
11523   EXPECT_EQ("void a(){\n"
11524             "    // line starts with '\t'\n"
11525             "};",
11526             format("void a(){\n"
11527                    "\t\t// line starts with '\t'\n"
11528                    "};",
11529                    Tab));
11530 
11531   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11532   EXPECT_EQ("void a(){\n"
11533             "    // line starts with '\t'\n"
11534             "};",
11535             format("void a(){\n"
11536                    "\t// line starts with '\t'\n"
11537                    "};",
11538                    Tab));
11539 
11540   EXPECT_EQ("void a(){\n"
11541             "    // line starts with '\t'\n"
11542             "};",
11543             format("void a(){\n"
11544                    "\t\t// line starts with '\t'\n"
11545                    "};",
11546                    Tab));
11547 
11548   Tab.UseTab = FormatStyle::UT_Always;
11549   EXPECT_EQ("void a(){\n"
11550             "// line starts with '\t'\n"
11551             "};",
11552             format("void a(){\n"
11553                    "\t// line starts with '\t'\n"
11554                    "};",
11555                    Tab));
11556 
11557   EXPECT_EQ("void a(){\n"
11558             "// line starts with '\t'\n"
11559             "};",
11560             format("void a(){\n"
11561                    "\t\t// line starts with '\t'\n"
11562                    "};",
11563                    Tab));
11564 }
11565 
11566 TEST_F(FormatTest, CalculatesOriginalColumn) {
11567   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11568             "q\"; /* some\n"
11569             "       comment */",
11570             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11571                    "q\"; /* some\n"
11572                    "       comment */",
11573                    getLLVMStyle()));
11574   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11575             "/* some\n"
11576             "   comment */",
11577             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11578                    " /* some\n"
11579                    "    comment */",
11580                    getLLVMStyle()));
11581   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11582             "qqq\n"
11583             "/* some\n"
11584             "   comment */",
11585             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11586                    "qqq\n"
11587                    " /* some\n"
11588                    "    comment */",
11589                    getLLVMStyle()));
11590   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11591             "wwww; /* some\n"
11592             "         comment */",
11593             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11594                    "wwww; /* some\n"
11595                    "         comment */",
11596                    getLLVMStyle()));
11597 }
11598 
11599 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11600   FormatStyle NoSpace = getLLVMStyle();
11601   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11602 
11603   verifyFormat("while(true)\n"
11604                "  continue;",
11605                NoSpace);
11606   verifyFormat("for(;;)\n"
11607                "  continue;",
11608                NoSpace);
11609   verifyFormat("if(true)\n"
11610                "  f();\n"
11611                "else if(true)\n"
11612                "  f();",
11613                NoSpace);
11614   verifyFormat("do {\n"
11615                "  do_something();\n"
11616                "} while(something());",
11617                NoSpace);
11618   verifyFormat("switch(x) {\n"
11619                "default:\n"
11620                "  break;\n"
11621                "}",
11622                NoSpace);
11623   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11624   verifyFormat("size_t x = sizeof(x);", NoSpace);
11625   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11626   verifyFormat("auto f(int x) -> typeof(x);", NoSpace);
11627   verifyFormat("auto f(int x) -> _Atomic(x);", NoSpace);
11628   verifyFormat("auto f(int x) -> __underlying_type(x);", NoSpace);
11629   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11630   verifyFormat("alignas(128) char a[128];", NoSpace);
11631   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11632   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11633   verifyFormat("int f() throw(Deprecated);", NoSpace);
11634   verifyFormat("typedef void (*cb)(int);", NoSpace);
11635   verifyFormat("T A::operator()();", NoSpace);
11636   verifyFormat("X A::operator++(T);", NoSpace);
11637   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11638 
11639   FormatStyle Space = getLLVMStyle();
11640   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11641 
11642   verifyFormat("int f ();", Space);
11643   verifyFormat("void f (int a, T b) {\n"
11644                "  while (true)\n"
11645                "    continue;\n"
11646                "}",
11647                Space);
11648   verifyFormat("if (true)\n"
11649                "  f ();\n"
11650                "else if (true)\n"
11651                "  f ();",
11652                Space);
11653   verifyFormat("do {\n"
11654                "  do_something ();\n"
11655                "} while (something ());",
11656                Space);
11657   verifyFormat("switch (x) {\n"
11658                "default:\n"
11659                "  break;\n"
11660                "}",
11661                Space);
11662   verifyFormat("A::A () : a (1) {}", Space);
11663   verifyFormat("void f () __attribute__ ((asdf));", Space);
11664   verifyFormat("*(&a + 1);\n"
11665                "&((&a)[1]);\n"
11666                "a[(b + c) * d];\n"
11667                "(((a + 1) * 2) + 3) * 4;",
11668                Space);
11669   verifyFormat("#define A(x) x", Space);
11670   verifyFormat("#define A (x) x", Space);
11671   verifyFormat("#if defined(x)\n"
11672                "#endif",
11673                Space);
11674   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11675   verifyFormat("size_t x = sizeof (x);", Space);
11676   verifyFormat("auto f (int x) -> decltype (x);", Space);
11677   verifyFormat("auto f (int x) -> typeof (x);", Space);
11678   verifyFormat("auto f (int x) -> _Atomic (x);", Space);
11679   verifyFormat("auto f (int x) -> __underlying_type (x);", Space);
11680   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11681   verifyFormat("alignas (128) char a[128];", Space);
11682   verifyFormat("size_t x = alignof (MyType);", Space);
11683   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11684   verifyFormat("int f () throw (Deprecated);", Space);
11685   verifyFormat("typedef void (*cb) (int);", Space);
11686   verifyFormat("T A::operator() ();", Space);
11687   verifyFormat("X A::operator++ (T);", Space);
11688   verifyFormat("auto lambda = [] () { return 0; };", Space);
11689   verifyFormat("int x = int (y);", Space);
11690 
11691   FormatStyle SomeSpace = getLLVMStyle();
11692   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11693 
11694   verifyFormat("[]() -> float {}", SomeSpace);
11695   verifyFormat("[] (auto foo) {}", SomeSpace);
11696   verifyFormat("[foo]() -> int {}", SomeSpace);
11697   verifyFormat("int f();", SomeSpace);
11698   verifyFormat("void f (int a, T b) {\n"
11699                "  while (true)\n"
11700                "    continue;\n"
11701                "}",
11702                SomeSpace);
11703   verifyFormat("if (true)\n"
11704                "  f();\n"
11705                "else if (true)\n"
11706                "  f();",
11707                SomeSpace);
11708   verifyFormat("do {\n"
11709                "  do_something();\n"
11710                "} while (something());",
11711                SomeSpace);
11712   verifyFormat("switch (x) {\n"
11713                "default:\n"
11714                "  break;\n"
11715                "}",
11716                SomeSpace);
11717   verifyFormat("A::A() : a (1) {}", SomeSpace);
11718   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11719   verifyFormat("*(&a + 1);\n"
11720                "&((&a)[1]);\n"
11721                "a[(b + c) * d];\n"
11722                "(((a + 1) * 2) + 3) * 4;",
11723                SomeSpace);
11724   verifyFormat("#define A(x) x", SomeSpace);
11725   verifyFormat("#define A (x) x", SomeSpace);
11726   verifyFormat("#if defined(x)\n"
11727                "#endif",
11728                SomeSpace);
11729   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11730   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11731   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11732   verifyFormat("auto f (int x) -> typeof (x);", SomeSpace);
11733   verifyFormat("auto f (int x) -> _Atomic (x);", SomeSpace);
11734   verifyFormat("auto f (int x) -> __underlying_type (x);", SomeSpace);
11735   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11736   verifyFormat("alignas (128) char a[128];", SomeSpace);
11737   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11738   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11739                SomeSpace);
11740   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11741   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11742   verifyFormat("T A::operator()();", SomeSpace);
11743   verifyFormat("X A::operator++ (T);", SomeSpace);
11744   verifyFormat("int x = int (y);", SomeSpace);
11745   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11746 }
11747 
11748 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11749   FormatStyle Spaces = getLLVMStyle();
11750   Spaces.SpaceAfterLogicalNot = true;
11751 
11752   verifyFormat("bool x = ! y", Spaces);
11753   verifyFormat("if (! isFailure())", Spaces);
11754   verifyFormat("if (! (a && b))", Spaces);
11755   verifyFormat("\"Error!\"", Spaces);
11756   verifyFormat("! ! x", Spaces);
11757 }
11758 
11759 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11760   FormatStyle Spaces = getLLVMStyle();
11761 
11762   Spaces.SpacesInParentheses = true;
11763   verifyFormat("do_something( ::globalVar );", Spaces);
11764   verifyFormat("call( x, y, z );", Spaces);
11765   verifyFormat("call();", Spaces);
11766   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11767   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11768                Spaces);
11769   verifyFormat("while ( (bool)1 )\n"
11770                "  continue;",
11771                Spaces);
11772   verifyFormat("for ( ;; )\n"
11773                "  continue;",
11774                Spaces);
11775   verifyFormat("if ( true )\n"
11776                "  f();\n"
11777                "else if ( true )\n"
11778                "  f();",
11779                Spaces);
11780   verifyFormat("do {\n"
11781                "  do_something( (int)i );\n"
11782                "} while ( something() );",
11783                Spaces);
11784   verifyFormat("switch ( x ) {\n"
11785                "default:\n"
11786                "  break;\n"
11787                "}",
11788                Spaces);
11789 
11790   Spaces.SpacesInParentheses = false;
11791   Spaces.SpacesInCStyleCastParentheses = true;
11792   verifyFormat("Type *A = ( Type * )P;", Spaces);
11793   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11794   verifyFormat("x = ( int32 )y;", Spaces);
11795   verifyFormat("int a = ( int )(2.0f);", Spaces);
11796   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11797   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11798   verifyFormat("#define x (( int )-1)", Spaces);
11799 
11800   // Run the first set of tests again with:
11801   Spaces.SpacesInParentheses = false;
11802   Spaces.SpaceInEmptyParentheses = true;
11803   Spaces.SpacesInCStyleCastParentheses = true;
11804   verifyFormat("call(x, y, z);", Spaces);
11805   verifyFormat("call( );", Spaces);
11806   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11807   verifyFormat("while (( bool )1)\n"
11808                "  continue;",
11809                Spaces);
11810   verifyFormat("for (;;)\n"
11811                "  continue;",
11812                Spaces);
11813   verifyFormat("if (true)\n"
11814                "  f( );\n"
11815                "else if (true)\n"
11816                "  f( );",
11817                Spaces);
11818   verifyFormat("do {\n"
11819                "  do_something(( int )i);\n"
11820                "} while (something( ));",
11821                Spaces);
11822   verifyFormat("switch (x) {\n"
11823                "default:\n"
11824                "  break;\n"
11825                "}",
11826                Spaces);
11827 
11828   // Run the first set of tests again with:
11829   Spaces.SpaceAfterCStyleCast = true;
11830   verifyFormat("call(x, y, z);", Spaces);
11831   verifyFormat("call( );", Spaces);
11832   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11833   verifyFormat("while (( bool ) 1)\n"
11834                "  continue;",
11835                Spaces);
11836   verifyFormat("for (;;)\n"
11837                "  continue;",
11838                Spaces);
11839   verifyFormat("if (true)\n"
11840                "  f( );\n"
11841                "else if (true)\n"
11842                "  f( );",
11843                Spaces);
11844   verifyFormat("do {\n"
11845                "  do_something(( int ) i);\n"
11846                "} while (something( ));",
11847                Spaces);
11848   verifyFormat("switch (x) {\n"
11849                "default:\n"
11850                "  break;\n"
11851                "}",
11852                Spaces);
11853 
11854   // Run subset of tests again with:
11855   Spaces.SpacesInCStyleCastParentheses = false;
11856   Spaces.SpaceAfterCStyleCast = true;
11857   verifyFormat("while ((bool) 1)\n"
11858                "  continue;",
11859                Spaces);
11860   verifyFormat("do {\n"
11861                "  do_something((int) i);\n"
11862                "} while (something( ));",
11863                Spaces);
11864 }
11865 
11866 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
11867   verifyFormat("int a[5];");
11868   verifyFormat("a[3] += 42;");
11869 
11870   FormatStyle Spaces = getLLVMStyle();
11871   Spaces.SpacesInSquareBrackets = true;
11872   // Not lambdas.
11873   verifyFormat("int a[ 5 ];", Spaces);
11874   verifyFormat("a[ 3 ] += 42;", Spaces);
11875   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
11876   verifyFormat("double &operator[](int i) { return 0; }\n"
11877                "int i;",
11878                Spaces);
11879   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
11880   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
11881   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
11882   // Lambdas.
11883   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
11884   verifyFormat("return [ i, args... ] {};", Spaces);
11885   verifyFormat("int foo = [ &bar ]() {};", Spaces);
11886   verifyFormat("int foo = [ = ]() {};", Spaces);
11887   verifyFormat("int foo = [ & ]() {};", Spaces);
11888   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
11889   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
11890 }
11891 
11892 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
11893   FormatStyle NoSpaceStyle = getLLVMStyle();
11894   verifyFormat("int a[5];", NoSpaceStyle);
11895   verifyFormat("a[3] += 42;", NoSpaceStyle);
11896 
11897   verifyFormat("int a[1];", NoSpaceStyle);
11898   verifyFormat("int 1 [a];", NoSpaceStyle);
11899   verifyFormat("int a[1][2];", NoSpaceStyle);
11900   verifyFormat("a[7] = 5;", NoSpaceStyle);
11901   verifyFormat("int a = (f())[23];", NoSpaceStyle);
11902   verifyFormat("f([] {})", NoSpaceStyle);
11903 
11904   FormatStyle Space = getLLVMStyle();
11905   Space.SpaceBeforeSquareBrackets = true;
11906   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
11907   verifyFormat("return [i, args...] {};", Space);
11908 
11909   verifyFormat("int a [5];", Space);
11910   verifyFormat("a [3] += 42;", Space);
11911   verifyFormat("constexpr char hello []{\"hello\"};", Space);
11912   verifyFormat("double &operator[](int i) { return 0; }\n"
11913                "int i;",
11914                Space);
11915   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
11916   verifyFormat("int i = a [a][a]->f();", Space);
11917   verifyFormat("int i = (*b) [a]->f();", Space);
11918 
11919   verifyFormat("int a [1];", Space);
11920   verifyFormat("int 1 [a];", Space);
11921   verifyFormat("int a [1][2];", Space);
11922   verifyFormat("a [7] = 5;", Space);
11923   verifyFormat("int a = (f()) [23];", Space);
11924   verifyFormat("f([] {})", Space);
11925 }
11926 
11927 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
11928   verifyFormat("int a = 5;");
11929   verifyFormat("a += 42;");
11930   verifyFormat("a or_eq 8;");
11931 
11932   FormatStyle Spaces = getLLVMStyle();
11933   Spaces.SpaceBeforeAssignmentOperators = false;
11934   verifyFormat("int a= 5;", Spaces);
11935   verifyFormat("a+= 42;", Spaces);
11936   verifyFormat("a or_eq 8;", Spaces);
11937 }
11938 
11939 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
11940   verifyFormat("class Foo : public Bar {};");
11941   verifyFormat("Foo::Foo() : foo(1) {}");
11942   verifyFormat("for (auto a : b) {\n}");
11943   verifyFormat("int x = a ? b : c;");
11944   verifyFormat("{\n"
11945                "label0:\n"
11946                "  int x = 0;\n"
11947                "}");
11948   verifyFormat("switch (x) {\n"
11949                "case 1:\n"
11950                "default:\n"
11951                "}");
11952 
11953   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
11954   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
11955   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
11956   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
11957   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
11958   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
11959   verifyFormat("{\n"
11960                "label1:\n"
11961                "  int x = 0;\n"
11962                "}",
11963                CtorInitializerStyle);
11964   verifyFormat("switch (x) {\n"
11965                "case 1:\n"
11966                "default:\n"
11967                "}",
11968                CtorInitializerStyle);
11969   CtorInitializerStyle.BreakConstructorInitializers =
11970       FormatStyle::BCIS_AfterColon;
11971   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
11972                "    aaaaaaaaaaaaaaaa(1),\n"
11973                "    bbbbbbbbbbbbbbbb(2) {}",
11974                CtorInitializerStyle);
11975   CtorInitializerStyle.BreakConstructorInitializers =
11976       FormatStyle::BCIS_BeforeComma;
11977   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11978                "    : aaaaaaaaaaaaaaaa(1)\n"
11979                "    , bbbbbbbbbbbbbbbb(2) {}",
11980                CtorInitializerStyle);
11981   CtorInitializerStyle.BreakConstructorInitializers =
11982       FormatStyle::BCIS_BeforeColon;
11983   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11984                "    : aaaaaaaaaaaaaaaa(1),\n"
11985                "      bbbbbbbbbbbbbbbb(2) {}",
11986                CtorInitializerStyle);
11987   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
11988   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11989                ": aaaaaaaaaaaaaaaa(1),\n"
11990                "  bbbbbbbbbbbbbbbb(2) {}",
11991                CtorInitializerStyle);
11992 
11993   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
11994   InheritanceStyle.SpaceBeforeInheritanceColon = false;
11995   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
11996   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
11997   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
11998   verifyFormat("int x = a ? b : c;", InheritanceStyle);
11999   verifyFormat("{\n"
12000                "label2:\n"
12001                "  int x = 0;\n"
12002                "}",
12003                InheritanceStyle);
12004   verifyFormat("switch (x) {\n"
12005                "case 1:\n"
12006                "default:\n"
12007                "}",
12008                InheritanceStyle);
12009   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
12010   verifyFormat("class Foooooooooooooooooooooo:\n"
12011                "    public aaaaaaaaaaaaaaaaaa,\n"
12012                "    public bbbbbbbbbbbbbbbbbb {\n"
12013                "}",
12014                InheritanceStyle);
12015   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
12016   verifyFormat("class Foooooooooooooooooooooo\n"
12017                "    : public aaaaaaaaaaaaaaaaaa\n"
12018                "    , public bbbbbbbbbbbbbbbbbb {\n"
12019                "}",
12020                InheritanceStyle);
12021   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
12022   verifyFormat("class Foooooooooooooooooooooo\n"
12023                "    : public aaaaaaaaaaaaaaaaaa,\n"
12024                "      public bbbbbbbbbbbbbbbbbb {\n"
12025                "}",
12026                InheritanceStyle);
12027   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
12028   verifyFormat("class Foooooooooooooooooooooo\n"
12029                ": public aaaaaaaaaaaaaaaaaa,\n"
12030                "  public bbbbbbbbbbbbbbbbbb {}",
12031                InheritanceStyle);
12032 
12033   FormatStyle ForLoopStyle = getLLVMStyle();
12034   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
12035   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
12036   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
12037   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
12038   verifyFormat("int x = a ? b : c;", ForLoopStyle);
12039   verifyFormat("{\n"
12040                "label2:\n"
12041                "  int x = 0;\n"
12042                "}",
12043                ForLoopStyle);
12044   verifyFormat("switch (x) {\n"
12045                "case 1:\n"
12046                "default:\n"
12047                "}",
12048                ForLoopStyle);
12049 
12050   FormatStyle NoSpaceStyle = getLLVMStyle();
12051   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
12052   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
12053   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
12054   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
12055   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
12056   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
12057   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
12058   verifyFormat("{\n"
12059                "label3:\n"
12060                "  int x = 0;\n"
12061                "}",
12062                NoSpaceStyle);
12063   verifyFormat("switch (x) {\n"
12064                "case 1:\n"
12065                "default:\n"
12066                "}",
12067                NoSpaceStyle);
12068 }
12069 
12070 TEST_F(FormatTest, AlignConsecutiveMacros) {
12071   FormatStyle Style = getLLVMStyle();
12072   Style.AlignConsecutiveAssignments = true;
12073   Style.AlignConsecutiveDeclarations = true;
12074   Style.AlignConsecutiveMacros = false;
12075 
12076   verifyFormat("#define a 3\n"
12077                "#define bbbb 4\n"
12078                "#define ccc (5)",
12079                Style);
12080 
12081   verifyFormat("#define f(x) (x * x)\n"
12082                "#define fff(x, y, z) (x * y + z)\n"
12083                "#define ffff(x, y) (x - y)",
12084                Style);
12085 
12086   verifyFormat("#define foo(x, y) (x + y)\n"
12087                "#define bar (5, 6)(2 + 2)",
12088                Style);
12089 
12090   verifyFormat("#define a 3\n"
12091                "#define bbbb 4\n"
12092                "#define ccc (5)\n"
12093                "#define f(x) (x * x)\n"
12094                "#define fff(x, y, z) (x * y + z)\n"
12095                "#define ffff(x, y) (x - y)",
12096                Style);
12097 
12098   Style.AlignConsecutiveMacros = true;
12099   verifyFormat("#define a    3\n"
12100                "#define bbbb 4\n"
12101                "#define ccc  (5)",
12102                Style);
12103 
12104   verifyFormat("#define f(x)         (x * x)\n"
12105                "#define fff(x, y, z) (x * y + z)\n"
12106                "#define ffff(x, y)   (x - y)",
12107                Style);
12108 
12109   verifyFormat("#define foo(x, y) (x + y)\n"
12110                "#define bar       (5, 6)(2 + 2)",
12111                Style);
12112 
12113   verifyFormat("#define a            3\n"
12114                "#define bbbb         4\n"
12115                "#define ccc          (5)\n"
12116                "#define f(x)         (x * x)\n"
12117                "#define fff(x, y, z) (x * y + z)\n"
12118                "#define ffff(x, y)   (x - y)",
12119                Style);
12120 
12121   verifyFormat("#define a         5\n"
12122                "#define foo(x, y) (x + y)\n"
12123                "#define CCC       (6)\n"
12124                "auto lambda = []() {\n"
12125                "  auto  ii = 0;\n"
12126                "  float j  = 0;\n"
12127                "  return 0;\n"
12128                "};\n"
12129                "int   i  = 0;\n"
12130                "float i2 = 0;\n"
12131                "auto  v  = type{\n"
12132                "    i = 1,   //\n"
12133                "    (i = 2), //\n"
12134                "    i = 3    //\n"
12135                "};",
12136                Style);
12137 
12138   Style.AlignConsecutiveMacros = false;
12139   Style.ColumnLimit = 20;
12140 
12141   verifyFormat("#define a          \\\n"
12142                "  \"aabbbbbbbbbbbb\"\n"
12143                "#define D          \\\n"
12144                "  \"aabbbbbbbbbbbb\" \\\n"
12145                "  \"ccddeeeeeeeee\"\n"
12146                "#define B          \\\n"
12147                "  \"QQQQQQQQQQQQQ\"  \\\n"
12148                "  \"FFFFFFFFFFFFF\"  \\\n"
12149                "  \"LLLLLLLL\"\n",
12150                Style);
12151 
12152   Style.AlignConsecutiveMacros = true;
12153   verifyFormat("#define a          \\\n"
12154                "  \"aabbbbbbbbbbbb\"\n"
12155                "#define D          \\\n"
12156                "  \"aabbbbbbbbbbbb\" \\\n"
12157                "  \"ccddeeeeeeeee\"\n"
12158                "#define B          \\\n"
12159                "  \"QQQQQQQQQQQQQ\"  \\\n"
12160                "  \"FFFFFFFFFFFFF\"  \\\n"
12161                "  \"LLLLLLLL\"\n",
12162                Style);
12163 }
12164 
12165 TEST_F(FormatTest, AlignConsecutiveAssignments) {
12166   FormatStyle Alignment = getLLVMStyle();
12167   Alignment.AlignConsecutiveMacros = true;
12168   Alignment.AlignConsecutiveAssignments = false;
12169   verifyFormat("int a = 5;\n"
12170                "int oneTwoThree = 123;",
12171                Alignment);
12172   verifyFormat("int a = 5;\n"
12173                "int oneTwoThree = 123;",
12174                Alignment);
12175 
12176   Alignment.AlignConsecutiveAssignments = true;
12177   verifyFormat("int a           = 5;\n"
12178                "int oneTwoThree = 123;",
12179                Alignment);
12180   verifyFormat("int a           = method();\n"
12181                "int oneTwoThree = 133;",
12182                Alignment);
12183   verifyFormat("a &= 5;\n"
12184                "bcd *= 5;\n"
12185                "ghtyf += 5;\n"
12186                "dvfvdb -= 5;\n"
12187                "a /= 5;\n"
12188                "vdsvsv %= 5;\n"
12189                "sfdbddfbdfbb ^= 5;\n"
12190                "dvsdsv |= 5;\n"
12191                "int dsvvdvsdvvv = 123;",
12192                Alignment);
12193   verifyFormat("int i = 1, j = 10;\n"
12194                "something = 2000;",
12195                Alignment);
12196   verifyFormat("something = 2000;\n"
12197                "int i = 1, j = 10;\n",
12198                Alignment);
12199   verifyFormat("something = 2000;\n"
12200                "another   = 911;\n"
12201                "int i = 1, j = 10;\n"
12202                "oneMore = 1;\n"
12203                "i       = 2;",
12204                Alignment);
12205   verifyFormat("int a   = 5;\n"
12206                "int one = 1;\n"
12207                "method();\n"
12208                "int oneTwoThree = 123;\n"
12209                "int oneTwo      = 12;",
12210                Alignment);
12211   verifyFormat("int oneTwoThree = 123;\n"
12212                "int oneTwo      = 12;\n"
12213                "method();\n",
12214                Alignment);
12215   verifyFormat("int oneTwoThree = 123; // comment\n"
12216                "int oneTwo      = 12;  // comment",
12217                Alignment);
12218 
12219   // Bug 25167
12220   verifyFormat("#if A\n"
12221                "#else\n"
12222                "int aaaaaaaa = 12;\n"
12223                "#endif\n"
12224                "#if B\n"
12225                "#else\n"
12226                "int a = 12;\n"
12227                "#endif\n",
12228                Alignment);
12229   verifyFormat("enum foo {\n"
12230                "#if A\n"
12231                "#else\n"
12232                "  aaaaaaaa = 12;\n"
12233                "#endif\n"
12234                "#if B\n"
12235                "#else\n"
12236                "  a = 12;\n"
12237                "#endif\n"
12238                "};\n",
12239                Alignment);
12240 
12241   EXPECT_EQ("int a = 5;\n"
12242             "\n"
12243             "int oneTwoThree = 123;",
12244             format("int a       = 5;\n"
12245                    "\n"
12246                    "int oneTwoThree= 123;",
12247                    Alignment));
12248   EXPECT_EQ("int a   = 5;\n"
12249             "int one = 1;\n"
12250             "\n"
12251             "int oneTwoThree = 123;",
12252             format("int a = 5;\n"
12253                    "int one = 1;\n"
12254                    "\n"
12255                    "int oneTwoThree = 123;",
12256                    Alignment));
12257   EXPECT_EQ("int a   = 5;\n"
12258             "int one = 1;\n"
12259             "\n"
12260             "int oneTwoThree = 123;\n"
12261             "int oneTwo      = 12;",
12262             format("int a = 5;\n"
12263                    "int one = 1;\n"
12264                    "\n"
12265                    "int oneTwoThree = 123;\n"
12266                    "int oneTwo = 12;",
12267                    Alignment));
12268   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12269   verifyFormat("#define A \\\n"
12270                "  int aaaa       = 12; \\\n"
12271                "  int b          = 23; \\\n"
12272                "  int ccc        = 234; \\\n"
12273                "  int dddddddddd = 2345;",
12274                Alignment);
12275   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12276   verifyFormat("#define A               \\\n"
12277                "  int aaaa       = 12;  \\\n"
12278                "  int b          = 23;  \\\n"
12279                "  int ccc        = 234; \\\n"
12280                "  int dddddddddd = 2345;",
12281                Alignment);
12282   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12283   verifyFormat("#define A                                                      "
12284                "                \\\n"
12285                "  int aaaa       = 12;                                         "
12286                "                \\\n"
12287                "  int b          = 23;                                         "
12288                "                \\\n"
12289                "  int ccc        = 234;                                        "
12290                "                \\\n"
12291                "  int dddddddddd = 2345;",
12292                Alignment);
12293   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12294                "k = 4, int l = 5,\n"
12295                "                  int m = 6) {\n"
12296                "  int j      = 10;\n"
12297                "  otherThing = 1;\n"
12298                "}",
12299                Alignment);
12300   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12301                "  int i   = 1;\n"
12302                "  int j   = 2;\n"
12303                "  int big = 10000;\n"
12304                "}",
12305                Alignment);
12306   verifyFormat("class C {\n"
12307                "public:\n"
12308                "  int i            = 1;\n"
12309                "  virtual void f() = 0;\n"
12310                "};",
12311                Alignment);
12312   verifyFormat("int i = 1;\n"
12313                "if (SomeType t = getSomething()) {\n"
12314                "}\n"
12315                "int j   = 2;\n"
12316                "int big = 10000;",
12317                Alignment);
12318   verifyFormat("int j = 7;\n"
12319                "for (int k = 0; k < N; ++k) {\n"
12320                "}\n"
12321                "int j   = 2;\n"
12322                "int big = 10000;\n"
12323                "}",
12324                Alignment);
12325   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12326   verifyFormat("int i = 1;\n"
12327                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12328                "    = someLooooooooooooooooongFunction();\n"
12329                "int j = 2;",
12330                Alignment);
12331   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12332   verifyFormat("int i = 1;\n"
12333                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12334                "    someLooooooooooooooooongFunction();\n"
12335                "int j = 2;",
12336                Alignment);
12337 
12338   verifyFormat("auto lambda = []() {\n"
12339                "  auto i = 0;\n"
12340                "  return 0;\n"
12341                "};\n"
12342                "int i  = 0;\n"
12343                "auto v = type{\n"
12344                "    i = 1,   //\n"
12345                "    (i = 2), //\n"
12346                "    i = 3    //\n"
12347                "};",
12348                Alignment);
12349 
12350   verifyFormat(
12351       "int i      = 1;\n"
12352       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12353       "                          loooooooooooooooooooooongParameterB);\n"
12354       "int j      = 2;",
12355       Alignment);
12356 
12357   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12358                "          typename B   = very_long_type_name_1,\n"
12359                "          typename T_2 = very_long_type_name_2>\n"
12360                "auto foo() {}\n",
12361                Alignment);
12362   verifyFormat("int a, b = 1;\n"
12363                "int c  = 2;\n"
12364                "int dd = 3;\n",
12365                Alignment);
12366   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12367                "float b[1][] = {{3.f}};\n",
12368                Alignment);
12369   verifyFormat("for (int i = 0; i < 1; i++)\n"
12370                "  int x = 1;\n",
12371                Alignment);
12372   verifyFormat("for (i = 0; i < 1; i++)\n"
12373                "  x = 1;\n"
12374                "y = 1;\n",
12375                Alignment);
12376 
12377   Alignment.ReflowComments = true;
12378   Alignment.ColumnLimit = 50;
12379   EXPECT_EQ("int x   = 0;\n"
12380             "int yy  = 1; /// specificlennospace\n"
12381             "int zzz = 2;\n",
12382             format("int x   = 0;\n"
12383                    "int yy  = 1; ///specificlennospace\n"
12384                    "int zzz = 2;\n",
12385                    Alignment));
12386 }
12387 
12388 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12389   FormatStyle Alignment = getLLVMStyle();
12390   Alignment.AlignConsecutiveBitFields = true;
12391   verifyFormat("int const a     : 5;\n"
12392                "int oneTwoThree : 23;",
12393                Alignment);
12394 
12395   // Initializers are allowed starting with c++2a
12396   verifyFormat("int const a     : 5 = 1;\n"
12397                "int oneTwoThree : 23 = 0;",
12398                Alignment);
12399 
12400   Alignment.AlignConsecutiveDeclarations = true;
12401   verifyFormat("int const a           : 5;\n"
12402                "int       oneTwoThree : 23;",
12403                Alignment);
12404 
12405   verifyFormat("int const a           : 5;  // comment\n"
12406                "int       oneTwoThree : 23; // comment",
12407                Alignment);
12408 
12409   verifyFormat("int const a           : 5 = 1;\n"
12410                "int       oneTwoThree : 23 = 0;",
12411                Alignment);
12412 
12413   Alignment.AlignConsecutiveAssignments = true;
12414   verifyFormat("int const a           : 5  = 1;\n"
12415                "int       oneTwoThree : 23 = 0;",
12416                Alignment);
12417   verifyFormat("int const a           : 5  = {1};\n"
12418                "int       oneTwoThree : 23 = 0;",
12419                Alignment);
12420 
12421   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_None;
12422   verifyFormat("int const a          :5;\n"
12423                "int       oneTwoThree:23;",
12424                Alignment);
12425 
12426   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_Before;
12427   verifyFormat("int const a           :5;\n"
12428                "int       oneTwoThree :23;",
12429                Alignment);
12430 
12431   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_After;
12432   verifyFormat("int const a          : 5;\n"
12433                "int       oneTwoThree: 23;",
12434                Alignment);
12435 
12436   // Known limitations: ':' is only recognized as a bitfield colon when
12437   // followed by a number.
12438   /*
12439   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12440                "int a           : 5;",
12441                Alignment);
12442   */
12443 }
12444 
12445 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12446   FormatStyle Alignment = getLLVMStyle();
12447   Alignment.AlignConsecutiveMacros = true;
12448   Alignment.AlignConsecutiveDeclarations = false;
12449   verifyFormat("float const a = 5;\n"
12450                "int oneTwoThree = 123;",
12451                Alignment);
12452   verifyFormat("int a = 5;\n"
12453                "float const oneTwoThree = 123;",
12454                Alignment);
12455 
12456   Alignment.AlignConsecutiveDeclarations = true;
12457   verifyFormat("float const a = 5;\n"
12458                "int         oneTwoThree = 123;",
12459                Alignment);
12460   verifyFormat("int         a = method();\n"
12461                "float const oneTwoThree = 133;",
12462                Alignment);
12463   verifyFormat("int i = 1, j = 10;\n"
12464                "something = 2000;",
12465                Alignment);
12466   verifyFormat("something = 2000;\n"
12467                "int i = 1, j = 10;\n",
12468                Alignment);
12469   verifyFormat("float      something = 2000;\n"
12470                "double     another = 911;\n"
12471                "int        i = 1, j = 10;\n"
12472                "const int *oneMore = 1;\n"
12473                "unsigned   i = 2;",
12474                Alignment);
12475   verifyFormat("float a = 5;\n"
12476                "int   one = 1;\n"
12477                "method();\n"
12478                "const double       oneTwoThree = 123;\n"
12479                "const unsigned int oneTwo = 12;",
12480                Alignment);
12481   verifyFormat("int      oneTwoThree{0}; // comment\n"
12482                "unsigned oneTwo;         // comment",
12483                Alignment);
12484   EXPECT_EQ("float const a = 5;\n"
12485             "\n"
12486             "int oneTwoThree = 123;",
12487             format("float const   a = 5;\n"
12488                    "\n"
12489                    "int           oneTwoThree= 123;",
12490                    Alignment));
12491   EXPECT_EQ("float a = 5;\n"
12492             "int   one = 1;\n"
12493             "\n"
12494             "unsigned oneTwoThree = 123;",
12495             format("float    a = 5;\n"
12496                    "int      one = 1;\n"
12497                    "\n"
12498                    "unsigned oneTwoThree = 123;",
12499                    Alignment));
12500   EXPECT_EQ("float a = 5;\n"
12501             "int   one = 1;\n"
12502             "\n"
12503             "unsigned oneTwoThree = 123;\n"
12504             "int      oneTwo = 12;",
12505             format("float    a = 5;\n"
12506                    "int one = 1;\n"
12507                    "\n"
12508                    "unsigned oneTwoThree = 123;\n"
12509                    "int oneTwo = 12;",
12510                    Alignment));
12511   // Function prototype alignment
12512   verifyFormat("int    a();\n"
12513                "double b();",
12514                Alignment);
12515   verifyFormat("int    a(int x);\n"
12516                "double b();",
12517                Alignment);
12518   unsigned OldColumnLimit = Alignment.ColumnLimit;
12519   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12520   // otherwise the function parameters will be re-flowed onto a single line.
12521   Alignment.ColumnLimit = 0;
12522   EXPECT_EQ("int    a(int   x,\n"
12523             "         float y);\n"
12524             "double b(int    x,\n"
12525             "         double y);",
12526             format("int a(int x,\n"
12527                    " float y);\n"
12528                    "double b(int x,\n"
12529                    " double y);",
12530                    Alignment));
12531   // This ensures that function parameters of function declarations are
12532   // correctly indented when their owning functions are indented.
12533   // The failure case here is for 'double y' to not be indented enough.
12534   EXPECT_EQ("double a(int x);\n"
12535             "int    b(int    y,\n"
12536             "         double z);",
12537             format("double a(int x);\n"
12538                    "int b(int y,\n"
12539                    " double z);",
12540                    Alignment));
12541   // Set ColumnLimit low so that we induce wrapping immediately after
12542   // the function name and opening paren.
12543   Alignment.ColumnLimit = 13;
12544   verifyFormat("int function(\n"
12545                "    int  x,\n"
12546                "    bool y);",
12547                Alignment);
12548   Alignment.ColumnLimit = OldColumnLimit;
12549   // Ensure function pointers don't screw up recursive alignment
12550   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12551                "double b();",
12552                Alignment);
12553   Alignment.AlignConsecutiveAssignments = true;
12554   // Ensure recursive alignment is broken by function braces, so that the
12555   // "a = 1" does not align with subsequent assignments inside the function
12556   // body.
12557   verifyFormat("int func(int a = 1) {\n"
12558                "  int b  = 2;\n"
12559                "  int cc = 3;\n"
12560                "}",
12561                Alignment);
12562   verifyFormat("float      something = 2000;\n"
12563                "double     another   = 911;\n"
12564                "int        i = 1, j = 10;\n"
12565                "const int *oneMore = 1;\n"
12566                "unsigned   i       = 2;",
12567                Alignment);
12568   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12569                "unsigned oneTwo      = 0;   // comment",
12570                Alignment);
12571   // Make sure that scope is correctly tracked, in the absence of braces
12572   verifyFormat("for (int i = 0; i < n; i++)\n"
12573                "  j = i;\n"
12574                "double x = 1;\n",
12575                Alignment);
12576   verifyFormat("if (int i = 0)\n"
12577                "  j = i;\n"
12578                "double x = 1;\n",
12579                Alignment);
12580   // Ensure operator[] and operator() are comprehended
12581   verifyFormat("struct test {\n"
12582                "  long long int foo();\n"
12583                "  int           operator[](int a);\n"
12584                "  double        bar();\n"
12585                "};\n",
12586                Alignment);
12587   verifyFormat("struct test {\n"
12588                "  long long int foo();\n"
12589                "  int           operator()(int a);\n"
12590                "  double        bar();\n"
12591                "};\n",
12592                Alignment);
12593   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12594             "  int const i   = 1;\n"
12595             "  int *     j   = 2;\n"
12596             "  int       big = 10000;\n"
12597             "\n"
12598             "  unsigned oneTwoThree = 123;\n"
12599             "  int      oneTwo      = 12;\n"
12600             "  method();\n"
12601             "  float k  = 2;\n"
12602             "  int   ll = 10000;\n"
12603             "}",
12604             format("void SomeFunction(int parameter= 0) {\n"
12605                    " int const  i= 1;\n"
12606                    "  int *j=2;\n"
12607                    " int big  =  10000;\n"
12608                    "\n"
12609                    "unsigned oneTwoThree  =123;\n"
12610                    "int oneTwo = 12;\n"
12611                    "  method();\n"
12612                    "float k= 2;\n"
12613                    "int ll=10000;\n"
12614                    "}",
12615                    Alignment));
12616   Alignment.AlignConsecutiveAssignments = false;
12617   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12618   verifyFormat("#define A \\\n"
12619                "  int       aaaa = 12; \\\n"
12620                "  float     b = 23; \\\n"
12621                "  const int ccc = 234; \\\n"
12622                "  unsigned  dddddddddd = 2345;",
12623                Alignment);
12624   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12625   verifyFormat("#define A              \\\n"
12626                "  int       aaaa = 12; \\\n"
12627                "  float     b = 23;    \\\n"
12628                "  const int ccc = 234; \\\n"
12629                "  unsigned  dddddddddd = 2345;",
12630                Alignment);
12631   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12632   Alignment.ColumnLimit = 30;
12633   verifyFormat("#define A                    \\\n"
12634                "  int       aaaa = 12;       \\\n"
12635                "  float     b = 23;          \\\n"
12636                "  const int ccc = 234;       \\\n"
12637                "  int       dddddddddd = 2345;",
12638                Alignment);
12639   Alignment.ColumnLimit = 80;
12640   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12641                "k = 4, int l = 5,\n"
12642                "                  int m = 6) {\n"
12643                "  const int j = 10;\n"
12644                "  otherThing = 1;\n"
12645                "}",
12646                Alignment);
12647   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12648                "  int const i = 1;\n"
12649                "  int *     j = 2;\n"
12650                "  int       big = 10000;\n"
12651                "}",
12652                Alignment);
12653   verifyFormat("class C {\n"
12654                "public:\n"
12655                "  int          i = 1;\n"
12656                "  virtual void f() = 0;\n"
12657                "};",
12658                Alignment);
12659   verifyFormat("float i = 1;\n"
12660                "if (SomeType t = getSomething()) {\n"
12661                "}\n"
12662                "const unsigned j = 2;\n"
12663                "int            big = 10000;",
12664                Alignment);
12665   verifyFormat("float j = 7;\n"
12666                "for (int k = 0; k < N; ++k) {\n"
12667                "}\n"
12668                "unsigned j = 2;\n"
12669                "int      big = 10000;\n"
12670                "}",
12671                Alignment);
12672   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12673   verifyFormat("float              i = 1;\n"
12674                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12675                "    = someLooooooooooooooooongFunction();\n"
12676                "int j = 2;",
12677                Alignment);
12678   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12679   verifyFormat("int                i = 1;\n"
12680                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12681                "    someLooooooooooooooooongFunction();\n"
12682                "int j = 2;",
12683                Alignment);
12684 
12685   Alignment.AlignConsecutiveAssignments = true;
12686   verifyFormat("auto lambda = []() {\n"
12687                "  auto  ii = 0;\n"
12688                "  float j  = 0;\n"
12689                "  return 0;\n"
12690                "};\n"
12691                "int   i  = 0;\n"
12692                "float i2 = 0;\n"
12693                "auto  v  = type{\n"
12694                "    i = 1,   //\n"
12695                "    (i = 2), //\n"
12696                "    i = 3    //\n"
12697                "};",
12698                Alignment);
12699   Alignment.AlignConsecutiveAssignments = false;
12700 
12701   verifyFormat(
12702       "int      i = 1;\n"
12703       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12704       "                          loooooooooooooooooooooongParameterB);\n"
12705       "int      j = 2;",
12706       Alignment);
12707 
12708   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12709   // We expect declarations and assignments to align, as long as it doesn't
12710   // exceed the column limit, starting a new alignment sequence whenever it
12711   // happens.
12712   Alignment.AlignConsecutiveAssignments = true;
12713   Alignment.ColumnLimit = 30;
12714   verifyFormat("float    ii              = 1;\n"
12715                "unsigned j               = 2;\n"
12716                "int someVerylongVariable = 1;\n"
12717                "AnotherLongType  ll = 123456;\n"
12718                "VeryVeryLongType k  = 2;\n"
12719                "int              myvar = 1;",
12720                Alignment);
12721   Alignment.ColumnLimit = 80;
12722   Alignment.AlignConsecutiveAssignments = false;
12723 
12724   verifyFormat(
12725       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12726       "          typename LongType, typename B>\n"
12727       "auto foo() {}\n",
12728       Alignment);
12729   verifyFormat("float a, b = 1;\n"
12730                "int   c = 2;\n"
12731                "int   dd = 3;\n",
12732                Alignment);
12733   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12734                "float b[1][] = {{3.f}};\n",
12735                Alignment);
12736   Alignment.AlignConsecutiveAssignments = true;
12737   verifyFormat("float a, b = 1;\n"
12738                "int   c  = 2;\n"
12739                "int   dd = 3;\n",
12740                Alignment);
12741   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12742                "float b[1][] = {{3.f}};\n",
12743                Alignment);
12744   Alignment.AlignConsecutiveAssignments = false;
12745 
12746   Alignment.ColumnLimit = 30;
12747   Alignment.BinPackParameters = false;
12748   verifyFormat("void foo(float     a,\n"
12749                "         float     b,\n"
12750                "         int       c,\n"
12751                "         uint32_t *d) {\n"
12752                "  int *  e = 0;\n"
12753                "  float  f = 0;\n"
12754                "  double g = 0;\n"
12755                "}\n"
12756                "void bar(ino_t     a,\n"
12757                "         int       b,\n"
12758                "         uint32_t *c,\n"
12759                "         bool      d) {}\n",
12760                Alignment);
12761   Alignment.BinPackParameters = true;
12762   Alignment.ColumnLimit = 80;
12763 
12764   // Bug 33507
12765   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12766   verifyFormat(
12767       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12768       "  static const Version verVs2017;\n"
12769       "  return true;\n"
12770       "});\n",
12771       Alignment);
12772   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12773 
12774   // See llvm.org/PR35641
12775   Alignment.AlignConsecutiveDeclarations = true;
12776   verifyFormat("int func() { //\n"
12777                "  int      b;\n"
12778                "  unsigned c;\n"
12779                "}",
12780                Alignment);
12781 
12782   // See PR37175
12783   FormatStyle Style = getMozillaStyle();
12784   Style.AlignConsecutiveDeclarations = true;
12785   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12786             "foo(int a);",
12787             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12788 }
12789 
12790 TEST_F(FormatTest, LinuxBraceBreaking) {
12791   FormatStyle LinuxBraceStyle = getLLVMStyle();
12792   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12793   verifyFormat("namespace a\n"
12794                "{\n"
12795                "class A\n"
12796                "{\n"
12797                "  void f()\n"
12798                "  {\n"
12799                "    if (true) {\n"
12800                "      a();\n"
12801                "      b();\n"
12802                "    } else {\n"
12803                "      a();\n"
12804                "    }\n"
12805                "  }\n"
12806                "  void g() { return; }\n"
12807                "};\n"
12808                "struct B {\n"
12809                "  int x;\n"
12810                "};\n"
12811                "} // namespace a\n",
12812                LinuxBraceStyle);
12813   verifyFormat("enum X {\n"
12814                "  Y = 0,\n"
12815                "}\n",
12816                LinuxBraceStyle);
12817   verifyFormat("struct S {\n"
12818                "  int Type;\n"
12819                "  union {\n"
12820                "    int x;\n"
12821                "    double y;\n"
12822                "  } Value;\n"
12823                "  class C\n"
12824                "  {\n"
12825                "    MyFavoriteType Value;\n"
12826                "  } Class;\n"
12827                "}\n",
12828                LinuxBraceStyle);
12829 }
12830 
12831 TEST_F(FormatTest, MozillaBraceBreaking) {
12832   FormatStyle MozillaBraceStyle = getLLVMStyle();
12833   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
12834   MozillaBraceStyle.FixNamespaceComments = false;
12835   verifyFormat("namespace a {\n"
12836                "class A\n"
12837                "{\n"
12838                "  void f()\n"
12839                "  {\n"
12840                "    if (true) {\n"
12841                "      a();\n"
12842                "      b();\n"
12843                "    }\n"
12844                "  }\n"
12845                "  void g() { return; }\n"
12846                "};\n"
12847                "enum E\n"
12848                "{\n"
12849                "  A,\n"
12850                "  // foo\n"
12851                "  B,\n"
12852                "  C\n"
12853                "};\n"
12854                "struct B\n"
12855                "{\n"
12856                "  int x;\n"
12857                "};\n"
12858                "}\n",
12859                MozillaBraceStyle);
12860   verifyFormat("struct S\n"
12861                "{\n"
12862                "  int Type;\n"
12863                "  union\n"
12864                "  {\n"
12865                "    int x;\n"
12866                "    double y;\n"
12867                "  } Value;\n"
12868                "  class C\n"
12869                "  {\n"
12870                "    MyFavoriteType Value;\n"
12871                "  } Class;\n"
12872                "}\n",
12873                MozillaBraceStyle);
12874 }
12875 
12876 TEST_F(FormatTest, StroustrupBraceBreaking) {
12877   FormatStyle StroustrupBraceStyle = getLLVMStyle();
12878   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12879   verifyFormat("namespace a {\n"
12880                "class A {\n"
12881                "  void f()\n"
12882                "  {\n"
12883                "    if (true) {\n"
12884                "      a();\n"
12885                "      b();\n"
12886                "    }\n"
12887                "  }\n"
12888                "  void g() { return; }\n"
12889                "};\n"
12890                "struct B {\n"
12891                "  int x;\n"
12892                "};\n"
12893                "} // namespace a\n",
12894                StroustrupBraceStyle);
12895 
12896   verifyFormat("void foo()\n"
12897                "{\n"
12898                "  if (a) {\n"
12899                "    a();\n"
12900                "  }\n"
12901                "  else {\n"
12902                "    b();\n"
12903                "  }\n"
12904                "}\n",
12905                StroustrupBraceStyle);
12906 
12907   verifyFormat("#ifdef _DEBUG\n"
12908                "int foo(int i = 0)\n"
12909                "#else\n"
12910                "int foo(int i = 5)\n"
12911                "#endif\n"
12912                "{\n"
12913                "  return i;\n"
12914                "}",
12915                StroustrupBraceStyle);
12916 
12917   verifyFormat("void foo() {}\n"
12918                "void bar()\n"
12919                "#ifdef _DEBUG\n"
12920                "{\n"
12921                "  foo();\n"
12922                "}\n"
12923                "#else\n"
12924                "{\n"
12925                "}\n"
12926                "#endif",
12927                StroustrupBraceStyle);
12928 
12929   verifyFormat("void foobar() { int i = 5; }\n"
12930                "#ifdef _DEBUG\n"
12931                "void bar() {}\n"
12932                "#else\n"
12933                "void bar() { foobar(); }\n"
12934                "#endif",
12935                StroustrupBraceStyle);
12936 }
12937 
12938 TEST_F(FormatTest, AllmanBraceBreaking) {
12939   FormatStyle AllmanBraceStyle = getLLVMStyle();
12940   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
12941 
12942   EXPECT_EQ("namespace a\n"
12943             "{\n"
12944             "void f();\n"
12945             "void g();\n"
12946             "} // namespace a\n",
12947             format("namespace a\n"
12948                    "{\n"
12949                    "void f();\n"
12950                    "void g();\n"
12951                    "}\n",
12952                    AllmanBraceStyle));
12953 
12954   verifyFormat("namespace a\n"
12955                "{\n"
12956                "class A\n"
12957                "{\n"
12958                "  void f()\n"
12959                "  {\n"
12960                "    if (true)\n"
12961                "    {\n"
12962                "      a();\n"
12963                "      b();\n"
12964                "    }\n"
12965                "  }\n"
12966                "  void g() { return; }\n"
12967                "};\n"
12968                "struct B\n"
12969                "{\n"
12970                "  int x;\n"
12971                "};\n"
12972                "union C\n"
12973                "{\n"
12974                "};\n"
12975                "} // namespace a",
12976                AllmanBraceStyle);
12977 
12978   verifyFormat("void f()\n"
12979                "{\n"
12980                "  if (true)\n"
12981                "  {\n"
12982                "    a();\n"
12983                "  }\n"
12984                "  else if (false)\n"
12985                "  {\n"
12986                "    b();\n"
12987                "  }\n"
12988                "  else\n"
12989                "  {\n"
12990                "    c();\n"
12991                "  }\n"
12992                "}\n",
12993                AllmanBraceStyle);
12994 
12995   verifyFormat("void f()\n"
12996                "{\n"
12997                "  for (int i = 0; i < 10; ++i)\n"
12998                "  {\n"
12999                "    a();\n"
13000                "  }\n"
13001                "  while (false)\n"
13002                "  {\n"
13003                "    b();\n"
13004                "  }\n"
13005                "  do\n"
13006                "  {\n"
13007                "    c();\n"
13008                "  } while (false)\n"
13009                "}\n",
13010                AllmanBraceStyle);
13011 
13012   verifyFormat("void f(int a)\n"
13013                "{\n"
13014                "  switch (a)\n"
13015                "  {\n"
13016                "  case 0:\n"
13017                "    break;\n"
13018                "  case 1:\n"
13019                "  {\n"
13020                "    break;\n"
13021                "  }\n"
13022                "  case 2:\n"
13023                "  {\n"
13024                "  }\n"
13025                "  break;\n"
13026                "  default:\n"
13027                "    break;\n"
13028                "  }\n"
13029                "}\n",
13030                AllmanBraceStyle);
13031 
13032   verifyFormat("enum X\n"
13033                "{\n"
13034                "  Y = 0,\n"
13035                "}\n",
13036                AllmanBraceStyle);
13037   verifyFormat("enum X\n"
13038                "{\n"
13039                "  Y = 0\n"
13040                "}\n",
13041                AllmanBraceStyle);
13042 
13043   verifyFormat("@interface BSApplicationController ()\n"
13044                "{\n"
13045                "@private\n"
13046                "  id _extraIvar;\n"
13047                "}\n"
13048                "@end\n",
13049                AllmanBraceStyle);
13050 
13051   verifyFormat("#ifdef _DEBUG\n"
13052                "int foo(int i = 0)\n"
13053                "#else\n"
13054                "int foo(int i = 5)\n"
13055                "#endif\n"
13056                "{\n"
13057                "  return i;\n"
13058                "}",
13059                AllmanBraceStyle);
13060 
13061   verifyFormat("void foo() {}\n"
13062                "void bar()\n"
13063                "#ifdef _DEBUG\n"
13064                "{\n"
13065                "  foo();\n"
13066                "}\n"
13067                "#else\n"
13068                "{\n"
13069                "}\n"
13070                "#endif",
13071                AllmanBraceStyle);
13072 
13073   verifyFormat("void foobar() { int i = 5; }\n"
13074                "#ifdef _DEBUG\n"
13075                "void bar() {}\n"
13076                "#else\n"
13077                "void bar() { foobar(); }\n"
13078                "#endif",
13079                AllmanBraceStyle);
13080 
13081   // This shouldn't affect ObjC blocks..
13082   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13083                "  // ...\n"
13084                "  int i;\n"
13085                "}];",
13086                AllmanBraceStyle);
13087   verifyFormat("void (^block)(void) = ^{\n"
13088                "  // ...\n"
13089                "  int i;\n"
13090                "};",
13091                AllmanBraceStyle);
13092   // .. or dict literals.
13093   verifyFormat("void f()\n"
13094                "{\n"
13095                "  // ...\n"
13096                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13097                "}",
13098                AllmanBraceStyle);
13099   verifyFormat("void f()\n"
13100                "{\n"
13101                "  // ...\n"
13102                "  [object someMethod:@{a : @\"b\"}];\n"
13103                "}",
13104                AllmanBraceStyle);
13105   verifyFormat("int f()\n"
13106                "{ // comment\n"
13107                "  return 42;\n"
13108                "}",
13109                AllmanBraceStyle);
13110 
13111   AllmanBraceStyle.ColumnLimit = 19;
13112   verifyFormat("void f() { int i; }", AllmanBraceStyle);
13113   AllmanBraceStyle.ColumnLimit = 18;
13114   verifyFormat("void f()\n"
13115                "{\n"
13116                "  int i;\n"
13117                "}",
13118                AllmanBraceStyle);
13119   AllmanBraceStyle.ColumnLimit = 80;
13120 
13121   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
13122   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13123       FormatStyle::SIS_WithoutElse;
13124   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13125   verifyFormat("void f(bool b)\n"
13126                "{\n"
13127                "  if (b)\n"
13128                "  {\n"
13129                "    return;\n"
13130                "  }\n"
13131                "}\n",
13132                BreakBeforeBraceShortIfs);
13133   verifyFormat("void f(bool b)\n"
13134                "{\n"
13135                "  if constexpr (b)\n"
13136                "  {\n"
13137                "    return;\n"
13138                "  }\n"
13139                "}\n",
13140                BreakBeforeBraceShortIfs);
13141   verifyFormat("void f(bool b)\n"
13142                "{\n"
13143                "  if CONSTEXPR (b)\n"
13144                "  {\n"
13145                "    return;\n"
13146                "  }\n"
13147                "}\n",
13148                BreakBeforeBraceShortIfs);
13149   verifyFormat("void f(bool b)\n"
13150                "{\n"
13151                "  if (b) return;\n"
13152                "}\n",
13153                BreakBeforeBraceShortIfs);
13154   verifyFormat("void f(bool b)\n"
13155                "{\n"
13156                "  if constexpr (b) return;\n"
13157                "}\n",
13158                BreakBeforeBraceShortIfs);
13159   verifyFormat("void f(bool b)\n"
13160                "{\n"
13161                "  if CONSTEXPR (b) return;\n"
13162                "}\n",
13163                BreakBeforeBraceShortIfs);
13164   verifyFormat("void f(bool b)\n"
13165                "{\n"
13166                "  while (b)\n"
13167                "  {\n"
13168                "    return;\n"
13169                "  }\n"
13170                "}\n",
13171                BreakBeforeBraceShortIfs);
13172 }
13173 
13174 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
13175   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
13176   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
13177 
13178   // Make a few changes to the style for testing purposes
13179   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
13180       FormatStyle::SFS_Empty;
13181   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
13182   WhitesmithsBraceStyle.ColumnLimit = 0;
13183 
13184   // FIXME: this test case can't decide whether there should be a blank line
13185   // after the ~D() line or not. It adds one if one doesn't exist in the test
13186   // and it removes the line if one exists.
13187   /*
13188   verifyFormat("class A;\n"
13189                "namespace B\n"
13190                "  {\n"
13191                "class C;\n"
13192                "// Comment\n"
13193                "class D\n"
13194                "  {\n"
13195                "public:\n"
13196                "  D();\n"
13197                "  ~D() {}\n"
13198                "private:\n"
13199                "  enum E\n"
13200                "    {\n"
13201                "    F\n"
13202                "    }\n"
13203                "  };\n"
13204                "  } // namespace B\n",
13205                WhitesmithsBraceStyle);
13206   */
13207 
13208   verifyFormat("namespace a\n"
13209                "  {\n"
13210                "class A\n"
13211                "  {\n"
13212                "  void f()\n"
13213                "    {\n"
13214                "    if (true)\n"
13215                "      {\n"
13216                "      a();\n"
13217                "      b();\n"
13218                "      }\n"
13219                "    }\n"
13220                "  void g()\n"
13221                "    {\n"
13222                "    return;\n"
13223                "    }\n"
13224                "  };\n"
13225                "struct B\n"
13226                "  {\n"
13227                "  int x;\n"
13228                "  };\n"
13229                "  } // namespace a",
13230                WhitesmithsBraceStyle);
13231 
13232   verifyFormat("void f()\n"
13233                "  {\n"
13234                "  if (true)\n"
13235                "    {\n"
13236                "    a();\n"
13237                "    }\n"
13238                "  else if (false)\n"
13239                "    {\n"
13240                "    b();\n"
13241                "    }\n"
13242                "  else\n"
13243                "    {\n"
13244                "    c();\n"
13245                "    }\n"
13246                "  }\n",
13247                WhitesmithsBraceStyle);
13248 
13249   verifyFormat("void f()\n"
13250                "  {\n"
13251                "  for (int i = 0; i < 10; ++i)\n"
13252                "    {\n"
13253                "    a();\n"
13254                "    }\n"
13255                "  while (false)\n"
13256                "    {\n"
13257                "    b();\n"
13258                "    }\n"
13259                "  do\n"
13260                "    {\n"
13261                "    c();\n"
13262                "    } while (false)\n"
13263                "  }\n",
13264                WhitesmithsBraceStyle);
13265 
13266   WhitesmithsBraceStyle.IndentCaseBlocks = true;
13267   verifyFormat("void switchTest1(int a)\n"
13268                "  {\n"
13269                "  switch (a)\n"
13270                "    {\n"
13271                "    case 2:\n"
13272                "      {\n"
13273                "      }\n"
13274                "    break;\n"
13275                "    }\n"
13276                "  }\n",
13277                WhitesmithsBraceStyle);
13278 
13279   verifyFormat("void switchTest2(int a)\n"
13280                "  {\n"
13281                "  switch (a)\n"
13282                "    {\n"
13283                "    case 0:\n"
13284                "    break;\n"
13285                "    case 1:\n"
13286                "      {\n"
13287                "      break;\n"
13288                "      }\n"
13289                "    case 2:\n"
13290                "      {\n"
13291                "      }\n"
13292                "    break;\n"
13293                "    default:\n"
13294                "    break;\n"
13295                "    }\n"
13296                "  }\n",
13297                WhitesmithsBraceStyle);
13298 
13299   verifyFormat("void switchTest3(int a)\n"
13300                "  {\n"
13301                "  switch (a)\n"
13302                "    {\n"
13303                "    case 0:\n"
13304                "      {\n"
13305                "      foo(x);\n"
13306                "      }\n"
13307                "    break;\n"
13308                "    default:\n"
13309                "      {\n"
13310                "      foo(1);\n"
13311                "      }\n"
13312                "    break;\n"
13313                "    }\n"
13314                "  }\n",
13315                WhitesmithsBraceStyle);
13316 
13317   WhitesmithsBraceStyle.IndentCaseBlocks = false;
13318 
13319   verifyFormat("void switchTest4(int a)\n"
13320                "  {\n"
13321                "  switch (a)\n"
13322                "    {\n"
13323                "    case 2:\n"
13324                "    {\n"
13325                "    }\n"
13326                "    break;\n"
13327                "    }\n"
13328                "  }\n",
13329                WhitesmithsBraceStyle);
13330 
13331   verifyFormat("void switchTest5(int a)\n"
13332                "  {\n"
13333                "  switch (a)\n"
13334                "    {\n"
13335                "    case 0:\n"
13336                "    break;\n"
13337                "    case 1:\n"
13338                "    {\n"
13339                "    foo();\n"
13340                "    break;\n"
13341                "    }\n"
13342                "    case 2:\n"
13343                "    {\n"
13344                "    }\n"
13345                "    break;\n"
13346                "    default:\n"
13347                "    break;\n"
13348                "    }\n"
13349                "  }\n",
13350                WhitesmithsBraceStyle);
13351 
13352   verifyFormat("void switchTest6(int a)\n"
13353                "  {\n"
13354                "  switch (a)\n"
13355                "    {\n"
13356                "    case 0:\n"
13357                "    {\n"
13358                "    foo(x);\n"
13359                "    }\n"
13360                "    break;\n"
13361                "    default:\n"
13362                "    {\n"
13363                "    foo(1);\n"
13364                "    }\n"
13365                "    break;\n"
13366                "    }\n"
13367                "  }\n",
13368                WhitesmithsBraceStyle);
13369 
13370   verifyFormat("enum X\n"
13371                "  {\n"
13372                "  Y = 0, // testing\n"
13373                "  }\n",
13374                WhitesmithsBraceStyle);
13375 
13376   verifyFormat("enum X\n"
13377                "  {\n"
13378                "  Y = 0\n"
13379                "  }\n",
13380                WhitesmithsBraceStyle);
13381   verifyFormat("enum X\n"
13382                "  {\n"
13383                "  Y = 0,\n"
13384                "  Z = 1\n"
13385                "  };\n",
13386                WhitesmithsBraceStyle);
13387 
13388   verifyFormat("@interface BSApplicationController ()\n"
13389                "  {\n"
13390                "@private\n"
13391                "  id _extraIvar;\n"
13392                "  }\n"
13393                "@end\n",
13394                WhitesmithsBraceStyle);
13395 
13396   verifyFormat("#ifdef _DEBUG\n"
13397                "int foo(int i = 0)\n"
13398                "#else\n"
13399                "int foo(int i = 5)\n"
13400                "#endif\n"
13401                "  {\n"
13402                "  return i;\n"
13403                "  }",
13404                WhitesmithsBraceStyle);
13405 
13406   verifyFormat("void foo() {}\n"
13407                "void bar()\n"
13408                "#ifdef _DEBUG\n"
13409                "  {\n"
13410                "  foo();\n"
13411                "  }\n"
13412                "#else\n"
13413                "  {\n"
13414                "  }\n"
13415                "#endif",
13416                WhitesmithsBraceStyle);
13417 
13418   verifyFormat("void foobar()\n"
13419                "  {\n"
13420                "  int i = 5;\n"
13421                "  }\n"
13422                "#ifdef _DEBUG\n"
13423                "void bar()\n"
13424                "  {\n"
13425                "  }\n"
13426                "#else\n"
13427                "void bar()\n"
13428                "  {\n"
13429                "  foobar();\n"
13430                "  }\n"
13431                "#endif",
13432                WhitesmithsBraceStyle);
13433 
13434   // This shouldn't affect ObjC blocks..
13435   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13436                "  // ...\n"
13437                "  int i;\n"
13438                "}];",
13439                WhitesmithsBraceStyle);
13440   verifyFormat("void (^block)(void) = ^{\n"
13441                "  // ...\n"
13442                "  int i;\n"
13443                "};",
13444                WhitesmithsBraceStyle);
13445   // .. or dict literals.
13446   verifyFormat("void f()\n"
13447                "  {\n"
13448                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13449                "  }",
13450                WhitesmithsBraceStyle);
13451 
13452   verifyFormat("int f()\n"
13453                "  { // comment\n"
13454                "  return 42;\n"
13455                "  }",
13456                WhitesmithsBraceStyle);
13457 
13458   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13459   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13460       FormatStyle::SIS_Always;
13461   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13462   verifyFormat("void f(bool b)\n"
13463                "  {\n"
13464                "  if (b)\n"
13465                "    {\n"
13466                "    return;\n"
13467                "    }\n"
13468                "  }\n",
13469                BreakBeforeBraceShortIfs);
13470   verifyFormat("void f(bool b)\n"
13471                "  {\n"
13472                "  if (b) return;\n"
13473                "  }\n",
13474                BreakBeforeBraceShortIfs);
13475   verifyFormat("void f(bool b)\n"
13476                "  {\n"
13477                "  while (b)\n"
13478                "    {\n"
13479                "    return;\n"
13480                "    }\n"
13481                "  }\n",
13482                BreakBeforeBraceShortIfs);
13483 }
13484 
13485 TEST_F(FormatTest, GNUBraceBreaking) {
13486   FormatStyle GNUBraceStyle = getLLVMStyle();
13487   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13488   verifyFormat("namespace a\n"
13489                "{\n"
13490                "class A\n"
13491                "{\n"
13492                "  void f()\n"
13493                "  {\n"
13494                "    int a;\n"
13495                "    {\n"
13496                "      int b;\n"
13497                "    }\n"
13498                "    if (true)\n"
13499                "      {\n"
13500                "        a();\n"
13501                "        b();\n"
13502                "      }\n"
13503                "  }\n"
13504                "  void g() { return; }\n"
13505                "}\n"
13506                "} // namespace a",
13507                GNUBraceStyle);
13508 
13509   verifyFormat("void f()\n"
13510                "{\n"
13511                "  if (true)\n"
13512                "    {\n"
13513                "      a();\n"
13514                "    }\n"
13515                "  else if (false)\n"
13516                "    {\n"
13517                "      b();\n"
13518                "    }\n"
13519                "  else\n"
13520                "    {\n"
13521                "      c();\n"
13522                "    }\n"
13523                "}\n",
13524                GNUBraceStyle);
13525 
13526   verifyFormat("void f()\n"
13527                "{\n"
13528                "  for (int i = 0; i < 10; ++i)\n"
13529                "    {\n"
13530                "      a();\n"
13531                "    }\n"
13532                "  while (false)\n"
13533                "    {\n"
13534                "      b();\n"
13535                "    }\n"
13536                "  do\n"
13537                "    {\n"
13538                "      c();\n"
13539                "    }\n"
13540                "  while (false);\n"
13541                "}\n",
13542                GNUBraceStyle);
13543 
13544   verifyFormat("void f(int a)\n"
13545                "{\n"
13546                "  switch (a)\n"
13547                "    {\n"
13548                "    case 0:\n"
13549                "      break;\n"
13550                "    case 1:\n"
13551                "      {\n"
13552                "        break;\n"
13553                "      }\n"
13554                "    case 2:\n"
13555                "      {\n"
13556                "      }\n"
13557                "      break;\n"
13558                "    default:\n"
13559                "      break;\n"
13560                "    }\n"
13561                "}\n",
13562                GNUBraceStyle);
13563 
13564   verifyFormat("enum X\n"
13565                "{\n"
13566                "  Y = 0,\n"
13567                "}\n",
13568                GNUBraceStyle);
13569 
13570   verifyFormat("@interface BSApplicationController ()\n"
13571                "{\n"
13572                "@private\n"
13573                "  id _extraIvar;\n"
13574                "}\n"
13575                "@end\n",
13576                GNUBraceStyle);
13577 
13578   verifyFormat("#ifdef _DEBUG\n"
13579                "int foo(int i = 0)\n"
13580                "#else\n"
13581                "int foo(int i = 5)\n"
13582                "#endif\n"
13583                "{\n"
13584                "  return i;\n"
13585                "}",
13586                GNUBraceStyle);
13587 
13588   verifyFormat("void foo() {}\n"
13589                "void bar()\n"
13590                "#ifdef _DEBUG\n"
13591                "{\n"
13592                "  foo();\n"
13593                "}\n"
13594                "#else\n"
13595                "{\n"
13596                "}\n"
13597                "#endif",
13598                GNUBraceStyle);
13599 
13600   verifyFormat("void foobar() { int i = 5; }\n"
13601                "#ifdef _DEBUG\n"
13602                "void bar() {}\n"
13603                "#else\n"
13604                "void bar() { foobar(); }\n"
13605                "#endif",
13606                GNUBraceStyle);
13607 }
13608 
13609 TEST_F(FormatTest, WebKitBraceBreaking) {
13610   FormatStyle WebKitBraceStyle = getLLVMStyle();
13611   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13612   WebKitBraceStyle.FixNamespaceComments = false;
13613   verifyFormat("namespace a {\n"
13614                "class A {\n"
13615                "  void f()\n"
13616                "  {\n"
13617                "    if (true) {\n"
13618                "      a();\n"
13619                "      b();\n"
13620                "    }\n"
13621                "  }\n"
13622                "  void g() { return; }\n"
13623                "};\n"
13624                "enum E {\n"
13625                "  A,\n"
13626                "  // foo\n"
13627                "  B,\n"
13628                "  C\n"
13629                "};\n"
13630                "struct B {\n"
13631                "  int x;\n"
13632                "};\n"
13633                "}\n",
13634                WebKitBraceStyle);
13635   verifyFormat("struct S {\n"
13636                "  int Type;\n"
13637                "  union {\n"
13638                "    int x;\n"
13639                "    double y;\n"
13640                "  } Value;\n"
13641                "  class C {\n"
13642                "    MyFavoriteType Value;\n"
13643                "  } Class;\n"
13644                "};\n",
13645                WebKitBraceStyle);
13646 }
13647 
13648 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13649   verifyFormat("void f() {\n"
13650                "  try {\n"
13651                "  } catch (const Exception &e) {\n"
13652                "  }\n"
13653                "}\n",
13654                getLLVMStyle());
13655 }
13656 
13657 TEST_F(FormatTest, UnderstandsPragmas) {
13658   verifyFormat("#pragma omp reduction(| : var)");
13659   verifyFormat("#pragma omp reduction(+ : var)");
13660 
13661   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13662             "(including parentheses).",
13663             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13664                    "(including parentheses)."));
13665 }
13666 
13667 TEST_F(FormatTest, UnderstandPragmaOption) {
13668   verifyFormat("#pragma option -C -A");
13669 
13670   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13671 }
13672 
13673 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13674   FormatStyle Style = getLLVMStyle();
13675   Style.ColumnLimit = 20;
13676 
13677   // See PR41213
13678   EXPECT_EQ("/*\n"
13679             " *\t9012345\n"
13680             " * /8901\n"
13681             " */",
13682             format("/*\n"
13683                    " *\t9012345 /8901\n"
13684                    " */",
13685                    Style));
13686   EXPECT_EQ("/*\n"
13687             " *345678\n"
13688             " *\t/8901\n"
13689             " */",
13690             format("/*\n"
13691                    " *345678\t/8901\n"
13692                    " */",
13693                    Style));
13694 
13695   verifyFormat("int a; // the\n"
13696                "       // comment",
13697                Style);
13698   EXPECT_EQ("int a; /* first line\n"
13699             "        * second\n"
13700             "        * line third\n"
13701             "        * line\n"
13702             "        */",
13703             format("int a; /* first line\n"
13704                    "        * second\n"
13705                    "        * line third\n"
13706                    "        * line\n"
13707                    "        */",
13708                    Style));
13709   EXPECT_EQ("int a; // first line\n"
13710             "       // second\n"
13711             "       // line third\n"
13712             "       // line",
13713             format("int a; // first line\n"
13714                    "       // second line\n"
13715                    "       // third line",
13716                    Style));
13717 
13718   Style.PenaltyExcessCharacter = 90;
13719   verifyFormat("int a; // the comment", Style);
13720   EXPECT_EQ("int a; // the comment\n"
13721             "       // aaa",
13722             format("int a; // the comment aaa", Style));
13723   EXPECT_EQ("int a; /* first line\n"
13724             "        * second line\n"
13725             "        * third line\n"
13726             "        */",
13727             format("int a; /* first line\n"
13728                    "        * second line\n"
13729                    "        * third line\n"
13730                    "        */",
13731                    Style));
13732   EXPECT_EQ("int a; // first line\n"
13733             "       // second line\n"
13734             "       // third line",
13735             format("int a; // first line\n"
13736                    "       // second line\n"
13737                    "       // third line",
13738                    Style));
13739   // FIXME: Investigate why this is not getting the same layout as the test
13740   // above.
13741   EXPECT_EQ("int a; /* first line\n"
13742             "        * second line\n"
13743             "        * third line\n"
13744             "        */",
13745             format("int a; /* first line second line third line"
13746                    "\n*/",
13747                    Style));
13748 
13749   EXPECT_EQ("// foo bar baz bazfoo\n"
13750             "// foo bar foo bar\n",
13751             format("// foo bar baz bazfoo\n"
13752                    "// foo bar foo           bar\n",
13753                    Style));
13754   EXPECT_EQ("// foo bar baz bazfoo\n"
13755             "// foo bar foo bar\n",
13756             format("// foo bar baz      bazfoo\n"
13757                    "// foo            bar foo bar\n",
13758                    Style));
13759 
13760   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13761   // next one.
13762   EXPECT_EQ("// foo bar baz bazfoo\n"
13763             "// bar foo bar\n",
13764             format("// foo bar baz      bazfoo bar\n"
13765                    "// foo            bar\n",
13766                    Style));
13767 
13768   EXPECT_EQ("// foo bar baz bazfoo\n"
13769             "// foo bar baz bazfoo\n"
13770             "// bar foo bar\n",
13771             format("// foo bar baz      bazfoo\n"
13772                    "// foo bar baz      bazfoo bar\n"
13773                    "// foo bar\n",
13774                    Style));
13775 
13776   EXPECT_EQ("// foo bar baz bazfoo\n"
13777             "// foo bar baz bazfoo\n"
13778             "// bar foo bar\n",
13779             format("// foo bar baz      bazfoo\n"
13780                    "// foo bar baz      bazfoo bar\n"
13781                    "// foo           bar\n",
13782                    Style));
13783 
13784   // Make sure we do not keep protruding characters if strict mode reflow is
13785   // cheaper than keeping protruding characters.
13786   Style.ColumnLimit = 21;
13787   EXPECT_EQ(
13788       "// foo foo foo foo\n"
13789       "// foo foo foo foo\n"
13790       "// foo foo foo foo\n",
13791       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13792 
13793   EXPECT_EQ("int a = /* long block\n"
13794             "           comment */\n"
13795             "    42;",
13796             format("int a = /* long block comment */ 42;", Style));
13797 }
13798 
13799 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13800   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13801   EXPECT_EQ(Styles[0], Styles[i])                                              \
13802       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13803 
13804 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13805   SmallVector<FormatStyle, 3> Styles;
13806   Styles.resize(3);
13807 
13808   Styles[0] = getLLVMStyle();
13809   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13810   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13811   EXPECT_ALL_STYLES_EQUAL(Styles);
13812 
13813   Styles[0] = getGoogleStyle();
13814   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13815   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13816   EXPECT_ALL_STYLES_EQUAL(Styles);
13817 
13818   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13819   EXPECT_TRUE(
13820       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13821   EXPECT_TRUE(
13822       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13823   EXPECT_ALL_STYLES_EQUAL(Styles);
13824 
13825   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13826   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13827   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
13828   EXPECT_ALL_STYLES_EQUAL(Styles);
13829 
13830   Styles[0] = getMozillaStyle();
13831   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
13832   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
13833   EXPECT_ALL_STYLES_EQUAL(Styles);
13834 
13835   Styles[0] = getWebKitStyle();
13836   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
13837   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
13838   EXPECT_ALL_STYLES_EQUAL(Styles);
13839 
13840   Styles[0] = getGNUStyle();
13841   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
13842   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
13843   EXPECT_ALL_STYLES_EQUAL(Styles);
13844 
13845   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
13846 }
13847 
13848 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
13849   SmallVector<FormatStyle, 8> Styles;
13850   Styles.resize(2);
13851 
13852   Styles[0] = getGoogleStyle();
13853   Styles[1] = getLLVMStyle();
13854   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13855   EXPECT_ALL_STYLES_EQUAL(Styles);
13856 
13857   Styles.resize(5);
13858   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13859   Styles[1] = getLLVMStyle();
13860   Styles[1].Language = FormatStyle::LK_JavaScript;
13861   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13862 
13863   Styles[2] = getLLVMStyle();
13864   Styles[2].Language = FormatStyle::LK_JavaScript;
13865   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
13866                                   "BasedOnStyle: Google",
13867                                   &Styles[2])
13868                    .value());
13869 
13870   Styles[3] = getLLVMStyle();
13871   Styles[3].Language = FormatStyle::LK_JavaScript;
13872   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
13873                                   "Language: JavaScript",
13874                                   &Styles[3])
13875                    .value());
13876 
13877   Styles[4] = getLLVMStyle();
13878   Styles[4].Language = FormatStyle::LK_JavaScript;
13879   EXPECT_EQ(0, parseConfiguration("---\n"
13880                                   "BasedOnStyle: LLVM\n"
13881                                   "IndentWidth: 123\n"
13882                                   "---\n"
13883                                   "BasedOnStyle: Google\n"
13884                                   "Language: JavaScript",
13885                                   &Styles[4])
13886                    .value());
13887   EXPECT_ALL_STYLES_EQUAL(Styles);
13888 }
13889 
13890 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
13891   Style.FIELD = false;                                                         \
13892   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
13893   EXPECT_TRUE(Style.FIELD);                                                    \
13894   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
13895   EXPECT_FALSE(Style.FIELD);
13896 
13897 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
13898 
13899 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
13900   Style.STRUCT.FIELD = false;                                                  \
13901   EXPECT_EQ(0,                                                                 \
13902             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
13903                 .value());                                                     \
13904   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
13905   EXPECT_EQ(0,                                                                 \
13906             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
13907                 .value());                                                     \
13908   EXPECT_FALSE(Style.STRUCT.FIELD);
13909 
13910 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
13911   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
13912 
13913 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
13914   EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!";          \
13915   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
13916   EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
13917 
13918 TEST_F(FormatTest, ParsesConfigurationBools) {
13919   FormatStyle Style = {};
13920   Style.Language = FormatStyle::LK_Cpp;
13921   CHECK_PARSE_BOOL(AlignTrailingComments);
13922   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
13923   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
13924   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
13925   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
13926   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
13927   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
13928   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
13929   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
13930   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
13931   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
13932   CHECK_PARSE_BOOL(BinPackArguments);
13933   CHECK_PARSE_BOOL(BinPackParameters);
13934   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
13935   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
13936   CHECK_PARSE_BOOL(BreakStringLiterals);
13937   CHECK_PARSE_BOOL(CompactNamespaces);
13938   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
13939   CHECK_PARSE_BOOL(DeriveLineEnding);
13940   CHECK_PARSE_BOOL(DerivePointerAlignment);
13941   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
13942   CHECK_PARSE_BOOL(DisableFormat);
13943   CHECK_PARSE_BOOL(IndentCaseLabels);
13944   CHECK_PARSE_BOOL(IndentCaseBlocks);
13945   CHECK_PARSE_BOOL(IndentGotoLabels);
13946   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
13947   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
13948   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
13949   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
13950   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
13951   CHECK_PARSE_BOOL(ReflowComments);
13952   CHECK_PARSE_BOOL(SortIncludes);
13953   CHECK_PARSE_BOOL(SortUsingDeclarations);
13954   CHECK_PARSE_BOOL(SpacesInParentheses);
13955   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
13956   CHECK_PARSE_BOOL(SpacesInAngles);
13957   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
13958   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
13959   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
13960   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
13961   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
13962   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
13963   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
13964   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
13965   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
13966   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
13967   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
13968   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
13969   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
13970   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
13971   CHECK_PARSE_BOOL(UseCRLF);
13972 
13973   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
13974   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
13975   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
13976   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
13977   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
13978   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
13979   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
13980   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
13981   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
13982   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
13983   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
13984   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
13985   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
13986   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
13987   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
13988   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
13989   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
13990 }
13991 
13992 #undef CHECK_PARSE_BOOL
13993 
13994 TEST_F(FormatTest, ParsesConfiguration) {
13995   FormatStyle Style = {};
13996   Style.Language = FormatStyle::LK_Cpp;
13997   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
13998   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
13999               ConstructorInitializerIndentWidth, 1234u);
14000   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
14001   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
14002   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
14003   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
14004   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
14005               PenaltyBreakBeforeFirstCallParameter, 1234u);
14006   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
14007               PenaltyBreakTemplateDeclaration, 1234u);
14008   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
14009   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
14010               PenaltyReturnTypeOnItsOwnLine, 1234u);
14011   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
14012               SpacesBeforeTrailingComments, 1234u);
14013   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
14014   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
14015   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
14016 
14017   Style.PointerAlignment = FormatStyle::PAS_Middle;
14018   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
14019               FormatStyle::PAS_Left);
14020   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
14021               FormatStyle::PAS_Right);
14022   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
14023               FormatStyle::PAS_Middle);
14024   // For backward compatibility:
14025   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
14026               FormatStyle::PAS_Left);
14027   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
14028               FormatStyle::PAS_Right);
14029   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
14030               FormatStyle::PAS_Middle);
14031 
14032   Style.Standard = FormatStyle::LS_Auto;
14033   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
14034   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
14035   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
14036   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
14037   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
14038   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
14039   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
14040   // Legacy aliases:
14041   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
14042   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
14043   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
14044   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
14045 
14046   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
14047   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
14048               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
14049   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
14050               FormatStyle::BOS_None);
14051   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
14052               FormatStyle::BOS_All);
14053   // For backward compatibility:
14054   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
14055               FormatStyle::BOS_None);
14056   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
14057               FormatStyle::BOS_All);
14058 
14059   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
14060   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
14061               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14062   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
14063               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
14064   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
14065               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
14066   // For backward compatibility:
14067   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
14068               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14069 
14070   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
14071   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
14072               FormatStyle::BILS_BeforeComma);
14073   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
14074               FormatStyle::BILS_AfterColon);
14075   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
14076               FormatStyle::BILS_BeforeColon);
14077   // For backward compatibility:
14078   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
14079               FormatStyle::BILS_BeforeComma);
14080 
14081   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14082   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
14083               FormatStyle::BAS_Align);
14084   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
14085               FormatStyle::BAS_DontAlign);
14086   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
14087               FormatStyle::BAS_AlwaysBreak);
14088   // For backward compatibility:
14089   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
14090               FormatStyle::BAS_DontAlign);
14091   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
14092               FormatStyle::BAS_Align);
14093 
14094   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
14095   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
14096               FormatStyle::ENAS_DontAlign);
14097   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
14098               FormatStyle::ENAS_Left);
14099   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
14100               FormatStyle::ENAS_Right);
14101   // For backward compatibility:
14102   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
14103               FormatStyle::ENAS_Left);
14104   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
14105               FormatStyle::ENAS_Right);
14106 
14107   Style.AlignOperands = FormatStyle::OAS_Align;
14108   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
14109               FormatStyle::OAS_DontAlign);
14110   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
14111   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
14112               FormatStyle::OAS_AlignAfterOperator);
14113   // For backward compatibility:
14114   CHECK_PARSE("AlignOperands: false", AlignOperands,
14115               FormatStyle::OAS_DontAlign);
14116   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
14117 
14118   Style.UseTab = FormatStyle::UT_ForIndentation;
14119   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
14120   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
14121   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
14122   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
14123               FormatStyle::UT_ForContinuationAndIndentation);
14124   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
14125               FormatStyle::UT_AlignWithSpaces);
14126   // For backward compatibility:
14127   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
14128   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
14129 
14130   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
14131   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
14132               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14133   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
14134               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
14135   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
14136               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14137   // For backward compatibility:
14138   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
14139               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14140   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
14141               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14142 
14143   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
14144   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
14145               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14146   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
14147               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
14148   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
14149               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
14150   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
14151               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14152   // For backward compatibility:
14153   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
14154               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14155   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
14156               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14157 
14158   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
14159   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
14160               FormatStyle::SBPO_Never);
14161   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
14162               FormatStyle::SBPO_Always);
14163   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
14164               FormatStyle::SBPO_ControlStatements);
14165   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
14166               FormatStyle::SBPO_NonEmptyParentheses);
14167   // For backward compatibility:
14168   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
14169               FormatStyle::SBPO_Never);
14170   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
14171               FormatStyle::SBPO_ControlStatements);
14172 
14173   Style.ColumnLimit = 123;
14174   FormatStyle BaseStyle = getLLVMStyle();
14175   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
14176   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
14177 
14178   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
14179   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
14180               FormatStyle::BS_Attach);
14181   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
14182               FormatStyle::BS_Linux);
14183   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
14184               FormatStyle::BS_Mozilla);
14185   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
14186               FormatStyle::BS_Stroustrup);
14187   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
14188               FormatStyle::BS_Allman);
14189   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
14190               FormatStyle::BS_Whitesmiths);
14191   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
14192   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
14193               FormatStyle::BS_WebKit);
14194   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
14195               FormatStyle::BS_Custom);
14196 
14197   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
14198   CHECK_PARSE("BraceWrapping:\n"
14199               "  AfterControlStatement: MultiLine",
14200               BraceWrapping.AfterControlStatement,
14201               FormatStyle::BWACS_MultiLine);
14202   CHECK_PARSE("BraceWrapping:\n"
14203               "  AfterControlStatement: Always",
14204               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14205   CHECK_PARSE("BraceWrapping:\n"
14206               "  AfterControlStatement: Never",
14207               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14208   // For backward compatibility:
14209   CHECK_PARSE("BraceWrapping:\n"
14210               "  AfterControlStatement: true",
14211               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14212   CHECK_PARSE("BraceWrapping:\n"
14213               "  AfterControlStatement: false",
14214               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14215 
14216   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
14217   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
14218               FormatStyle::RTBS_None);
14219   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
14220               FormatStyle::RTBS_All);
14221   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
14222               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
14223   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
14224               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
14225   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
14226               AlwaysBreakAfterReturnType,
14227               FormatStyle::RTBS_TopLevelDefinitions);
14228 
14229   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
14230   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
14231               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
14232   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
14233               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14234   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
14235               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14236   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
14237               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14238   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
14239               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14240 
14241   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
14242   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
14243               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
14244   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
14245               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
14246   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
14247               AlwaysBreakAfterDefinitionReturnType,
14248               FormatStyle::DRTBS_TopLevel);
14249 
14250   Style.NamespaceIndentation = FormatStyle::NI_All;
14251   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
14252               FormatStyle::NI_None);
14253   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
14254               FormatStyle::NI_Inner);
14255   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
14256               FormatStyle::NI_All);
14257 
14258   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
14259   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
14260               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14261   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
14262               AllowShortIfStatementsOnASingleLine,
14263               FormatStyle::SIS_WithoutElse);
14264   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
14265               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
14266   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
14267               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14268   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
14269               AllowShortIfStatementsOnASingleLine,
14270               FormatStyle::SIS_WithoutElse);
14271 
14272   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
14273   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
14274               FormatStyle::IEBS_AfterExternBlock);
14275   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
14276               FormatStyle::IEBS_Indent);
14277   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
14278               FormatStyle::IEBS_NoIndent);
14279   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
14280               FormatStyle::IEBS_Indent);
14281   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
14282               FormatStyle::IEBS_NoIndent);
14283 
14284   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
14285   CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
14286               FormatStyle::BFCS_Both);
14287   CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
14288               FormatStyle::BFCS_None);
14289   CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
14290               FormatStyle::BFCS_Before);
14291   CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
14292               FormatStyle::BFCS_After);
14293 
14294   // FIXME: This is required because parsing a configuration simply overwrites
14295   // the first N elements of the list instead of resetting it.
14296   Style.ForEachMacros.clear();
14297   std::vector<std::string> BoostForeach;
14298   BoostForeach.push_back("BOOST_FOREACH");
14299   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
14300   std::vector<std::string> BoostAndQForeach;
14301   BoostAndQForeach.push_back("BOOST_FOREACH");
14302   BoostAndQForeach.push_back("Q_FOREACH");
14303   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
14304               BoostAndQForeach);
14305 
14306   Style.AttributeMacros.clear();
14307   CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
14308               std::vector<std::string>{"__capability"});
14309   CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
14310               std::vector<std::string>({"attr1", "attr2"}));
14311 
14312   Style.StatementMacros.clear();
14313   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
14314               std::vector<std::string>{"QUNUSED"});
14315   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
14316               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
14317 
14318   Style.NamespaceMacros.clear();
14319   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
14320               std::vector<std::string>{"TESTSUITE"});
14321   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
14322               std::vector<std::string>({"TESTSUITE", "SUITE"}));
14323 
14324   Style.WhitespaceSensitiveMacros.clear();
14325   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
14326               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14327   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
14328               WhitespaceSensitiveMacros,
14329               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14330   Style.WhitespaceSensitiveMacros.clear();
14331   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
14332               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14333   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
14334               WhitespaceSensitiveMacros,
14335               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14336 
14337   Style.IncludeStyle.IncludeCategories.clear();
14338   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
14339       {"abc/.*", 2, 0}, {".*", 1, 0}};
14340   CHECK_PARSE("IncludeCategories:\n"
14341               "  - Regex: abc/.*\n"
14342               "    Priority: 2\n"
14343               "  - Regex: .*\n"
14344               "    Priority: 1",
14345               IncludeStyle.IncludeCategories, ExpectedCategories);
14346   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
14347               "abc$");
14348   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
14349               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
14350 
14351   Style.RawStringFormats.clear();
14352   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
14353       {
14354           FormatStyle::LK_TextProto,
14355           {"pb", "proto"},
14356           {"PARSE_TEXT_PROTO"},
14357           /*CanonicalDelimiter=*/"",
14358           "llvm",
14359       },
14360       {
14361           FormatStyle::LK_Cpp,
14362           {"cc", "cpp"},
14363           {"C_CODEBLOCK", "CPPEVAL"},
14364           /*CanonicalDelimiter=*/"cc",
14365           /*BasedOnStyle=*/"",
14366       },
14367   };
14368 
14369   CHECK_PARSE("RawStringFormats:\n"
14370               "  - Language: TextProto\n"
14371               "    Delimiters:\n"
14372               "      - 'pb'\n"
14373               "      - 'proto'\n"
14374               "    EnclosingFunctions:\n"
14375               "      - 'PARSE_TEXT_PROTO'\n"
14376               "    BasedOnStyle: llvm\n"
14377               "  - Language: Cpp\n"
14378               "    Delimiters:\n"
14379               "      - 'cc'\n"
14380               "      - 'cpp'\n"
14381               "    EnclosingFunctions:\n"
14382               "      - 'C_CODEBLOCK'\n"
14383               "      - 'CPPEVAL'\n"
14384               "    CanonicalDelimiter: 'cc'",
14385               RawStringFormats, ExpectedRawStringFormats);
14386 }
14387 
14388 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
14389   FormatStyle Style = {};
14390   Style.Language = FormatStyle::LK_Cpp;
14391   CHECK_PARSE("Language: Cpp\n"
14392               "IndentWidth: 12",
14393               IndentWidth, 12u);
14394   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
14395                                "IndentWidth: 34",
14396                                &Style),
14397             ParseError::Unsuitable);
14398   FormatStyle BinPackedTCS = {};
14399   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
14400   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
14401                                "InsertTrailingCommas: Wrapped",
14402                                &BinPackedTCS),
14403             ParseError::BinPackTrailingCommaConflict);
14404   EXPECT_EQ(12u, Style.IndentWidth);
14405   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14406   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14407 
14408   Style.Language = FormatStyle::LK_JavaScript;
14409   CHECK_PARSE("Language: JavaScript\n"
14410               "IndentWidth: 12",
14411               IndentWidth, 12u);
14412   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14413   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14414                                "IndentWidth: 34",
14415                                &Style),
14416             ParseError::Unsuitable);
14417   EXPECT_EQ(23u, Style.IndentWidth);
14418   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14419   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14420 
14421   CHECK_PARSE("BasedOnStyle: LLVM\n"
14422               "IndentWidth: 67",
14423               IndentWidth, 67u);
14424 
14425   CHECK_PARSE("---\n"
14426               "Language: JavaScript\n"
14427               "IndentWidth: 12\n"
14428               "---\n"
14429               "Language: Cpp\n"
14430               "IndentWidth: 34\n"
14431               "...\n",
14432               IndentWidth, 12u);
14433 
14434   Style.Language = FormatStyle::LK_Cpp;
14435   CHECK_PARSE("---\n"
14436               "Language: JavaScript\n"
14437               "IndentWidth: 12\n"
14438               "---\n"
14439               "Language: Cpp\n"
14440               "IndentWidth: 34\n"
14441               "...\n",
14442               IndentWidth, 34u);
14443   CHECK_PARSE("---\n"
14444               "IndentWidth: 78\n"
14445               "---\n"
14446               "Language: JavaScript\n"
14447               "IndentWidth: 56\n"
14448               "...\n",
14449               IndentWidth, 78u);
14450 
14451   Style.ColumnLimit = 123;
14452   Style.IndentWidth = 234;
14453   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14454   Style.TabWidth = 345;
14455   EXPECT_FALSE(parseConfiguration("---\n"
14456                                   "IndentWidth: 456\n"
14457                                   "BreakBeforeBraces: Allman\n"
14458                                   "---\n"
14459                                   "Language: JavaScript\n"
14460                                   "IndentWidth: 111\n"
14461                                   "TabWidth: 111\n"
14462                                   "---\n"
14463                                   "Language: Cpp\n"
14464                                   "BreakBeforeBraces: Stroustrup\n"
14465                                   "TabWidth: 789\n"
14466                                   "...\n",
14467                                   &Style));
14468   EXPECT_EQ(123u, Style.ColumnLimit);
14469   EXPECT_EQ(456u, Style.IndentWidth);
14470   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14471   EXPECT_EQ(789u, Style.TabWidth);
14472 
14473   EXPECT_EQ(parseConfiguration("---\n"
14474                                "Language: JavaScript\n"
14475                                "IndentWidth: 56\n"
14476                                "---\n"
14477                                "IndentWidth: 78\n"
14478                                "...\n",
14479                                &Style),
14480             ParseError::Error);
14481   EXPECT_EQ(parseConfiguration("---\n"
14482                                "Language: JavaScript\n"
14483                                "IndentWidth: 56\n"
14484                                "---\n"
14485                                "Language: JavaScript\n"
14486                                "IndentWidth: 78\n"
14487                                "...\n",
14488                                &Style),
14489             ParseError::Error);
14490 
14491   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14492 }
14493 
14494 #undef CHECK_PARSE
14495 
14496 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14497   FormatStyle Style = {};
14498   Style.Language = FormatStyle::LK_JavaScript;
14499   Style.BreakBeforeTernaryOperators = true;
14500   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14501   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14502 
14503   Style.BreakBeforeTernaryOperators = true;
14504   EXPECT_EQ(0, parseConfiguration("---\n"
14505                                   "BasedOnStyle: Google\n"
14506                                   "---\n"
14507                                   "Language: JavaScript\n"
14508                                   "IndentWidth: 76\n"
14509                                   "...\n",
14510                                   &Style)
14511                    .value());
14512   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14513   EXPECT_EQ(76u, Style.IndentWidth);
14514   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14515 }
14516 
14517 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14518   FormatStyle Style = getLLVMStyle();
14519   std::string YAML = configurationAsText(Style);
14520   FormatStyle ParsedStyle = {};
14521   ParsedStyle.Language = FormatStyle::LK_Cpp;
14522   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14523   EXPECT_EQ(Style, ParsedStyle);
14524 }
14525 
14526 TEST_F(FormatTest, WorksFor8bitEncodings) {
14527   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14528             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14529             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14530             "\"\xef\xee\xf0\xf3...\"",
14531             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14532                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14533                    "\xef\xee\xf0\xf3...\"",
14534                    getLLVMStyleWithColumns(12)));
14535 }
14536 
14537 TEST_F(FormatTest, HandlesUTF8BOM) {
14538   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14539   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14540             format("\xef\xbb\xbf#include <iostream>"));
14541   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14542             format("\xef\xbb\xbf\n#include <iostream>"));
14543 }
14544 
14545 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14546 #if !defined(_MSC_VER)
14547 
14548 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14549   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14550                getLLVMStyleWithColumns(35));
14551   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14552                getLLVMStyleWithColumns(31));
14553   verifyFormat("// Однажды в студёную зимнюю пору...",
14554                getLLVMStyleWithColumns(36));
14555   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14556   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14557                getLLVMStyleWithColumns(39));
14558   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14559                getLLVMStyleWithColumns(35));
14560 }
14561 
14562 TEST_F(FormatTest, SplitsUTF8Strings) {
14563   // Non-printable characters' width is currently considered to be the length in
14564   // bytes in UTF8. The characters can be displayed in very different manner
14565   // (zero-width, single width with a substitution glyph, expanded to their code
14566   // (e.g. "<8d>"), so there's no single correct way to handle them.
14567   EXPECT_EQ("\"aaaaÄ\"\n"
14568             "\"\xc2\x8d\";",
14569             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14570   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14571             "\"\xc2\x8d\";",
14572             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14573   EXPECT_EQ("\"Однажды, в \"\n"
14574             "\"студёную \"\n"
14575             "\"зимнюю \"\n"
14576             "\"пору,\"",
14577             format("\"Однажды, в студёную зимнюю пору,\"",
14578                    getLLVMStyleWithColumns(13)));
14579   EXPECT_EQ(
14580       "\"一 二 三 \"\n"
14581       "\"四 五六 \"\n"
14582       "\"七 八 九 \"\n"
14583       "\"十\"",
14584       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14585   EXPECT_EQ("\"一\t\"\n"
14586             "\"二 \t\"\n"
14587             "\"三 四 \"\n"
14588             "\"五\t\"\n"
14589             "\"六 \t\"\n"
14590             "\"七 \"\n"
14591             "\"八九十\tqq\"",
14592             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14593                    getLLVMStyleWithColumns(11)));
14594 
14595   // UTF8 character in an escape sequence.
14596   EXPECT_EQ("\"aaaaaa\"\n"
14597             "\"\\\xC2\x8D\"",
14598             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14599 }
14600 
14601 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14602   EXPECT_EQ("const char *sssss =\n"
14603             "    \"一二三四五六七八\\\n"
14604             " 九 十\";",
14605             format("const char *sssss = \"一二三四五六七八\\\n"
14606                    " 九 十\";",
14607                    getLLVMStyleWithColumns(30)));
14608 }
14609 
14610 TEST_F(FormatTest, SplitsUTF8LineComments) {
14611   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14612             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14613   EXPECT_EQ("// Я из лесу\n"
14614             "// вышел; был\n"
14615             "// сильный\n"
14616             "// мороз.",
14617             format("// Я из лесу вышел; был сильный мороз.",
14618                    getLLVMStyleWithColumns(13)));
14619   EXPECT_EQ("// 一二三\n"
14620             "// 四五六七\n"
14621             "// 八  九\n"
14622             "// 十",
14623             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14624 }
14625 
14626 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14627   EXPECT_EQ("/* Гляжу,\n"
14628             " * поднимается\n"
14629             " * медленно в\n"
14630             " * гору\n"
14631             " * Лошадка,\n"
14632             " * везущая\n"
14633             " * хворосту\n"
14634             " * воз. */",
14635             format("/* Гляжу, поднимается медленно в гору\n"
14636                    " * Лошадка, везущая хворосту воз. */",
14637                    getLLVMStyleWithColumns(13)));
14638   EXPECT_EQ(
14639       "/* 一二三\n"
14640       " * 四五六七\n"
14641       " * 八  九\n"
14642       " * 十  */",
14643       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14644   EXPECT_EQ("/* �������� ��������\n"
14645             " * ��������\n"
14646             " * ������-�� */",
14647             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14648 }
14649 
14650 #endif // _MSC_VER
14651 
14652 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14653   FormatStyle Style = getLLVMStyle();
14654 
14655   Style.ConstructorInitializerIndentWidth = 4;
14656   verifyFormat(
14657       "SomeClass::Constructor()\n"
14658       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14659       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14660       Style);
14661 
14662   Style.ConstructorInitializerIndentWidth = 2;
14663   verifyFormat(
14664       "SomeClass::Constructor()\n"
14665       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14666       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14667       Style);
14668 
14669   Style.ConstructorInitializerIndentWidth = 0;
14670   verifyFormat(
14671       "SomeClass::Constructor()\n"
14672       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14673       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14674       Style);
14675   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14676   verifyFormat(
14677       "SomeLongTemplateVariableName<\n"
14678       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14679       Style);
14680   verifyFormat("bool smaller = 1 < "
14681                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14682                "                       "
14683                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14684                Style);
14685 
14686   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14687   verifyFormat("SomeClass::Constructor() :\n"
14688                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14689                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14690                Style);
14691 }
14692 
14693 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14694   FormatStyle Style = getLLVMStyle();
14695   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14696   Style.ConstructorInitializerIndentWidth = 4;
14697   verifyFormat("SomeClass::Constructor()\n"
14698                "    : a(a)\n"
14699                "    , b(b)\n"
14700                "    , c(c) {}",
14701                Style);
14702   verifyFormat("SomeClass::Constructor()\n"
14703                "    : a(a) {}",
14704                Style);
14705 
14706   Style.ColumnLimit = 0;
14707   verifyFormat("SomeClass::Constructor()\n"
14708                "    : a(a) {}",
14709                Style);
14710   verifyFormat("SomeClass::Constructor() noexcept\n"
14711                "    : a(a) {}",
14712                Style);
14713   verifyFormat("SomeClass::Constructor()\n"
14714                "    : a(a)\n"
14715                "    , b(b)\n"
14716                "    , c(c) {}",
14717                Style);
14718   verifyFormat("SomeClass::Constructor()\n"
14719                "    : a(a) {\n"
14720                "  foo();\n"
14721                "  bar();\n"
14722                "}",
14723                Style);
14724 
14725   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14726   verifyFormat("SomeClass::Constructor()\n"
14727                "    : a(a)\n"
14728                "    , b(b)\n"
14729                "    , c(c) {\n}",
14730                Style);
14731   verifyFormat("SomeClass::Constructor()\n"
14732                "    : a(a) {\n}",
14733                Style);
14734 
14735   Style.ColumnLimit = 80;
14736   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14737   Style.ConstructorInitializerIndentWidth = 2;
14738   verifyFormat("SomeClass::Constructor()\n"
14739                "  : a(a)\n"
14740                "  , b(b)\n"
14741                "  , c(c) {}",
14742                Style);
14743 
14744   Style.ConstructorInitializerIndentWidth = 0;
14745   verifyFormat("SomeClass::Constructor()\n"
14746                ": a(a)\n"
14747                ", b(b)\n"
14748                ", c(c) {}",
14749                Style);
14750 
14751   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14752   Style.ConstructorInitializerIndentWidth = 4;
14753   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14754   verifyFormat(
14755       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14756       Style);
14757   verifyFormat(
14758       "SomeClass::Constructor()\n"
14759       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14760       Style);
14761   Style.ConstructorInitializerIndentWidth = 4;
14762   Style.ColumnLimit = 60;
14763   verifyFormat("SomeClass::Constructor()\n"
14764                "    : aaaaaaaa(aaaaaaaa)\n"
14765                "    , aaaaaaaa(aaaaaaaa)\n"
14766                "    , aaaaaaaa(aaaaaaaa) {}",
14767                Style);
14768 }
14769 
14770 TEST_F(FormatTest, Destructors) {
14771   verifyFormat("void F(int &i) { i.~int(); }");
14772   verifyFormat("void F(int &i) { i->~int(); }");
14773 }
14774 
14775 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14776   FormatStyle Style = getWebKitStyle();
14777 
14778   // Don't indent in outer namespaces.
14779   verifyFormat("namespace outer {\n"
14780                "int i;\n"
14781                "namespace inner {\n"
14782                "    int i;\n"
14783                "} // namespace inner\n"
14784                "} // namespace outer\n"
14785                "namespace other_outer {\n"
14786                "int i;\n"
14787                "}",
14788                Style);
14789 
14790   // Don't indent case labels.
14791   verifyFormat("switch (variable) {\n"
14792                "case 1:\n"
14793                "case 2:\n"
14794                "    doSomething();\n"
14795                "    break;\n"
14796                "default:\n"
14797                "    ++variable;\n"
14798                "}",
14799                Style);
14800 
14801   // Wrap before binary operators.
14802   EXPECT_EQ("void f()\n"
14803             "{\n"
14804             "    if (aaaaaaaaaaaaaaaa\n"
14805             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14806             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14807             "        return;\n"
14808             "}",
14809             format("void f() {\n"
14810                    "if (aaaaaaaaaaaaaaaa\n"
14811                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
14812                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14813                    "return;\n"
14814                    "}",
14815                    Style));
14816 
14817   // Allow functions on a single line.
14818   verifyFormat("void f() { return; }", Style);
14819 
14820   // Allow empty blocks on a single line and insert a space in empty blocks.
14821   EXPECT_EQ("void f() { }", format("void f() {}", Style));
14822   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
14823   // However, don't merge non-empty short loops.
14824   EXPECT_EQ("while (true) {\n"
14825             "    continue;\n"
14826             "}",
14827             format("while (true) { continue; }", Style));
14828 
14829   // Constructor initializers are formatted one per line with the "," on the
14830   // new line.
14831   verifyFormat("Constructor()\n"
14832                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
14833                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
14834                "          aaaaaaaaaaaaaa)\n"
14835                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
14836                "{\n"
14837                "}",
14838                Style);
14839   verifyFormat("SomeClass::Constructor()\n"
14840                "    : a(a)\n"
14841                "{\n"
14842                "}",
14843                Style);
14844   EXPECT_EQ("SomeClass::Constructor()\n"
14845             "    : a(a)\n"
14846             "{\n"
14847             "}",
14848             format("SomeClass::Constructor():a(a){}", Style));
14849   verifyFormat("SomeClass::Constructor()\n"
14850                "    : a(a)\n"
14851                "    , b(b)\n"
14852                "    , c(c)\n"
14853                "{\n"
14854                "}",
14855                Style);
14856   verifyFormat("SomeClass::Constructor()\n"
14857                "    : a(a)\n"
14858                "{\n"
14859                "    foo();\n"
14860                "    bar();\n"
14861                "}",
14862                Style);
14863 
14864   // Access specifiers should be aligned left.
14865   verifyFormat("class C {\n"
14866                "public:\n"
14867                "    int i;\n"
14868                "};",
14869                Style);
14870 
14871   // Do not align comments.
14872   verifyFormat("int a; // Do not\n"
14873                "double b; // align comments.",
14874                Style);
14875 
14876   // Do not align operands.
14877   EXPECT_EQ("ASSERT(aaaa\n"
14878             "    || bbbb);",
14879             format("ASSERT ( aaaa\n||bbbb);", Style));
14880 
14881   // Accept input's line breaks.
14882   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
14883             "    || bbbbbbbbbbbbbbb) {\n"
14884             "    i++;\n"
14885             "}",
14886             format("if (aaaaaaaaaaaaaaa\n"
14887                    "|| bbbbbbbbbbbbbbb) { i++; }",
14888                    Style));
14889   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
14890             "    i++;\n"
14891             "}",
14892             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
14893 
14894   // Don't automatically break all macro definitions (llvm.org/PR17842).
14895   verifyFormat("#define aNumber 10", Style);
14896   // However, generally keep the line breaks that the user authored.
14897   EXPECT_EQ("#define aNumber \\\n"
14898             "    10",
14899             format("#define aNumber \\\n"
14900                    " 10",
14901                    Style));
14902 
14903   // Keep empty and one-element array literals on a single line.
14904   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
14905             "                                  copyItems:YES];",
14906             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
14907                    "copyItems:YES];",
14908                    Style));
14909   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
14910             "                                  copyItems:YES];",
14911             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
14912                    "             copyItems:YES];",
14913                    Style));
14914   // FIXME: This does not seem right, there should be more indentation before
14915   // the array literal's entries. Nested blocks have the same problem.
14916   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14917             "    @\"a\",\n"
14918             "    @\"a\"\n"
14919             "]\n"
14920             "                                  copyItems:YES];",
14921             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14922                    "     @\"a\",\n"
14923                    "     @\"a\"\n"
14924                    "     ]\n"
14925                    "       copyItems:YES];",
14926                    Style));
14927   EXPECT_EQ(
14928       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14929       "                                  copyItems:YES];",
14930       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14931              "   copyItems:YES];",
14932              Style));
14933 
14934   verifyFormat("[self.a b:c c:d];", Style);
14935   EXPECT_EQ("[self.a b:c\n"
14936             "        c:d];",
14937             format("[self.a b:c\n"
14938                    "c:d];",
14939                    Style));
14940 }
14941 
14942 TEST_F(FormatTest, FormatsLambdas) {
14943   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
14944   verifyFormat(
14945       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
14946   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
14947   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
14948   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
14949   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
14950   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
14951   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
14952   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
14953   verifyFormat("int x = f(*+[] {});");
14954   verifyFormat("void f() {\n"
14955                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
14956                "}\n");
14957   verifyFormat("void f() {\n"
14958                "  other(x.begin(), //\n"
14959                "        x.end(),   //\n"
14960                "        [&](int, int) { return 1; });\n"
14961                "}\n");
14962   verifyFormat("void f() {\n"
14963                "  other.other.other.other.other(\n"
14964                "      x.begin(), x.end(),\n"
14965                "      [something, rather](int, int, int, int, int, int, int) { "
14966                "return 1; });\n"
14967                "}\n");
14968   verifyFormat(
14969       "void f() {\n"
14970       "  other.other.other.other.other(\n"
14971       "      x.begin(), x.end(),\n"
14972       "      [something, rather](int, int, int, int, int, int, int) {\n"
14973       "        //\n"
14974       "      });\n"
14975       "}\n");
14976   verifyFormat("SomeFunction([]() { // A cool function...\n"
14977                "  return 43;\n"
14978                "});");
14979   EXPECT_EQ("SomeFunction([]() {\n"
14980             "#define A a\n"
14981             "  return 43;\n"
14982             "});",
14983             format("SomeFunction([](){\n"
14984                    "#define A a\n"
14985                    "return 43;\n"
14986                    "});"));
14987   verifyFormat("void f() {\n"
14988                "  SomeFunction([](decltype(x), A *a) {});\n"
14989                "  SomeFunction([](typeof(x), A *a) {});\n"
14990                "  SomeFunction([](_Atomic(x), A *a) {});\n"
14991                "  SomeFunction([](__underlying_type(x), A *a) {});\n"
14992                "}");
14993   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14994                "    [](const aaaaaaaaaa &a) { return a; });");
14995   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
14996                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
14997                "});");
14998   verifyFormat("Constructor()\n"
14999                "    : Field([] { // comment\n"
15000                "        int i;\n"
15001                "      }) {}");
15002   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
15003                "  return some_parameter.size();\n"
15004                "};");
15005   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
15006                "    [](const string &s) { return s; };");
15007   verifyFormat("int i = aaaaaa ? 1 //\n"
15008                "               : [] {\n"
15009                "                   return 2; //\n"
15010                "                 }();");
15011   verifyFormat("llvm::errs() << \"number of twos is \"\n"
15012                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
15013                "                  return x == 2; // force break\n"
15014                "                });");
15015   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15016                "    [=](int iiiiiiiiiiii) {\n"
15017                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
15018                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
15019                "    });",
15020                getLLVMStyleWithColumns(60));
15021   verifyFormat("SomeFunction({[&] {\n"
15022                "                // comment\n"
15023                "              },\n"
15024                "              [&] {\n"
15025                "                // comment\n"
15026                "              }});");
15027   verifyFormat("SomeFunction({[&] {\n"
15028                "  // comment\n"
15029                "}});");
15030   verifyFormat(
15031       "virtual aaaaaaaaaaaaaaaa(\n"
15032       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
15033       "    aaaaa aaaaaaaaa);");
15034 
15035   // Lambdas with return types.
15036   verifyFormat("int c = []() -> int { return 2; }();\n");
15037   verifyFormat("int c = []() -> int * { return 2; }();\n");
15038   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
15039   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
15040   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
15041   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
15042   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
15043   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
15044   verifyFormat("[a, a]() -> a<1> {};");
15045   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
15046   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
15047   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
15048   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
15049   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
15050   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
15051   verifyFormat("[]() -> foo<!5> { return {}; };");
15052   verifyFormat("[]() -> foo<~5> { return {}; };");
15053   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
15054   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
15055   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
15056   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
15057   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
15058   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
15059   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
15060   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
15061   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
15062   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
15063   verifyFormat("namespace bar {\n"
15064                "// broken:\n"
15065                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
15066                "} // namespace bar");
15067   verifyFormat("namespace bar {\n"
15068                "// broken:\n"
15069                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
15070                "} // namespace bar");
15071   verifyFormat("namespace bar {\n"
15072                "// broken:\n"
15073                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
15074                "} // namespace bar");
15075   verifyFormat("namespace bar {\n"
15076                "// broken:\n"
15077                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
15078                "} // namespace bar");
15079   verifyFormat("namespace bar {\n"
15080                "// broken:\n"
15081                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
15082                "} // namespace bar");
15083   verifyFormat("namespace bar {\n"
15084                "// broken:\n"
15085                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
15086                "} // namespace bar");
15087   verifyFormat("namespace bar {\n"
15088                "// broken:\n"
15089                "auto foo{[]() -> foo<!5> { return {}; }};\n"
15090                "} // namespace bar");
15091   verifyFormat("namespace bar {\n"
15092                "// broken:\n"
15093                "auto foo{[]() -> foo<~5> { return {}; }};\n"
15094                "} // namespace bar");
15095   verifyFormat("namespace bar {\n"
15096                "// broken:\n"
15097                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
15098                "} // namespace bar");
15099   verifyFormat("namespace bar {\n"
15100                "// broken:\n"
15101                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
15102                "} // namespace bar");
15103   verifyFormat("namespace bar {\n"
15104                "// broken:\n"
15105                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
15106                "} // namespace bar");
15107   verifyFormat("namespace bar {\n"
15108                "// broken:\n"
15109                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
15110                "} // namespace bar");
15111   verifyFormat("namespace bar {\n"
15112                "// broken:\n"
15113                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
15114                "} // namespace bar");
15115   verifyFormat("namespace bar {\n"
15116                "// broken:\n"
15117                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
15118                "} // namespace bar");
15119   verifyFormat("namespace bar {\n"
15120                "// broken:\n"
15121                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
15122                "} // namespace bar");
15123   verifyFormat("namespace bar {\n"
15124                "// broken:\n"
15125                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
15126                "} // namespace bar");
15127   verifyFormat("namespace bar {\n"
15128                "// broken:\n"
15129                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
15130                "} // namespace bar");
15131   verifyFormat("namespace bar {\n"
15132                "// broken:\n"
15133                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
15134                "} // namespace bar");
15135   verifyFormat("[]() -> a<1> {};");
15136   verifyFormat("[]() -> a<1> { ; };");
15137   verifyFormat("[]() -> a<1> { ; }();");
15138   verifyFormat("[a, a]() -> a<true> {};");
15139   verifyFormat("[]() -> a<true> {};");
15140   verifyFormat("[]() -> a<true> { ; };");
15141   verifyFormat("[]() -> a<true> { ; }();");
15142   verifyFormat("[a, a]() -> a<false> {};");
15143   verifyFormat("[]() -> a<false> {};");
15144   verifyFormat("[]() -> a<false> { ; };");
15145   verifyFormat("[]() -> a<false> { ; }();");
15146   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
15147   verifyFormat("namespace bar {\n"
15148                "auto foo{[]() -> foo<false> { ; }};\n"
15149                "} // namespace bar");
15150   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
15151                "                   int j) -> int {\n"
15152                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
15153                "};");
15154   verifyFormat(
15155       "aaaaaaaaaaaaaaaaaaaaaa(\n"
15156       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
15157       "      return aaaaaaaaaaaaaaaaa;\n"
15158       "    });",
15159       getLLVMStyleWithColumns(70));
15160   verifyFormat("[]() //\n"
15161                "    -> int {\n"
15162                "  return 1; //\n"
15163                "};");
15164   verifyFormat("[]() -> Void<T...> {};");
15165   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
15166 
15167   // Lambdas with explicit template argument lists.
15168   verifyFormat(
15169       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
15170 
15171   // Multiple lambdas in the same parentheses change indentation rules. These
15172   // lambdas are forced to start on new lines.
15173   verifyFormat("SomeFunction(\n"
15174                "    []() {\n"
15175                "      //\n"
15176                "    },\n"
15177                "    []() {\n"
15178                "      //\n"
15179                "    });");
15180 
15181   // A lambda passed as arg0 is always pushed to the next line.
15182   verifyFormat("SomeFunction(\n"
15183                "    [this] {\n"
15184                "      //\n"
15185                "    },\n"
15186                "    1);\n");
15187 
15188   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
15189   // the arg0 case above.
15190   auto Style = getGoogleStyle();
15191   Style.BinPackArguments = false;
15192   verifyFormat("SomeFunction(\n"
15193                "    a,\n"
15194                "    [this] {\n"
15195                "      //\n"
15196                "    },\n"
15197                "    b);\n",
15198                Style);
15199   verifyFormat("SomeFunction(\n"
15200                "    a,\n"
15201                "    [this] {\n"
15202                "      //\n"
15203                "    },\n"
15204                "    b);\n");
15205 
15206   // A lambda with a very long line forces arg0 to be pushed out irrespective of
15207   // the BinPackArguments value (as long as the code is wide enough).
15208   verifyFormat(
15209       "something->SomeFunction(\n"
15210       "    a,\n"
15211       "    [this] {\n"
15212       "      "
15213       "D0000000000000000000000000000000000000000000000000000000000001();\n"
15214       "    },\n"
15215       "    b);\n");
15216 
15217   // A multi-line lambda is pulled up as long as the introducer fits on the
15218   // previous line and there are no further args.
15219   verifyFormat("function(1, [this, that] {\n"
15220                "  //\n"
15221                "});\n");
15222   verifyFormat("function([this, that] {\n"
15223                "  //\n"
15224                "});\n");
15225   // FIXME: this format is not ideal and we should consider forcing the first
15226   // arg onto its own line.
15227   verifyFormat("function(a, b, c, //\n"
15228                "         d, [this, that] {\n"
15229                "           //\n"
15230                "         });\n");
15231 
15232   // Multiple lambdas are treated correctly even when there is a short arg0.
15233   verifyFormat("SomeFunction(\n"
15234                "    1,\n"
15235                "    [this] {\n"
15236                "      //\n"
15237                "    },\n"
15238                "    [this] {\n"
15239                "      //\n"
15240                "    },\n"
15241                "    1);\n");
15242 
15243   // More complex introducers.
15244   verifyFormat("return [i, args...] {};");
15245 
15246   // Not lambdas.
15247   verifyFormat("constexpr char hello[]{\"hello\"};");
15248   verifyFormat("double &operator[](int i) { return 0; }\n"
15249                "int i;");
15250   verifyFormat("std::unique_ptr<int[]> foo() {}");
15251   verifyFormat("int i = a[a][a]->f();");
15252   verifyFormat("int i = (*b)[a]->f();");
15253 
15254   // Other corner cases.
15255   verifyFormat("void f() {\n"
15256                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
15257                "  );\n"
15258                "}");
15259 
15260   // Lambdas created through weird macros.
15261   verifyFormat("void f() {\n"
15262                "  MACRO((const AA &a) { return 1; });\n"
15263                "  MACRO((AA &a) { return 1; });\n"
15264                "}");
15265 
15266   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
15267                "      doo_dah();\n"
15268                "      doo_dah();\n"
15269                "    })) {\n"
15270                "}");
15271   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
15272                "                doo_dah();\n"
15273                "                doo_dah();\n"
15274                "              })) {\n"
15275                "}");
15276   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
15277                "                doo_dah();\n"
15278                "                doo_dah();\n"
15279                "              })) {\n"
15280                "}");
15281   verifyFormat("auto lambda = []() {\n"
15282                "  int a = 2\n"
15283                "#if A\n"
15284                "          + 2\n"
15285                "#endif\n"
15286                "      ;\n"
15287                "};");
15288 
15289   // Lambdas with complex multiline introducers.
15290   verifyFormat(
15291       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15292       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
15293       "        -> ::std::unordered_set<\n"
15294       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
15295       "      //\n"
15296       "    });");
15297 
15298   FormatStyle DoNotMerge = getLLVMStyle();
15299   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
15300   verifyFormat("auto c = []() {\n"
15301                "  return b;\n"
15302                "};",
15303                "auto c = []() { return b; };", DoNotMerge);
15304   verifyFormat("auto c = []() {\n"
15305                "};",
15306                " auto c = []() {};", DoNotMerge);
15307 
15308   FormatStyle MergeEmptyOnly = getLLVMStyle();
15309   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
15310   verifyFormat("auto c = []() {\n"
15311                "  return b;\n"
15312                "};",
15313                "auto c = []() {\n"
15314                "  return b;\n"
15315                " };",
15316                MergeEmptyOnly);
15317   verifyFormat("auto c = []() {};",
15318                "auto c = []() {\n"
15319                "};",
15320                MergeEmptyOnly);
15321 
15322   FormatStyle MergeInline = getLLVMStyle();
15323   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
15324   verifyFormat("auto c = []() {\n"
15325                "  return b;\n"
15326                "};",
15327                "auto c = []() { return b; };", MergeInline);
15328   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
15329                MergeInline);
15330   verifyFormat("function([]() { return b; }, a)",
15331                "function([]() { return b; }, a)", MergeInline);
15332   verifyFormat("function(a, []() { return b; })",
15333                "function(a, []() { return b; })", MergeInline);
15334 
15335   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
15336   // AllowShortLambdasOnASingleLine
15337   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15338   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15339   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15340   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15341       FormatStyle::ShortLambdaStyle::SLS_None;
15342   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
15343                "    []()\n"
15344                "    {\n"
15345                "      return 17;\n"
15346                "    });",
15347                LLVMWithBeforeLambdaBody);
15348   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
15349                "    []()\n"
15350                "    {\n"
15351                "    });",
15352                LLVMWithBeforeLambdaBody);
15353   verifyFormat("auto fct_SLS_None = []()\n"
15354                "{\n"
15355                "  return 17;\n"
15356                "};",
15357                LLVMWithBeforeLambdaBody);
15358   verifyFormat("TwoNestedLambdas_SLS_None(\n"
15359                "    []()\n"
15360                "    {\n"
15361                "      return Call(\n"
15362                "          []()\n"
15363                "          {\n"
15364                "            return 17;\n"
15365                "          });\n"
15366                "    });",
15367                LLVMWithBeforeLambdaBody);
15368   verifyFormat("void Fct()\n"
15369                "{\n"
15370                "  return {[]()\n"
15371                "          {\n"
15372                "            return 17;\n"
15373                "          }};\n"
15374                "}",
15375                LLVMWithBeforeLambdaBody);
15376 
15377   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15378       FormatStyle::ShortLambdaStyle::SLS_Empty;
15379   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
15380                "    []()\n"
15381                "    {\n"
15382                "      return 17;\n"
15383                "    });",
15384                LLVMWithBeforeLambdaBody);
15385   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
15386                LLVMWithBeforeLambdaBody);
15387   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
15388                "ongFunctionName_SLS_Empty(\n"
15389                "    []() {});",
15390                LLVMWithBeforeLambdaBody);
15391   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
15392                "                                []()\n"
15393                "                                {\n"
15394                "                                  return 17;\n"
15395                "                                });",
15396                LLVMWithBeforeLambdaBody);
15397   verifyFormat("auto fct_SLS_Empty = []()\n"
15398                "{\n"
15399                "  return 17;\n"
15400                "};",
15401                LLVMWithBeforeLambdaBody);
15402   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
15403                "    []()\n"
15404                "    {\n"
15405                "      return Call([]() {});\n"
15406                "    });",
15407                LLVMWithBeforeLambdaBody);
15408   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15409                "                           []()\n"
15410                "                           {\n"
15411                "                             return Call([]() {});\n"
15412                "                           });",
15413                LLVMWithBeforeLambdaBody);
15414   verifyFormat(
15415       "FctWithLongLineInLambda_SLS_Empty(\n"
15416       "    []()\n"
15417       "    {\n"
15418       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15419       "                               AndShouldNotBeConsiderAsInline,\n"
15420       "                               LambdaBodyMustBeBreak);\n"
15421       "    });",
15422       LLVMWithBeforeLambdaBody);
15423 
15424   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15425       FormatStyle::ShortLambdaStyle::SLS_Inline;
15426   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15427                LLVMWithBeforeLambdaBody);
15428   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15429                LLVMWithBeforeLambdaBody);
15430   verifyFormat("auto fct_SLS_Inline = []()\n"
15431                "{\n"
15432                "  return 17;\n"
15433                "};",
15434                LLVMWithBeforeLambdaBody);
15435   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15436                "17; }); });",
15437                LLVMWithBeforeLambdaBody);
15438   verifyFormat(
15439       "FctWithLongLineInLambda_SLS_Inline(\n"
15440       "    []()\n"
15441       "    {\n"
15442       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15443       "                               AndShouldNotBeConsiderAsInline,\n"
15444       "                               LambdaBodyMustBeBreak);\n"
15445       "    });",
15446       LLVMWithBeforeLambdaBody);
15447   verifyFormat("FctWithMultipleParams_SLS_Inline("
15448                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15449                "                                 []() { return 17; });",
15450                LLVMWithBeforeLambdaBody);
15451   verifyFormat(
15452       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15453       LLVMWithBeforeLambdaBody);
15454 
15455   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15456       FormatStyle::ShortLambdaStyle::SLS_All;
15457   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15458                LLVMWithBeforeLambdaBody);
15459   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15460                LLVMWithBeforeLambdaBody);
15461   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15462                LLVMWithBeforeLambdaBody);
15463   verifyFormat("FctWithOneParam_SLS_All(\n"
15464                "    []()\n"
15465                "    {\n"
15466                "      // A cool function...\n"
15467                "      return 43;\n"
15468                "    });",
15469                LLVMWithBeforeLambdaBody);
15470   verifyFormat("FctWithMultipleParams_SLS_All("
15471                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15472                "                              []() { return 17; });",
15473                LLVMWithBeforeLambdaBody);
15474   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15475                LLVMWithBeforeLambdaBody);
15476   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15477                LLVMWithBeforeLambdaBody);
15478   verifyFormat(
15479       "FctWithLongLineInLambda_SLS_All(\n"
15480       "    []()\n"
15481       "    {\n"
15482       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15483       "                               AndShouldNotBeConsiderAsInline,\n"
15484       "                               LambdaBodyMustBeBreak);\n"
15485       "    });",
15486       LLVMWithBeforeLambdaBody);
15487   verifyFormat(
15488       "auto fct_SLS_All = []()\n"
15489       "{\n"
15490       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15491       "                           AndShouldNotBeConsiderAsInline,\n"
15492       "                           LambdaBodyMustBeBreak);\n"
15493       "};",
15494       LLVMWithBeforeLambdaBody);
15495   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15496   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15497                LLVMWithBeforeLambdaBody);
15498   verifyFormat(
15499       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15500       "                                FirstParam,\n"
15501       "                                SecondParam,\n"
15502       "                                ThirdParam,\n"
15503       "                                FourthParam);",
15504       LLVMWithBeforeLambdaBody);
15505   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15506                "    []() { return "
15507                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15508                "    FirstParam,\n"
15509                "    SecondParam,\n"
15510                "    ThirdParam,\n"
15511                "    FourthParam);",
15512                LLVMWithBeforeLambdaBody);
15513   verifyFormat(
15514       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15515       "                                SecondParam,\n"
15516       "                                ThirdParam,\n"
15517       "                                FourthParam,\n"
15518       "                                []() { return SomeValueNotSoLong; });",
15519       LLVMWithBeforeLambdaBody);
15520   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15521                "    []()\n"
15522                "    {\n"
15523                "      return "
15524                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15525                "eConsiderAsInline;\n"
15526                "    });",
15527                LLVMWithBeforeLambdaBody);
15528   verifyFormat(
15529       "FctWithLongLineInLambda_SLS_All(\n"
15530       "    []()\n"
15531       "    {\n"
15532       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15533       "                               AndShouldNotBeConsiderAsInline,\n"
15534       "                               LambdaBodyMustBeBreak);\n"
15535       "    });",
15536       LLVMWithBeforeLambdaBody);
15537   verifyFormat("FctWithTwoParams_SLS_All(\n"
15538                "    []()\n"
15539                "    {\n"
15540                "      // A cool function...\n"
15541                "      return 43;\n"
15542                "    },\n"
15543                "    87);",
15544                LLVMWithBeforeLambdaBody);
15545   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15546                LLVMWithBeforeLambdaBody);
15547   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15548                LLVMWithBeforeLambdaBody);
15549   verifyFormat(
15550       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15551       LLVMWithBeforeLambdaBody);
15552   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15553                "}); }, x);",
15554                LLVMWithBeforeLambdaBody);
15555   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15556                "    []()\n"
15557                "    {\n"
15558                "      // A cool function...\n"
15559                "      return Call([]() { return 17; });\n"
15560                "    });",
15561                LLVMWithBeforeLambdaBody);
15562   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15563                "    []()\n"
15564                "    {\n"
15565                "      return Call(\n"
15566                "          []()\n"
15567                "          {\n"
15568                "            // A cool function...\n"
15569                "            return 17;\n"
15570                "          });\n"
15571                "    });",
15572                LLVMWithBeforeLambdaBody);
15573 }
15574 
15575 TEST_F(FormatTest, LambdaWithLineComments) {
15576   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15577   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15578   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15579   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15580       FormatStyle::ShortLambdaStyle::SLS_All;
15581 
15582   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15583   verifyFormat("auto k = []() // comment\n"
15584                "{ return; }",
15585                LLVMWithBeforeLambdaBody);
15586   verifyFormat("auto k = []() /* comment */ { return; }",
15587                LLVMWithBeforeLambdaBody);
15588   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15589                LLVMWithBeforeLambdaBody);
15590   verifyFormat("auto k = []() // X\n"
15591                "{ return; }",
15592                LLVMWithBeforeLambdaBody);
15593   verifyFormat(
15594       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15595       "{ return; }",
15596       LLVMWithBeforeLambdaBody);
15597 }
15598 
15599 TEST_F(FormatTest, EmptyLinesInLambdas) {
15600   verifyFormat("auto lambda = []() {\n"
15601                "  x(); //\n"
15602                "};",
15603                "auto lambda = []() {\n"
15604                "\n"
15605                "  x(); //\n"
15606                "\n"
15607                "};");
15608 }
15609 
15610 TEST_F(FormatTest, FormatsBlocks) {
15611   FormatStyle ShortBlocks = getLLVMStyle();
15612   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15613   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15614   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15615   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15616   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15617   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15618   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15619 
15620   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15621   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15622   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15623 
15624   verifyFormat("[operation setCompletionBlock:^{\n"
15625                "  [self onOperationDone];\n"
15626                "}];");
15627   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15628                "  [self onOperationDone];\n"
15629                "}]};");
15630   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15631                "  f();\n"
15632                "}];");
15633   verifyFormat("int a = [operation block:^int(int *i) {\n"
15634                "  return 1;\n"
15635                "}];");
15636   verifyFormat("[myObject doSomethingWith:arg1\n"
15637                "                      aaa:^int(int *a) {\n"
15638                "                        return 1;\n"
15639                "                      }\n"
15640                "                      bbb:f(a * bbbbbbbb)];");
15641 
15642   verifyFormat("[operation setCompletionBlock:^{\n"
15643                "  [self.delegate newDataAvailable];\n"
15644                "}];",
15645                getLLVMStyleWithColumns(60));
15646   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15647                "  NSString *path = [self sessionFilePath];\n"
15648                "  if (path) {\n"
15649                "    // ...\n"
15650                "  }\n"
15651                "});");
15652   verifyFormat("[[SessionService sharedService]\n"
15653                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15654                "      if (window) {\n"
15655                "        [self windowDidLoad:window];\n"
15656                "      } else {\n"
15657                "        [self errorLoadingWindow];\n"
15658                "      }\n"
15659                "    }];");
15660   verifyFormat("void (^largeBlock)(void) = ^{\n"
15661                "  // ...\n"
15662                "};\n",
15663                getLLVMStyleWithColumns(40));
15664   verifyFormat("[[SessionService sharedService]\n"
15665                "    loadWindowWithCompletionBlock: //\n"
15666                "        ^(SessionWindow *window) {\n"
15667                "          if (window) {\n"
15668                "            [self windowDidLoad:window];\n"
15669                "          } else {\n"
15670                "            [self errorLoadingWindow];\n"
15671                "          }\n"
15672                "        }];",
15673                getLLVMStyleWithColumns(60));
15674   verifyFormat("[myObject doSomethingWith:arg1\n"
15675                "    firstBlock:^(Foo *a) {\n"
15676                "      // ...\n"
15677                "      int i;\n"
15678                "    }\n"
15679                "    secondBlock:^(Bar *b) {\n"
15680                "      // ...\n"
15681                "      int i;\n"
15682                "    }\n"
15683                "    thirdBlock:^Foo(Bar *b) {\n"
15684                "      // ...\n"
15685                "      int i;\n"
15686                "    }];");
15687   verifyFormat("[myObject doSomethingWith:arg1\n"
15688                "               firstBlock:-1\n"
15689                "              secondBlock:^(Bar *b) {\n"
15690                "                // ...\n"
15691                "                int i;\n"
15692                "              }];");
15693 
15694   verifyFormat("f(^{\n"
15695                "  @autoreleasepool {\n"
15696                "    if (a) {\n"
15697                "      g();\n"
15698                "    }\n"
15699                "  }\n"
15700                "});");
15701   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15702   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15703                "};");
15704 
15705   FormatStyle FourIndent = getLLVMStyle();
15706   FourIndent.ObjCBlockIndentWidth = 4;
15707   verifyFormat("[operation setCompletionBlock:^{\n"
15708                "    [self onOperationDone];\n"
15709                "}];",
15710                FourIndent);
15711 }
15712 
15713 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15714   FormatStyle ZeroColumn = getLLVMStyle();
15715   ZeroColumn.ColumnLimit = 0;
15716 
15717   verifyFormat("[[SessionService sharedService] "
15718                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15719                "  if (window) {\n"
15720                "    [self windowDidLoad:window];\n"
15721                "  } else {\n"
15722                "    [self errorLoadingWindow];\n"
15723                "  }\n"
15724                "}];",
15725                ZeroColumn);
15726   EXPECT_EQ("[[SessionService sharedService]\n"
15727             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15728             "      if (window) {\n"
15729             "        [self windowDidLoad:window];\n"
15730             "      } else {\n"
15731             "        [self errorLoadingWindow];\n"
15732             "      }\n"
15733             "    }];",
15734             format("[[SessionService sharedService]\n"
15735                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15736                    "                if (window) {\n"
15737                    "    [self windowDidLoad:window];\n"
15738                    "  } else {\n"
15739                    "    [self errorLoadingWindow];\n"
15740                    "  }\n"
15741                    "}];",
15742                    ZeroColumn));
15743   verifyFormat("[myObject doSomethingWith:arg1\n"
15744                "    firstBlock:^(Foo *a) {\n"
15745                "      // ...\n"
15746                "      int i;\n"
15747                "    }\n"
15748                "    secondBlock:^(Bar *b) {\n"
15749                "      // ...\n"
15750                "      int i;\n"
15751                "    }\n"
15752                "    thirdBlock:^Foo(Bar *b) {\n"
15753                "      // ...\n"
15754                "      int i;\n"
15755                "    }];",
15756                ZeroColumn);
15757   verifyFormat("f(^{\n"
15758                "  @autoreleasepool {\n"
15759                "    if (a) {\n"
15760                "      g();\n"
15761                "    }\n"
15762                "  }\n"
15763                "});",
15764                ZeroColumn);
15765   verifyFormat("void (^largeBlock)(void) = ^{\n"
15766                "  // ...\n"
15767                "};",
15768                ZeroColumn);
15769 
15770   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15771   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15772             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15773   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15774   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15775             "  int i;\n"
15776             "};",
15777             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15778 }
15779 
15780 TEST_F(FormatTest, SupportsCRLF) {
15781   EXPECT_EQ("int a;\r\n"
15782             "int b;\r\n"
15783             "int c;\r\n",
15784             format("int a;\r\n"
15785                    "  int b;\r\n"
15786                    "    int c;\r\n",
15787                    getLLVMStyle()));
15788   EXPECT_EQ("int a;\r\n"
15789             "int b;\r\n"
15790             "int c;\r\n",
15791             format("int a;\r\n"
15792                    "  int b;\n"
15793                    "    int c;\r\n",
15794                    getLLVMStyle()));
15795   EXPECT_EQ("int a;\n"
15796             "int b;\n"
15797             "int c;\n",
15798             format("int a;\r\n"
15799                    "  int b;\n"
15800                    "    int c;\n",
15801                    getLLVMStyle()));
15802   EXPECT_EQ("\"aaaaaaa \"\r\n"
15803             "\"bbbbbbb\";\r\n",
15804             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15805   EXPECT_EQ("#define A \\\r\n"
15806             "  b;      \\\r\n"
15807             "  c;      \\\r\n"
15808             "  d;\r\n",
15809             format("#define A \\\r\n"
15810                    "  b; \\\r\n"
15811                    "  c; d; \r\n",
15812                    getGoogleStyle()));
15813 
15814   EXPECT_EQ("/*\r\n"
15815             "multi line block comments\r\n"
15816             "should not introduce\r\n"
15817             "an extra carriage return\r\n"
15818             "*/\r\n",
15819             format("/*\r\n"
15820                    "multi line block comments\r\n"
15821                    "should not introduce\r\n"
15822                    "an extra carriage return\r\n"
15823                    "*/\r\n"));
15824   EXPECT_EQ("/*\r\n"
15825             "\r\n"
15826             "*/",
15827             format("/*\r\n"
15828                    "    \r\r\r\n"
15829                    "*/"));
15830 
15831   FormatStyle style = getLLVMStyle();
15832 
15833   style.DeriveLineEnding = true;
15834   style.UseCRLF = false;
15835   EXPECT_EQ("union FooBarBazQux {\n"
15836             "  int foo;\n"
15837             "  int bar;\n"
15838             "  int baz;\n"
15839             "};",
15840             format("union FooBarBazQux {\r\n"
15841                    "  int foo;\n"
15842                    "  int bar;\r\n"
15843                    "  int baz;\n"
15844                    "};",
15845                    style));
15846   style.UseCRLF = true;
15847   EXPECT_EQ("union FooBarBazQux {\r\n"
15848             "  int foo;\r\n"
15849             "  int bar;\r\n"
15850             "  int baz;\r\n"
15851             "};",
15852             format("union FooBarBazQux {\r\n"
15853                    "  int foo;\n"
15854                    "  int bar;\r\n"
15855                    "  int baz;\n"
15856                    "};",
15857                    style));
15858 
15859   style.DeriveLineEnding = false;
15860   style.UseCRLF = false;
15861   EXPECT_EQ("union FooBarBazQux {\n"
15862             "  int foo;\n"
15863             "  int bar;\n"
15864             "  int baz;\n"
15865             "  int qux;\n"
15866             "};",
15867             format("union FooBarBazQux {\r\n"
15868                    "  int foo;\n"
15869                    "  int bar;\r\n"
15870                    "  int baz;\n"
15871                    "  int qux;\r\n"
15872                    "};",
15873                    style));
15874   style.UseCRLF = true;
15875   EXPECT_EQ("union FooBarBazQux {\r\n"
15876             "  int foo;\r\n"
15877             "  int bar;\r\n"
15878             "  int baz;\r\n"
15879             "  int qux;\r\n"
15880             "};",
15881             format("union FooBarBazQux {\r\n"
15882                    "  int foo;\n"
15883                    "  int bar;\r\n"
15884                    "  int baz;\n"
15885                    "  int qux;\n"
15886                    "};",
15887                    style));
15888 
15889   style.DeriveLineEnding = true;
15890   style.UseCRLF = false;
15891   EXPECT_EQ("union FooBarBazQux {\r\n"
15892             "  int foo;\r\n"
15893             "  int bar;\r\n"
15894             "  int baz;\r\n"
15895             "  int qux;\r\n"
15896             "};",
15897             format("union FooBarBazQux {\r\n"
15898                    "  int foo;\n"
15899                    "  int bar;\r\n"
15900                    "  int baz;\n"
15901                    "  int qux;\r\n"
15902                    "};",
15903                    style));
15904   style.UseCRLF = true;
15905   EXPECT_EQ("union FooBarBazQux {\n"
15906             "  int foo;\n"
15907             "  int bar;\n"
15908             "  int baz;\n"
15909             "  int qux;\n"
15910             "};",
15911             format("union FooBarBazQux {\r\n"
15912                    "  int foo;\n"
15913                    "  int bar;\r\n"
15914                    "  int baz;\n"
15915                    "  int qux;\n"
15916                    "};",
15917                    style));
15918 }
15919 
15920 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
15921   verifyFormat("MY_CLASS(C) {\n"
15922                "  int i;\n"
15923                "  int j;\n"
15924                "};");
15925 }
15926 
15927 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
15928   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
15929   TwoIndent.ContinuationIndentWidth = 2;
15930 
15931   EXPECT_EQ("int i =\n"
15932             "  longFunction(\n"
15933             "    arg);",
15934             format("int i = longFunction(arg);", TwoIndent));
15935 
15936   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
15937   SixIndent.ContinuationIndentWidth = 6;
15938 
15939   EXPECT_EQ("int i =\n"
15940             "      longFunction(\n"
15941             "            arg);",
15942             format("int i = longFunction(arg);", SixIndent));
15943 }
15944 
15945 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
15946   FormatStyle Style = getLLVMStyle();
15947   verifyFormat("int Foo::getter(\n"
15948                "    //\n"
15949                ") const {\n"
15950                "  return foo;\n"
15951                "}",
15952                Style);
15953   verifyFormat("void Foo::setter(\n"
15954                "    //\n"
15955                ") {\n"
15956                "  foo = 1;\n"
15957                "}",
15958                Style);
15959 }
15960 
15961 TEST_F(FormatTest, SpacesInAngles) {
15962   FormatStyle Spaces = getLLVMStyle();
15963   Spaces.SpacesInAngles = true;
15964 
15965   verifyFormat("static_cast< int >(arg);", Spaces);
15966   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
15967   verifyFormat("f< int, float >();", Spaces);
15968   verifyFormat("template <> g() {}", Spaces);
15969   verifyFormat("template < std::vector< int > > f() {}", Spaces);
15970   verifyFormat("std::function< void(int, int) > fct;", Spaces);
15971   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
15972                Spaces);
15973 
15974   Spaces.Standard = FormatStyle::LS_Cpp03;
15975   Spaces.SpacesInAngles = true;
15976   verifyFormat("A< A< int > >();", Spaces);
15977 
15978   Spaces.SpacesInAngles = false;
15979   verifyFormat("A<A<int> >();", Spaces);
15980 
15981   Spaces.Standard = FormatStyle::LS_Cpp11;
15982   Spaces.SpacesInAngles = true;
15983   verifyFormat("A< A< int > >();", Spaces);
15984 
15985   Spaces.SpacesInAngles = false;
15986   verifyFormat("A<A<int>>();", Spaces);
15987 }
15988 
15989 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
15990   FormatStyle Style = getLLVMStyle();
15991   Style.SpaceAfterTemplateKeyword = false;
15992   verifyFormat("template<int> void foo();", Style);
15993 }
15994 
15995 TEST_F(FormatTest, TripleAngleBrackets) {
15996   verifyFormat("f<<<1, 1>>>();");
15997   verifyFormat("f<<<1, 1, 1, s>>>();");
15998   verifyFormat("f<<<a, b, c, d>>>();");
15999   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
16000   verifyFormat("f<param><<<1, 1>>>();");
16001   verifyFormat("f<1><<<1, 1>>>();");
16002   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
16003   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16004                "aaaaaaaaaaa<<<\n    1, 1>>>();");
16005   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
16006                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
16007 }
16008 
16009 TEST_F(FormatTest, MergeLessLessAtEnd) {
16010   verifyFormat("<<");
16011   EXPECT_EQ("< < <", format("\\\n<<<"));
16012   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16013                "aaallvm::outs() <<");
16014   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16015                "aaaallvm::outs()\n    <<");
16016 }
16017 
16018 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
16019   std::string code = "#if A\n"
16020                      "#if B\n"
16021                      "a.\n"
16022                      "#endif\n"
16023                      "    a = 1;\n"
16024                      "#else\n"
16025                      "#endif\n"
16026                      "#if C\n"
16027                      "#else\n"
16028                      "#endif\n";
16029   EXPECT_EQ(code, format(code));
16030 }
16031 
16032 TEST_F(FormatTest, HandleConflictMarkers) {
16033   // Git/SVN conflict markers.
16034   EXPECT_EQ("int a;\n"
16035             "void f() {\n"
16036             "  callme(some(parameter1,\n"
16037             "<<<<<<< text by the vcs\n"
16038             "              parameter2),\n"
16039             "||||||| text by the vcs\n"
16040             "              parameter2),\n"
16041             "         parameter3,\n"
16042             "======= text by the vcs\n"
16043             "              parameter2, parameter3),\n"
16044             ">>>>>>> text by the vcs\n"
16045             "         otherparameter);\n",
16046             format("int a;\n"
16047                    "void f() {\n"
16048                    "  callme(some(parameter1,\n"
16049                    "<<<<<<< text by the vcs\n"
16050                    "  parameter2),\n"
16051                    "||||||| text by the vcs\n"
16052                    "  parameter2),\n"
16053                    "  parameter3,\n"
16054                    "======= text by the vcs\n"
16055                    "  parameter2,\n"
16056                    "  parameter3),\n"
16057                    ">>>>>>> text by the vcs\n"
16058                    "  otherparameter);\n"));
16059 
16060   // Perforce markers.
16061   EXPECT_EQ("void f() {\n"
16062             "  function(\n"
16063             ">>>> text by the vcs\n"
16064             "      parameter,\n"
16065             "==== text by the vcs\n"
16066             "      parameter,\n"
16067             "==== text by the vcs\n"
16068             "      parameter,\n"
16069             "<<<< text by the vcs\n"
16070             "      parameter);\n",
16071             format("void f() {\n"
16072                    "  function(\n"
16073                    ">>>> text by the vcs\n"
16074                    "  parameter,\n"
16075                    "==== text by the vcs\n"
16076                    "  parameter,\n"
16077                    "==== text by the vcs\n"
16078                    "  parameter,\n"
16079                    "<<<< text by the vcs\n"
16080                    "  parameter);\n"));
16081 
16082   EXPECT_EQ("<<<<<<<\n"
16083             "|||||||\n"
16084             "=======\n"
16085             ">>>>>>>",
16086             format("<<<<<<<\n"
16087                    "|||||||\n"
16088                    "=======\n"
16089                    ">>>>>>>"));
16090 
16091   EXPECT_EQ("<<<<<<<\n"
16092             "|||||||\n"
16093             "int i;\n"
16094             "=======\n"
16095             ">>>>>>>",
16096             format("<<<<<<<\n"
16097                    "|||||||\n"
16098                    "int i;\n"
16099                    "=======\n"
16100                    ">>>>>>>"));
16101 
16102   // FIXME: Handle parsing of macros around conflict markers correctly:
16103   EXPECT_EQ("#define Macro \\\n"
16104             "<<<<<<<\n"
16105             "Something \\\n"
16106             "|||||||\n"
16107             "Else \\\n"
16108             "=======\n"
16109             "Other \\\n"
16110             ">>>>>>>\n"
16111             "    End int i;\n",
16112             format("#define Macro \\\n"
16113                    "<<<<<<<\n"
16114                    "  Something \\\n"
16115                    "|||||||\n"
16116                    "  Else \\\n"
16117                    "=======\n"
16118                    "  Other \\\n"
16119                    ">>>>>>>\n"
16120                    "  End\n"
16121                    "int i;\n"));
16122 }
16123 
16124 TEST_F(FormatTest, DisableRegions) {
16125   EXPECT_EQ("int i;\n"
16126             "// clang-format off\n"
16127             "  int j;\n"
16128             "// clang-format on\n"
16129             "int k;",
16130             format(" int  i;\n"
16131                    "   // clang-format off\n"
16132                    "  int j;\n"
16133                    " // clang-format on\n"
16134                    "   int   k;"));
16135   EXPECT_EQ("int i;\n"
16136             "/* clang-format off */\n"
16137             "  int j;\n"
16138             "/* clang-format on */\n"
16139             "int k;",
16140             format(" int  i;\n"
16141                    "   /* clang-format off */\n"
16142                    "  int j;\n"
16143                    " /* clang-format on */\n"
16144                    "   int   k;"));
16145 
16146   // Don't reflow comments within disabled regions.
16147   EXPECT_EQ("// clang-format off\n"
16148             "// long long long long long long line\n"
16149             "/* clang-format on */\n"
16150             "/* long long long\n"
16151             " * long long long\n"
16152             " * line */\n"
16153             "int i;\n"
16154             "/* clang-format off */\n"
16155             "/* long long long long long long line */\n",
16156             format("// clang-format off\n"
16157                    "// long long long long long long line\n"
16158                    "/* clang-format on */\n"
16159                    "/* long long long long long long line */\n"
16160                    "int i;\n"
16161                    "/* clang-format off */\n"
16162                    "/* long long long long long long line */\n",
16163                    getLLVMStyleWithColumns(20)));
16164 }
16165 
16166 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
16167   format("? ) =");
16168   verifyNoCrash("#define a\\\n /**/}");
16169 }
16170 
16171 TEST_F(FormatTest, FormatsTableGenCode) {
16172   FormatStyle Style = getLLVMStyle();
16173   Style.Language = FormatStyle::LK_TableGen;
16174   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
16175 }
16176 
16177 TEST_F(FormatTest, ArrayOfTemplates) {
16178   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
16179             format("auto a = new unique_ptr<int > [ 10];"));
16180 
16181   FormatStyle Spaces = getLLVMStyle();
16182   Spaces.SpacesInSquareBrackets = true;
16183   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
16184             format("auto a = new unique_ptr<int > [10];", Spaces));
16185 }
16186 
16187 TEST_F(FormatTest, ArrayAsTemplateType) {
16188   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
16189             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
16190 
16191   FormatStyle Spaces = getLLVMStyle();
16192   Spaces.SpacesInSquareBrackets = true;
16193   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
16194             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
16195 }
16196 
16197 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
16198 
16199 TEST(FormatStyle, GetStyleWithEmptyFileName) {
16200   llvm::vfs::InMemoryFileSystem FS;
16201   auto Style1 = getStyle("file", "", "Google", "", &FS);
16202   ASSERT_TRUE((bool)Style1);
16203   ASSERT_EQ(*Style1, getGoogleStyle());
16204 }
16205 
16206 TEST(FormatStyle, GetStyleOfFile) {
16207   llvm::vfs::InMemoryFileSystem FS;
16208   // Test 1: format file in the same directory.
16209   ASSERT_TRUE(
16210       FS.addFile("/a/.clang-format", 0,
16211                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
16212   ASSERT_TRUE(
16213       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16214   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
16215   ASSERT_TRUE((bool)Style1);
16216   ASSERT_EQ(*Style1, getLLVMStyle());
16217 
16218   // Test 2.1: fallback to default.
16219   ASSERT_TRUE(
16220       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16221   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
16222   ASSERT_TRUE((bool)Style2);
16223   ASSERT_EQ(*Style2, getMozillaStyle());
16224 
16225   // Test 2.2: no format on 'none' fallback style.
16226   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16227   ASSERT_TRUE((bool)Style2);
16228   ASSERT_EQ(*Style2, getNoStyle());
16229 
16230   // Test 2.3: format if config is found with no based style while fallback is
16231   // 'none'.
16232   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
16233                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
16234   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16235   ASSERT_TRUE((bool)Style2);
16236   ASSERT_EQ(*Style2, getLLVMStyle());
16237 
16238   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
16239   Style2 = getStyle("{}", "a.h", "none", "", &FS);
16240   ASSERT_TRUE((bool)Style2);
16241   ASSERT_EQ(*Style2, getLLVMStyle());
16242 
16243   // Test 3: format file in parent directory.
16244   ASSERT_TRUE(
16245       FS.addFile("/c/.clang-format", 0,
16246                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
16247   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
16248                          llvm::MemoryBuffer::getMemBuffer("int i;")));
16249   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
16250   ASSERT_TRUE((bool)Style3);
16251   ASSERT_EQ(*Style3, getGoogleStyle());
16252 
16253   // Test 4: error on invalid fallback style
16254   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
16255   ASSERT_FALSE((bool)Style4);
16256   llvm::consumeError(Style4.takeError());
16257 
16258   // Test 5: error on invalid yaml on command line
16259   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
16260   ASSERT_FALSE((bool)Style5);
16261   llvm::consumeError(Style5.takeError());
16262 
16263   // Test 6: error on invalid style
16264   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
16265   ASSERT_FALSE((bool)Style6);
16266   llvm::consumeError(Style6.takeError());
16267 
16268   // Test 7: found config file, error on parsing it
16269   ASSERT_TRUE(
16270       FS.addFile("/d/.clang-format", 0,
16271                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
16272                                                   "InvalidKey: InvalidValue")));
16273   ASSERT_TRUE(
16274       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16275   auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
16276   ASSERT_FALSE((bool)Style7);
16277   llvm::consumeError(Style7.takeError());
16278 
16279   // Test 8: inferred per-language defaults apply.
16280   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
16281   ASSERT_TRUE((bool)StyleTd);
16282   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
16283 }
16284 
16285 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
16286   // Column limit is 20.
16287   std::string Code = "Type *a =\n"
16288                      "    new Type();\n"
16289                      "g(iiiii, 0, jjjjj,\n"
16290                      "  0, kkkkk, 0, mm);\n"
16291                      "int  bad     = format   ;";
16292   std::string Expected = "auto a = new Type();\n"
16293                          "g(iiiii, nullptr,\n"
16294                          "  jjjjj, nullptr,\n"
16295                          "  kkkkk, nullptr,\n"
16296                          "  mm);\n"
16297                          "int  bad     = format   ;";
16298   FileID ID = Context.createInMemoryFile("format.cpp", Code);
16299   tooling::Replacements Replaces = toReplacements(
16300       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
16301                             "auto "),
16302        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
16303                             "nullptr"),
16304        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
16305                             "nullptr"),
16306        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
16307                             "nullptr")});
16308 
16309   format::FormatStyle Style = format::getLLVMStyle();
16310   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
16311   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16312   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16313       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16314   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16315   EXPECT_TRUE(static_cast<bool>(Result));
16316   EXPECT_EQ(Expected, *Result);
16317 }
16318 
16319 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
16320   std::string Code = "#include \"a.h\"\n"
16321                      "#include \"c.h\"\n"
16322                      "\n"
16323                      "int main() {\n"
16324                      "  return 0;\n"
16325                      "}";
16326   std::string Expected = "#include \"a.h\"\n"
16327                          "#include \"b.h\"\n"
16328                          "#include \"c.h\"\n"
16329                          "\n"
16330                          "int main() {\n"
16331                          "  return 0;\n"
16332                          "}";
16333   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
16334   tooling::Replacements Replaces = toReplacements(
16335       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
16336                             "#include \"b.h\"\n")});
16337 
16338   format::FormatStyle Style = format::getLLVMStyle();
16339   Style.SortIncludes = true;
16340   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16341   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16342       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16343   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16344   EXPECT_TRUE(static_cast<bool>(Result));
16345   EXPECT_EQ(Expected, *Result);
16346 }
16347 
16348 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
16349   EXPECT_EQ("using std::cin;\n"
16350             "using std::cout;",
16351             format("using std::cout;\n"
16352                    "using std::cin;",
16353                    getGoogleStyle()));
16354 }
16355 
16356 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
16357   format::FormatStyle Style = format::getLLVMStyle();
16358   Style.Standard = FormatStyle::LS_Cpp03;
16359   // cpp03 recognize this string as identifier u8 and literal character 'a'
16360   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
16361 }
16362 
16363 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
16364   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
16365   // all modes, including C++11, C++14 and C++17
16366   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
16367 }
16368 
16369 TEST_F(FormatTest, DoNotFormatLikelyXml) {
16370   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
16371   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
16372 }
16373 
16374 TEST_F(FormatTest, StructuredBindings) {
16375   // Structured bindings is a C++17 feature.
16376   // all modes, including C++11, C++14 and C++17
16377   verifyFormat("auto [a, b] = f();");
16378   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
16379   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
16380   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
16381   EXPECT_EQ("auto const volatile [a, b] = f();",
16382             format("auto  const   volatile[a, b] = f();"));
16383   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
16384   EXPECT_EQ("auto &[a, b, c] = f();",
16385             format("auto   &[  a  ,  b,c   ] = f();"));
16386   EXPECT_EQ("auto &&[a, b, c] = f();",
16387             format("auto   &&[  a  ,  b,c   ] = f();"));
16388   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
16389   EXPECT_EQ("auto const volatile &&[a, b] = f();",
16390             format("auto  const  volatile  &&[a, b] = f();"));
16391   EXPECT_EQ("auto const &&[a, b] = f();",
16392             format("auto  const   &&  [a, b] = f();"));
16393   EXPECT_EQ("const auto &[a, b] = f();",
16394             format("const  auto  &  [a, b] = f();"));
16395   EXPECT_EQ("const auto volatile &&[a, b] = f();",
16396             format("const  auto   volatile  &&[a, b] = f();"));
16397   EXPECT_EQ("volatile const auto &&[a, b] = f();",
16398             format("volatile  const  auto   &&[a, b] = f();"));
16399   EXPECT_EQ("const auto &&[a, b] = f();",
16400             format("const  auto  &&  [a, b] = f();"));
16401 
16402   // Make sure we don't mistake structured bindings for lambdas.
16403   FormatStyle PointerMiddle = getLLVMStyle();
16404   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16405   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16406   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16407   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16408   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16409   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16410   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16411   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16412   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16413   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16414   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16415   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16416   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16417 
16418   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16419             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16420   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16421             format("for (const auto   &   [a, b] : some_range) {\n}"));
16422   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16423             format("for (const auto[a, b] : some_range) {\n}"));
16424   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16425   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16426   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16427   EXPECT_EQ("auto const &[x, y](expr);",
16428             format("auto  const  &  [x,y]  (expr);"));
16429   EXPECT_EQ("auto const &&[x, y](expr);",
16430             format("auto  const  &&  [x,y]  (expr);"));
16431   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16432   EXPECT_EQ("auto const &[x, y]{expr};",
16433             format("auto  const  &  [x,y]  {expr};"));
16434   EXPECT_EQ("auto const &&[x, y]{expr};",
16435             format("auto  const  &&  [x,y]  {expr};"));
16436 
16437   format::FormatStyle Spaces = format::getLLVMStyle();
16438   Spaces.SpacesInSquareBrackets = true;
16439   verifyFormat("auto [ a, b ] = f();", Spaces);
16440   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16441   verifyFormat("auto &[ a, b ] = f();", Spaces);
16442   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16443   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16444 }
16445 
16446 TEST_F(FormatTest, FileAndCode) {
16447   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16448   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16449   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16450   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16451   EXPECT_EQ(FormatStyle::LK_ObjC,
16452             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16453   EXPECT_EQ(
16454       FormatStyle::LK_ObjC,
16455       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16456   EXPECT_EQ(FormatStyle::LK_ObjC,
16457             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16458   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16459   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16460   EXPECT_EQ(FormatStyle::LK_ObjC,
16461             guessLanguage("foo", "@interface Foo\n@end\n"));
16462   EXPECT_EQ(FormatStyle::LK_ObjC,
16463             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16464   EXPECT_EQ(
16465       FormatStyle::LK_ObjC,
16466       guessLanguage("foo.h",
16467                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16468   EXPECT_EQ(
16469       FormatStyle::LK_Cpp,
16470       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16471 }
16472 
16473 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16474   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16475   EXPECT_EQ(FormatStyle::LK_ObjC,
16476             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16477   EXPECT_EQ(FormatStyle::LK_Cpp,
16478             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16479   EXPECT_EQ(
16480       FormatStyle::LK_Cpp,
16481       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16482   EXPECT_EQ(FormatStyle::LK_ObjC,
16483             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16484   EXPECT_EQ(FormatStyle::LK_Cpp,
16485             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16486   EXPECT_EQ(FormatStyle::LK_ObjC,
16487             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16488   EXPECT_EQ(FormatStyle::LK_Cpp,
16489             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16490   EXPECT_EQ(FormatStyle::LK_Cpp,
16491             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16492   EXPECT_EQ(FormatStyle::LK_ObjC,
16493             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16494   EXPECT_EQ(FormatStyle::LK_Cpp,
16495             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16496   EXPECT_EQ(
16497       FormatStyle::LK_Cpp,
16498       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16499   EXPECT_EQ(
16500       FormatStyle::LK_Cpp,
16501       guessLanguage("foo.h",
16502                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16503   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16504 }
16505 
16506 TEST_F(FormatTest, GuessLanguageWithCaret) {
16507   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16508   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16509   EXPECT_EQ(FormatStyle::LK_ObjC,
16510             guessLanguage("foo.h", "int(^)(char, float);"));
16511   EXPECT_EQ(FormatStyle::LK_ObjC,
16512             guessLanguage("foo.h", "int(^foo)(char, float);"));
16513   EXPECT_EQ(FormatStyle::LK_ObjC,
16514             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16515   EXPECT_EQ(FormatStyle::LK_ObjC,
16516             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16517   EXPECT_EQ(
16518       FormatStyle::LK_ObjC,
16519       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16520 }
16521 
16522 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16523   // ASM symbolic names are identifiers that must be surrounded by [] without
16524   // space in between:
16525   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16526 
16527   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16528   verifyFormat(R"(//
16529 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16530 )");
16531 
16532   // A list of several ASM symbolic names.
16533   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16534 
16535   // ASM symbolic names in inline ASM with inputs and outputs.
16536   verifyFormat(R"(//
16537 asm("cmoveq %1, %2, %[result]"
16538     : [result] "=r"(result)
16539     : "r"(test), "r"(new), "[result]"(old));
16540 )");
16541 
16542   // ASM symbolic names in inline ASM with no outputs.
16543   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16544 }
16545 
16546 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
16547   EXPECT_EQ(FormatStyle::LK_Cpp,
16548             guessLanguage("foo.h", "void f() {\n"
16549                                    "  asm (\"mov %[e], %[d]\"\n"
16550                                    "     : [d] \"=rm\" (d)\n"
16551                                    "       [e] \"rm\" (*e));\n"
16552                                    "}"));
16553   EXPECT_EQ(FormatStyle::LK_Cpp,
16554             guessLanguage("foo.h", "void f() {\n"
16555                                    "  _asm (\"mov %[e], %[d]\"\n"
16556                                    "     : [d] \"=rm\" (d)\n"
16557                                    "       [e] \"rm\" (*e));\n"
16558                                    "}"));
16559   EXPECT_EQ(FormatStyle::LK_Cpp,
16560             guessLanguage("foo.h", "void f() {\n"
16561                                    "  __asm (\"mov %[e], %[d]\"\n"
16562                                    "     : [d] \"=rm\" (d)\n"
16563                                    "       [e] \"rm\" (*e));\n"
16564                                    "}"));
16565   EXPECT_EQ(FormatStyle::LK_Cpp,
16566             guessLanguage("foo.h", "void f() {\n"
16567                                    "  __asm__ (\"mov %[e], %[d]\"\n"
16568                                    "     : [d] \"=rm\" (d)\n"
16569                                    "       [e] \"rm\" (*e));\n"
16570                                    "}"));
16571   EXPECT_EQ(FormatStyle::LK_Cpp,
16572             guessLanguage("foo.h", "void f() {\n"
16573                                    "  asm (\"mov %[e], %[d]\"\n"
16574                                    "     : [d] \"=rm\" (d),\n"
16575                                    "       [e] \"rm\" (*e));\n"
16576                                    "}"));
16577   EXPECT_EQ(FormatStyle::LK_Cpp,
16578             guessLanguage("foo.h", "void f() {\n"
16579                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16580                                    "     : [d] \"=rm\" (d)\n"
16581                                    "       [e] \"rm\" (*e));\n"
16582                                    "}"));
16583 }
16584 
16585 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16586   EXPECT_EQ(FormatStyle::LK_Cpp,
16587             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16588   EXPECT_EQ(FormatStyle::LK_ObjC,
16589             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16590   EXPECT_EQ(
16591       FormatStyle::LK_Cpp,
16592       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16593   EXPECT_EQ(
16594       FormatStyle::LK_ObjC,
16595       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16596 }
16597 
16598 TEST_F(FormatTest, TypenameMacros) {
16599   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16600 
16601   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16602   FormatStyle Google = getGoogleStyleWithColumns(0);
16603   Google.TypenameMacros = TypenameMacros;
16604   verifyFormat("struct foo {\n"
16605                "  int bar;\n"
16606                "  TAILQ_ENTRY(a) bleh;\n"
16607                "};",
16608                Google);
16609 
16610   FormatStyle Macros = getLLVMStyle();
16611   Macros.TypenameMacros = TypenameMacros;
16612 
16613   verifyFormat("STACK_OF(int) a;", Macros);
16614   verifyFormat("STACK_OF(int) *a;", Macros);
16615   verifyFormat("STACK_OF(int const *) *a;", Macros);
16616   verifyFormat("STACK_OF(int *const) *a;", Macros);
16617   verifyFormat("STACK_OF(int, string) a;", Macros);
16618   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16619   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16620   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16621   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16622   verifyFormat("vector<LIST(uint64_t) *attr> x;", Macros);
16623   verifyFormat("vector<LIST(uint64_t) *const> f(LIST(uint64_t) *arg);", Macros);
16624 
16625   Macros.PointerAlignment = FormatStyle::PAS_Left;
16626   verifyFormat("STACK_OF(int)* a;", Macros);
16627   verifyFormat("STACK_OF(int*)* a;", Macros);
16628   verifyFormat("x = (STACK_OF(uint64_t))*a;", Macros);
16629   verifyFormat("x = (STACK_OF(uint64_t))&a;", Macros);
16630   verifyFormat("vector<STACK_OF(uint64_t)* attr> x;", Macros);
16631 }
16632 
16633 TEST_F(FormatTest, AtomicQualifier) {
16634   // Check that we treate _Atomic as a type and not a function call
16635   FormatStyle Google = getGoogleStyleWithColumns(0);
16636   verifyFormat("struct foo {\n"
16637                "  int a1;\n"
16638                "  _Atomic(a) a2;\n"
16639                "  _Atomic(_Atomic(int) *const) a3;\n"
16640                "};",
16641                Google);
16642   verifyFormat("_Atomic(uint64_t) a;");
16643   verifyFormat("_Atomic(uint64_t) *a;");
16644   verifyFormat("_Atomic(uint64_t const *) *a;");
16645   verifyFormat("_Atomic(uint64_t *const) *a;");
16646   verifyFormat("_Atomic(const uint64_t *) *a;");
16647   verifyFormat("_Atomic(uint64_t) a;");
16648   verifyFormat("_Atomic(_Atomic(uint64_t)) a;");
16649   verifyFormat("_Atomic(_Atomic(uint64_t)) a, b;");
16650   verifyFormat("for (_Atomic(uint64_t) *a = NULL; a;) {\n}");
16651   verifyFormat("_Atomic(uint64_t) f(_Atomic(uint64_t) *arg);");
16652 
16653   verifyFormat("_Atomic(uint64_t) *s(InitValue);");
16654   verifyFormat("_Atomic(uint64_t) *s{InitValue};");
16655   FormatStyle Style = getLLVMStyle();
16656   Style.PointerAlignment = FormatStyle::PAS_Left;
16657   verifyFormat("_Atomic(uint64_t)* s(InitValue);", Style);
16658   verifyFormat("_Atomic(uint64_t)* s{InitValue};", Style);
16659   verifyFormat("_Atomic(int)* a;", Style);
16660   verifyFormat("_Atomic(int*)* a;", Style);
16661   verifyFormat("vector<_Atomic(uint64_t)* attr> x;", Style);
16662 
16663   Style.SpacesInCStyleCastParentheses = true;
16664   Style.SpacesInParentheses = false;
16665   verifyFormat("x = ( _Atomic(uint64_t) )*a;", Style);
16666   Style.SpacesInCStyleCastParentheses = false;
16667   Style.SpacesInParentheses = true;
16668   verifyFormat("x = (_Atomic( uint64_t ))*a;", Style);
16669   verifyFormat("x = (_Atomic( uint64_t ))&a;", Style);
16670 }
16671 
16672 TEST_F(FormatTest, AmbersandInLamda) {
16673   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16674   FormatStyle AlignStyle = getLLVMStyle();
16675   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16676   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16677   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16678   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16679 }
16680 
16681 TEST_F(FormatTest, SpacesInConditionalStatement) {
16682   FormatStyle Spaces = getLLVMStyle();
16683   Spaces.SpacesInConditionalStatement = true;
16684   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16685   verifyFormat("if ( !a )\n  return;", Spaces);
16686   verifyFormat("if ( a )\n  return;", Spaces);
16687   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16688   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16689   verifyFormat("while ( a )\n  return;", Spaces);
16690   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16691   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16692   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16693   // Check that space on the left of "::" is inserted as expected at beginning
16694   // of condition.
16695   verifyFormat("while ( ::func() )\n  return;", Spaces);
16696 }
16697 
16698 TEST_F(FormatTest, AlternativeOperators) {
16699   // Test case for ensuring alternate operators are not
16700   // combined with their right most neighbour.
16701   verifyFormat("int a and b;");
16702   verifyFormat("int a and_eq b;");
16703   verifyFormat("int a bitand b;");
16704   verifyFormat("int a bitor b;");
16705   verifyFormat("int a compl b;");
16706   verifyFormat("int a not b;");
16707   verifyFormat("int a not_eq b;");
16708   verifyFormat("int a or b;");
16709   verifyFormat("int a xor b;");
16710   verifyFormat("int a xor_eq b;");
16711   verifyFormat("return this not_eq bitand other;");
16712   verifyFormat("bool operator not_eq(const X bitand other)");
16713 
16714   verifyFormat("int a and 5;");
16715   verifyFormat("int a and_eq 5;");
16716   verifyFormat("int a bitand 5;");
16717   verifyFormat("int a bitor 5;");
16718   verifyFormat("int a compl 5;");
16719   verifyFormat("int a not 5;");
16720   verifyFormat("int a not_eq 5;");
16721   verifyFormat("int a or 5;");
16722   verifyFormat("int a xor 5;");
16723   verifyFormat("int a xor_eq 5;");
16724 
16725   verifyFormat("int a compl(5);");
16726   verifyFormat("int a not(5);");
16727 
16728   /* FIXME handle alternate tokens
16729    * https://en.cppreference.com/w/cpp/language/operator_alternative
16730   // alternative tokens
16731   verifyFormat("compl foo();");     //  ~foo();
16732   verifyFormat("foo() <%%>;");      // foo();
16733   verifyFormat("void foo() <%%>;"); // void foo(){}
16734   verifyFormat("int a <:1:>;");     // int a[1];[
16735   verifyFormat("%:define ABC abc"); // #define ABC abc
16736   verifyFormat("%:%:");             // ##
16737   */
16738 }
16739 
16740 TEST_F(FormatTest, STLWhileNotDefineChed) {
16741   verifyFormat("#if defined(while)\n"
16742                "#define while EMIT WARNING C4005\n"
16743                "#endif // while");
16744 }
16745 
16746 TEST_F(FormatTest, OperatorSpacing) {
16747   FormatStyle Style = getLLVMStyle();
16748   Style.PointerAlignment = FormatStyle::PAS_Right;
16749   verifyFormat("Foo::operator*();", Style);
16750   verifyFormat("Foo::operator void *();", Style);
16751   verifyFormat("Foo::operator void **();", Style);
16752   verifyFormat("Foo::operator void *&();", Style);
16753   verifyFormat("Foo::operator void *&&();", Style);
16754   verifyFormat("Foo::operator()(void *);", Style);
16755   verifyFormat("Foo::operator*(void *);", Style);
16756   verifyFormat("Foo::operator*();", Style);
16757   verifyFormat("Foo::operator**();", Style);
16758   verifyFormat("Foo::operator&();", Style);
16759   verifyFormat("Foo::operator<int> *();", Style);
16760   verifyFormat("Foo::operator<Foo> *();", Style);
16761   verifyFormat("Foo::operator<int> **();", Style);
16762   verifyFormat("Foo::operator<Foo> **();", Style);
16763   verifyFormat("Foo::operator<int> &();", Style);
16764   verifyFormat("Foo::operator<Foo> &();", Style);
16765   verifyFormat("Foo::operator<int> &&();", Style);
16766   verifyFormat("Foo::operator<Foo> &&();", Style);
16767   verifyFormat("Foo::operator<int> *&();", Style);
16768   verifyFormat("Foo::operator<Foo> *&();", Style);
16769   verifyFormat("Foo::operator<int> *&&();", Style);
16770   verifyFormat("Foo::operator<Foo> *&&();", Style);
16771   verifyFormat("operator*(int (*)(), class Foo);", Style);
16772 
16773   verifyFormat("Foo::operator&();", Style);
16774   verifyFormat("Foo::operator void &();", Style);
16775   verifyFormat("Foo::operator()(void &);", Style);
16776   verifyFormat("Foo::operator&(void &);", Style);
16777   verifyFormat("Foo::operator&();", Style);
16778   verifyFormat("operator&(int (&)(), class Foo);", Style);
16779 
16780   verifyFormat("Foo::operator&&();", Style);
16781   verifyFormat("Foo::operator**();", Style);
16782   verifyFormat("Foo::operator void &&();", Style);
16783   verifyFormat("Foo::operator()(void &&);", Style);
16784   verifyFormat("Foo::operator&&(void &&);", Style);
16785   verifyFormat("Foo::operator&&();", Style);
16786   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16787   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16788   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16789                Style);
16790   verifyFormat("operator void **()", Style);
16791   verifyFormat("operator const FooRight<Object> &()", Style);
16792   verifyFormat("operator const FooRight<Object> *()", Style);
16793   verifyFormat("operator const FooRight<Object> **()", Style);
16794   verifyFormat("operator const FooRight<Object> *&()", Style);
16795   verifyFormat("operator const FooRight<Object> *&&()", Style);
16796 
16797   Style.PointerAlignment = FormatStyle::PAS_Left;
16798   verifyFormat("Foo::operator*();", Style);
16799   verifyFormat("Foo::operator**();", Style);
16800   verifyFormat("Foo::operator void*();", Style);
16801   verifyFormat("Foo::operator void**();", Style);
16802   verifyFormat("Foo::operator void*&();", Style);
16803   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16804   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16805   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16806   verifyFormat("Foo::operator()(void*);", Style);
16807   verifyFormat("Foo::operator*(void*);", Style);
16808   verifyFormat("Foo::operator*();", Style);
16809   verifyFormat("Foo::operator<int>*();", Style);
16810   verifyFormat("Foo::operator<Foo>*();", Style);
16811   verifyFormat("Foo::operator<int>**();", Style);
16812   verifyFormat("Foo::operator<Foo>**();", Style);
16813   verifyFormat("Foo::operator<Foo>*&();", Style);
16814   verifyFormat("Foo::operator<int>&();", Style);
16815   verifyFormat("Foo::operator<Foo>&();", Style);
16816   verifyFormat("Foo::operator<int>&&();", Style);
16817   verifyFormat("Foo::operator<Foo>&&();", Style);
16818   verifyFormat("Foo::operator<int>*&();", Style);
16819   verifyFormat("Foo::operator<Foo>*&();", Style);
16820   verifyFormat("operator*(int (*)(), class Foo);", Style);
16821 
16822   verifyFormat("Foo::operator&();", Style);
16823   verifyFormat("Foo::operator void&();", Style);
16824   verifyFormat("Foo::operator/*comment*/ void&();", Style);
16825   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
16826   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
16827   verifyFormat("Foo::operator()(void&);", Style);
16828   verifyFormat("Foo::operator&(void&);", Style);
16829   verifyFormat("Foo::operator&();", Style);
16830   verifyFormat("operator&(int (&)(), class Foo);", Style);
16831 
16832   verifyFormat("Foo::operator&&();", Style);
16833   verifyFormat("Foo::operator void&&();", Style);
16834   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
16835   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
16836   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
16837   verifyFormat("Foo::operator()(void&&);", Style);
16838   verifyFormat("Foo::operator&&(void&&);", Style);
16839   verifyFormat("Foo::operator&&();", Style);
16840   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16841   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
16842   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
16843                Style);
16844   verifyFormat("operator void**()", Style);
16845   verifyFormat("operator const FooLeft<Object>&()", Style);
16846   verifyFormat("operator const FooLeft<Object>*()", Style);
16847   verifyFormat("operator const FooLeft<Object>**()", Style);
16848   verifyFormat("operator const FooLeft<Object>*&()", Style);
16849   verifyFormat("operator const FooLeft<Object>*&&()", Style);
16850 
16851   // PR45107
16852   verifyFormat("operator Vector<String>&();", Style);
16853   verifyFormat("operator const Vector<String>&();", Style);
16854   verifyFormat("operator foo::Bar*();", Style);
16855   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
16856   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
16857                Style);
16858 
16859   Style.PointerAlignment = FormatStyle::PAS_Middle;
16860   verifyFormat("Foo::operator*();", Style);
16861   verifyFormat("Foo::operator void *();", Style);
16862   verifyFormat("Foo::operator()(void *);", Style);
16863   verifyFormat("Foo::operator*(void *);", Style);
16864   verifyFormat("Foo::operator*();", Style);
16865   verifyFormat("operator*(int (*)(), class Foo);", Style);
16866 
16867   verifyFormat("Foo::operator&();", Style);
16868   verifyFormat("Foo::operator void &();", Style);
16869   verifyFormat("Foo::operator()(void &);", Style);
16870   verifyFormat("Foo::operator&(void &);", Style);
16871   verifyFormat("Foo::operator&();", Style);
16872   verifyFormat("operator&(int (&)(), class Foo);", Style);
16873 
16874   verifyFormat("Foo::operator&&();", Style);
16875   verifyFormat("Foo::operator void &&();", Style);
16876   verifyFormat("Foo::operator()(void &&);", Style);
16877   verifyFormat("Foo::operator&&(void &&);", Style);
16878   verifyFormat("Foo::operator&&();", Style);
16879   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16880 }
16881 
16882 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
16883   FormatStyle Style = getLLVMStyle();
16884   // PR46157
16885   verifyFormat("foo(operator+, -42);", Style);
16886   verifyFormat("foo(operator++, -42);", Style);
16887   verifyFormat("foo(operator--, -42);", Style);
16888   verifyFormat("foo(-42, operator--);", Style);
16889   verifyFormat("foo(-42, operator, );", Style);
16890   verifyFormat("foo(operator, , -42);", Style);
16891 }
16892 
16893 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
16894   FormatStyle Style = getLLVMStyle();
16895   Style.WhitespaceSensitiveMacros.push_back("FOO");
16896 
16897   // Don't use the helpers here, since 'mess up' will change the whitespace
16898   // and these are all whitespace sensitive by definition
16899   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
16900             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
16901   EXPECT_EQ(
16902       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
16903       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
16904   EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
16905             format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
16906   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
16907             "       Still=Intentional);",
16908             format("FOO(String-ized&Messy+But,: :\n"
16909                    "       Still=Intentional);",
16910                    Style));
16911   Style.AlignConsecutiveAssignments = true;
16912   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
16913             "       Still=Intentional);",
16914             format("FOO(String-ized=&Messy+But,: :\n"
16915                    "       Still=Intentional);",
16916                    Style));
16917 
16918   Style.ColumnLimit = 21;
16919   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
16920             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
16921 }
16922 
16923 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
16924   // These tests are not in NamespaceFixer because that doesn't
16925   // test its interaction with line wrapping
16926   FormatStyle Style = getLLVMStyle();
16927   Style.ColumnLimit = 80;
16928   verifyFormat("namespace {\n"
16929                "int i;\n"
16930                "int j;\n"
16931                "} // namespace",
16932                Style);
16933 
16934   verifyFormat("namespace AAA {\n"
16935                "int i;\n"
16936                "int j;\n"
16937                "} // namespace AAA",
16938                Style);
16939 
16940   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
16941             "int i;\n"
16942             "int j;\n"
16943             "} // namespace Averyveryveryverylongnamespace",
16944             format("namespace Averyveryveryverylongnamespace {\n"
16945                    "int i;\n"
16946                    "int j;\n"
16947                    "}",
16948                    Style));
16949 
16950   EXPECT_EQ(
16951       "namespace "
16952       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16953       "    went::mad::now {\n"
16954       "int i;\n"
16955       "int j;\n"
16956       "} // namespace\n"
16957       "  // "
16958       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16959       "went::mad::now",
16960       format("namespace "
16961              "would::it::save::you::a::lot::of::time::if_::i::"
16962              "just::gave::up::and_::went::mad::now {\n"
16963              "int i;\n"
16964              "int j;\n"
16965              "}",
16966              Style));
16967 
16968   // This used to duplicate the comment again and again on subsequent runs
16969   EXPECT_EQ(
16970       "namespace "
16971       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16972       "    went::mad::now {\n"
16973       "int i;\n"
16974       "int j;\n"
16975       "} // namespace\n"
16976       "  // "
16977       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16978       "went::mad::now",
16979       format("namespace "
16980              "would::it::save::you::a::lot::of::time::if_::i::"
16981              "just::gave::up::and_::went::mad::now {\n"
16982              "int i;\n"
16983              "int j;\n"
16984              "} // namespace\n"
16985              "  // "
16986              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
16987              "and_::went::mad::now",
16988              Style));
16989 }
16990 
16991 TEST_F(FormatTest, LikelyUnlikely) {
16992   FormatStyle Style = getLLVMStyle();
16993 
16994   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16995                "  return 29;\n"
16996                "}",
16997                Style);
16998 
16999   verifyFormat("if (argc > 5) [[likely]] {\n"
17000                "  return 29;\n"
17001                "}",
17002                Style);
17003 
17004   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17005                "  return 29;\n"
17006                "} else [[likely]] {\n"
17007                "  return 42;\n"
17008                "}\n",
17009                Style);
17010 
17011   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17012                "  return 29;\n"
17013                "} else if (argc > 10) [[likely]] {\n"
17014                "  return 99;\n"
17015                "} else {\n"
17016                "  return 42;\n"
17017                "}\n",
17018                Style);
17019 
17020   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
17021                "  return 29;\n"
17022                "}",
17023                Style);
17024 }
17025 
17026 TEST_F(FormatTest, LLVMDefaultStyle) {
17027   FormatStyle Style = getLLVMStyle();
17028   verifyFormat("extern \"C\" {\n"
17029                "int foo();\n"
17030                "}",
17031                Style);
17032 }
17033 TEST_F(FormatTest, GNUDefaultStyle) {
17034   FormatStyle Style = getGNUStyle();
17035   verifyFormat("extern \"C\"\n"
17036                "{\n"
17037                "  int foo ();\n"
17038                "}",
17039                Style);
17040 }
17041 TEST_F(FormatTest, MozillaDefaultStyle) {
17042   FormatStyle Style = getMozillaStyle();
17043   verifyFormat("extern \"C\"\n"
17044                "{\n"
17045                "  int foo();\n"
17046                "}",
17047                Style);
17048 }
17049 TEST_F(FormatTest, GoogleDefaultStyle) {
17050   FormatStyle Style = getGoogleStyle();
17051   verifyFormat("extern \"C\" {\n"
17052                "int foo();\n"
17053                "}",
17054                Style);
17055 }
17056 TEST_F(FormatTest, ChromiumDefaultStyle) {
17057   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
17058   verifyFormat("extern \"C\" {\n"
17059                "int foo();\n"
17060                "}",
17061                Style);
17062 }
17063 TEST_F(FormatTest, MicrosoftDefaultStyle) {
17064   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
17065   verifyFormat("extern \"C\"\n"
17066                "{\n"
17067                "    int foo();\n"
17068                "}",
17069                Style);
17070 }
17071 TEST_F(FormatTest, WebKitDefaultStyle) {
17072   FormatStyle Style = getWebKitStyle();
17073   verifyFormat("extern \"C\" {\n"
17074                "int foo();\n"
17075                "}",
17076                Style);
17077 }
17078 } // namespace
17079 } // namespace format
17080 } // namespace clang
17081