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 
24 namespace clang {
25 namespace format {
26 namespace {
27 
28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
29 
30 class FormatTest : public ::testing::Test {
31 protected:
32   enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck };
33 
34   std::string format(llvm::StringRef Code,
35                      const FormatStyle &Style = getLLVMStyle(),
36                      StatusCheck CheckComplete = SC_ExpectComplete) {
37     LLVM_DEBUG(llvm::errs() << "---\n");
38     LLVM_DEBUG(llvm::errs() << Code << "\n\n");
39     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
40     FormattingAttemptStatus Status;
41     tooling::Replacements Replaces =
42         reformat(Style, Code, Ranges, "<stdin>", &Status);
43     if (CheckComplete != SC_DoNotCheck) {
44       bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete;
45       EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
46           << Code << "\n\n";
47     }
48     ReplacementCount = Replaces.size();
49     auto Result = applyAllReplacements(Code, Replaces);
50     EXPECT_TRUE(static_cast<bool>(Result));
51     LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
52     return *Result;
53   }
54 
55   FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) {
56     Style.ColumnLimit = ColumnLimit;
57     return Style;
58   }
59 
60   FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
61     return getStyleWithColumns(getLLVMStyle(), ColumnLimit);
62   }
63 
64   FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
65     return getStyleWithColumns(getGoogleStyle(), ColumnLimit);
66   }
67 
68   void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code,
69                     const FormatStyle &Style = getLLVMStyle()) {
70     EXPECT_EQ(Expected.str(), format(Expected, Style))
71         << "Expected code is not stable";
72     EXPECT_EQ(Expected.str(), format(Code, Style));
73     if (Style.Language == FormatStyle::LK_Cpp) {
74       // Objective-C++ is a superset of C++, so everything checked for C++
75       // needs to be checked for Objective-C++ as well.
76       FormatStyle ObjCStyle = Style;
77       ObjCStyle.Language = FormatStyle::LK_ObjC;
78       EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
79     }
80   }
81 
82   void verifyFormat(llvm::StringRef Code,
83                     const FormatStyle &Style = getLLVMStyle()) {
84     verifyFormat(Code, test::messUp(Code), Style);
85   }
86 
87   void verifyIncompleteFormat(llvm::StringRef Code,
88                               const FormatStyle &Style = getLLVMStyle()) {
89     EXPECT_EQ(Code.str(),
90               format(test::messUp(Code), Style, SC_ExpectIncomplete));
91   }
92 
93   void verifyGoogleFormat(llvm::StringRef Code) {
94     verifyFormat(Code, getGoogleStyle());
95   }
96 
97   void verifyIndependentOfContext(llvm::StringRef text) {
98     verifyFormat(text);
99     verifyFormat(llvm::Twine("void f() { " + text + " }").str());
100   }
101 
102   /// \brief Verify that clang-format does not crash on the given input.
103   void verifyNoCrash(llvm::StringRef Code,
104                      const FormatStyle &Style = getLLVMStyle()) {
105     format(Code, Style, SC_DoNotCheck);
106   }
107 
108   int ReplacementCount;
109 };
110 
111 TEST_F(FormatTest, MessUp) {
112   EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
113   EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
114   EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
115   EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
116   EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
117 }
118 
119 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) {
120   EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language);
121 }
122 
123 TEST_F(FormatTest, LLVMStyleOverride) {
124   EXPECT_EQ(FormatStyle::LK_Proto,
125             getLLVMStyle(FormatStyle::LK_Proto).Language);
126 }
127 
128 //===----------------------------------------------------------------------===//
129 // Basic function tests.
130 //===----------------------------------------------------------------------===//
131 
132 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
133   EXPECT_EQ(";", format(";"));
134 }
135 
136 TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
137   EXPECT_EQ("int i;", format("  int i;"));
138   EXPECT_EQ("\nint i;", format(" \n\t \v \f  int i;"));
139   EXPECT_EQ("int i;\nint j;", format("    int i; int j;"));
140   EXPECT_EQ("int i;\nint j;", format("    int i;\n  int j;"));
141 }
142 
143 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
144   EXPECT_EQ("int i;", format("int\ni;"));
145 }
146 
147 TEST_F(FormatTest, FormatsNestedBlockStatements) {
148   EXPECT_EQ("{\n  {\n    {}\n  }\n}", format("{{{}}}"));
149 }
150 
151 TEST_F(FormatTest, FormatsNestedCall) {
152   verifyFormat("Method(f1, f2(f3));");
153   verifyFormat("Method(f1(f2, f3()));");
154   verifyFormat("Method(f1(f2, (f3())));");
155 }
156 
157 TEST_F(FormatTest, NestedNameSpecifiers) {
158   verifyFormat("vector<::Type> v;");
159   verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
160   verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
161   verifyFormat("bool a = 2 < ::SomeFunction();");
162   verifyFormat("ALWAYS_INLINE ::std::string getName();");
163   verifyFormat("some::string getName();");
164 }
165 
166 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
167   EXPECT_EQ("if (a) {\n"
168             "  f();\n"
169             "}",
170             format("if(a){f();}"));
171   EXPECT_EQ(4, ReplacementCount);
172   EXPECT_EQ("if (a) {\n"
173             "  f();\n"
174             "}",
175             format("if (a) {\n"
176                    "  f();\n"
177                    "}"));
178   EXPECT_EQ(0, ReplacementCount);
179   EXPECT_EQ("/*\r\n"
180             "\r\n"
181             "*/\r\n",
182             format("/*\r\n"
183                    "\r\n"
184                    "*/\r\n"));
185   EXPECT_EQ(0, ReplacementCount);
186 }
187 
188 TEST_F(FormatTest, RemovesEmptyLines) {
189   EXPECT_EQ("class C {\n"
190             "  int i;\n"
191             "};",
192             format("class C {\n"
193                    " int i;\n"
194                    "\n"
195                    "};"));
196 
197   // Don't remove empty lines at the start of namespaces or extern "C" blocks.
198   EXPECT_EQ("namespace N {\n"
199             "\n"
200             "int i;\n"
201             "}",
202             format("namespace N {\n"
203                    "\n"
204                    "int    i;\n"
205                    "}",
206                    getGoogleStyle()));
207   EXPECT_EQ("/* something */ namespace N {\n"
208             "\n"
209             "int i;\n"
210             "}",
211             format("/* something */ namespace N {\n"
212                    "\n"
213                    "int    i;\n"
214                    "}",
215                    getGoogleStyle()));
216   EXPECT_EQ("inline namespace N {\n"
217             "\n"
218             "int i;\n"
219             "}",
220             format("inline namespace N {\n"
221                    "\n"
222                    "int    i;\n"
223                    "}",
224                    getGoogleStyle()));
225   EXPECT_EQ("/* something */ inline namespace N {\n"
226             "\n"
227             "int i;\n"
228             "}",
229             format("/* something */ inline namespace N {\n"
230                    "\n"
231                    "int    i;\n"
232                    "}",
233                    getGoogleStyle()));
234   EXPECT_EQ("export namespace N {\n"
235             "\n"
236             "int i;\n"
237             "}",
238             format("export namespace N {\n"
239                    "\n"
240                    "int    i;\n"
241                    "}",
242                    getGoogleStyle()));
243   EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
244             "\n"
245             "int i;\n"
246             "}",
247             format("extern /**/ \"C\" /**/ {\n"
248                    "\n"
249                    "int    i;\n"
250                    "}",
251                    getGoogleStyle()));
252 
253   // ...but do keep inlining and removing empty lines for non-block extern "C"
254   // functions.
255   verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
256   EXPECT_EQ("extern \"C\" int f() {\n"
257             "  int i = 42;\n"
258             "  return i;\n"
259             "}",
260             format("extern \"C\" int f() {\n"
261                    "\n"
262                    "  int i = 42;\n"
263                    "  return i;\n"
264                    "}",
265                    getGoogleStyle()));
266 
267   // Remove empty lines at the beginning and end of blocks.
268   EXPECT_EQ("void f() {\n"
269             "\n"
270             "  if (a) {\n"
271             "\n"
272             "    f();\n"
273             "  }\n"
274             "}",
275             format("void f() {\n"
276                    "\n"
277                    "  if (a) {\n"
278                    "\n"
279                    "    f();\n"
280                    "\n"
281                    "  }\n"
282                    "\n"
283                    "}",
284                    getLLVMStyle()));
285   EXPECT_EQ("void f() {\n"
286             "  if (a) {\n"
287             "    f();\n"
288             "  }\n"
289             "}",
290             format("void f() {\n"
291                    "\n"
292                    "  if (a) {\n"
293                    "\n"
294                    "    f();\n"
295                    "\n"
296                    "  }\n"
297                    "\n"
298                    "}",
299                    getGoogleStyle()));
300 
301   // Don't remove empty lines in more complex control statements.
302   EXPECT_EQ("void f() {\n"
303             "  if (a) {\n"
304             "    f();\n"
305             "\n"
306             "  } else if (b) {\n"
307             "    f();\n"
308             "  }\n"
309             "}",
310             format("void f() {\n"
311                    "  if (a) {\n"
312                    "    f();\n"
313                    "\n"
314                    "  } else if (b) {\n"
315                    "    f();\n"
316                    "\n"
317                    "  }\n"
318                    "\n"
319                    "}"));
320 
321   // Don't remove empty lines before namespace endings.
322   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
323   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
324   EXPECT_EQ("namespace {\n"
325             "int i;\n"
326             "\n"
327             "}",
328             format("namespace {\n"
329                    "int i;\n"
330                    "\n"
331                    "}",
332                    LLVMWithNoNamespaceFix));
333   EXPECT_EQ("namespace {\n"
334             "int i;\n"
335             "}",
336             format("namespace {\n"
337                    "int i;\n"
338                    "}",
339                    LLVMWithNoNamespaceFix));
340   EXPECT_EQ("namespace {\n"
341             "int i;\n"
342             "\n"
343             "};",
344             format("namespace {\n"
345                    "int i;\n"
346                    "\n"
347                    "};",
348                    LLVMWithNoNamespaceFix));
349   EXPECT_EQ("namespace {\n"
350             "int i;\n"
351             "};",
352             format("namespace {\n"
353                    "int i;\n"
354                    "};",
355                    LLVMWithNoNamespaceFix));
356   EXPECT_EQ("namespace {\n"
357             "int i;\n"
358             "\n"
359             "}",
360             format("namespace {\n"
361                    "int i;\n"
362                    "\n"
363                    "}"));
364   EXPECT_EQ("namespace {\n"
365             "int i;\n"
366             "\n"
367             "} // namespace",
368             format("namespace {\n"
369                    "int i;\n"
370                    "\n"
371                    "}  // namespace"));
372 
373   FormatStyle Style = getLLVMStyle();
374   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
375   Style.MaxEmptyLinesToKeep = 2;
376   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
377   Style.BraceWrapping.AfterClass = true;
378   Style.BraceWrapping.AfterFunction = true;
379   Style.KeepEmptyLinesAtTheStartOfBlocks = false;
380 
381   EXPECT_EQ("class Foo\n"
382             "{\n"
383             "  Foo() {}\n"
384             "\n"
385             "  void funk() {}\n"
386             "};",
387             format("class Foo\n"
388                    "{\n"
389                    "  Foo()\n"
390                    "  {\n"
391                    "  }\n"
392                    "\n"
393                    "  void funk() {}\n"
394                    "};",
395                    Style));
396 }
397 
398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
399   verifyFormat("x = (a) and (b);");
400   verifyFormat("x = (a) or (b);");
401   verifyFormat("x = (a) bitand (b);");
402   verifyFormat("x = (a) bitor (b);");
403   verifyFormat("x = (a) not_eq (b);");
404   verifyFormat("x = (a) and_eq (b);");
405   verifyFormat("x = (a) or_eq (b);");
406   verifyFormat("x = (a) xor (b);");
407 }
408 
409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) {
410   verifyFormat("x = compl(a);");
411   verifyFormat("x = not(a);");
412   verifyFormat("x = bitand(a);");
413   // Unary operator must not be merged with the next identifier
414   verifyFormat("x = compl a;");
415   verifyFormat("x = not a;");
416   verifyFormat("x = bitand a;");
417 }
418 
419 //===----------------------------------------------------------------------===//
420 // Tests for control statements.
421 //===----------------------------------------------------------------------===//
422 
423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
424   verifyFormat("if (true)\n  f();\ng();");
425   verifyFormat("if (a)\n  if (b)\n    if (c)\n      g();\nh();");
426   verifyFormat("if (a)\n  if (b) {\n    f();\n  }\ng();");
427   verifyFormat("if constexpr (true)\n"
428                "  f();\ng();");
429   verifyFormat("if CONSTEXPR (true)\n"
430                "  f();\ng();");
431   verifyFormat("if constexpr (a)\n"
432                "  if constexpr (b)\n"
433                "    if constexpr (c)\n"
434                "      g();\n"
435                "h();");
436   verifyFormat("if CONSTEXPR (a)\n"
437                "  if CONSTEXPR (b)\n"
438                "    if CONSTEXPR (c)\n"
439                "      g();\n"
440                "h();");
441   verifyFormat("if constexpr (a)\n"
442                "  if constexpr (b) {\n"
443                "    f();\n"
444                "  }\n"
445                "g();");
446   verifyFormat("if CONSTEXPR (a)\n"
447                "  if CONSTEXPR (b) {\n"
448                "    f();\n"
449                "  }\n"
450                "g();");
451 
452   FormatStyle AllowsMergedIf = getLLVMStyle();
453   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
454   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
455       FormatStyle::SIS_WithoutElse;
456   verifyFormat("if (a)\n"
457                "  // comment\n"
458                "  f();",
459                AllowsMergedIf);
460   verifyFormat("{\n"
461                "  if (a)\n"
462                "  label:\n"
463                "    f();\n"
464                "}",
465                AllowsMergedIf);
466   verifyFormat("#define A \\\n"
467                "  if (a)  \\\n"
468                "  label:  \\\n"
469                "    f()",
470                AllowsMergedIf);
471   verifyFormat("if (a)\n"
472                "  ;",
473                AllowsMergedIf);
474   verifyFormat("if (a)\n"
475                "  if (b) return;",
476                AllowsMergedIf);
477 
478   verifyFormat("if (a) // Can't merge this\n"
479                "  f();\n",
480                AllowsMergedIf);
481   verifyFormat("if (a) /* still don't merge */\n"
482                "  f();",
483                AllowsMergedIf);
484   verifyFormat("if (a) { // Never merge this\n"
485                "  f();\n"
486                "}",
487                AllowsMergedIf);
488   verifyFormat("if (a) { /* Never merge this */\n"
489                "  f();\n"
490                "}",
491                AllowsMergedIf);
492 
493   AllowsMergedIf.ColumnLimit = 14;
494   verifyFormat("if (a) return;", AllowsMergedIf);
495   verifyFormat("if (aaaaaaaaa)\n"
496                "  return;",
497                AllowsMergedIf);
498 
499   AllowsMergedIf.ColumnLimit = 13;
500   verifyFormat("if (a)\n  return;", AllowsMergedIf);
501 }
502 
503 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) {
504   FormatStyle AllowsMergedIf = getLLVMStyle();
505   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
506   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
507       FormatStyle::SIS_WithoutElse;
508   verifyFormat("if (a)\n"
509                "  f();\n"
510                "else {\n"
511                "  g();\n"
512                "}",
513                AllowsMergedIf);
514   verifyFormat("if (a)\n"
515                "  f();\n"
516                "else\n"
517                "  g();\n",
518                AllowsMergedIf);
519 
520   AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
521 
522   verifyFormat("if (a) f();\n"
523                "else {\n"
524                "  g();\n"
525                "}",
526                AllowsMergedIf);
527   verifyFormat("if (a) f();\n"
528                "else {\n"
529                "  if (a) f();\n"
530                "  else {\n"
531                "    g();\n"
532                "  }\n"
533                "  g();\n"
534                "}",
535                AllowsMergedIf);
536 }
537 
538 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
539   FormatStyle AllowsMergedLoops = getLLVMStyle();
540   AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
541   verifyFormat("while (true) continue;", AllowsMergedLoops);
542   verifyFormat("for (;;) continue;", AllowsMergedLoops);
543   verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
544   verifyFormat("while (true)\n"
545                "  ;",
546                AllowsMergedLoops);
547   verifyFormat("for (;;)\n"
548                "  ;",
549                AllowsMergedLoops);
550   verifyFormat("for (;;)\n"
551                "  for (;;) continue;",
552                AllowsMergedLoops);
553   verifyFormat("for (;;) // Can't merge this\n"
554                "  continue;",
555                AllowsMergedLoops);
556   verifyFormat("for (;;) /* still don't merge */\n"
557                "  continue;",
558                AllowsMergedLoops);
559   verifyFormat("do a++;\n"
560                "while (true);",
561                AllowsMergedLoops);
562   verifyFormat("do /* Don't merge */\n"
563                "  a++;\n"
564                "while (true);",
565                AllowsMergedLoops);
566   verifyFormat("do // Don't merge\n"
567                "  a++;\n"
568                "while (true);",
569                AllowsMergedLoops);
570   verifyFormat("do\n"
571                "  // Don't merge\n"
572                "  a++;\n"
573                "while (true);",
574                AllowsMergedLoops);
575   // Without braces labels are interpreted differently.
576   verifyFormat("{\n"
577                "  do\n"
578                "  label:\n"
579                "    a++;\n"
580                "  while (true);\n"
581                "}",
582                AllowsMergedLoops);
583 }
584 
585 TEST_F(FormatTest, FormatShortBracedStatements) {
586   FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
587   AllowSimpleBracedStatements.ColumnLimit = 40;
588   AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine =
589       FormatStyle::SBS_Always;
590 
591   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
592       FormatStyle::SIS_WithoutElse;
593   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
594 
595   AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom;
596   AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true;
597   AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false;
598 
599   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
600   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
601   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
602   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
603   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
604   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
605   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
606   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
607   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
608   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
609   verifyFormat("if (true) {\n"
610                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
611                "}",
612                AllowSimpleBracedStatements);
613   verifyFormat("if (true) { //\n"
614                "  f();\n"
615                "}",
616                AllowSimpleBracedStatements);
617   verifyFormat("if (true) {\n"
618                "  f();\n"
619                "  f();\n"
620                "}",
621                AllowSimpleBracedStatements);
622   verifyFormat("if (true) {\n"
623                "  f();\n"
624                "} else {\n"
625                "  f();\n"
626                "}",
627                AllowSimpleBracedStatements);
628 
629   verifyFormat("struct A2 {\n"
630                "  int X;\n"
631                "};",
632                AllowSimpleBracedStatements);
633   verifyFormat("typedef struct A2 {\n"
634                "  int X;\n"
635                "} A2_t;",
636                AllowSimpleBracedStatements);
637   verifyFormat("template <int> struct A2 {\n"
638                "  struct B {};\n"
639                "};",
640                AllowSimpleBracedStatements);
641 
642   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
643       FormatStyle::SIS_Never;
644   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
645   verifyFormat("if (true) {\n"
646                "  f();\n"
647                "}",
648                AllowSimpleBracedStatements);
649   verifyFormat("if (true) {\n"
650                "  f();\n"
651                "} else {\n"
652                "  f();\n"
653                "}",
654                AllowSimpleBracedStatements);
655 
656   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
657   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
658   verifyFormat("while (true) {\n"
659                "  f();\n"
660                "}",
661                AllowSimpleBracedStatements);
662   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
663   verifyFormat("for (;;) {\n"
664                "  f();\n"
665                "}",
666                AllowSimpleBracedStatements);
667 
668   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
669       FormatStyle::SIS_WithoutElse;
670   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
671   AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement =
672       FormatStyle::BWACS_Always;
673 
674   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
675   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
676   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
677   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
678   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
679   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
680   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
681   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
682   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
683   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
684   verifyFormat("if (true)\n"
685                "{\n"
686                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
687                "}",
688                AllowSimpleBracedStatements);
689   verifyFormat("if (true)\n"
690                "{ //\n"
691                "  f();\n"
692                "}",
693                AllowSimpleBracedStatements);
694   verifyFormat("if (true)\n"
695                "{\n"
696                "  f();\n"
697                "  f();\n"
698                "}",
699                AllowSimpleBracedStatements);
700   verifyFormat("if (true)\n"
701                "{\n"
702                "  f();\n"
703                "} else\n"
704                "{\n"
705                "  f();\n"
706                "}",
707                AllowSimpleBracedStatements);
708 
709   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
710       FormatStyle::SIS_Never;
711   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
712   verifyFormat("if (true)\n"
713                "{\n"
714                "  f();\n"
715                "}",
716                AllowSimpleBracedStatements);
717   verifyFormat("if (true)\n"
718                "{\n"
719                "  f();\n"
720                "} else\n"
721                "{\n"
722                "  f();\n"
723                "}",
724                AllowSimpleBracedStatements);
725 
726   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
727   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
728   verifyFormat("while (true)\n"
729                "{\n"
730                "  f();\n"
731                "}",
732                AllowSimpleBracedStatements);
733   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
734   verifyFormat("for (;;)\n"
735                "{\n"
736                "  f();\n"
737                "}",
738                AllowSimpleBracedStatements);
739 }
740 
741 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) {
742   FormatStyle Style = getLLVMStyleWithColumns(60);
743   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
744   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
745   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
746   EXPECT_EQ("#define A                                                  \\\n"
747             "  if (HANDLEwernufrnuLwrmviferuvnierv)                     \\\n"
748             "  { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n"
749             "X;",
750             format("#define A \\\n"
751                    "   if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"
752                    "      RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
753                    "   }\n"
754                    "X;",
755                    Style));
756 }
757 
758 TEST_F(FormatTest, ParseIfElse) {
759   verifyFormat("if (true)\n"
760                "  if (true)\n"
761                "    if (true)\n"
762                "      f();\n"
763                "    else\n"
764                "      g();\n"
765                "  else\n"
766                "    h();\n"
767                "else\n"
768                "  i();");
769   verifyFormat("if (true)\n"
770                "  if (true)\n"
771                "    if (true) {\n"
772                "      if (true)\n"
773                "        f();\n"
774                "    } else {\n"
775                "      g();\n"
776                "    }\n"
777                "  else\n"
778                "    h();\n"
779                "else {\n"
780                "  i();\n"
781                "}");
782   verifyFormat("if (true)\n"
783                "  if constexpr (true)\n"
784                "    if (true) {\n"
785                "      if constexpr (true)\n"
786                "        f();\n"
787                "    } else {\n"
788                "      g();\n"
789                "    }\n"
790                "  else\n"
791                "    h();\n"
792                "else {\n"
793                "  i();\n"
794                "}");
795   verifyFormat("if (true)\n"
796                "  if CONSTEXPR (true)\n"
797                "    if (true) {\n"
798                "      if CONSTEXPR (true)\n"
799                "        f();\n"
800                "    } else {\n"
801                "      g();\n"
802                "    }\n"
803                "  else\n"
804                "    h();\n"
805                "else {\n"
806                "  i();\n"
807                "}");
808   verifyFormat("void f() {\n"
809                "  if (a) {\n"
810                "  } else {\n"
811                "  }\n"
812                "}");
813 }
814 
815 TEST_F(FormatTest, ElseIf) {
816   verifyFormat("if (a) {\n} else if (b) {\n}");
817   verifyFormat("if (a)\n"
818                "  f();\n"
819                "else if (b)\n"
820                "  g();\n"
821                "else\n"
822                "  h();");
823   verifyFormat("if constexpr (a)\n"
824                "  f();\n"
825                "else if constexpr (b)\n"
826                "  g();\n"
827                "else\n"
828                "  h();");
829   verifyFormat("if CONSTEXPR (a)\n"
830                "  f();\n"
831                "else if CONSTEXPR (b)\n"
832                "  g();\n"
833                "else\n"
834                "  h();");
835   verifyFormat("if (a) {\n"
836                "  f();\n"
837                "}\n"
838                "// or else ..\n"
839                "else {\n"
840                "  g()\n"
841                "}");
842 
843   verifyFormat("if (a) {\n"
844                "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
845                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
846                "}");
847   verifyFormat("if (a) {\n"
848                "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
849                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
850                "}");
851   verifyFormat("if (a) {\n"
852                "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
853                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
854                "}");
855   verifyFormat("if (a) {\n"
856                "} else if (\n"
857                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
858                "}",
859                getLLVMStyleWithColumns(62));
860   verifyFormat("if (a) {\n"
861                "} else if constexpr (\n"
862                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
863                "}",
864                getLLVMStyleWithColumns(62));
865   verifyFormat("if (a) {\n"
866                "} else if CONSTEXPR (\n"
867                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
868                "}",
869                getLLVMStyleWithColumns(62));
870 }
871 
872 TEST_F(FormatTest, FormatsForLoop) {
873   verifyFormat(
874       "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
875       "     ++VeryVeryLongLoopVariable)\n"
876       "  ;");
877   verifyFormat("for (;;)\n"
878                "  f();");
879   verifyFormat("for (;;) {\n}");
880   verifyFormat("for (;;) {\n"
881                "  f();\n"
882                "}");
883   verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
884 
885   verifyFormat(
886       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
887       "                                          E = UnwrappedLines.end();\n"
888       "     I != E; ++I) {\n}");
889 
890   verifyFormat(
891       "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
892       "     ++IIIII) {\n}");
893   verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
894                "         aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
895                "     aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
896   verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
897                "         I = FD->getDeclsInPrototypeScope().begin(),\n"
898                "         E = FD->getDeclsInPrototypeScope().end();\n"
899                "     I != E; ++I) {\n}");
900   verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
901                "         I = Container.begin(),\n"
902                "         E = Container.end();\n"
903                "     I != E; ++I) {\n}",
904                getLLVMStyleWithColumns(76));
905 
906   verifyFormat(
907       "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
908       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
909       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
910       "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
911       "     ++aaaaaaaaaaa) {\n}");
912   verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
913                "                bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
914                "     ++i) {\n}");
915   verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
916                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
917                "}");
918   verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
919                "         aaaaaaaaaa);\n"
920                "     iter; ++iter) {\n"
921                "}");
922   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
923                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
924                "     aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
925                "     ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
926 
927   // These should not be formatted as Objective-C for-in loops.
928   verifyFormat("for (Foo *x = 0; x != in; x++) {\n}");
929   verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}");
930   verifyFormat("Foo *x;\nfor (x in y) {\n}");
931   verifyFormat(
932       "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}");
933 
934   FormatStyle NoBinPacking = getLLVMStyle();
935   NoBinPacking.BinPackParameters = false;
936   verifyFormat("for (int aaaaaaaaaaa = 1;\n"
937                "     aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
938                "                                           aaaaaaaaaaaaaaaa,\n"
939                "                                           aaaaaaaaaaaaaaaa,\n"
940                "                                           aaaaaaaaaaaaaaaa);\n"
941                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
942                "}",
943                NoBinPacking);
944   verifyFormat(
945       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
946       "                                          E = UnwrappedLines.end();\n"
947       "     I != E;\n"
948       "     ++I) {\n}",
949       NoBinPacking);
950 
951   FormatStyle AlignLeft = getLLVMStyle();
952   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
953   verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
954 }
955 
956 TEST_F(FormatTest, RangeBasedForLoops) {
957   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
958                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
959   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
960                "     aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
961   verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
962                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
963   verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
964                "     aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
965 }
966 
967 TEST_F(FormatTest, ForEachLoops) {
968   verifyFormat("void f() {\n"
969                "  foreach (Item *item, itemlist) {}\n"
970                "  Q_FOREACH (Item *item, itemlist) {}\n"
971                "  BOOST_FOREACH (Item *item, itemlist) {}\n"
972                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
973                "}");
974 
975   FormatStyle Style = getLLVMStyle();
976   Style.SpaceBeforeParens =
977       FormatStyle::SBPO_ControlStatementsExceptForEachMacros;
978   verifyFormat("void f() {\n"
979                "  foreach(Item *item, itemlist) {}\n"
980                "  Q_FOREACH(Item *item, itemlist) {}\n"
981                "  BOOST_FOREACH(Item *item, itemlist) {}\n"
982                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
983                "}",
984                Style);
985 
986   // As function-like macros.
987   verifyFormat("#define foreach(x, y)\n"
988                "#define Q_FOREACH(x, y)\n"
989                "#define BOOST_FOREACH(x, y)\n"
990                "#define UNKNOWN_FOREACH(x, y)\n");
991 
992   // Not as function-like macros.
993   verifyFormat("#define foreach (x, y)\n"
994                "#define Q_FOREACH (x, y)\n"
995                "#define BOOST_FOREACH (x, y)\n"
996                "#define UNKNOWN_FOREACH (x, y)\n");
997 
998   // handle microsoft non standard extension
999   verifyFormat("for each (char c in x->MyStringProperty)");
1000 }
1001 
1002 TEST_F(FormatTest, FormatsWhileLoop) {
1003   verifyFormat("while (true) {\n}");
1004   verifyFormat("while (true)\n"
1005                "  f();");
1006   verifyFormat("while () {\n}");
1007   verifyFormat("while () {\n"
1008                "  f();\n"
1009                "}");
1010 }
1011 
1012 TEST_F(FormatTest, FormatsDoWhile) {
1013   verifyFormat("do {\n"
1014                "  do_something();\n"
1015                "} while (something());");
1016   verifyFormat("do\n"
1017                "  do_something();\n"
1018                "while (something());");
1019 }
1020 
1021 TEST_F(FormatTest, FormatsSwitchStatement) {
1022   verifyFormat("switch (x) {\n"
1023                "case 1:\n"
1024                "  f();\n"
1025                "  break;\n"
1026                "case kFoo:\n"
1027                "case ns::kBar:\n"
1028                "case kBaz:\n"
1029                "  break;\n"
1030                "default:\n"
1031                "  g();\n"
1032                "  break;\n"
1033                "}");
1034   verifyFormat("switch (x) {\n"
1035                "case 1: {\n"
1036                "  f();\n"
1037                "  break;\n"
1038                "}\n"
1039                "case 2: {\n"
1040                "  break;\n"
1041                "}\n"
1042                "}");
1043   verifyFormat("switch (x) {\n"
1044                "case 1: {\n"
1045                "  f();\n"
1046                "  {\n"
1047                "    g();\n"
1048                "    h();\n"
1049                "  }\n"
1050                "  break;\n"
1051                "}\n"
1052                "}");
1053   verifyFormat("switch (x) {\n"
1054                "case 1: {\n"
1055                "  f();\n"
1056                "  if (foo) {\n"
1057                "    g();\n"
1058                "    h();\n"
1059                "  }\n"
1060                "  break;\n"
1061                "}\n"
1062                "}");
1063   verifyFormat("switch (x) {\n"
1064                "case 1: {\n"
1065                "  f();\n"
1066                "  g();\n"
1067                "} break;\n"
1068                "}");
1069   verifyFormat("switch (test)\n"
1070                "  ;");
1071   verifyFormat("switch (x) {\n"
1072                "default: {\n"
1073                "  // Do nothing.\n"
1074                "}\n"
1075                "}");
1076   verifyFormat("switch (x) {\n"
1077                "// comment\n"
1078                "// if 1, do f()\n"
1079                "case 1:\n"
1080                "  f();\n"
1081                "}");
1082   verifyFormat("switch (x) {\n"
1083                "case 1:\n"
1084                "  // Do amazing stuff\n"
1085                "  {\n"
1086                "    f();\n"
1087                "    g();\n"
1088                "  }\n"
1089                "  break;\n"
1090                "}");
1091   verifyFormat("#define A          \\\n"
1092                "  switch (x) {     \\\n"
1093                "  case a:          \\\n"
1094                "    foo = b;       \\\n"
1095                "  }",
1096                getLLVMStyleWithColumns(20));
1097   verifyFormat("#define OPERATION_CASE(name)           \\\n"
1098                "  case OP_name:                        \\\n"
1099                "    return operations::Operation##name\n",
1100                getLLVMStyleWithColumns(40));
1101   verifyFormat("switch (x) {\n"
1102                "case 1:;\n"
1103                "default:;\n"
1104                "  int i;\n"
1105                "}");
1106 
1107   verifyGoogleFormat("switch (x) {\n"
1108                      "  case 1:\n"
1109                      "    f();\n"
1110                      "    break;\n"
1111                      "  case kFoo:\n"
1112                      "  case ns::kBar:\n"
1113                      "  case kBaz:\n"
1114                      "    break;\n"
1115                      "  default:\n"
1116                      "    g();\n"
1117                      "    break;\n"
1118                      "}");
1119   verifyGoogleFormat("switch (x) {\n"
1120                      "  case 1: {\n"
1121                      "    f();\n"
1122                      "    break;\n"
1123                      "  }\n"
1124                      "}");
1125   verifyGoogleFormat("switch (test)\n"
1126                      "  ;");
1127 
1128   verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
1129                      "  case OP_name:              \\\n"
1130                      "    return operations::Operation##name\n");
1131   verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
1132                      "  // Get the correction operation class.\n"
1133                      "  switch (OpCode) {\n"
1134                      "    CASE(Add);\n"
1135                      "    CASE(Subtract);\n"
1136                      "    default:\n"
1137                      "      return operations::Unknown;\n"
1138                      "  }\n"
1139                      "#undef OPERATION_CASE\n"
1140                      "}");
1141   verifyFormat("DEBUG({\n"
1142                "  switch (x) {\n"
1143                "  case A:\n"
1144                "    f();\n"
1145                "    break;\n"
1146                "    // fallthrough\n"
1147                "  case B:\n"
1148                "    g();\n"
1149                "    break;\n"
1150                "  }\n"
1151                "});");
1152   EXPECT_EQ("DEBUG({\n"
1153             "  switch (x) {\n"
1154             "  case A:\n"
1155             "    f();\n"
1156             "    break;\n"
1157             "  // On B:\n"
1158             "  case B:\n"
1159             "    g();\n"
1160             "    break;\n"
1161             "  }\n"
1162             "});",
1163             format("DEBUG({\n"
1164                    "  switch (x) {\n"
1165                    "  case A:\n"
1166                    "    f();\n"
1167                    "    break;\n"
1168                    "  // On B:\n"
1169                    "  case B:\n"
1170                    "    g();\n"
1171                    "    break;\n"
1172                    "  }\n"
1173                    "});",
1174                    getLLVMStyle()));
1175   EXPECT_EQ("switch (n) {\n"
1176             "case 0: {\n"
1177             "  return false;\n"
1178             "}\n"
1179             "default: {\n"
1180             "  return true;\n"
1181             "}\n"
1182             "}",
1183             format("switch (n)\n"
1184                    "{\n"
1185                    "case 0: {\n"
1186                    "  return false;\n"
1187                    "}\n"
1188                    "default: {\n"
1189                    "  return true;\n"
1190                    "}\n"
1191                    "}",
1192                    getLLVMStyle()));
1193   verifyFormat("switch (a) {\n"
1194                "case (b):\n"
1195                "  return;\n"
1196                "}");
1197 
1198   verifyFormat("switch (a) {\n"
1199                "case some_namespace::\n"
1200                "    some_constant:\n"
1201                "  return;\n"
1202                "}",
1203                getLLVMStyleWithColumns(34));
1204 
1205   FormatStyle Style = getLLVMStyle();
1206   Style.IndentCaseLabels = true;
1207   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
1208   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1209   Style.BraceWrapping.AfterCaseLabel = true;
1210   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1211   EXPECT_EQ("switch (n)\n"
1212             "{\n"
1213             "  case 0:\n"
1214             "  {\n"
1215             "    return false;\n"
1216             "  }\n"
1217             "  default:\n"
1218             "  {\n"
1219             "    return true;\n"
1220             "  }\n"
1221             "}",
1222             format("switch (n) {\n"
1223                    "  case 0: {\n"
1224                    "    return false;\n"
1225                    "  }\n"
1226                    "  default: {\n"
1227                    "    return true;\n"
1228                    "  }\n"
1229                    "}",
1230                    Style));
1231   Style.BraceWrapping.AfterCaseLabel = false;
1232   EXPECT_EQ("switch (n)\n"
1233             "{\n"
1234             "  case 0: {\n"
1235             "    return false;\n"
1236             "  }\n"
1237             "  default: {\n"
1238             "    return true;\n"
1239             "  }\n"
1240             "}",
1241             format("switch (n) {\n"
1242                    "  case 0:\n"
1243                    "  {\n"
1244                    "    return false;\n"
1245                    "  }\n"
1246                    "  default:\n"
1247                    "  {\n"
1248                    "    return true;\n"
1249                    "  }\n"
1250                    "}",
1251                    Style));
1252   Style.IndentCaseLabels = false;
1253   Style.IndentCaseBlocks = true;
1254   EXPECT_EQ("switch (n)\n"
1255             "{\n"
1256             "case 0:\n"
1257             "  {\n"
1258             "    return false;\n"
1259             "  }\n"
1260             "case 1:\n"
1261             "  break;\n"
1262             "default:\n"
1263             "  {\n"
1264             "    return true;\n"
1265             "  }\n"
1266             "}",
1267             format("switch (n) {\n"
1268                    "case 0: {\n"
1269                    "  return false;\n"
1270                    "}\n"
1271                    "case 1:\n"
1272                    "  break;\n"
1273                    "default: {\n"
1274                    "  return true;\n"
1275                    "}\n"
1276                    "}",
1277                    Style));
1278   Style.IndentCaseLabels = true;
1279   Style.IndentCaseBlocks = true;
1280   EXPECT_EQ("switch (n)\n"
1281             "{\n"
1282             "  case 0:\n"
1283             "    {\n"
1284             "      return false;\n"
1285             "    }\n"
1286             "  case 1:\n"
1287             "    break;\n"
1288             "  default:\n"
1289             "    {\n"
1290             "      return true;\n"
1291             "    }\n"
1292             "}",
1293             format("switch (n) {\n"
1294                    "case 0: {\n"
1295                    "  return false;\n"
1296                    "}\n"
1297                    "case 1:\n"
1298                    "  break;\n"
1299                    "default: {\n"
1300                    "  return true;\n"
1301                    "}\n"
1302                    "}",
1303                    Style));
1304 }
1305 
1306 TEST_F(FormatTest, CaseRanges) {
1307   verifyFormat("switch (x) {\n"
1308                "case 'A' ... 'Z':\n"
1309                "case 1 ... 5:\n"
1310                "case a ... b:\n"
1311                "  break;\n"
1312                "}");
1313 }
1314 
1315 TEST_F(FormatTest, ShortEnums) {
1316   FormatStyle Style = getLLVMStyle();
1317   Style.AllowShortEnumsOnASingleLine = true;
1318   verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style);
1319   Style.AllowShortEnumsOnASingleLine = false;
1320   verifyFormat("enum\n"
1321                "{\n"
1322                "  A,\n"
1323                "  B,\n"
1324                "  C\n"
1325                "} ShortEnum1, ShortEnum2;",
1326                Style);
1327 }
1328 
1329 TEST_F(FormatTest, ShortCaseLabels) {
1330   FormatStyle Style = getLLVMStyle();
1331   Style.AllowShortCaseLabelsOnASingleLine = true;
1332   verifyFormat("switch (a) {\n"
1333                "case 1: x = 1; break;\n"
1334                "case 2: return;\n"
1335                "case 3:\n"
1336                "case 4:\n"
1337                "case 5: return;\n"
1338                "case 6: // comment\n"
1339                "  return;\n"
1340                "case 7:\n"
1341                "  // comment\n"
1342                "  return;\n"
1343                "case 8:\n"
1344                "  x = 8; // comment\n"
1345                "  break;\n"
1346                "default: y = 1; break;\n"
1347                "}",
1348                Style);
1349   verifyFormat("switch (a) {\n"
1350                "case 0: return; // comment\n"
1351                "case 1: break;  // comment\n"
1352                "case 2: return;\n"
1353                "// comment\n"
1354                "case 3: return;\n"
1355                "// comment 1\n"
1356                "// comment 2\n"
1357                "// comment 3\n"
1358                "case 4: break; /* comment */\n"
1359                "case 5:\n"
1360                "  // comment\n"
1361                "  break;\n"
1362                "case 6: /* comment */ x = 1; break;\n"
1363                "case 7: x = /* comment */ 1; break;\n"
1364                "case 8:\n"
1365                "  x = 1; /* comment */\n"
1366                "  break;\n"
1367                "case 9:\n"
1368                "  break; // comment line 1\n"
1369                "         // comment line 2\n"
1370                "}",
1371                Style);
1372   EXPECT_EQ("switch (a) {\n"
1373             "case 1:\n"
1374             "  x = 8;\n"
1375             "  // fall through\n"
1376             "case 2: x = 8;\n"
1377             "// comment\n"
1378             "case 3:\n"
1379             "  return; /* comment line 1\n"
1380             "           * comment line 2 */\n"
1381             "case 4: i = 8;\n"
1382             "// something else\n"
1383             "#if FOO\n"
1384             "case 5: break;\n"
1385             "#endif\n"
1386             "}",
1387             format("switch (a) {\n"
1388                    "case 1: x = 8;\n"
1389                    "  // fall through\n"
1390                    "case 2:\n"
1391                    "  x = 8;\n"
1392                    "// comment\n"
1393                    "case 3:\n"
1394                    "  return; /* comment line 1\n"
1395                    "           * comment line 2 */\n"
1396                    "case 4:\n"
1397                    "  i = 8;\n"
1398                    "// something else\n"
1399                    "#if FOO\n"
1400                    "case 5: break;\n"
1401                    "#endif\n"
1402                    "}",
1403                    Style));
1404   EXPECT_EQ("switch (a) {\n"
1405             "case 0:\n"
1406             "  return; // long long long long long long long long long long "
1407             "long long comment\n"
1408             "          // line\n"
1409             "}",
1410             format("switch (a) {\n"
1411                    "case 0: return; // long long long long long long long long "
1412                    "long long long long comment line\n"
1413                    "}",
1414                    Style));
1415   EXPECT_EQ("switch (a) {\n"
1416             "case 0:\n"
1417             "  return; /* long long long long long long long long long long "
1418             "long long comment\n"
1419             "             line */\n"
1420             "}",
1421             format("switch (a) {\n"
1422                    "case 0: return; /* long long long long long long long long "
1423                    "long long long long comment line */\n"
1424                    "}",
1425                    Style));
1426   verifyFormat("switch (a) {\n"
1427                "#if FOO\n"
1428                "case 0: return 0;\n"
1429                "#endif\n"
1430                "}",
1431                Style);
1432   verifyFormat("switch (a) {\n"
1433                "case 1: {\n"
1434                "}\n"
1435                "case 2: {\n"
1436                "  return;\n"
1437                "}\n"
1438                "case 3: {\n"
1439                "  x = 1;\n"
1440                "  return;\n"
1441                "}\n"
1442                "case 4:\n"
1443                "  if (x)\n"
1444                "    return;\n"
1445                "}",
1446                Style);
1447   Style.ColumnLimit = 21;
1448   verifyFormat("switch (a) {\n"
1449                "case 1: x = 1; break;\n"
1450                "case 2: return;\n"
1451                "case 3:\n"
1452                "case 4:\n"
1453                "case 5: return;\n"
1454                "default:\n"
1455                "  y = 1;\n"
1456                "  break;\n"
1457                "}",
1458                Style);
1459   Style.ColumnLimit = 80;
1460   Style.AllowShortCaseLabelsOnASingleLine = false;
1461   Style.IndentCaseLabels = true;
1462   EXPECT_EQ("switch (n) {\n"
1463             "  default /*comments*/:\n"
1464             "    return true;\n"
1465             "  case 0:\n"
1466             "    return false;\n"
1467             "}",
1468             format("switch (n) {\n"
1469                    "default/*comments*/:\n"
1470                    "  return true;\n"
1471                    "case 0:\n"
1472                    "  return false;\n"
1473                    "}",
1474                    Style));
1475   Style.AllowShortCaseLabelsOnASingleLine = true;
1476   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1477   Style.BraceWrapping.AfterCaseLabel = true;
1478   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1479   EXPECT_EQ("switch (n)\n"
1480             "{\n"
1481             "  case 0:\n"
1482             "  {\n"
1483             "    return false;\n"
1484             "  }\n"
1485             "  default:\n"
1486             "  {\n"
1487             "    return true;\n"
1488             "  }\n"
1489             "}",
1490             format("switch (n) {\n"
1491                    "  case 0: {\n"
1492                    "    return false;\n"
1493                    "  }\n"
1494                    "  default:\n"
1495                    "  {\n"
1496                    "    return true;\n"
1497                    "  }\n"
1498                    "}",
1499                    Style));
1500 }
1501 
1502 TEST_F(FormatTest, FormatsLabels) {
1503   verifyFormat("void f() {\n"
1504                "  some_code();\n"
1505                "test_label:\n"
1506                "  some_other_code();\n"
1507                "  {\n"
1508                "    some_more_code();\n"
1509                "  another_label:\n"
1510                "    some_more_code();\n"
1511                "  }\n"
1512                "}");
1513   verifyFormat("{\n"
1514                "  some_code();\n"
1515                "test_label:\n"
1516                "  some_other_code();\n"
1517                "}");
1518   verifyFormat("{\n"
1519                "  some_code();\n"
1520                "test_label:;\n"
1521                "  int i = 0;\n"
1522                "}");
1523   FormatStyle Style = getLLVMStyle();
1524   Style.IndentGotoLabels = false;
1525   verifyFormat("void f() {\n"
1526                "  some_code();\n"
1527                "test_label:\n"
1528                "  some_other_code();\n"
1529                "  {\n"
1530                "    some_more_code();\n"
1531                "another_label:\n"
1532                "    some_more_code();\n"
1533                "  }\n"
1534                "}",
1535                Style);
1536   verifyFormat("{\n"
1537                "  some_code();\n"
1538                "test_label:\n"
1539                "  some_other_code();\n"
1540                "}",
1541                Style);
1542   verifyFormat("{\n"
1543                "  some_code();\n"
1544                "test_label:;\n"
1545                "  int i = 0;\n"
1546                "}");
1547 }
1548 
1549 TEST_F(FormatTest, MultiLineControlStatements) {
1550   FormatStyle Style = getLLVMStyle();
1551   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1552   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine;
1553   Style.ColumnLimit = 20;
1554   // Short lines should keep opening brace on same line.
1555   EXPECT_EQ("if (foo) {\n"
1556             "  bar();\n"
1557             "}",
1558             format("if(foo){bar();}", Style));
1559   EXPECT_EQ("if (foo) {\n"
1560             "  bar();\n"
1561             "} else {\n"
1562             "  baz();\n"
1563             "}",
1564             format("if(foo){bar();}else{baz();}", Style));
1565   EXPECT_EQ("if (foo && bar) {\n"
1566             "  baz();\n"
1567             "}",
1568             format("if(foo&&bar){baz();}", Style));
1569   EXPECT_EQ("if (foo) {\n"
1570             "  bar();\n"
1571             "} else if (baz) {\n"
1572             "  quux();\n"
1573             "}",
1574             format("if(foo){bar();}else if(baz){quux();}", Style));
1575   EXPECT_EQ(
1576       "if (foo) {\n"
1577       "  bar();\n"
1578       "} else if (baz) {\n"
1579       "  quux();\n"
1580       "} else {\n"
1581       "  foobar();\n"
1582       "}",
1583       format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style));
1584   EXPECT_EQ("for (;;) {\n"
1585             "  foo();\n"
1586             "}",
1587             format("for(;;){foo();}"));
1588   EXPECT_EQ("while (1) {\n"
1589             "  foo();\n"
1590             "}",
1591             format("while(1){foo();}", Style));
1592   EXPECT_EQ("switch (foo) {\n"
1593             "case bar:\n"
1594             "  return;\n"
1595             "}",
1596             format("switch(foo){case bar:return;}", Style));
1597   EXPECT_EQ("try {\n"
1598             "  foo();\n"
1599             "} catch (...) {\n"
1600             "  bar();\n"
1601             "}",
1602             format("try{foo();}catch(...){bar();}", Style));
1603   EXPECT_EQ("do {\n"
1604             "  foo();\n"
1605             "} while (bar &&\n"
1606             "         baz);",
1607             format("do{foo();}while(bar&&baz);", Style));
1608   // Long lines should put opening brace on new line.
1609   EXPECT_EQ("if (foo && bar &&\n"
1610             "    baz)\n"
1611             "{\n"
1612             "  quux();\n"
1613             "}",
1614             format("if(foo&&bar&&baz){quux();}", Style));
1615   EXPECT_EQ("if (foo && bar &&\n"
1616             "    baz)\n"
1617             "{\n"
1618             "  quux();\n"
1619             "}",
1620             format("if (foo && bar &&\n"
1621                    "    baz) {\n"
1622                    "  quux();\n"
1623                    "}",
1624                    Style));
1625   EXPECT_EQ("if (foo) {\n"
1626             "  bar();\n"
1627             "} else if (baz ||\n"
1628             "           quux)\n"
1629             "{\n"
1630             "  foobar();\n"
1631             "}",
1632             format("if(foo){bar();}else if(baz||quux){foobar();}", Style));
1633   EXPECT_EQ(
1634       "if (foo) {\n"
1635       "  bar();\n"
1636       "} else if (baz ||\n"
1637       "           quux)\n"
1638       "{\n"
1639       "  foobar();\n"
1640       "} else {\n"
1641       "  barbaz();\n"
1642       "}",
1643       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1644              Style));
1645   EXPECT_EQ("for (int i = 0;\n"
1646             "     i < 10; ++i)\n"
1647             "{\n"
1648             "  foo();\n"
1649             "}",
1650             format("for(int i=0;i<10;++i){foo();}", Style));
1651   EXPECT_EQ("while (foo || bar ||\n"
1652             "       baz)\n"
1653             "{\n"
1654             "  quux();\n"
1655             "}",
1656             format("while(foo||bar||baz){quux();}", Style));
1657   EXPECT_EQ("switch (\n"
1658             "    foo = barbaz)\n"
1659             "{\n"
1660             "case quux:\n"
1661             "  return;\n"
1662             "}",
1663             format("switch(foo=barbaz){case quux:return;}", Style));
1664   EXPECT_EQ("try {\n"
1665             "  foo();\n"
1666             "} catch (\n"
1667             "    Exception &bar)\n"
1668             "{\n"
1669             "  baz();\n"
1670             "}",
1671             format("try{foo();}catch(Exception&bar){baz();}", Style));
1672   Style.ColumnLimit =
1673       40; // to concentrate at brace wrapping, not line wrap due to column limit
1674   EXPECT_EQ("try {\n"
1675             "  foo();\n"
1676             "} catch (Exception &bar) {\n"
1677             "  baz();\n"
1678             "}",
1679             format("try{foo();}catch(Exception&bar){baz();}", Style));
1680   Style.ColumnLimit =
1681       20; // to concentrate at brace wrapping, not line wrap due to column limit
1682 
1683   Style.BraceWrapping.BeforeElse = true;
1684   EXPECT_EQ(
1685       "if (foo) {\n"
1686       "  bar();\n"
1687       "}\n"
1688       "else if (baz ||\n"
1689       "         quux)\n"
1690       "{\n"
1691       "  foobar();\n"
1692       "}\n"
1693       "else {\n"
1694       "  barbaz();\n"
1695       "}",
1696       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1697              Style));
1698 
1699   Style.BraceWrapping.BeforeCatch = true;
1700   EXPECT_EQ("try {\n"
1701             "  foo();\n"
1702             "}\n"
1703             "catch (...) {\n"
1704             "  baz();\n"
1705             "}",
1706             format("try{foo();}catch(...){baz();}", Style));
1707 }
1708 
1709 TEST_F(FormatTest, BeforeWhile) {
1710   FormatStyle Style = getLLVMStyle();
1711   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1712 
1713   verifyFormat("do {\n"
1714                "  foo();\n"
1715                "} while (1);",
1716                Style);
1717   Style.BraceWrapping.BeforeWhile = true;
1718   verifyFormat("do {\n"
1719                "  foo();\n"
1720                "}\n"
1721                "while (1);",
1722                Style);
1723 }
1724 
1725 //===----------------------------------------------------------------------===//
1726 // Tests for classes, namespaces, etc.
1727 //===----------------------------------------------------------------------===//
1728 
1729 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
1730   verifyFormat("class A {};");
1731 }
1732 
1733 TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1734   verifyFormat("class A {\n"
1735                "public:\n"
1736                "public: // comment\n"
1737                "protected:\n"
1738                "private:\n"
1739                "  void f() {}\n"
1740                "};");
1741   verifyFormat("export class A {\n"
1742                "public:\n"
1743                "public: // comment\n"
1744                "protected:\n"
1745                "private:\n"
1746                "  void f() {}\n"
1747                "};");
1748   verifyGoogleFormat("class A {\n"
1749                      " public:\n"
1750                      " protected:\n"
1751                      " private:\n"
1752                      "  void f() {}\n"
1753                      "};");
1754   verifyGoogleFormat("export class A {\n"
1755                      " public:\n"
1756                      " protected:\n"
1757                      " private:\n"
1758                      "  void f() {}\n"
1759                      "};");
1760   verifyFormat("class A {\n"
1761                "public slots:\n"
1762                "  void f1() {}\n"
1763                "public Q_SLOTS:\n"
1764                "  void f2() {}\n"
1765                "protected slots:\n"
1766                "  void f3() {}\n"
1767                "protected Q_SLOTS:\n"
1768                "  void f4() {}\n"
1769                "private slots:\n"
1770                "  void f5() {}\n"
1771                "private Q_SLOTS:\n"
1772                "  void f6() {}\n"
1773                "signals:\n"
1774                "  void g1();\n"
1775                "Q_SIGNALS:\n"
1776                "  void g2();\n"
1777                "};");
1778 
1779   // Don't interpret 'signals' the wrong way.
1780   verifyFormat("signals.set();");
1781   verifyFormat("for (Signals signals : f()) {\n}");
1782   verifyFormat("{\n"
1783                "  signals.set(); // This needs indentation.\n"
1784                "}");
1785   verifyFormat("void f() {\n"
1786                "label:\n"
1787                "  signals.baz();\n"
1788                "}");
1789 }
1790 
1791 TEST_F(FormatTest, SeparatesLogicalBlocks) {
1792   EXPECT_EQ("class A {\n"
1793             "public:\n"
1794             "  void f();\n"
1795             "\n"
1796             "private:\n"
1797             "  void g() {}\n"
1798             "  // test\n"
1799             "protected:\n"
1800             "  int h;\n"
1801             "};",
1802             format("class A {\n"
1803                    "public:\n"
1804                    "void f();\n"
1805                    "private:\n"
1806                    "void g() {}\n"
1807                    "// test\n"
1808                    "protected:\n"
1809                    "int h;\n"
1810                    "};"));
1811   EXPECT_EQ("class A {\n"
1812             "protected:\n"
1813             "public:\n"
1814             "  void f();\n"
1815             "};",
1816             format("class A {\n"
1817                    "protected:\n"
1818                    "\n"
1819                    "public:\n"
1820                    "\n"
1821                    "  void f();\n"
1822                    "};"));
1823 
1824   // Even ensure proper spacing inside macros.
1825   EXPECT_EQ("#define B     \\\n"
1826             "  class A {   \\\n"
1827             "   protected: \\\n"
1828             "   public:    \\\n"
1829             "    void f(); \\\n"
1830             "  };",
1831             format("#define B     \\\n"
1832                    "  class A {   \\\n"
1833                    "   protected: \\\n"
1834                    "              \\\n"
1835                    "   public:    \\\n"
1836                    "              \\\n"
1837                    "    void f(); \\\n"
1838                    "  };",
1839                    getGoogleStyle()));
1840   // But don't remove empty lines after macros ending in access specifiers.
1841   EXPECT_EQ("#define A private:\n"
1842             "\n"
1843             "int i;",
1844             format("#define A         private:\n"
1845                    "\n"
1846                    "int              i;"));
1847 }
1848 
1849 TEST_F(FormatTest, FormatsClasses) {
1850   verifyFormat("class A : public B {};");
1851   verifyFormat("class A : public ::B {};");
1852 
1853   verifyFormat(
1854       "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1855       "                             public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1856   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1857                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1858                "      public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1859   verifyFormat(
1860       "class A : public B, public C, public D, public E, public F {};");
1861   verifyFormat("class AAAAAAAAAAAA : public B,\n"
1862                "                     public C,\n"
1863                "                     public D,\n"
1864                "                     public E,\n"
1865                "                     public F,\n"
1866                "                     public G {};");
1867 
1868   verifyFormat("class\n"
1869                "    ReallyReallyLongClassName {\n"
1870                "  int i;\n"
1871                "};",
1872                getLLVMStyleWithColumns(32));
1873   verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1874                "                           aaaaaaaaaaaaaaaa> {};");
1875   verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1876                "    : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1877                "                                 aaaaaaaaaaaaaaaaaaaaaa> {};");
1878   verifyFormat("template <class R, class C>\n"
1879                "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1880                "    : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
1881   verifyFormat("class ::A::B {};");
1882 }
1883 
1884 TEST_F(FormatTest, BreakInheritanceStyle) {
1885   FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle();
1886   StyleWithInheritanceBreakBeforeComma.BreakInheritanceList =
1887       FormatStyle::BILS_BeforeComma;
1888   verifyFormat("class MyClass : public X {};",
1889                StyleWithInheritanceBreakBeforeComma);
1890   verifyFormat("class MyClass\n"
1891                "    : public X\n"
1892                "    , public Y {};",
1893                StyleWithInheritanceBreakBeforeComma);
1894   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
1895                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"
1896                "    , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1897                StyleWithInheritanceBreakBeforeComma);
1898   verifyFormat("struct aaaaaaaaaaaaa\n"
1899                "    : public aaaaaaaaaaaaaaaaaaa< // break\n"
1900                "          aaaaaaaaaaaaaaaa> {};",
1901                StyleWithInheritanceBreakBeforeComma);
1902 
1903   FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle();
1904   StyleWithInheritanceBreakAfterColon.BreakInheritanceList =
1905       FormatStyle::BILS_AfterColon;
1906   verifyFormat("class MyClass : public X {};",
1907                StyleWithInheritanceBreakAfterColon);
1908   verifyFormat("class MyClass : public X, public Y {};",
1909                StyleWithInheritanceBreakAfterColon);
1910   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
1911                "    public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1912                "    public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1913                StyleWithInheritanceBreakAfterColon);
1914   verifyFormat("struct aaaaaaaaaaaaa :\n"
1915                "    public aaaaaaaaaaaaaaaaaaa< // break\n"
1916                "        aaaaaaaaaaaaaaaa> {};",
1917                StyleWithInheritanceBreakAfterColon);
1918 }
1919 
1920 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
1921   verifyFormat("class A {\n} a, b;");
1922   verifyFormat("struct A {\n} a, b;");
1923   verifyFormat("union A {\n} a;");
1924 }
1925 
1926 TEST_F(FormatTest, FormatsEnum) {
1927   verifyFormat("enum {\n"
1928                "  Zero,\n"
1929                "  One = 1,\n"
1930                "  Two = One + 1,\n"
1931                "  Three = (One + Two),\n"
1932                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1933                "  Five = (One, Two, Three, Four, 5)\n"
1934                "};");
1935   verifyGoogleFormat("enum {\n"
1936                      "  Zero,\n"
1937                      "  One = 1,\n"
1938                      "  Two = One + 1,\n"
1939                      "  Three = (One + Two),\n"
1940                      "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1941                      "  Five = (One, Two, Three, Four, 5)\n"
1942                      "};");
1943   verifyFormat("enum Enum {};");
1944   verifyFormat("enum {};");
1945   verifyFormat("enum X E {} d;");
1946   verifyFormat("enum __attribute__((...)) E {} d;");
1947   verifyFormat("enum __declspec__((...)) E {} d;");
1948   verifyFormat("enum {\n"
1949                "  Bar = Foo<int, int>::value\n"
1950                "};",
1951                getLLVMStyleWithColumns(30));
1952 
1953   verifyFormat("enum ShortEnum { A, B, C };");
1954   verifyGoogleFormat("enum ShortEnum { A, B, C };");
1955 
1956   EXPECT_EQ("enum KeepEmptyLines {\n"
1957             "  ONE,\n"
1958             "\n"
1959             "  TWO,\n"
1960             "\n"
1961             "  THREE\n"
1962             "}",
1963             format("enum KeepEmptyLines {\n"
1964                    "  ONE,\n"
1965                    "\n"
1966                    "  TWO,\n"
1967                    "\n"
1968                    "\n"
1969                    "  THREE\n"
1970                    "}"));
1971   verifyFormat("enum E { // comment\n"
1972                "  ONE,\n"
1973                "  TWO\n"
1974                "};\n"
1975                "int i;");
1976 
1977   FormatStyle EightIndent = getLLVMStyle();
1978   EightIndent.IndentWidth = 8;
1979   verifyFormat("enum {\n"
1980                "        VOID,\n"
1981                "        CHAR,\n"
1982                "        SHORT,\n"
1983                "        INT,\n"
1984                "        LONG,\n"
1985                "        SIGNED,\n"
1986                "        UNSIGNED,\n"
1987                "        BOOL,\n"
1988                "        FLOAT,\n"
1989                "        DOUBLE,\n"
1990                "        COMPLEX\n"
1991                "};",
1992                EightIndent);
1993 
1994   // Not enums.
1995   verifyFormat("enum X f() {\n"
1996                "  a();\n"
1997                "  return 42;\n"
1998                "}");
1999   verifyFormat("enum X Type::f() {\n"
2000                "  a();\n"
2001                "  return 42;\n"
2002                "}");
2003   verifyFormat("enum ::X f() {\n"
2004                "  a();\n"
2005                "  return 42;\n"
2006                "}");
2007   verifyFormat("enum ns::X f() {\n"
2008                "  a();\n"
2009                "  return 42;\n"
2010                "}");
2011 }
2012 
2013 TEST_F(FormatTest, FormatsEnumsWithErrors) {
2014   verifyFormat("enum Type {\n"
2015                "  One = 0; // These semicolons should be commas.\n"
2016                "  Two = 1;\n"
2017                "};");
2018   verifyFormat("namespace n {\n"
2019                "enum Type {\n"
2020                "  One,\n"
2021                "  Two, // missing };\n"
2022                "  int i;\n"
2023                "}\n"
2024                "void g() {}");
2025 }
2026 
2027 TEST_F(FormatTest, FormatsEnumStruct) {
2028   verifyFormat("enum struct {\n"
2029                "  Zero,\n"
2030                "  One = 1,\n"
2031                "  Two = One + 1,\n"
2032                "  Three = (One + Two),\n"
2033                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2034                "  Five = (One, Two, Three, Four, 5)\n"
2035                "};");
2036   verifyFormat("enum struct Enum {};");
2037   verifyFormat("enum struct {};");
2038   verifyFormat("enum struct X E {} d;");
2039   verifyFormat("enum struct __attribute__((...)) E {} d;");
2040   verifyFormat("enum struct __declspec__((...)) E {} d;");
2041   verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
2042 }
2043 
2044 TEST_F(FormatTest, FormatsEnumClass) {
2045   verifyFormat("enum class {\n"
2046                "  Zero,\n"
2047                "  One = 1,\n"
2048                "  Two = One + 1,\n"
2049                "  Three = (One + Two),\n"
2050                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2051                "  Five = (One, Two, Three, Four, 5)\n"
2052                "};");
2053   verifyFormat("enum class Enum {};");
2054   verifyFormat("enum class {};");
2055   verifyFormat("enum class X E {} d;");
2056   verifyFormat("enum class __attribute__((...)) E {} d;");
2057   verifyFormat("enum class __declspec__((...)) E {} d;");
2058   verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
2059 }
2060 
2061 TEST_F(FormatTest, FormatsEnumTypes) {
2062   verifyFormat("enum X : int {\n"
2063                "  A, // Force multiple lines.\n"
2064                "  B\n"
2065                "};");
2066   verifyFormat("enum X : int { A, B };");
2067   verifyFormat("enum X : std::uint32_t { A, B };");
2068 }
2069 
2070 TEST_F(FormatTest, FormatsTypedefEnum) {
2071   FormatStyle Style = getLLVMStyle();
2072   Style.ColumnLimit = 40;
2073   verifyFormat("typedef enum {} EmptyEnum;");
2074   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2075   verifyFormat("typedef enum {\n"
2076                "  ZERO = 0,\n"
2077                "  ONE = 1,\n"
2078                "  TWO = 2,\n"
2079                "  THREE = 3\n"
2080                "} LongEnum;",
2081                Style);
2082   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2083   Style.BraceWrapping.AfterEnum = true;
2084   verifyFormat("typedef enum {} EmptyEnum;");
2085   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2086   verifyFormat("typedef enum\n"
2087                "{\n"
2088                "  ZERO = 0,\n"
2089                "  ONE = 1,\n"
2090                "  TWO = 2,\n"
2091                "  THREE = 3\n"
2092                "} LongEnum;",
2093                Style);
2094 }
2095 
2096 TEST_F(FormatTest, FormatsNSEnums) {
2097   verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
2098   verifyGoogleFormat(
2099       "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }");
2100   verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
2101                      "  // Information about someDecentlyLongValue.\n"
2102                      "  someDecentlyLongValue,\n"
2103                      "  // Information about anotherDecentlyLongValue.\n"
2104                      "  anotherDecentlyLongValue,\n"
2105                      "  // Information about aThirdDecentlyLongValue.\n"
2106                      "  aThirdDecentlyLongValue\n"
2107                      "};");
2108   verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n"
2109                      "  // Information about someDecentlyLongValue.\n"
2110                      "  someDecentlyLongValue,\n"
2111                      "  // Information about anotherDecentlyLongValue.\n"
2112                      "  anotherDecentlyLongValue,\n"
2113                      "  // Information about aThirdDecentlyLongValue.\n"
2114                      "  aThirdDecentlyLongValue\n"
2115                      "};");
2116   verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
2117                      "  a = 1,\n"
2118                      "  b = 2,\n"
2119                      "  c = 3,\n"
2120                      "};");
2121   verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
2122                      "  a = 1,\n"
2123                      "  b = 2,\n"
2124                      "  c = 3,\n"
2125                      "};");
2126   verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n"
2127                      "  a = 1,\n"
2128                      "  b = 2,\n"
2129                      "  c = 3,\n"
2130                      "};");
2131   verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
2132                      "  a = 1,\n"
2133                      "  b = 2,\n"
2134                      "  c = 3,\n"
2135                      "};");
2136 }
2137 
2138 TEST_F(FormatTest, FormatsBitfields) {
2139   verifyFormat("struct Bitfields {\n"
2140                "  unsigned sClass : 8;\n"
2141                "  unsigned ValueKind : 2;\n"
2142                "};");
2143   verifyFormat("struct A {\n"
2144                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
2145                "      bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
2146                "};");
2147   verifyFormat("struct MyStruct {\n"
2148                "  uchar data;\n"
2149                "  uchar : 8;\n"
2150                "  uchar : 8;\n"
2151                "  uchar other;\n"
2152                "};");
2153 }
2154 
2155 TEST_F(FormatTest, FormatsNamespaces) {
2156   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
2157   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
2158 
2159   verifyFormat("namespace some_namespace {\n"
2160                "class A {};\n"
2161                "void f() { f(); }\n"
2162                "}",
2163                LLVMWithNoNamespaceFix);
2164   verifyFormat("namespace N::inline D {\n"
2165                "class A {};\n"
2166                "void f() { f(); }\n"
2167                "}",
2168                LLVMWithNoNamespaceFix);
2169   verifyFormat("namespace N::inline D::E {\n"
2170                "class A {};\n"
2171                "void f() { f(); }\n"
2172                "}",
2173                LLVMWithNoNamespaceFix);
2174   verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
2175                "class A {};\n"
2176                "void f() { f(); }\n"
2177                "}",
2178                LLVMWithNoNamespaceFix);
2179   verifyFormat("/* something */ namespace some_namespace {\n"
2180                "class A {};\n"
2181                "void f() { f(); }\n"
2182                "}",
2183                LLVMWithNoNamespaceFix);
2184   verifyFormat("namespace {\n"
2185                "class A {};\n"
2186                "void f() { f(); }\n"
2187                "}",
2188                LLVMWithNoNamespaceFix);
2189   verifyFormat("/* something */ namespace {\n"
2190                "class A {};\n"
2191                "void f() { f(); }\n"
2192                "}",
2193                LLVMWithNoNamespaceFix);
2194   verifyFormat("inline namespace X {\n"
2195                "class A {};\n"
2196                "void f() { f(); }\n"
2197                "}",
2198                LLVMWithNoNamespaceFix);
2199   verifyFormat("/* something */ inline namespace X {\n"
2200                "class A {};\n"
2201                "void f() { f(); }\n"
2202                "}",
2203                LLVMWithNoNamespaceFix);
2204   verifyFormat("export namespace X {\n"
2205                "class A {};\n"
2206                "void f() { f(); }\n"
2207                "}",
2208                LLVMWithNoNamespaceFix);
2209   verifyFormat("using namespace some_namespace;\n"
2210                "class A {};\n"
2211                "void f() { f(); }",
2212                LLVMWithNoNamespaceFix);
2213 
2214   // This code is more common than we thought; if we
2215   // layout this correctly the semicolon will go into
2216   // its own line, which is undesirable.
2217   verifyFormat("namespace {};", LLVMWithNoNamespaceFix);
2218   verifyFormat("namespace {\n"
2219                "class A {};\n"
2220                "};",
2221                LLVMWithNoNamespaceFix);
2222 
2223   verifyFormat("namespace {\n"
2224                "int SomeVariable = 0; // comment\n"
2225                "} // namespace",
2226                LLVMWithNoNamespaceFix);
2227   EXPECT_EQ("#ifndef HEADER_GUARD\n"
2228             "#define HEADER_GUARD\n"
2229             "namespace my_namespace {\n"
2230             "int i;\n"
2231             "} // my_namespace\n"
2232             "#endif // HEADER_GUARD",
2233             format("#ifndef HEADER_GUARD\n"
2234                    " #define HEADER_GUARD\n"
2235                    "   namespace my_namespace {\n"
2236                    "int i;\n"
2237                    "}    // my_namespace\n"
2238                    "#endif    // HEADER_GUARD",
2239                    LLVMWithNoNamespaceFix));
2240 
2241   EXPECT_EQ("namespace A::B {\n"
2242             "class C {};\n"
2243             "}",
2244             format("namespace A::B {\n"
2245                    "class C {};\n"
2246                    "}",
2247                    LLVMWithNoNamespaceFix));
2248 
2249   FormatStyle Style = getLLVMStyle();
2250   Style.NamespaceIndentation = FormatStyle::NI_All;
2251   EXPECT_EQ("namespace out {\n"
2252             "  int i;\n"
2253             "  namespace in {\n"
2254             "    int i;\n"
2255             "  } // namespace in\n"
2256             "} // namespace out",
2257             format("namespace out {\n"
2258                    "int i;\n"
2259                    "namespace in {\n"
2260                    "int i;\n"
2261                    "} // namespace in\n"
2262                    "} // namespace out",
2263                    Style));
2264 
2265   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2266   EXPECT_EQ("namespace out {\n"
2267             "int i;\n"
2268             "namespace in {\n"
2269             "  int i;\n"
2270             "} // namespace in\n"
2271             "} // namespace out",
2272             format("namespace out {\n"
2273                    "int i;\n"
2274                    "namespace in {\n"
2275                    "int i;\n"
2276                    "} // namespace in\n"
2277                    "} // namespace out",
2278                    Style));
2279 }
2280 
2281 TEST_F(FormatTest, NamespaceMacros) {
2282   FormatStyle Style = getLLVMStyle();
2283   Style.NamespaceMacros.push_back("TESTSUITE");
2284 
2285   verifyFormat("TESTSUITE(A) {\n"
2286                "int foo();\n"
2287                "} // TESTSUITE(A)",
2288                Style);
2289 
2290   verifyFormat("TESTSUITE(A, B) {\n"
2291                "int foo();\n"
2292                "} // TESTSUITE(A)",
2293                Style);
2294 
2295   // Properly indent according to NamespaceIndentation style
2296   Style.NamespaceIndentation = FormatStyle::NI_All;
2297   verifyFormat("TESTSUITE(A) {\n"
2298                "  int foo();\n"
2299                "} // TESTSUITE(A)",
2300                Style);
2301   verifyFormat("TESTSUITE(A) {\n"
2302                "  namespace B {\n"
2303                "    int foo();\n"
2304                "  } // namespace B\n"
2305                "} // TESTSUITE(A)",
2306                Style);
2307   verifyFormat("namespace A {\n"
2308                "  TESTSUITE(B) {\n"
2309                "    int foo();\n"
2310                "  } // TESTSUITE(B)\n"
2311                "} // namespace A",
2312                Style);
2313 
2314   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2315   verifyFormat("TESTSUITE(A) {\n"
2316                "TESTSUITE(B) {\n"
2317                "  int foo();\n"
2318                "} // TESTSUITE(B)\n"
2319                "} // TESTSUITE(A)",
2320                Style);
2321   verifyFormat("TESTSUITE(A) {\n"
2322                "namespace B {\n"
2323                "  int foo();\n"
2324                "} // namespace B\n"
2325                "} // TESTSUITE(A)",
2326                Style);
2327   verifyFormat("namespace A {\n"
2328                "TESTSUITE(B) {\n"
2329                "  int foo();\n"
2330                "} // TESTSUITE(B)\n"
2331                "} // namespace A",
2332                Style);
2333 
2334   // Properly merge namespace-macros blocks in CompactNamespaces mode
2335   Style.NamespaceIndentation = FormatStyle::NI_None;
2336   Style.CompactNamespaces = true;
2337   verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
2338                "}} // TESTSUITE(A::B)",
2339                Style);
2340 
2341   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2342             "}} // TESTSUITE(out::in)",
2343             format("TESTSUITE(out) {\n"
2344                    "TESTSUITE(in) {\n"
2345                    "} // TESTSUITE(in)\n"
2346                    "} // TESTSUITE(out)",
2347                    Style));
2348 
2349   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2350             "}} // TESTSUITE(out::in)",
2351             format("TESTSUITE(out) {\n"
2352                    "TESTSUITE(in) {\n"
2353                    "} // TESTSUITE(in)\n"
2354                    "} // TESTSUITE(out)",
2355                    Style));
2356 
2357   // Do not merge different namespaces/macros
2358   EXPECT_EQ("namespace out {\n"
2359             "TESTSUITE(in) {\n"
2360             "} // TESTSUITE(in)\n"
2361             "} // namespace out",
2362             format("namespace out {\n"
2363                    "TESTSUITE(in) {\n"
2364                    "} // TESTSUITE(in)\n"
2365                    "} // namespace out",
2366                    Style));
2367   EXPECT_EQ("TESTSUITE(out) {\n"
2368             "namespace in {\n"
2369             "} // namespace in\n"
2370             "} // TESTSUITE(out)",
2371             format("TESTSUITE(out) {\n"
2372                    "namespace in {\n"
2373                    "} // namespace in\n"
2374                    "} // TESTSUITE(out)",
2375                    Style));
2376   Style.NamespaceMacros.push_back("FOOBAR");
2377   EXPECT_EQ("TESTSUITE(out) {\n"
2378             "FOOBAR(in) {\n"
2379             "} // FOOBAR(in)\n"
2380             "} // TESTSUITE(out)",
2381             format("TESTSUITE(out) {\n"
2382                    "FOOBAR(in) {\n"
2383                    "} // FOOBAR(in)\n"
2384                    "} // TESTSUITE(out)",
2385                    Style));
2386 }
2387 
2388 TEST_F(FormatTest, FormatsCompactNamespaces) {
2389   FormatStyle Style = getLLVMStyle();
2390   Style.CompactNamespaces = true;
2391   Style.NamespaceMacros.push_back("TESTSUITE");
2392 
2393   verifyFormat("namespace A { namespace B {\n"
2394                "}} // namespace A::B",
2395                Style);
2396 
2397   EXPECT_EQ("namespace out { namespace in {\n"
2398             "}} // namespace out::in",
2399             format("namespace out {\n"
2400                    "namespace in {\n"
2401                    "} // namespace in\n"
2402                    "} // namespace out",
2403                    Style));
2404 
2405   // Only namespaces which have both consecutive opening and end get compacted
2406   EXPECT_EQ("namespace out {\n"
2407             "namespace in1 {\n"
2408             "} // namespace in1\n"
2409             "namespace in2 {\n"
2410             "} // namespace in2\n"
2411             "} // namespace out",
2412             format("namespace out {\n"
2413                    "namespace in1 {\n"
2414                    "} // namespace in1\n"
2415                    "namespace in2 {\n"
2416                    "} // namespace in2\n"
2417                    "} // namespace out",
2418                    Style));
2419 
2420   EXPECT_EQ("namespace out {\n"
2421             "int i;\n"
2422             "namespace in {\n"
2423             "int j;\n"
2424             "} // namespace in\n"
2425             "int k;\n"
2426             "} // namespace out",
2427             format("namespace out { int i;\n"
2428                    "namespace in { int j; } // namespace in\n"
2429                    "int k; } // namespace out",
2430                    Style));
2431 
2432   EXPECT_EQ("namespace A { namespace B { namespace C {\n"
2433             "}}} // namespace A::B::C\n",
2434             format("namespace A { namespace B {\n"
2435                    "namespace C {\n"
2436                    "}} // namespace B::C\n"
2437                    "} // namespace A\n",
2438                    Style));
2439 
2440   Style.ColumnLimit = 40;
2441   EXPECT_EQ("namespace aaaaaaaaaa {\n"
2442             "namespace bbbbbbbbbb {\n"
2443             "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
2444             format("namespace aaaaaaaaaa {\n"
2445                    "namespace bbbbbbbbbb {\n"
2446                    "} // namespace bbbbbbbbbb\n"
2447                    "} // namespace aaaaaaaaaa",
2448                    Style));
2449 
2450   EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
2451             "namespace cccccc {\n"
2452             "}}} // namespace aaaaaa::bbbbbb::cccccc",
2453             format("namespace aaaaaa {\n"
2454                    "namespace bbbbbb {\n"
2455                    "namespace cccccc {\n"
2456                    "} // namespace cccccc\n"
2457                    "} // namespace bbbbbb\n"
2458                    "} // namespace aaaaaa",
2459                    Style));
2460   Style.ColumnLimit = 80;
2461 
2462   // Extra semicolon after 'inner' closing brace prevents merging
2463   EXPECT_EQ("namespace out { namespace in {\n"
2464             "}; } // namespace out::in",
2465             format("namespace out {\n"
2466                    "namespace in {\n"
2467                    "}; // namespace in\n"
2468                    "} // namespace out",
2469                    Style));
2470 
2471   // Extra semicolon after 'outer' closing brace is conserved
2472   EXPECT_EQ("namespace out { namespace in {\n"
2473             "}}; // namespace out::in",
2474             format("namespace out {\n"
2475                    "namespace in {\n"
2476                    "} // namespace in\n"
2477                    "}; // namespace out",
2478                    Style));
2479 
2480   Style.NamespaceIndentation = FormatStyle::NI_All;
2481   EXPECT_EQ("namespace out { namespace in {\n"
2482             "  int i;\n"
2483             "}} // namespace out::in",
2484             format("namespace out {\n"
2485                    "namespace in {\n"
2486                    "int i;\n"
2487                    "} // namespace in\n"
2488                    "} // namespace out",
2489                    Style));
2490   EXPECT_EQ("namespace out { namespace mid {\n"
2491             "  namespace in {\n"
2492             "    int j;\n"
2493             "  } // namespace in\n"
2494             "  int k;\n"
2495             "}} // namespace out::mid",
2496             format("namespace out { namespace mid {\n"
2497                    "namespace in { int j; } // namespace in\n"
2498                    "int k; }} // namespace out::mid",
2499                    Style));
2500 
2501   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2502   EXPECT_EQ("namespace out { namespace in {\n"
2503             "  int i;\n"
2504             "}} // namespace out::in",
2505             format("namespace out {\n"
2506                    "namespace in {\n"
2507                    "int i;\n"
2508                    "} // namespace in\n"
2509                    "} // namespace out",
2510                    Style));
2511   EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
2512             "  int i;\n"
2513             "}}} // namespace out::mid::in",
2514             format("namespace out {\n"
2515                    "namespace mid {\n"
2516                    "namespace in {\n"
2517                    "int i;\n"
2518                    "} // namespace in\n"
2519                    "} // namespace mid\n"
2520                    "} // namespace out",
2521                    Style));
2522 }
2523 
2524 TEST_F(FormatTest, FormatsExternC) {
2525   verifyFormat("extern \"C\" {\nint a;");
2526   verifyFormat("extern \"C\" {}");
2527   verifyFormat("extern \"C\" {\n"
2528                "int foo();\n"
2529                "}");
2530   verifyFormat("extern \"C\" int foo() {}");
2531   verifyFormat("extern \"C\" int foo();");
2532   verifyFormat("extern \"C\" int foo() {\n"
2533                "  int i = 42;\n"
2534                "  return i;\n"
2535                "}");
2536 
2537   FormatStyle Style = getLLVMStyle();
2538   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2539   Style.BraceWrapping.AfterFunction = true;
2540   verifyFormat("extern \"C\" int foo() {}", Style);
2541   verifyFormat("extern \"C\" int foo();", Style);
2542   verifyFormat("extern \"C\" int foo()\n"
2543                "{\n"
2544                "  int i = 42;\n"
2545                "  return i;\n"
2546                "}",
2547                Style);
2548 
2549   Style.BraceWrapping.AfterExternBlock = true;
2550   Style.BraceWrapping.SplitEmptyRecord = false;
2551   verifyFormat("extern \"C\"\n"
2552                "{}",
2553                Style);
2554   verifyFormat("extern \"C\"\n"
2555                "{\n"
2556                "  int foo();\n"
2557                "}",
2558                Style);
2559 }
2560 
2561 TEST_F(FormatTest, IndentExternBlockStyle) {
2562   FormatStyle Style = getLLVMStyle();
2563   Style.IndentWidth = 2;
2564 
2565   Style.IndentExternBlock = FormatStyle::IEBS_Indent;
2566   verifyFormat("extern \"C\" { /*9*/\n}", Style);
2567   verifyFormat("extern \"C\" {\n"
2568                "  int foo10();\n"
2569                "}",
2570                Style);
2571 
2572   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
2573   verifyFormat("extern \"C\" { /*11*/\n}", Style);
2574   verifyFormat("extern \"C\" {\n"
2575                "int foo12();\n"
2576                "}",
2577                Style);
2578 
2579   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2580   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2581   Style.BraceWrapping.AfterExternBlock = true;
2582   verifyFormat("extern \"C\"\n{ /*13*/\n}", Style);
2583   verifyFormat("extern \"C\"\n{\n"
2584                "  int foo14();\n"
2585                "}",
2586                Style);
2587 
2588   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2589   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2590   Style.BraceWrapping.AfterExternBlock = false;
2591   verifyFormat("extern \"C\" { /*15*/\n}", Style);
2592   verifyFormat("extern \"C\" {\n"
2593                "int foo16();\n"
2594                "}",
2595                Style);
2596 }
2597 
2598 TEST_F(FormatTest, FormatsInlineASM) {
2599   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
2600   verifyFormat("asm(\"nop\" ::: \"memory\");");
2601   verifyFormat(
2602       "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
2603       "    \"cpuid\\n\\t\"\n"
2604       "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
2605       "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
2606       "    : \"a\"(value));");
2607   EXPECT_EQ(
2608       "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
2609       "  __asm {\n"
2610       "        mov     edx,[that] // vtable in edx\n"
2611       "        mov     eax,methodIndex\n"
2612       "        call    [edx][eax*4] // stdcall\n"
2613       "  }\n"
2614       "}",
2615       format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
2616              "    __asm {\n"
2617              "        mov     edx,[that] // vtable in edx\n"
2618              "        mov     eax,methodIndex\n"
2619              "        call    [edx][eax*4] // stdcall\n"
2620              "    }\n"
2621              "}"));
2622   EXPECT_EQ("_asm {\n"
2623             "  xor eax, eax;\n"
2624             "  cpuid;\n"
2625             "}",
2626             format("_asm {\n"
2627                    "  xor eax, eax;\n"
2628                    "  cpuid;\n"
2629                    "}"));
2630   verifyFormat("void function() {\n"
2631                "  // comment\n"
2632                "  asm(\"\");\n"
2633                "}");
2634   EXPECT_EQ("__asm {\n"
2635             "}\n"
2636             "int i;",
2637             format("__asm   {\n"
2638                    "}\n"
2639                    "int   i;"));
2640 }
2641 
2642 TEST_F(FormatTest, FormatTryCatch) {
2643   verifyFormat("try {\n"
2644                "  throw a * b;\n"
2645                "} catch (int a) {\n"
2646                "  // Do nothing.\n"
2647                "} catch (...) {\n"
2648                "  exit(42);\n"
2649                "}");
2650 
2651   // Function-level try statements.
2652   verifyFormat("int f() try { return 4; } catch (...) {\n"
2653                "  return 5;\n"
2654                "}");
2655   verifyFormat("class A {\n"
2656                "  int a;\n"
2657                "  A() try : a(0) {\n"
2658                "  } catch (...) {\n"
2659                "    throw;\n"
2660                "  }\n"
2661                "};\n");
2662 
2663   // Incomplete try-catch blocks.
2664   verifyIncompleteFormat("try {} catch (");
2665 }
2666 
2667 TEST_F(FormatTest, FormatSEHTryCatch) {
2668   verifyFormat("__try {\n"
2669                "  int a = b * c;\n"
2670                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2671                "  // Do nothing.\n"
2672                "}");
2673 
2674   verifyFormat("__try {\n"
2675                "  int a = b * c;\n"
2676                "} __finally {\n"
2677                "  // Do nothing.\n"
2678                "}");
2679 
2680   verifyFormat("DEBUG({\n"
2681                "  __try {\n"
2682                "  } __finally {\n"
2683                "  }\n"
2684                "});\n");
2685 }
2686 
2687 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2688   verifyFormat("try {\n"
2689                "  f();\n"
2690                "} catch {\n"
2691                "  g();\n"
2692                "}");
2693   verifyFormat("try {\n"
2694                "  f();\n"
2695                "} catch (A a) MACRO(x) {\n"
2696                "  g();\n"
2697                "} catch (B b) MACRO(x) {\n"
2698                "  g();\n"
2699                "}");
2700 }
2701 
2702 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2703   FormatStyle Style = getLLVMStyle();
2704   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2705                           FormatStyle::BS_WebKit}) {
2706     Style.BreakBeforeBraces = BraceStyle;
2707     verifyFormat("try {\n"
2708                  "  // something\n"
2709                  "} catch (...) {\n"
2710                  "  // something\n"
2711                  "}",
2712                  Style);
2713   }
2714   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2715   verifyFormat("try {\n"
2716                "  // something\n"
2717                "}\n"
2718                "catch (...) {\n"
2719                "  // something\n"
2720                "}",
2721                Style);
2722   verifyFormat("__try {\n"
2723                "  // something\n"
2724                "}\n"
2725                "__finally {\n"
2726                "  // something\n"
2727                "}",
2728                Style);
2729   verifyFormat("@try {\n"
2730                "  // something\n"
2731                "}\n"
2732                "@finally {\n"
2733                "  // something\n"
2734                "}",
2735                Style);
2736   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2737   verifyFormat("try\n"
2738                "{\n"
2739                "  // something\n"
2740                "}\n"
2741                "catch (...)\n"
2742                "{\n"
2743                "  // something\n"
2744                "}",
2745                Style);
2746   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2747   verifyFormat("try\n"
2748                "  {\n"
2749                "  // something white\n"
2750                "  }\n"
2751                "catch (...)\n"
2752                "  {\n"
2753                "  // something white\n"
2754                "  }",
2755                Style);
2756   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2757   verifyFormat("try\n"
2758                "  {\n"
2759                "    // something\n"
2760                "  }\n"
2761                "catch (...)\n"
2762                "  {\n"
2763                "    // something\n"
2764                "  }",
2765                Style);
2766   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2767   Style.BraceWrapping.BeforeCatch = true;
2768   verifyFormat("try {\n"
2769                "  // something\n"
2770                "}\n"
2771                "catch (...) {\n"
2772                "  // something\n"
2773                "}",
2774                Style);
2775 }
2776 
2777 TEST_F(FormatTest, StaticInitializers) {
2778   verifyFormat("static SomeClass SC = {1, 'a'};");
2779 
2780   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2781                "    100000000, "
2782                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2783 
2784   // Here, everything other than the "}" would fit on a line.
2785   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2786                "    10000000000000000000000000};");
2787   EXPECT_EQ("S s = {a,\n"
2788             "\n"
2789             "       b};",
2790             format("S s = {\n"
2791                    "  a,\n"
2792                    "\n"
2793                    "  b\n"
2794                    "};"));
2795 
2796   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2797   // line. However, the formatting looks a bit off and this probably doesn't
2798   // happen often in practice.
2799   verifyFormat("static int Variable[1] = {\n"
2800                "    {1000000000000000000000000000000000000}};",
2801                getLLVMStyleWithColumns(40));
2802 }
2803 
2804 TEST_F(FormatTest, DesignatedInitializers) {
2805   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2806   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2807                "                    .bbbbbbbbbb = 2,\n"
2808                "                    .cccccccccc = 3,\n"
2809                "                    .dddddddddd = 4,\n"
2810                "                    .eeeeeeeeee = 5};");
2811   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2812                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2813                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2814                "    .ccccccccccccccccccccccccccc = 3,\n"
2815                "    .ddddddddddddddddddddddddddd = 4,\n"
2816                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2817 
2818   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2819 
2820   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2821   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2822                "                    [2] = bbbbbbbbbb,\n"
2823                "                    [3] = cccccccccc,\n"
2824                "                    [4] = dddddddddd,\n"
2825                "                    [5] = eeeeeeeeee};");
2826   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2827                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2828                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2829                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2830                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2831                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2832 }
2833 
2834 TEST_F(FormatTest, NestedStaticInitializers) {
2835   verifyFormat("static A x = {{{}}};\n");
2836   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2837                "               {init1, init2, init3, init4}}};",
2838                getLLVMStyleWithColumns(50));
2839 
2840   verifyFormat("somes Status::global_reps[3] = {\n"
2841                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2842                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2843                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2844                getLLVMStyleWithColumns(60));
2845   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2846                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2847                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2848                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2849   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2850                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
2851                "rect.fTop}};");
2852 
2853   verifyFormat(
2854       "SomeArrayOfSomeType a = {\n"
2855       "    {{1, 2, 3},\n"
2856       "     {1, 2, 3},\n"
2857       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
2858       "      333333333333333333333333333333},\n"
2859       "     {1, 2, 3},\n"
2860       "     {1, 2, 3}}};");
2861   verifyFormat(
2862       "SomeArrayOfSomeType a = {\n"
2863       "    {{1, 2, 3}},\n"
2864       "    {{1, 2, 3}},\n"
2865       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2866       "      333333333333333333333333333333}},\n"
2867       "    {{1, 2, 3}},\n"
2868       "    {{1, 2, 3}}};");
2869 
2870   verifyFormat("struct {\n"
2871                "  unsigned bit;\n"
2872                "  const char *const name;\n"
2873                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2874                "                 {kOsWin, \"Windows\"},\n"
2875                "                 {kOsLinux, \"Linux\"},\n"
2876                "                 {kOsCrOS, \"Chrome OS\"}};");
2877   verifyFormat("struct {\n"
2878                "  unsigned bit;\n"
2879                "  const char *const name;\n"
2880                "} kBitsToOs[] = {\n"
2881                "    {kOsMac, \"Mac\"},\n"
2882                "    {kOsWin, \"Windows\"},\n"
2883                "    {kOsLinux, \"Linux\"},\n"
2884                "    {kOsCrOS, \"Chrome OS\"},\n"
2885                "};");
2886 }
2887 
2888 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2889   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2890                "                      \\\n"
2891                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2892 }
2893 
2894 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
2895   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2896                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
2897 
2898   // Do break defaulted and deleted functions.
2899   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2900                "    default;",
2901                getLLVMStyleWithColumns(40));
2902   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2903                "    delete;",
2904                getLLVMStyleWithColumns(40));
2905 }
2906 
2907 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2908   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2909                getLLVMStyleWithColumns(40));
2910   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2911                getLLVMStyleWithColumns(40));
2912   EXPECT_EQ("#define Q                              \\\n"
2913             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
2914             "  \"aaaaaaaa.cpp\"",
2915             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2916                    getLLVMStyleWithColumns(40)));
2917 }
2918 
2919 TEST_F(FormatTest, UnderstandsLinePPDirective) {
2920   EXPECT_EQ("# 123 \"A string literal\"",
2921             format("   #     123    \"A string literal\""));
2922 }
2923 
2924 TEST_F(FormatTest, LayoutUnknownPPDirective) {
2925   EXPECT_EQ("#;", format("#;"));
2926   verifyFormat("#\n;\n;\n;");
2927 }
2928 
2929 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
2930   EXPECT_EQ("#line 42 \"test\"\n",
2931             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
2932   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
2933                                     getLLVMStyleWithColumns(12)));
2934 }
2935 
2936 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
2937   EXPECT_EQ("#line 42 \"test\"",
2938             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
2939   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
2940 }
2941 
2942 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
2943   verifyFormat("#define A \\x20");
2944   verifyFormat("#define A \\ x20");
2945   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
2946   verifyFormat("#define A ''");
2947   verifyFormat("#define A ''qqq");
2948   verifyFormat("#define A `qqq");
2949   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
2950   EXPECT_EQ("const char *c = STRINGIFY(\n"
2951             "\\na : b);",
2952             format("const char * c = STRINGIFY(\n"
2953                    "\\na : b);"));
2954 
2955   verifyFormat("a\r\\");
2956   verifyFormat("a\v\\");
2957   verifyFormat("a\f\\");
2958 }
2959 
2960 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
2961   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
2962   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
2963   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
2964   // FIXME: We never break before the macro name.
2965   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
2966 
2967   verifyFormat("#define A A\n#define A A");
2968   verifyFormat("#define A(X) A\n#define A A");
2969 
2970   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
2971   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
2972 }
2973 
2974 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
2975   EXPECT_EQ("// somecomment\n"
2976             "#include \"a.h\"\n"
2977             "#define A(  \\\n"
2978             "    A, B)\n"
2979             "#include \"b.h\"\n"
2980             "// somecomment\n",
2981             format("  // somecomment\n"
2982                    "  #include \"a.h\"\n"
2983                    "#define A(A,\\\n"
2984                    "    B)\n"
2985                    "    #include \"b.h\"\n"
2986                    " // somecomment\n",
2987                    getLLVMStyleWithColumns(13)));
2988 }
2989 
2990 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
2991 
2992 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
2993   EXPECT_EQ("#define A    \\\n"
2994             "  c;         \\\n"
2995             "  e;\n"
2996             "f;",
2997             format("#define A c; e;\n"
2998                    "f;",
2999                    getLLVMStyleWithColumns(14)));
3000 }
3001 
3002 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
3003 
3004 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
3005   EXPECT_EQ("int x,\n"
3006             "#define A\n"
3007             "    y;",
3008             format("int x,\n#define A\ny;"));
3009 }
3010 
3011 TEST_F(FormatTest, HashInMacroDefinition) {
3012   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
3013   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
3014   verifyFormat("#define A  \\\n"
3015                "  {        \\\n"
3016                "    f(#c); \\\n"
3017                "  }",
3018                getLLVMStyleWithColumns(11));
3019 
3020   verifyFormat("#define A(X)         \\\n"
3021                "  void function##X()",
3022                getLLVMStyleWithColumns(22));
3023 
3024   verifyFormat("#define A(a, b, c)   \\\n"
3025                "  void a##b##c()",
3026                getLLVMStyleWithColumns(22));
3027 
3028   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
3029 }
3030 
3031 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
3032   EXPECT_EQ("#define A (x)", format("#define A (x)"));
3033   EXPECT_EQ("#define A(x)", format("#define A(x)"));
3034 
3035   FormatStyle Style = getLLVMStyle();
3036   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
3037   verifyFormat("#define true ((foo)1)", Style);
3038   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
3039   verifyFormat("#define false((foo)0)", Style);
3040 }
3041 
3042 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
3043   EXPECT_EQ("#define A b;", format("#define A \\\n"
3044                                    "          \\\n"
3045                                    "  b;",
3046                                    getLLVMStyleWithColumns(25)));
3047   EXPECT_EQ("#define A \\\n"
3048             "          \\\n"
3049             "  a;      \\\n"
3050             "  b;",
3051             format("#define A \\\n"
3052                    "          \\\n"
3053                    "  a;      \\\n"
3054                    "  b;",
3055                    getLLVMStyleWithColumns(11)));
3056   EXPECT_EQ("#define A \\\n"
3057             "  a;      \\\n"
3058             "          \\\n"
3059             "  b;",
3060             format("#define A \\\n"
3061                    "  a;      \\\n"
3062                    "          \\\n"
3063                    "  b;",
3064                    getLLVMStyleWithColumns(11)));
3065 }
3066 
3067 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
3068   verifyIncompleteFormat("#define A :");
3069   verifyFormat("#define SOMECASES  \\\n"
3070                "  case 1:          \\\n"
3071                "  case 2\n",
3072                getLLVMStyleWithColumns(20));
3073   verifyFormat("#define MACRO(a) \\\n"
3074                "  if (a)         \\\n"
3075                "    f();         \\\n"
3076                "  else           \\\n"
3077                "    g()",
3078                getLLVMStyleWithColumns(18));
3079   verifyFormat("#define A template <typename T>");
3080   verifyIncompleteFormat("#define STR(x) #x\n"
3081                          "f(STR(this_is_a_string_literal{));");
3082   verifyFormat("#pragma omp threadprivate( \\\n"
3083                "    y)), // expected-warning",
3084                getLLVMStyleWithColumns(28));
3085   verifyFormat("#d, = };");
3086   verifyFormat("#if \"a");
3087   verifyIncompleteFormat("({\n"
3088                          "#define b     \\\n"
3089                          "  }           \\\n"
3090                          "  a\n"
3091                          "a",
3092                          getLLVMStyleWithColumns(15));
3093   verifyFormat("#define A     \\\n"
3094                "  {           \\\n"
3095                "    {\n"
3096                "#define B     \\\n"
3097                "  }           \\\n"
3098                "  }",
3099                getLLVMStyleWithColumns(15));
3100   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
3101   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
3102   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
3103   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
3104 }
3105 
3106 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
3107   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
3108   EXPECT_EQ("class A : public QObject {\n"
3109             "  Q_OBJECT\n"
3110             "\n"
3111             "  A() {}\n"
3112             "};",
3113             format("class A  :  public QObject {\n"
3114                    "     Q_OBJECT\n"
3115                    "\n"
3116                    "  A() {\n}\n"
3117                    "}  ;"));
3118   EXPECT_EQ("MACRO\n"
3119             "/*static*/ int i;",
3120             format("MACRO\n"
3121                    " /*static*/ int   i;"));
3122   EXPECT_EQ("SOME_MACRO\n"
3123             "namespace {\n"
3124             "void f();\n"
3125             "} // namespace",
3126             format("SOME_MACRO\n"
3127                    "  namespace    {\n"
3128                    "void   f(  );\n"
3129                    "} // namespace"));
3130   // Only if the identifier contains at least 5 characters.
3131   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
3132   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
3133   // Only if everything is upper case.
3134   EXPECT_EQ("class A : public QObject {\n"
3135             "  Q_Object A() {}\n"
3136             "};",
3137             format("class A  :  public QObject {\n"
3138                    "     Q_Object\n"
3139                    "  A() {\n}\n"
3140                    "}  ;"));
3141 
3142   // Only if the next line can actually start an unwrapped line.
3143   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
3144             format("SOME_WEIRD_LOG_MACRO\n"
3145                    "<< SomeThing;"));
3146 
3147   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3148                "(n, buffers))\n",
3149                getChromiumStyle(FormatStyle::LK_Cpp));
3150 
3151   // See PR41483
3152   EXPECT_EQ("/**/ FOO(a)\n"
3153             "FOO(b)",
3154             format("/**/ FOO(a)\n"
3155                    "FOO(b)"));
3156 }
3157 
3158 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
3159   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3160             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3161             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3162             "class X {};\n"
3163             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3164             "int *createScopDetectionPass() { return 0; }",
3165             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3166                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3167                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3168                    "  class X {};\n"
3169                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3170                    "  int *createScopDetectionPass() { return 0; }"));
3171   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
3172   // braces, so that inner block is indented one level more.
3173   EXPECT_EQ("int q() {\n"
3174             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3175             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3176             "  IPC_END_MESSAGE_MAP()\n"
3177             "}",
3178             format("int q() {\n"
3179                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3180                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3181                    "  IPC_END_MESSAGE_MAP()\n"
3182                    "}"));
3183 
3184   // Same inside macros.
3185   EXPECT_EQ("#define LIST(L) \\\n"
3186             "  L(A)          \\\n"
3187             "  L(B)          \\\n"
3188             "  L(C)",
3189             format("#define LIST(L) \\\n"
3190                    "  L(A) \\\n"
3191                    "  L(B) \\\n"
3192                    "  L(C)",
3193                    getGoogleStyle()));
3194 
3195   // These must not be recognized as macros.
3196   EXPECT_EQ("int q() {\n"
3197             "  f(x);\n"
3198             "  f(x) {}\n"
3199             "  f(x)->g();\n"
3200             "  f(x)->*g();\n"
3201             "  f(x).g();\n"
3202             "  f(x) = x;\n"
3203             "  f(x) += x;\n"
3204             "  f(x) -= x;\n"
3205             "  f(x) *= x;\n"
3206             "  f(x) /= x;\n"
3207             "  f(x) %= x;\n"
3208             "  f(x) &= x;\n"
3209             "  f(x) |= x;\n"
3210             "  f(x) ^= x;\n"
3211             "  f(x) >>= x;\n"
3212             "  f(x) <<= x;\n"
3213             "  f(x)[y].z();\n"
3214             "  LOG(INFO) << x;\n"
3215             "  ifstream(x) >> x;\n"
3216             "}\n",
3217             format("int q() {\n"
3218                    "  f(x)\n;\n"
3219                    "  f(x)\n {}\n"
3220                    "  f(x)\n->g();\n"
3221                    "  f(x)\n->*g();\n"
3222                    "  f(x)\n.g();\n"
3223                    "  f(x)\n = x;\n"
3224                    "  f(x)\n += x;\n"
3225                    "  f(x)\n -= x;\n"
3226                    "  f(x)\n *= x;\n"
3227                    "  f(x)\n /= x;\n"
3228                    "  f(x)\n %= x;\n"
3229                    "  f(x)\n &= x;\n"
3230                    "  f(x)\n |= x;\n"
3231                    "  f(x)\n ^= x;\n"
3232                    "  f(x)\n >>= x;\n"
3233                    "  f(x)\n <<= x;\n"
3234                    "  f(x)\n[y].z();\n"
3235                    "  LOG(INFO)\n << x;\n"
3236                    "  ifstream(x)\n >> x;\n"
3237                    "}\n"));
3238   EXPECT_EQ("int q() {\n"
3239             "  F(x)\n"
3240             "  if (1) {\n"
3241             "  }\n"
3242             "  F(x)\n"
3243             "  while (1) {\n"
3244             "  }\n"
3245             "  F(x)\n"
3246             "  G(x);\n"
3247             "  F(x)\n"
3248             "  try {\n"
3249             "    Q();\n"
3250             "  } catch (...) {\n"
3251             "  }\n"
3252             "}\n",
3253             format("int q() {\n"
3254                    "F(x)\n"
3255                    "if (1) {}\n"
3256                    "F(x)\n"
3257                    "while (1) {}\n"
3258                    "F(x)\n"
3259                    "G(x);\n"
3260                    "F(x)\n"
3261                    "try { Q(); } catch (...) {}\n"
3262                    "}\n"));
3263   EXPECT_EQ("class A {\n"
3264             "  A() : t(0) {}\n"
3265             "  A(int i) noexcept() : {}\n"
3266             "  A(X x)\n" // FIXME: function-level try blocks are broken.
3267             "  try : t(0) {\n"
3268             "  } catch (...) {\n"
3269             "  }\n"
3270             "};",
3271             format("class A {\n"
3272                    "  A()\n : t(0) {}\n"
3273                    "  A(int i)\n noexcept() : {}\n"
3274                    "  A(X x)\n"
3275                    "  try : t(0) {} catch (...) {}\n"
3276                    "};"));
3277   FormatStyle Style = getLLVMStyle();
3278   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3279   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3280   Style.BraceWrapping.AfterFunction = true;
3281   EXPECT_EQ("void f()\n"
3282             "try\n"
3283             "{\n"
3284             "}",
3285             format("void f() try {\n"
3286                    "}",
3287                    Style));
3288   EXPECT_EQ("class SomeClass {\n"
3289             "public:\n"
3290             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3291             "};",
3292             format("class SomeClass {\n"
3293                    "public:\n"
3294                    "  SomeClass()\n"
3295                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3296                    "};"));
3297   EXPECT_EQ("class SomeClass {\n"
3298             "public:\n"
3299             "  SomeClass()\n"
3300             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3301             "};",
3302             format("class SomeClass {\n"
3303                    "public:\n"
3304                    "  SomeClass()\n"
3305                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3306                    "};",
3307                    getLLVMStyleWithColumns(40)));
3308 
3309   verifyFormat("MACRO(>)");
3310 
3311   // Some macros contain an implicit semicolon.
3312   Style = getLLVMStyle();
3313   Style.StatementMacros.push_back("FOO");
3314   verifyFormat("FOO(a) int b = 0;");
3315   verifyFormat("FOO(a)\n"
3316                "int b = 0;",
3317                Style);
3318   verifyFormat("FOO(a);\n"
3319                "int b = 0;",
3320                Style);
3321   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3322                "int b = 0;",
3323                Style);
3324   verifyFormat("FOO()\n"
3325                "int b = 0;",
3326                Style);
3327   verifyFormat("FOO\n"
3328                "int b = 0;",
3329                Style);
3330   verifyFormat("void f() {\n"
3331                "  FOO(a)\n"
3332                "  return a;\n"
3333                "}",
3334                Style);
3335   verifyFormat("FOO(a)\n"
3336                "FOO(b)",
3337                Style);
3338   verifyFormat("int a = 0;\n"
3339                "FOO(b)\n"
3340                "int c = 0;",
3341                Style);
3342   verifyFormat("int a = 0;\n"
3343                "int x = FOO(a)\n"
3344                "int b = 0;",
3345                Style);
3346   verifyFormat("void foo(int a) { FOO(a) }\n"
3347                "uint32_t bar() {}",
3348                Style);
3349 }
3350 
3351 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3352   verifyFormat("#define A \\\n"
3353                "  f({     \\\n"
3354                "    g();  \\\n"
3355                "  });",
3356                getLLVMStyleWithColumns(11));
3357 }
3358 
3359 TEST_F(FormatTest, IndentPreprocessorDirectives) {
3360   FormatStyle Style = getLLVMStyle();
3361   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3362   Style.ColumnLimit = 40;
3363   verifyFormat("#ifdef _WIN32\n"
3364                "#define A 0\n"
3365                "#ifdef VAR2\n"
3366                "#define B 1\n"
3367                "#include <someheader.h>\n"
3368                "#define MACRO                          \\\n"
3369                "  some_very_long_func_aaaaaaaaaa();\n"
3370                "#endif\n"
3371                "#else\n"
3372                "#define A 1\n"
3373                "#endif",
3374                Style);
3375   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3376   verifyFormat("#ifdef _WIN32\n"
3377                "#  define A 0\n"
3378                "#  ifdef VAR2\n"
3379                "#    define B 1\n"
3380                "#    include <someheader.h>\n"
3381                "#    define MACRO                      \\\n"
3382                "      some_very_long_func_aaaaaaaaaa();\n"
3383                "#  endif\n"
3384                "#else\n"
3385                "#  define A 1\n"
3386                "#endif",
3387                Style);
3388   verifyFormat("#if A\n"
3389                "#  define MACRO                        \\\n"
3390                "    void a(int x) {                    \\\n"
3391                "      b();                             \\\n"
3392                "      c();                             \\\n"
3393                "      d();                             \\\n"
3394                "      e();                             \\\n"
3395                "      f();                             \\\n"
3396                "    }\n"
3397                "#endif",
3398                Style);
3399   // Comments before include guard.
3400   verifyFormat("// file comment\n"
3401                "// file comment\n"
3402                "#ifndef HEADER_H\n"
3403                "#define HEADER_H\n"
3404                "code();\n"
3405                "#endif",
3406                Style);
3407   // Test with include guards.
3408   verifyFormat("#ifndef HEADER_H\n"
3409                "#define HEADER_H\n"
3410                "code();\n"
3411                "#endif",
3412                Style);
3413   // Include guards must have a #define with the same variable immediately
3414   // after #ifndef.
3415   verifyFormat("#ifndef NOT_GUARD\n"
3416                "#  define FOO\n"
3417                "code();\n"
3418                "#endif",
3419                Style);
3420 
3421   // Include guards must cover the entire file.
3422   verifyFormat("code();\n"
3423                "code();\n"
3424                "#ifndef NOT_GUARD\n"
3425                "#  define NOT_GUARD\n"
3426                "code();\n"
3427                "#endif",
3428                Style);
3429   verifyFormat("#ifndef NOT_GUARD\n"
3430                "#  define NOT_GUARD\n"
3431                "code();\n"
3432                "#endif\n"
3433                "code();",
3434                Style);
3435   // Test with trailing blank lines.
3436   verifyFormat("#ifndef HEADER_H\n"
3437                "#define HEADER_H\n"
3438                "code();\n"
3439                "#endif\n",
3440                Style);
3441   // Include guards don't have #else.
3442   verifyFormat("#ifndef NOT_GUARD\n"
3443                "#  define NOT_GUARD\n"
3444                "code();\n"
3445                "#else\n"
3446                "#endif",
3447                Style);
3448   verifyFormat("#ifndef NOT_GUARD\n"
3449                "#  define NOT_GUARD\n"
3450                "code();\n"
3451                "#elif FOO\n"
3452                "#endif",
3453                Style);
3454   // Non-identifier #define after potential include guard.
3455   verifyFormat("#ifndef FOO\n"
3456                "#  define 1\n"
3457                "#endif\n",
3458                Style);
3459   // #if closes past last non-preprocessor line.
3460   verifyFormat("#ifndef FOO\n"
3461                "#define FOO\n"
3462                "#if 1\n"
3463                "int i;\n"
3464                "#  define A 0\n"
3465                "#endif\n"
3466                "#endif\n",
3467                Style);
3468   // Don't crash if there is an #elif directive without a condition.
3469   verifyFormat("#if 1\n"
3470                "int x;\n"
3471                "#elif\n"
3472                "int y;\n"
3473                "#else\n"
3474                "int z;\n"
3475                "#endif",
3476                Style);
3477   // FIXME: This doesn't handle the case where there's code between the
3478   // #ifndef and #define but all other conditions hold. This is because when
3479   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3480   // previous code line yet, so we can't detect it.
3481   EXPECT_EQ("#ifndef NOT_GUARD\n"
3482             "code();\n"
3483             "#define NOT_GUARD\n"
3484             "code();\n"
3485             "#endif",
3486             format("#ifndef NOT_GUARD\n"
3487                    "code();\n"
3488                    "#  define NOT_GUARD\n"
3489                    "code();\n"
3490                    "#endif",
3491                    Style));
3492   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3493   // be outside an include guard. Examples are #pragma once and
3494   // #pragma GCC diagnostic, or anything else that does not change the meaning
3495   // of the file if it's included multiple times.
3496   EXPECT_EQ("#ifdef WIN32\n"
3497             "#  pragma once\n"
3498             "#endif\n"
3499             "#ifndef HEADER_H\n"
3500             "#  define HEADER_H\n"
3501             "code();\n"
3502             "#endif",
3503             format("#ifdef WIN32\n"
3504                    "#  pragma once\n"
3505                    "#endif\n"
3506                    "#ifndef HEADER_H\n"
3507                    "#define HEADER_H\n"
3508                    "code();\n"
3509                    "#endif",
3510                    Style));
3511   // FIXME: This does not detect when there is a single non-preprocessor line
3512   // in front of an include-guard-like structure where other conditions hold
3513   // because ScopedLineState hides the line.
3514   EXPECT_EQ("code();\n"
3515             "#ifndef HEADER_H\n"
3516             "#define HEADER_H\n"
3517             "code();\n"
3518             "#endif",
3519             format("code();\n"
3520                    "#ifndef HEADER_H\n"
3521                    "#  define HEADER_H\n"
3522                    "code();\n"
3523                    "#endif",
3524                    Style));
3525   // Keep comments aligned with #, otherwise indent comments normally. These
3526   // tests cannot use verifyFormat because messUp manipulates leading
3527   // whitespace.
3528   {
3529     const char *Expected = ""
3530                            "void f() {\n"
3531                            "#if 1\n"
3532                            "// Preprocessor aligned.\n"
3533                            "#  define A 0\n"
3534                            "  // Code. Separated by blank line.\n"
3535                            "\n"
3536                            "#  define B 0\n"
3537                            "  // Code. Not aligned with #\n"
3538                            "#  define C 0\n"
3539                            "#endif";
3540     const char *ToFormat = ""
3541                            "void f() {\n"
3542                            "#if 1\n"
3543                            "// Preprocessor aligned.\n"
3544                            "#  define A 0\n"
3545                            "// Code. Separated by blank line.\n"
3546                            "\n"
3547                            "#  define B 0\n"
3548                            "   // Code. Not aligned with #\n"
3549                            "#  define C 0\n"
3550                            "#endif";
3551     EXPECT_EQ(Expected, format(ToFormat, Style));
3552     EXPECT_EQ(Expected, format(Expected, Style));
3553   }
3554   // Keep block quotes aligned.
3555   {
3556     const char *Expected = ""
3557                            "void f() {\n"
3558                            "#if 1\n"
3559                            "/* Preprocessor aligned. */\n"
3560                            "#  define A 0\n"
3561                            "  /* Code. Separated by blank line. */\n"
3562                            "\n"
3563                            "#  define B 0\n"
3564                            "  /* Code. Not aligned with # */\n"
3565                            "#  define C 0\n"
3566                            "#endif";
3567     const char *ToFormat = ""
3568                            "void f() {\n"
3569                            "#if 1\n"
3570                            "/* Preprocessor aligned. */\n"
3571                            "#  define A 0\n"
3572                            "/* Code. Separated by blank line. */\n"
3573                            "\n"
3574                            "#  define B 0\n"
3575                            "   /* Code. Not aligned with # */\n"
3576                            "#  define C 0\n"
3577                            "#endif";
3578     EXPECT_EQ(Expected, format(ToFormat, Style));
3579     EXPECT_EQ(Expected, format(Expected, Style));
3580   }
3581   // Keep comments aligned with un-indented directives.
3582   {
3583     const char *Expected = ""
3584                            "void f() {\n"
3585                            "// Preprocessor aligned.\n"
3586                            "#define A 0\n"
3587                            "  // Code. Separated by blank line.\n"
3588                            "\n"
3589                            "#define B 0\n"
3590                            "  // Code. Not aligned with #\n"
3591                            "#define C 0\n";
3592     const char *ToFormat = ""
3593                            "void f() {\n"
3594                            "// Preprocessor aligned.\n"
3595                            "#define A 0\n"
3596                            "// Code. Separated by blank line.\n"
3597                            "\n"
3598                            "#define B 0\n"
3599                            "   // Code. Not aligned with #\n"
3600                            "#define C 0\n";
3601     EXPECT_EQ(Expected, format(ToFormat, Style));
3602     EXPECT_EQ(Expected, format(Expected, Style));
3603   }
3604   // Test AfterHash with tabs.
3605   {
3606     FormatStyle Tabbed = Style;
3607     Tabbed.UseTab = FormatStyle::UT_Always;
3608     Tabbed.IndentWidth = 8;
3609     Tabbed.TabWidth = 8;
3610     verifyFormat("#ifdef _WIN32\n"
3611                  "#\tdefine A 0\n"
3612                  "#\tifdef VAR2\n"
3613                  "#\t\tdefine B 1\n"
3614                  "#\t\tinclude <someheader.h>\n"
3615                  "#\t\tdefine MACRO          \\\n"
3616                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3617                  "#\tendif\n"
3618                  "#else\n"
3619                  "#\tdefine A 1\n"
3620                  "#endif",
3621                  Tabbed);
3622   }
3623 
3624   // Regression test: Multiline-macro inside include guards.
3625   verifyFormat("#ifndef HEADER_H\n"
3626                "#define HEADER_H\n"
3627                "#define A()        \\\n"
3628                "  int i;           \\\n"
3629                "  int j;\n"
3630                "#endif // HEADER_H",
3631                getLLVMStyleWithColumns(20));
3632 
3633   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3634   // Basic before hash indent tests
3635   verifyFormat("#ifdef _WIN32\n"
3636                "  #define A 0\n"
3637                "  #ifdef VAR2\n"
3638                "    #define B 1\n"
3639                "    #include <someheader.h>\n"
3640                "    #define MACRO                      \\\n"
3641                "      some_very_long_func_aaaaaaaaaa();\n"
3642                "  #endif\n"
3643                "#else\n"
3644                "  #define A 1\n"
3645                "#endif",
3646                Style);
3647   verifyFormat("#if A\n"
3648                "  #define MACRO                        \\\n"
3649                "    void a(int x) {                    \\\n"
3650                "      b();                             \\\n"
3651                "      c();                             \\\n"
3652                "      d();                             \\\n"
3653                "      e();                             \\\n"
3654                "      f();                             \\\n"
3655                "    }\n"
3656                "#endif",
3657                Style);
3658   // Keep comments aligned with indented directives. These
3659   // tests cannot use verifyFormat because messUp manipulates leading
3660   // whitespace.
3661   {
3662     const char *Expected = "void f() {\n"
3663                            "// Aligned to preprocessor.\n"
3664                            "#if 1\n"
3665                            "  // Aligned to code.\n"
3666                            "  int a;\n"
3667                            "  #if 1\n"
3668                            "    // Aligned to preprocessor.\n"
3669                            "    #define A 0\n"
3670                            "  // Aligned to code.\n"
3671                            "  int b;\n"
3672                            "  #endif\n"
3673                            "#endif\n"
3674                            "}";
3675     const char *ToFormat = "void f() {\n"
3676                            "// Aligned to preprocessor.\n"
3677                            "#if 1\n"
3678                            "// Aligned to code.\n"
3679                            "int a;\n"
3680                            "#if 1\n"
3681                            "// Aligned to preprocessor.\n"
3682                            "#define A 0\n"
3683                            "// Aligned to code.\n"
3684                            "int b;\n"
3685                            "#endif\n"
3686                            "#endif\n"
3687                            "}";
3688     EXPECT_EQ(Expected, format(ToFormat, Style));
3689     EXPECT_EQ(Expected, format(Expected, Style));
3690   }
3691   {
3692     const char *Expected = "void f() {\n"
3693                            "/* Aligned to preprocessor. */\n"
3694                            "#if 1\n"
3695                            "  /* Aligned to code. */\n"
3696                            "  int a;\n"
3697                            "  #if 1\n"
3698                            "    /* Aligned to preprocessor. */\n"
3699                            "    #define A 0\n"
3700                            "  /* Aligned to code. */\n"
3701                            "  int b;\n"
3702                            "  #endif\n"
3703                            "#endif\n"
3704                            "}";
3705     const char *ToFormat = "void f() {\n"
3706                            "/* Aligned to preprocessor. */\n"
3707                            "#if 1\n"
3708                            "/* Aligned to code. */\n"
3709                            "int a;\n"
3710                            "#if 1\n"
3711                            "/* Aligned to preprocessor. */\n"
3712                            "#define A 0\n"
3713                            "/* Aligned to code. */\n"
3714                            "int b;\n"
3715                            "#endif\n"
3716                            "#endif\n"
3717                            "}";
3718     EXPECT_EQ(Expected, format(ToFormat, Style));
3719     EXPECT_EQ(Expected, format(Expected, Style));
3720   }
3721 
3722   // Test single comment before preprocessor
3723   verifyFormat("// Comment\n"
3724                "\n"
3725                "#if 1\n"
3726                "#endif",
3727                Style);
3728 }
3729 
3730 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3731   verifyFormat("{\n  { a #c; }\n}");
3732 }
3733 
3734 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3735   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
3736             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3737   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
3738             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3739 }
3740 
3741 TEST_F(FormatTest, EscapedNewlines) {
3742   FormatStyle Narrow = getLLVMStyleWithColumns(11);
3743   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
3744             format("#define A \\\nint i;\\\n  int j;", Narrow));
3745   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3746   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3747   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
3748   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3749 
3750   FormatStyle AlignLeft = getLLVMStyle();
3751   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3752   EXPECT_EQ("#define MACRO(x) \\\n"
3753             "private:         \\\n"
3754             "  int x(int a);\n",
3755             format("#define MACRO(x) \\\n"
3756                    "private:         \\\n"
3757                    "  int x(int a);\n",
3758                    AlignLeft));
3759 
3760   // CRLF line endings
3761   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
3762             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
3763   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3764   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3765   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
3766   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3767   EXPECT_EQ("#define MACRO(x) \\\r\n"
3768             "private:         \\\r\n"
3769             "  int x(int a);\r\n",
3770             format("#define MACRO(x) \\\r\n"
3771                    "private:         \\\r\n"
3772                    "  int x(int a);\r\n",
3773                    AlignLeft));
3774 
3775   FormatStyle DontAlign = getLLVMStyle();
3776   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3777   DontAlign.MaxEmptyLinesToKeep = 3;
3778   // FIXME: can't use verifyFormat here because the newline before
3779   // "public:" is not inserted the first time it's reformatted
3780   EXPECT_EQ("#define A \\\n"
3781             "  class Foo { \\\n"
3782             "    void bar(); \\\n"
3783             "\\\n"
3784             "\\\n"
3785             "\\\n"
3786             "  public: \\\n"
3787             "    void baz(); \\\n"
3788             "  };",
3789             format("#define A \\\n"
3790                    "  class Foo { \\\n"
3791                    "    void bar(); \\\n"
3792                    "\\\n"
3793                    "\\\n"
3794                    "\\\n"
3795                    "  public: \\\n"
3796                    "    void baz(); \\\n"
3797                    "  };",
3798                    DontAlign));
3799 }
3800 
3801 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3802   verifyFormat("#define A \\\n"
3803                "  int v(  \\\n"
3804                "      a); \\\n"
3805                "  int i;",
3806                getLLVMStyleWithColumns(11));
3807 }
3808 
3809 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3810   EXPECT_EQ(
3811       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3812       "                      \\\n"
3813       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3814       "\n"
3815       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3816       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3817       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
3818              "\\\n"
3819              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3820              "  \n"
3821              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3822              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3823 }
3824 
3825 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3826   EXPECT_EQ("int\n"
3827             "#define A\n"
3828             "    a;",
3829             format("int\n#define A\na;"));
3830   verifyFormat("functionCallTo(\n"
3831                "    someOtherFunction(\n"
3832                "        withSomeParameters, whichInSequence,\n"
3833                "        areLongerThanALine(andAnotherCall,\n"
3834                "#define A B\n"
3835                "                           withMoreParamters,\n"
3836                "                           whichStronglyInfluenceTheLayout),\n"
3837                "        andMoreParameters),\n"
3838                "    trailing);",
3839                getLLVMStyleWithColumns(69));
3840   verifyFormat("Foo::Foo()\n"
3841                "#ifdef BAR\n"
3842                "    : baz(0)\n"
3843                "#endif\n"
3844                "{\n"
3845                "}");
3846   verifyFormat("void f() {\n"
3847                "  if (true)\n"
3848                "#ifdef A\n"
3849                "    f(42);\n"
3850                "  x();\n"
3851                "#else\n"
3852                "    g();\n"
3853                "  x();\n"
3854                "#endif\n"
3855                "}");
3856   verifyFormat("void f(param1, param2,\n"
3857                "       param3,\n"
3858                "#ifdef A\n"
3859                "       param4(param5,\n"
3860                "#ifdef A1\n"
3861                "              param6,\n"
3862                "#ifdef A2\n"
3863                "              param7),\n"
3864                "#else\n"
3865                "              param8),\n"
3866                "       param9,\n"
3867                "#endif\n"
3868                "       param10,\n"
3869                "#endif\n"
3870                "       param11)\n"
3871                "#else\n"
3872                "       param12)\n"
3873                "#endif\n"
3874                "{\n"
3875                "  x();\n"
3876                "}",
3877                getLLVMStyleWithColumns(28));
3878   verifyFormat("#if 1\n"
3879                "int i;");
3880   verifyFormat("#if 1\n"
3881                "#endif\n"
3882                "#if 1\n"
3883                "#else\n"
3884                "#endif\n");
3885   verifyFormat("DEBUG({\n"
3886                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3887                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
3888                "});\n"
3889                "#if a\n"
3890                "#else\n"
3891                "#endif");
3892 
3893   verifyIncompleteFormat("void f(\n"
3894                          "#if A\n"
3895                          ");\n"
3896                          "#else\n"
3897                          "#endif");
3898 }
3899 
3900 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
3901   verifyFormat("#endif\n"
3902                "#if B");
3903 }
3904 
3905 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
3906   FormatStyle SingleLine = getLLVMStyle();
3907   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
3908   verifyFormat("#if 0\n"
3909                "#elif 1\n"
3910                "#endif\n"
3911                "void foo() {\n"
3912                "  if (test) foo2();\n"
3913                "}",
3914                SingleLine);
3915 }
3916 
3917 TEST_F(FormatTest, LayoutBlockInsideParens) {
3918   verifyFormat("functionCall({ int i; });");
3919   verifyFormat("functionCall({\n"
3920                "  int i;\n"
3921                "  int j;\n"
3922                "});");
3923   verifyFormat("functionCall(\n"
3924                "    {\n"
3925                "      int i;\n"
3926                "      int j;\n"
3927                "    },\n"
3928                "    aaaa, bbbb, cccc);");
3929   verifyFormat("functionA(functionB({\n"
3930                "            int i;\n"
3931                "            int j;\n"
3932                "          }),\n"
3933                "          aaaa, bbbb, cccc);");
3934   verifyFormat("functionCall(\n"
3935                "    {\n"
3936                "      int i;\n"
3937                "      int j;\n"
3938                "    },\n"
3939                "    aaaa, bbbb, // comment\n"
3940                "    cccc);");
3941   verifyFormat("functionA(functionB({\n"
3942                "            int i;\n"
3943                "            int j;\n"
3944                "          }),\n"
3945                "          aaaa, bbbb, // comment\n"
3946                "          cccc);");
3947   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
3948   verifyFormat("functionCall(aaaa, bbbb, {\n"
3949                "  int i;\n"
3950                "  int j;\n"
3951                "});");
3952   verifyFormat(
3953       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
3954       "    {\n"
3955       "      int i; // break\n"
3956       "    },\n"
3957       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
3958       "                                     ccccccccccccccccc));");
3959   verifyFormat("DEBUG({\n"
3960                "  if (a)\n"
3961                "    f();\n"
3962                "});");
3963 }
3964 
3965 TEST_F(FormatTest, LayoutBlockInsideStatement) {
3966   EXPECT_EQ("SOME_MACRO { int i; }\n"
3967             "int i;",
3968             format("  SOME_MACRO  {int i;}  int i;"));
3969 }
3970 
3971 TEST_F(FormatTest, LayoutNestedBlocks) {
3972   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
3973                "  struct s {\n"
3974                "    int i;\n"
3975                "  };\n"
3976                "  s kBitsToOs[] = {{10}};\n"
3977                "  for (int i = 0; i < 10; ++i)\n"
3978                "    return;\n"
3979                "}");
3980   verifyFormat("call(parameter, {\n"
3981                "  something();\n"
3982                "  // Comment using all columns.\n"
3983                "  somethingelse();\n"
3984                "});",
3985                getLLVMStyleWithColumns(40));
3986   verifyFormat("DEBUG( //\n"
3987                "    { f(); }, a);");
3988   verifyFormat("DEBUG( //\n"
3989                "    {\n"
3990                "      f(); //\n"
3991                "    },\n"
3992                "    a);");
3993 
3994   EXPECT_EQ("call(parameter, {\n"
3995             "  something();\n"
3996             "  // Comment too\n"
3997             "  // looooooooooong.\n"
3998             "  somethingElse();\n"
3999             "});",
4000             format("call(parameter, {\n"
4001                    "  something();\n"
4002                    "  // Comment too looooooooooong.\n"
4003                    "  somethingElse();\n"
4004                    "});",
4005                    getLLVMStyleWithColumns(29)));
4006   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
4007   EXPECT_EQ("DEBUG({ // comment\n"
4008             "  int i;\n"
4009             "});",
4010             format("DEBUG({ // comment\n"
4011                    "int  i;\n"
4012                    "});"));
4013   EXPECT_EQ("DEBUG({\n"
4014             "  int i;\n"
4015             "\n"
4016             "  // comment\n"
4017             "  int j;\n"
4018             "});",
4019             format("DEBUG({\n"
4020                    "  int  i;\n"
4021                    "\n"
4022                    "  // comment\n"
4023                    "  int  j;\n"
4024                    "});"));
4025 
4026   verifyFormat("DEBUG({\n"
4027                "  if (a)\n"
4028                "    return;\n"
4029                "});");
4030   verifyGoogleFormat("DEBUG({\n"
4031                      "  if (a) return;\n"
4032                      "});");
4033   FormatStyle Style = getGoogleStyle();
4034   Style.ColumnLimit = 45;
4035   verifyFormat("Debug(\n"
4036                "    aaaaa,\n"
4037                "    {\n"
4038                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
4039                "    },\n"
4040                "    a);",
4041                Style);
4042 
4043   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
4044 
4045   verifyNoCrash("^{v^{a}}");
4046 }
4047 
4048 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
4049   EXPECT_EQ("#define MACRO()                     \\\n"
4050             "  Debug(aaa, /* force line break */ \\\n"
4051             "        {                           \\\n"
4052             "          int i;                    \\\n"
4053             "          int j;                    \\\n"
4054             "        })",
4055             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
4056                    "          {  int   i;  int  j;   })",
4057                    getGoogleStyle()));
4058 
4059   EXPECT_EQ("#define A                                       \\\n"
4060             "  [] {                                          \\\n"
4061             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
4062             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
4063             "  }",
4064             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4065                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
4066                    getGoogleStyle()));
4067 }
4068 
4069 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
4070   EXPECT_EQ("{}", format("{}"));
4071   verifyFormat("enum E {};");
4072   verifyFormat("enum E {}");
4073   FormatStyle Style = getLLVMStyle();
4074   Style.SpaceInEmptyBlock = true;
4075   EXPECT_EQ("void f() { }", format("void f() {}", Style));
4076   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
4077   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4078 }
4079 
4080 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
4081   FormatStyle Style = getLLVMStyle();
4082   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
4083   Style.MacroBlockEnd = "^[A-Z_]+_END$";
4084   verifyFormat("FOO_BEGIN\n"
4085                "  FOO_ENTRY\n"
4086                "FOO_END",
4087                Style);
4088   verifyFormat("FOO_BEGIN\n"
4089                "  NESTED_FOO_BEGIN\n"
4090                "    NESTED_FOO_ENTRY\n"
4091                "  NESTED_FOO_END\n"
4092                "FOO_END",
4093                Style);
4094   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
4095                "  int x;\n"
4096                "  x = 1;\n"
4097                "FOO_END(Baz)",
4098                Style);
4099 }
4100 
4101 //===----------------------------------------------------------------------===//
4102 // Line break tests.
4103 //===----------------------------------------------------------------------===//
4104 
4105 TEST_F(FormatTest, PreventConfusingIndents) {
4106   verifyFormat(
4107       "void f() {\n"
4108       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
4109       "                         parameter, parameter, parameter)),\n"
4110       "                     SecondLongCall(parameter));\n"
4111       "}");
4112   verifyFormat(
4113       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4114       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4115       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4116       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
4117   verifyFormat(
4118       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4119       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
4120       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4121       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
4122   verifyFormat(
4123       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
4124       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
4125       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
4126       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
4127   verifyFormat("int a = bbbb && ccc &&\n"
4128                "        fffff(\n"
4129                "#define A Just forcing a new line\n"
4130                "            ddd);");
4131 }
4132 
4133 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
4134   verifyFormat(
4135       "bool aaaaaaa =\n"
4136       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
4137       "    bbbbbbbb();");
4138   verifyFormat(
4139       "bool aaaaaaa =\n"
4140       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
4141       "    bbbbbbbb();");
4142 
4143   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4144                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
4145                "    ccccccccc == ddddddddddd;");
4146   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4147                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
4148                "    ccccccccc == ddddddddddd;");
4149   verifyFormat(
4150       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
4151       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
4152       "    ccccccccc == ddddddddddd;");
4153 
4154   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4155                "                 aaaaaa) &&\n"
4156                "         bbbbbb && cccccc;");
4157   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4158                "                 aaaaaa) >>\n"
4159                "         bbbbbb;");
4160   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
4161                "    SourceMgr.getSpellingColumnNumber(\n"
4162                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
4163                "    1);");
4164 
4165   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4166                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
4167                "    cccccc) {\n}");
4168   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4169                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4170                "              cccccc) {\n}");
4171   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4172                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4173                "              cccccc) {\n}");
4174   verifyFormat("b = a &&\n"
4175                "    // Comment\n"
4176                "    b.c && d;");
4177 
4178   // If the LHS of a comparison is not a binary expression itself, the
4179   // additional linebreak confuses many people.
4180   verifyFormat(
4181       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4182       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
4183       "}");
4184   verifyFormat(
4185       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4186       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4187       "}");
4188   verifyFormat(
4189       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
4190       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4191       "}");
4192   verifyFormat(
4193       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4194       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
4195       "}");
4196   // Even explicit parentheses stress the precedence enough to make the
4197   // additional break unnecessary.
4198   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4199                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4200                "}");
4201   // This cases is borderline, but with the indentation it is still readable.
4202   verifyFormat(
4203       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4204       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4205       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4206       "}",
4207       getLLVMStyleWithColumns(75));
4208 
4209   // If the LHS is a binary expression, we should still use the additional break
4210   // as otherwise the formatting hides the operator precedence.
4211   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4212                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4213                "    5) {\n"
4214                "}");
4215   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4216                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4217                "    5) {\n"
4218                "}");
4219 
4220   FormatStyle OnePerLine = getLLVMStyle();
4221   OnePerLine.BinPackParameters = false;
4222   verifyFormat(
4223       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4224       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4225       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4226       OnePerLine);
4227 
4228   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4229                "                .aaa(aaaaaaaaaaaaa) *\n"
4230                "            aaaaaaa +\n"
4231                "        aaaaaaa;",
4232                getLLVMStyleWithColumns(40));
4233 }
4234 
4235 TEST_F(FormatTest, ExpressionIndentation) {
4236   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4237                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4238                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4239                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4240                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4241                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4242                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4243                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4244                "                 ccccccccccccccccccccccccccccccccccccccccc;");
4245   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4246                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4247                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4248                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4249   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4250                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4251                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4252                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4253   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4254                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4255                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4256                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4257   verifyFormat("if () {\n"
4258                "} else if (aaaaa && bbbbb > // break\n"
4259                "                        ccccc) {\n"
4260                "}");
4261   verifyFormat("if () {\n"
4262                "} else if constexpr (aaaaa && bbbbb > // break\n"
4263                "                                  ccccc) {\n"
4264                "}");
4265   verifyFormat("if () {\n"
4266                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4267                "                                  ccccc) {\n"
4268                "}");
4269   verifyFormat("if () {\n"
4270                "} else if (aaaaa &&\n"
4271                "           bbbbb > // break\n"
4272                "               ccccc &&\n"
4273                "           ddddd) {\n"
4274                "}");
4275 
4276   // Presence of a trailing comment used to change indentation of b.
4277   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4278                "       b;\n"
4279                "return aaaaaaaaaaaaaaaaaaa +\n"
4280                "       b; //",
4281                getLLVMStyleWithColumns(30));
4282 }
4283 
4284 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4285   // Not sure what the best system is here. Like this, the LHS can be found
4286   // immediately above an operator (everything with the same or a higher
4287   // indent). The RHS is aligned right of the operator and so compasses
4288   // everything until something with the same indent as the operator is found.
4289   // FIXME: Is this a good system?
4290   FormatStyle Style = getLLVMStyle();
4291   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4292   verifyFormat(
4293       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4294       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4295       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4296       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4297       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4298       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4299       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4300       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4301       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
4302       Style);
4303   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4304                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4305                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4306                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4307                Style);
4308   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4309                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4310                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4311                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4312                Style);
4313   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4314                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4315                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4316                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4317                Style);
4318   verifyFormat("if () {\n"
4319                "} else if (aaaaa\n"
4320                "           && bbbbb // break\n"
4321                "                  > ccccc) {\n"
4322                "}",
4323                Style);
4324   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4325                "       && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4326                Style);
4327   verifyFormat("return (a)\n"
4328                "       // comment\n"
4329                "       + b;",
4330                Style);
4331   verifyFormat(
4332       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4333       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4334       "             + cc;",
4335       Style);
4336 
4337   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4338                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4339                Style);
4340 
4341   // Forced by comments.
4342   verifyFormat(
4343       "unsigned ContentSize =\n"
4344       "    sizeof(int16_t)   // DWARF ARange version number\n"
4345       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4346       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4347       "    + sizeof(int8_t); // Segment Size (in bytes)");
4348 
4349   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4350                "       == boost::fusion::at_c<1>(iiii).second;",
4351                Style);
4352 
4353   Style.ColumnLimit = 60;
4354   verifyFormat("zzzzzzzzzz\n"
4355                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4356                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4357                Style);
4358 
4359   Style.ColumnLimit = 80;
4360   Style.IndentWidth = 4;
4361   Style.TabWidth = 4;
4362   Style.UseTab = FormatStyle::UT_Always;
4363   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4364   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4365   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4366             "\t&& (someOtherLongishConditionPart1\n"
4367             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4368             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4369                    "(someOtherLongishConditionPart1 || "
4370                    "someOtherEvenLongerNestedConditionPart2);",
4371                    Style));
4372 }
4373 
4374 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
4375   FormatStyle Style = getLLVMStyle();
4376   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4377   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
4378 
4379   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4380                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4381                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4382                "              == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4383                "                         * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4384                "                     + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4385                "          && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4386                "                     * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4387                "                 > ccccccccccccccccccccccccccccccccccccccccc;",
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 (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4400                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4401                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4402                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4403                Style);
4404   verifyFormat("if () {\n"
4405                "} else if (aaaaa\n"
4406                "           && bbbbb // break\n"
4407                "                  > ccccc) {\n"
4408                "}",
4409                Style);
4410   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4411                "    && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4412                Style);
4413   verifyFormat("return (a)\n"
4414                "     // comment\n"
4415                "     + b;",
4416                Style);
4417   verifyFormat(
4418       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4419       "               * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4420       "           + cc;",
4421       Style);
4422   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
4423                "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4424                "                        : 3333333333333333;",
4425                Style);
4426   verifyFormat(
4427       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
4428       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
4429       "                                             : eeeeeeeeeeeeeeeeee)\n"
4430       "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4431       "                        : 3333333333333333;",
4432       Style);
4433   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4434                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4435                Style);
4436 
4437   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4438                "    == boost::fusion::at_c<1>(iiii).second;",
4439                Style);
4440 
4441   Style.ColumnLimit = 60;
4442   verifyFormat("zzzzzzzzzzzzz\n"
4443                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4444                "   >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4445                Style);
4446 
4447   // Forced by comments.
4448   Style.ColumnLimit = 80;
4449   verifyFormat(
4450       "unsigned ContentSize\n"
4451       "    = sizeof(int16_t) // DWARF ARange version number\n"
4452       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4453       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4454       "    + sizeof(int8_t); // Segment Size (in bytes)",
4455       Style);
4456 
4457   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4458   verifyFormat(
4459       "unsigned ContentSize =\n"
4460       "    sizeof(int16_t)   // DWARF ARange version number\n"
4461       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4462       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4463       "    + sizeof(int8_t); // Segment Size (in bytes)",
4464       Style);
4465 
4466   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4467   verifyFormat(
4468       "unsigned ContentSize =\n"
4469       "    sizeof(int16_t)   // DWARF ARange version number\n"
4470       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4471       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4472       "    + sizeof(int8_t); // Segment Size (in bytes)",
4473       Style);
4474 }
4475 
4476 TEST_F(FormatTest, EnforcedOperatorWraps) {
4477   // Here we'd like to wrap after the || operators, but a comment is forcing an
4478   // earlier wrap.
4479   verifyFormat("bool x = aaaaa //\n"
4480                "         || bbbbb\n"
4481                "         //\n"
4482                "         || cccc;");
4483 }
4484 
4485 TEST_F(FormatTest, NoOperandAlignment) {
4486   FormatStyle Style = getLLVMStyle();
4487   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4488   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4489                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4490                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4491                Style);
4492   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4493   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4494                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4495                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4496                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4497                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4498                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4499                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4500                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4501                "        > ccccccccccccccccccccccccccccccccccccccccc;",
4502                Style);
4503 
4504   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4505                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4506                "    + cc;",
4507                Style);
4508   verifyFormat("int a = aa\n"
4509                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4510                "        * cccccccccccccccccccccccccccccccccccc;\n",
4511                Style);
4512 
4513   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4514   verifyFormat("return (a > b\n"
4515                "    // comment1\n"
4516                "    // comment2\n"
4517                "    || c);",
4518                Style);
4519 }
4520 
4521 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4522   FormatStyle Style = getLLVMStyle();
4523   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4524   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4525                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4526                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4527                Style);
4528 }
4529 
4530 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4531   FormatStyle Style = getLLVMStyle();
4532   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4533   Style.BinPackArguments = false;
4534   Style.ColumnLimit = 40;
4535   verifyFormat("void test() {\n"
4536                "  someFunction(\n"
4537                "      this + argument + is + quite\n"
4538                "      + long + so + it + gets + wrapped\n"
4539                "      + but + remains + bin - packed);\n"
4540                "}",
4541                Style);
4542   verifyFormat("void test() {\n"
4543                "  someFunction(arg1,\n"
4544                "               this + argument + is\n"
4545                "                   + quite + long + so\n"
4546                "                   + it + gets + wrapped\n"
4547                "                   + but + remains + bin\n"
4548                "                   - packed,\n"
4549                "               arg3);\n"
4550                "}",
4551                Style);
4552   verifyFormat("void test() {\n"
4553                "  someFunction(\n"
4554                "      arg1,\n"
4555                "      this + argument + has\n"
4556                "          + anotherFunc(nested,\n"
4557                "                        calls + whose\n"
4558                "                            + arguments\n"
4559                "                            + are + also\n"
4560                "                            + wrapped,\n"
4561                "                        in + addition)\n"
4562                "          + to + being + bin - packed,\n"
4563                "      arg3);\n"
4564                "}",
4565                Style);
4566 
4567   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4568   verifyFormat("void test() {\n"
4569                "  someFunction(\n"
4570                "      arg1,\n"
4571                "      this + argument + has +\n"
4572                "          anotherFunc(nested,\n"
4573                "                      calls + whose +\n"
4574                "                          arguments +\n"
4575                "                          are + also +\n"
4576                "                          wrapped,\n"
4577                "                      in + addition) +\n"
4578                "          to + being + bin - packed,\n"
4579                "      arg3);\n"
4580                "}",
4581                Style);
4582 }
4583 
4584 TEST_F(FormatTest, ConstructorInitializers) {
4585   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4586   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4587                getLLVMStyleWithColumns(45));
4588   verifyFormat("Constructor()\n"
4589                "    : Inttializer(FitsOnTheLine) {}",
4590                getLLVMStyleWithColumns(44));
4591   verifyFormat("Constructor()\n"
4592                "    : Inttializer(FitsOnTheLine) {}",
4593                getLLVMStyleWithColumns(43));
4594 
4595   verifyFormat("template <typename T>\n"
4596                "Constructor() : Initializer(FitsOnTheLine) {}",
4597                getLLVMStyleWithColumns(45));
4598 
4599   verifyFormat(
4600       "SomeClass::Constructor()\n"
4601       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4602 
4603   verifyFormat(
4604       "SomeClass::Constructor()\n"
4605       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4606       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4607   verifyFormat(
4608       "SomeClass::Constructor()\n"
4609       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4610       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4611   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4612                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4613                "    : aaaaaaaaaa(aaaaaa) {}");
4614 
4615   verifyFormat("Constructor()\n"
4616                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4617                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4618                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4619                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
4620 
4621   verifyFormat("Constructor()\n"
4622                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4623                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4624 
4625   verifyFormat("Constructor(int Parameter = 0)\n"
4626                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4627                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4628   verifyFormat("Constructor()\n"
4629                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4630                "}",
4631                getLLVMStyleWithColumns(60));
4632   verifyFormat("Constructor()\n"
4633                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4634                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4635 
4636   // Here a line could be saved by splitting the second initializer onto two
4637   // lines, but that is not desirable.
4638   verifyFormat("Constructor()\n"
4639                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4640                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
4641                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4642 
4643   FormatStyle OnePerLine = getLLVMStyle();
4644   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4645   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4646   verifyFormat("SomeClass::Constructor()\n"
4647                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4648                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4649                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4650                OnePerLine);
4651   verifyFormat("SomeClass::Constructor()\n"
4652                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4653                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4654                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4655                OnePerLine);
4656   verifyFormat("MyClass::MyClass(int var)\n"
4657                "    : some_var_(var),            // 4 space indent\n"
4658                "      some_other_var_(var + 1) { // lined up\n"
4659                "}",
4660                OnePerLine);
4661   verifyFormat("Constructor()\n"
4662                "    : aaaaa(aaaaaa),\n"
4663                "      aaaaa(aaaaaa),\n"
4664                "      aaaaa(aaaaaa),\n"
4665                "      aaaaa(aaaaaa),\n"
4666                "      aaaaa(aaaaaa) {}",
4667                OnePerLine);
4668   verifyFormat("Constructor()\n"
4669                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4670                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
4671                OnePerLine);
4672   OnePerLine.BinPackParameters = false;
4673   verifyFormat(
4674       "Constructor()\n"
4675       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4676       "          aaaaaaaaaaa().aaa(),\n"
4677       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4678       OnePerLine);
4679   OnePerLine.ColumnLimit = 60;
4680   verifyFormat("Constructor()\n"
4681                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4682                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4683                OnePerLine);
4684 
4685   EXPECT_EQ("Constructor()\n"
4686             "    : // Comment forcing unwanted break.\n"
4687             "      aaaa(aaaa) {}",
4688             format("Constructor() :\n"
4689                    "    // Comment forcing unwanted break.\n"
4690                    "    aaaa(aaaa) {}"));
4691 }
4692 
4693 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4694   FormatStyle Style = getLLVMStyle();
4695   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4696   Style.ColumnLimit = 60;
4697   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4698   Style.AllowAllConstructorInitializersOnNextLine = true;
4699   Style.BinPackParameters = false;
4700 
4701   for (int i = 0; i < 4; ++i) {
4702     // Test all combinations of parameters that should not have an effect.
4703     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4704     Style.AllowAllArgumentsOnNextLine = i & 2;
4705 
4706     Style.AllowAllConstructorInitializersOnNextLine = true;
4707     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4708     verifyFormat("Constructor()\n"
4709                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4710                  Style);
4711     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4712 
4713     Style.AllowAllConstructorInitializersOnNextLine = false;
4714     verifyFormat("Constructor()\n"
4715                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4716                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4717                  Style);
4718     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4719 
4720     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4721     Style.AllowAllConstructorInitializersOnNextLine = true;
4722     verifyFormat("Constructor()\n"
4723                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4724                  Style);
4725 
4726     Style.AllowAllConstructorInitializersOnNextLine = false;
4727     verifyFormat("Constructor()\n"
4728                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4729                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4730                  Style);
4731 
4732     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4733     Style.AllowAllConstructorInitializersOnNextLine = true;
4734     verifyFormat("Constructor() :\n"
4735                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4736                  Style);
4737 
4738     Style.AllowAllConstructorInitializersOnNextLine = false;
4739     verifyFormat("Constructor() :\n"
4740                  "    aaaaaaaaaaaaaaaaaa(a),\n"
4741                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4742                  Style);
4743   }
4744 
4745   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4746   // AllowAllConstructorInitializersOnNextLine in all
4747   // BreakConstructorInitializers modes
4748   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4749   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4750   Style.AllowAllConstructorInitializersOnNextLine = false;
4751   verifyFormat("SomeClassWithALongName::Constructor(\n"
4752                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4753                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4754                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4755                Style);
4756 
4757   Style.AllowAllConstructorInitializersOnNextLine = true;
4758   verifyFormat("SomeClassWithALongName::Constructor(\n"
4759                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4760                "    int bbbbbbbbbbbbb,\n"
4761                "    int cccccccccccccccc)\n"
4762                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4763                Style);
4764 
4765   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4766   Style.AllowAllConstructorInitializersOnNextLine = false;
4767   verifyFormat("SomeClassWithALongName::Constructor(\n"
4768                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4769                "    int bbbbbbbbbbbbb)\n"
4770                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4771                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4772                Style);
4773 
4774   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4775 
4776   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4777   verifyFormat("SomeClassWithALongName::Constructor(\n"
4778                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4779                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4780                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4781                Style);
4782 
4783   Style.AllowAllConstructorInitializersOnNextLine = true;
4784   verifyFormat("SomeClassWithALongName::Constructor(\n"
4785                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4786                "    int bbbbbbbbbbbbb,\n"
4787                "    int cccccccccccccccc)\n"
4788                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4789                Style);
4790 
4791   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4792   Style.AllowAllConstructorInitializersOnNextLine = false;
4793   verifyFormat("SomeClassWithALongName::Constructor(\n"
4794                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4795                "    int bbbbbbbbbbbbb)\n"
4796                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4797                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4798                Style);
4799 
4800   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4801   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4802   verifyFormat("SomeClassWithALongName::Constructor(\n"
4803                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4804                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4805                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4806                Style);
4807 
4808   Style.AllowAllConstructorInitializersOnNextLine = true;
4809   verifyFormat("SomeClassWithALongName::Constructor(\n"
4810                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4811                "    int bbbbbbbbbbbbb,\n"
4812                "    int cccccccccccccccc) :\n"
4813                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4814                Style);
4815 
4816   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4817   Style.AllowAllConstructorInitializersOnNextLine = false;
4818   verifyFormat("SomeClassWithALongName::Constructor(\n"
4819                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4820                "    int bbbbbbbbbbbbb) :\n"
4821                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4822                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4823                Style);
4824 }
4825 
4826 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4827   FormatStyle Style = getLLVMStyle();
4828   Style.ColumnLimit = 60;
4829   Style.BinPackArguments = false;
4830   for (int i = 0; i < 4; ++i) {
4831     // Test all combinations of parameters that should not have an effect.
4832     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4833     Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4834 
4835     Style.AllowAllArgumentsOnNextLine = true;
4836     verifyFormat("void foo() {\n"
4837                  "  FunctionCallWithReallyLongName(\n"
4838                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4839                  "}",
4840                  Style);
4841     Style.AllowAllArgumentsOnNextLine = false;
4842     verifyFormat("void foo() {\n"
4843                  "  FunctionCallWithReallyLongName(\n"
4844                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4845                  "      bbbbbbbbbbbb);\n"
4846                  "}",
4847                  Style);
4848 
4849     Style.AllowAllArgumentsOnNextLine = true;
4850     verifyFormat("void foo() {\n"
4851                  "  auto VariableWithReallyLongName = {\n"
4852                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4853                  "}",
4854                  Style);
4855     Style.AllowAllArgumentsOnNextLine = false;
4856     verifyFormat("void foo() {\n"
4857                  "  auto VariableWithReallyLongName = {\n"
4858                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4859                  "      bbbbbbbbbbbb};\n"
4860                  "}",
4861                  Style);
4862   }
4863 
4864   // This parameter should not affect declarations.
4865   Style.BinPackParameters = false;
4866   Style.AllowAllArgumentsOnNextLine = false;
4867   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4868   verifyFormat("void FunctionCallWithReallyLongName(\n"
4869                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
4870                Style);
4871   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4872   verifyFormat("void FunctionCallWithReallyLongName(\n"
4873                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
4874                "    int bbbbbbbbbbbb);",
4875                Style);
4876 }
4877 
4878 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
4879   FormatStyle Style = getLLVMStyle();
4880   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4881 
4882   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4883   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
4884                getStyleWithColumns(Style, 45));
4885   verifyFormat("Constructor() :\n"
4886                "    Initializer(FitsOnTheLine) {}",
4887                getStyleWithColumns(Style, 44));
4888   verifyFormat("Constructor() :\n"
4889                "    Initializer(FitsOnTheLine) {}",
4890                getStyleWithColumns(Style, 43));
4891 
4892   verifyFormat("template <typename T>\n"
4893                "Constructor() : Initializer(FitsOnTheLine) {}",
4894                getStyleWithColumns(Style, 50));
4895   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4896   verifyFormat(
4897       "SomeClass::Constructor() :\n"
4898       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4899       Style);
4900 
4901   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
4902   verifyFormat(
4903       "SomeClass::Constructor() :\n"
4904       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4905       Style);
4906 
4907   verifyFormat(
4908       "SomeClass::Constructor() :\n"
4909       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4910       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4911       Style);
4912   verifyFormat(
4913       "SomeClass::Constructor() :\n"
4914       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4915       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4916       Style);
4917   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4918                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4919                "    aaaaaaaaaa(aaaaaa) {}",
4920                Style);
4921 
4922   verifyFormat("Constructor() :\n"
4923                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4924                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4925                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4926                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
4927                Style);
4928 
4929   verifyFormat("Constructor() :\n"
4930                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4931                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4932                Style);
4933 
4934   verifyFormat("Constructor(int Parameter = 0) :\n"
4935                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4936                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
4937                Style);
4938   verifyFormat("Constructor() :\n"
4939                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4940                "}",
4941                getStyleWithColumns(Style, 60));
4942   verifyFormat("Constructor() :\n"
4943                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4944                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
4945                Style);
4946 
4947   // Here a line could be saved by splitting the second initializer onto two
4948   // lines, but that is not desirable.
4949   verifyFormat("Constructor() :\n"
4950                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4951                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
4952                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4953                Style);
4954 
4955   FormatStyle OnePerLine = Style;
4956   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4957   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
4958   verifyFormat("SomeClass::Constructor() :\n"
4959                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4960                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4961                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4962                OnePerLine);
4963   verifyFormat("SomeClass::Constructor() :\n"
4964                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4965                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4966                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4967                OnePerLine);
4968   verifyFormat("MyClass::MyClass(int var) :\n"
4969                "    some_var_(var),            // 4 space indent\n"
4970                "    some_other_var_(var + 1) { // lined up\n"
4971                "}",
4972                OnePerLine);
4973   verifyFormat("Constructor() :\n"
4974                "    aaaaa(aaaaaa),\n"
4975                "    aaaaa(aaaaaa),\n"
4976                "    aaaaa(aaaaaa),\n"
4977                "    aaaaa(aaaaaa),\n"
4978                "    aaaaa(aaaaaa) {}",
4979                OnePerLine);
4980   verifyFormat("Constructor() :\n"
4981                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4982                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
4983                OnePerLine);
4984   OnePerLine.BinPackParameters = false;
4985   verifyFormat("Constructor() :\n"
4986                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4987                "        aaaaaaaaaaa().aaa(),\n"
4988                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4989                OnePerLine);
4990   OnePerLine.ColumnLimit = 60;
4991   verifyFormat("Constructor() :\n"
4992                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4993                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4994                OnePerLine);
4995 
4996   EXPECT_EQ("Constructor() :\n"
4997             "    // Comment forcing unwanted break.\n"
4998             "    aaaa(aaaa) {}",
4999             format("Constructor() :\n"
5000                    "    // Comment forcing unwanted break.\n"
5001                    "    aaaa(aaaa) {}",
5002                    Style));
5003 
5004   Style.ColumnLimit = 0;
5005   verifyFormat("SomeClass::Constructor() :\n"
5006                "    a(a) {}",
5007                Style);
5008   verifyFormat("SomeClass::Constructor() noexcept :\n"
5009                "    a(a) {}",
5010                Style);
5011   verifyFormat("SomeClass::Constructor() :\n"
5012                "    a(a), b(b), c(c) {}",
5013                Style);
5014   verifyFormat("SomeClass::Constructor() :\n"
5015                "    a(a) {\n"
5016                "  foo();\n"
5017                "  bar();\n"
5018                "}",
5019                Style);
5020 
5021   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5022   verifyFormat("SomeClass::Constructor() :\n"
5023                "    a(a), b(b), c(c) {\n"
5024                "}",
5025                Style);
5026   verifyFormat("SomeClass::Constructor() :\n"
5027                "    a(a) {\n"
5028                "}",
5029                Style);
5030 
5031   Style.ColumnLimit = 80;
5032   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5033   Style.ConstructorInitializerIndentWidth = 2;
5034   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5035   verifyFormat("SomeClass::Constructor() :\n"
5036                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5037                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5038                Style);
5039 
5040   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5041   // well
5042   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5043   verifyFormat(
5044       "class SomeClass\n"
5045       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5046       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5047       Style);
5048   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5049   verifyFormat(
5050       "class SomeClass\n"
5051       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5052       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5053       Style);
5054   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5055   verifyFormat(
5056       "class SomeClass :\n"
5057       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5058       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5059       Style);
5060 }
5061 
5062 #ifndef EXPENSIVE_CHECKS
5063 // Expensive checks enables libstdc++ checking which includes validating the
5064 // state of ranges used in std::priority_queue - this blows out the
5065 // runtime/scalability of the function and makes this test unacceptably slow.
5066 TEST_F(FormatTest, MemoizationTests) {
5067   // This breaks if the memoization lookup does not take \c Indent and
5068   // \c LastSpace into account.
5069   verifyFormat(
5070       "extern CFRunLoopTimerRef\n"
5071       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5072       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
5073       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
5074       "                     CFRunLoopTimerContext *context) {}");
5075 
5076   // Deep nesting somewhat works around our memoization.
5077   verifyFormat(
5078       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5079       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5080       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5081       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5082       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
5083       getLLVMStyleWithColumns(65));
5084   verifyFormat(
5085       "aaaaa(\n"
5086       "    aaaaa,\n"
5087       "    aaaaa(\n"
5088       "        aaaaa,\n"
5089       "        aaaaa(\n"
5090       "            aaaaa,\n"
5091       "            aaaaa(\n"
5092       "                aaaaa,\n"
5093       "                aaaaa(\n"
5094       "                    aaaaa,\n"
5095       "                    aaaaa(\n"
5096       "                        aaaaa,\n"
5097       "                        aaaaa(\n"
5098       "                            aaaaa,\n"
5099       "                            aaaaa(\n"
5100       "                                aaaaa,\n"
5101       "                                aaaaa(\n"
5102       "                                    aaaaa,\n"
5103       "                                    aaaaa(\n"
5104       "                                        aaaaa,\n"
5105       "                                        aaaaa(\n"
5106       "                                            aaaaa,\n"
5107       "                                            aaaaa(\n"
5108       "                                                aaaaa,\n"
5109       "                                                aaaaa))))))))))));",
5110       getLLVMStyleWithColumns(65));
5111   verifyFormat(
5112       "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"
5113       "                                  a),\n"
5114       "                                a),\n"
5115       "                              a),\n"
5116       "                            a),\n"
5117       "                          a),\n"
5118       "                        a),\n"
5119       "                      a),\n"
5120       "                    a),\n"
5121       "                  a),\n"
5122       "                a),\n"
5123       "              a),\n"
5124       "            a),\n"
5125       "          a),\n"
5126       "        a),\n"
5127       "      a),\n"
5128       "    a),\n"
5129       "  a)",
5130       getLLVMStyleWithColumns(65));
5131 
5132   // This test takes VERY long when memoization is broken.
5133   FormatStyle OnePerLine = getLLVMStyle();
5134   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5135   OnePerLine.BinPackParameters = false;
5136   std::string input = "Constructor()\n"
5137                       "    : aaaa(a,\n";
5138   for (unsigned i = 0, e = 80; i != e; ++i) {
5139     input += "           a,\n";
5140   }
5141   input += "           a) {}";
5142   verifyFormat(input, OnePerLine);
5143 }
5144 #endif
5145 
5146 TEST_F(FormatTest, BreaksAsHighAsPossible) {
5147   verifyFormat(
5148       "void f() {\n"
5149       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5150       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5151       "    f();\n"
5152       "}");
5153   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5154                "    Intervals[i - 1].getRange().getLast()) {\n}");
5155 }
5156 
5157 TEST_F(FormatTest, BreaksFunctionDeclarations) {
5158   // Principially, we break function declarations in a certain order:
5159   // 1) break amongst arguments.
5160   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5161                "                              Cccccccccccccc cccccccccccccc);");
5162   verifyFormat("template <class TemplateIt>\n"
5163                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5164                "                            TemplateIt *stop) {}");
5165 
5166   // 2) break after return type.
5167   verifyFormat(
5168       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5169       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5170       getGoogleStyle());
5171 
5172   // 3) break after (.
5173   verifyFormat(
5174       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5175       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5176       getGoogleStyle());
5177 
5178   // 4) break before after nested name specifiers.
5179   verifyFormat(
5180       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5181       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5182       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5183       getGoogleStyle());
5184 
5185   // However, there are exceptions, if a sufficient amount of lines can be
5186   // saved.
5187   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5188   // more adjusting.
5189   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5190                "                                  Cccccccccccccc cccccccccc,\n"
5191                "                                  Cccccccccccccc cccccccccc,\n"
5192                "                                  Cccccccccccccc cccccccccc,\n"
5193                "                                  Cccccccccccccc cccccccccc);");
5194   verifyFormat(
5195       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5196       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5197       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5198       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5199       getGoogleStyle());
5200   verifyFormat(
5201       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5202       "                                          Cccccccccccccc cccccccccc,\n"
5203       "                                          Cccccccccccccc cccccccccc,\n"
5204       "                                          Cccccccccccccc cccccccccc,\n"
5205       "                                          Cccccccccccccc cccccccccc,\n"
5206       "                                          Cccccccccccccc cccccccccc,\n"
5207       "                                          Cccccccccccccc cccccccccc);");
5208   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5209                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5210                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5211                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5212                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5213 
5214   // Break after multi-line parameters.
5215   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5216                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5217                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5218                "    bbbb bbbb);");
5219   verifyFormat("void SomeLoooooooooooongFunction(\n"
5220                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5221                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5222                "    int bbbbbbbbbbbbb);");
5223 
5224   // Treat overloaded operators like other functions.
5225   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5226                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5227   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5228                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5229   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5230                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5231   verifyGoogleFormat(
5232       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5233       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5234   verifyGoogleFormat(
5235       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5236       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5237   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5238                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5239   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5240                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5241   verifyGoogleFormat(
5242       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5243       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5244       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5245   verifyGoogleFormat("template <typename T>\n"
5246                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5247                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5248                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5249 
5250   FormatStyle Style = getLLVMStyle();
5251   Style.PointerAlignment = FormatStyle::PAS_Left;
5252   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5253                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5254                Style);
5255   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5256                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5257                Style);
5258 }
5259 
5260 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5261   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5262   // Prefer keeping `::` followed by `operator` together.
5263   EXPECT_EQ("const aaaa::bbbbbbb &\n"
5264             "ccccccccc::operator++() {\n"
5265             "  stuff();\n"
5266             "}",
5267             format("const aaaa::bbbbbbb\n"
5268                    "&ccccccccc::operator++() { stuff(); }",
5269                    getLLVMStyleWithColumns(40)));
5270 }
5271 
5272 TEST_F(FormatTest, TrailingReturnType) {
5273   verifyFormat("auto foo() -> int;\n");
5274   // correct trailing return type spacing
5275   verifyFormat("auto operator->() -> int;\n");
5276   verifyFormat("auto operator++(int) -> int;\n");
5277 
5278   verifyFormat("struct S {\n"
5279                "  auto bar() const -> int;\n"
5280                "};");
5281   verifyFormat("template <size_t Order, typename T>\n"
5282                "auto load_img(const std::string &filename)\n"
5283                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
5284   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5285                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5286   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5287   verifyFormat("template <typename T>\n"
5288                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5289                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5290 
5291   // Not trailing return types.
5292   verifyFormat("void f() { auto a = b->c(); }");
5293 }
5294 
5295 TEST_F(FormatTest, DeductionGuides) {
5296   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5297   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5298   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5299   verifyFormat(
5300       "template <class... T>\n"
5301       "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5302   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5303   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5304   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5305   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5306   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5307   verifyFormat("template <class T> x() -> x<1>;");
5308   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5309 
5310   // Ensure not deduction guides.
5311   verifyFormat("c()->f<int>();");
5312   verifyFormat("x()->foo<1>;");
5313   verifyFormat("x = p->foo<3>();");
5314   verifyFormat("x()->x<1>();");
5315   verifyFormat("x()->x<1>;");
5316 }
5317 
5318 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5319   // Avoid breaking before trailing 'const' or other trailing annotations, if
5320   // they are not function-like.
5321   FormatStyle Style = getGoogleStyle();
5322   Style.ColumnLimit = 47;
5323   verifyFormat("void someLongFunction(\n"
5324                "    int someLoooooooooooooongParameter) const {\n}",
5325                getLLVMStyleWithColumns(47));
5326   verifyFormat("LoooooongReturnType\n"
5327                "someLoooooooongFunction() const {}",
5328                getLLVMStyleWithColumns(47));
5329   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5330                "    const {}",
5331                Style);
5332   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5333                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5334   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5335                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5336   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5337                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5338   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5339                "                   aaaaaaaaaaa aaaaa) const override;");
5340   verifyGoogleFormat(
5341       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5342       "    const override;");
5343 
5344   // Even if the first parameter has to be wrapped.
5345   verifyFormat("void someLongFunction(\n"
5346                "    int someLongParameter) const {}",
5347                getLLVMStyleWithColumns(46));
5348   verifyFormat("void someLongFunction(\n"
5349                "    int someLongParameter) const {}",
5350                Style);
5351   verifyFormat("void someLongFunction(\n"
5352                "    int someLongParameter) override {}",
5353                Style);
5354   verifyFormat("void someLongFunction(\n"
5355                "    int someLongParameter) OVERRIDE {}",
5356                Style);
5357   verifyFormat("void someLongFunction(\n"
5358                "    int someLongParameter) final {}",
5359                Style);
5360   verifyFormat("void someLongFunction(\n"
5361                "    int someLongParameter) FINAL {}",
5362                Style);
5363   verifyFormat("void someLongFunction(\n"
5364                "    int parameter) const override {}",
5365                Style);
5366 
5367   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5368   verifyFormat("void someLongFunction(\n"
5369                "    int someLongParameter) const\n"
5370                "{\n"
5371                "}",
5372                Style);
5373 
5374   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5375   verifyFormat("void someLongFunction(\n"
5376                "    int someLongParameter) const\n"
5377                "  {\n"
5378                "  }",
5379                Style);
5380 
5381   // Unless these are unknown annotations.
5382   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5383                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5384                "    LONG_AND_UGLY_ANNOTATION;");
5385 
5386   // Breaking before function-like trailing annotations is fine to keep them
5387   // close to their arguments.
5388   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5389                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5390   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5391                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5392   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5393                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5394   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5395                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5396   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5397 
5398   verifyFormat(
5399       "void aaaaaaaaaaaaaaaaaa()\n"
5400       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5401       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5402   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5403                "    __attribute__((unused));");
5404   verifyGoogleFormat(
5405       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5406       "    GUARDED_BY(aaaaaaaaaaaa);");
5407   verifyGoogleFormat(
5408       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5409       "    GUARDED_BY(aaaaaaaaaaaa);");
5410   verifyGoogleFormat(
5411       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5412       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5413   verifyGoogleFormat(
5414       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5415       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5416 }
5417 
5418 TEST_F(FormatTest, FunctionAnnotations) {
5419   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5420                "int OldFunction(const string &parameter) {}");
5421   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5422                "string OldFunction(const string &parameter) {}");
5423   verifyFormat("template <typename T>\n"
5424                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5425                "string OldFunction(const string &parameter) {}");
5426 
5427   // Not function annotations.
5428   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5429                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5430   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5431                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5432   verifyFormat("MACRO(abc).function() // wrap\n"
5433                "    << abc;");
5434   verifyFormat("MACRO(abc)->function() // wrap\n"
5435                "    << abc;");
5436   verifyFormat("MACRO(abc)::function() // wrap\n"
5437                "    << abc;");
5438 }
5439 
5440 TEST_F(FormatTest, BreaksDesireably) {
5441   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5442                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5443                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5444   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5445                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5446                "}");
5447 
5448   verifyFormat(
5449       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5450       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5451 
5452   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5453                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5454                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5455 
5456   verifyFormat(
5457       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5458       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5459       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5460       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5461       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5462 
5463   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5464                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5465 
5466   verifyFormat(
5467       "void f() {\n"
5468       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5469       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5470       "}");
5471   verifyFormat(
5472       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5473       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5474   verifyFormat(
5475       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5476       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5477   verifyFormat(
5478       "aaaaaa(aaa,\n"
5479       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5480       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5481       "       aaaa);");
5482   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5483                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5484                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5485 
5486   // Indent consistently independent of call expression and unary operator.
5487   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5488                "    dddddddddddddddddddddddddddddd));");
5489   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5490                "    dddddddddddddddddddddddddddddd));");
5491   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5492                "    dddddddddddddddddddddddddddddd));");
5493 
5494   // This test case breaks on an incorrect memoization, i.e. an optimization not
5495   // taking into account the StopAt value.
5496   verifyFormat(
5497       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5498       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5499       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5500       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5501 
5502   verifyFormat("{\n  {\n    {\n"
5503                "      Annotation.SpaceRequiredBefore =\n"
5504                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5505                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5506                "    }\n  }\n}");
5507 
5508   // Break on an outer level if there was a break on an inner level.
5509   EXPECT_EQ("f(g(h(a, // comment\n"
5510             "      b, c),\n"
5511             "    d, e),\n"
5512             "  x, y);",
5513             format("f(g(h(a, // comment\n"
5514                    "    b, c), d, e), x, y);"));
5515 
5516   // Prefer breaking similar line breaks.
5517   verifyFormat(
5518       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5519       "                             NSTrackingMouseEnteredAndExited |\n"
5520       "                             NSTrackingActiveAlways;");
5521 }
5522 
5523 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5524   FormatStyle NoBinPacking = getGoogleStyle();
5525   NoBinPacking.BinPackParameters = false;
5526   NoBinPacking.BinPackArguments = true;
5527   verifyFormat("void f() {\n"
5528                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5529                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5530                "}",
5531                NoBinPacking);
5532   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5533                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5534                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5535                NoBinPacking);
5536 
5537   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5538   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5539                "                        vector<int> bbbbbbbbbbbbbbb);",
5540                NoBinPacking);
5541   // FIXME: This behavior difference is probably not wanted. However, currently
5542   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5543   // template arguments from BreakBeforeParameter being set because of the
5544   // one-per-line formatting.
5545   verifyFormat(
5546       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5547       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5548       NoBinPacking);
5549   verifyFormat(
5550       "void fffffffffff(\n"
5551       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5552       "        aaaaaaaaaa);");
5553 }
5554 
5555 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5556   FormatStyle NoBinPacking = getGoogleStyle();
5557   NoBinPacking.BinPackParameters = false;
5558   NoBinPacking.BinPackArguments = false;
5559   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5560                "  aaaaaaaaaaaaaaaaaaaa,\n"
5561                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5562                NoBinPacking);
5563   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5564                "        aaaaaaaaaaaaa,\n"
5565                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5566                NoBinPacking);
5567   verifyFormat(
5568       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5569       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5570       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5571       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5572       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5573       NoBinPacking);
5574   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5575                "    .aaaaaaaaaaaaaaaaaa();",
5576                NoBinPacking);
5577   verifyFormat("void f() {\n"
5578                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5579                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5580                "}",
5581                NoBinPacking);
5582 
5583   verifyFormat(
5584       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5585       "             aaaaaaaaaaaa,\n"
5586       "             aaaaaaaaaaaa);",
5587       NoBinPacking);
5588   verifyFormat(
5589       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5590       "                               ddddddddddddddddddddddddddddd),\n"
5591       "             test);",
5592       NoBinPacking);
5593 
5594   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5595                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5596                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5597                "    aaaaaaaaaaaaaaaaaa;",
5598                NoBinPacking);
5599   verifyFormat("a(\"a\"\n"
5600                "  \"a\",\n"
5601                "  a);");
5602 
5603   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5604   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5605                "                aaaaaaaaa,\n"
5606                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5607                NoBinPacking);
5608   verifyFormat(
5609       "void f() {\n"
5610       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5611       "      .aaaaaaa();\n"
5612       "}",
5613       NoBinPacking);
5614   verifyFormat(
5615       "template <class SomeType, class SomeOtherType>\n"
5616       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5617       NoBinPacking);
5618 }
5619 
5620 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5621   FormatStyle Style = getLLVMStyleWithColumns(15);
5622   Style.ExperimentalAutoDetectBinPacking = true;
5623   EXPECT_EQ("aaa(aaaa,\n"
5624             "    aaaa,\n"
5625             "    aaaa);\n"
5626             "aaa(aaaa,\n"
5627             "    aaaa,\n"
5628             "    aaaa);",
5629             format("aaa(aaaa,\n" // one-per-line
5630                    "  aaaa,\n"
5631                    "    aaaa  );\n"
5632                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5633                    Style));
5634   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5635             "    aaaa);\n"
5636             "aaa(aaaa, aaaa,\n"
5637             "    aaaa);",
5638             format("aaa(aaaa,  aaaa,\n" // bin-packed
5639                    "    aaaa  );\n"
5640                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5641                    Style));
5642 }
5643 
5644 TEST_F(FormatTest, FormatsBuilderPattern) {
5645   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5646                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5647                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5648                "    .StartsWith(\".init\", ORDER_INIT)\n"
5649                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5650                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5651                "    .Default(ORDER_TEXT);\n");
5652 
5653   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5654                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5655   verifyFormat("aaaaaaa->aaaaaaa\n"
5656                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5657                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5658                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5659   verifyFormat(
5660       "aaaaaaa->aaaaaaa\n"
5661       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5662       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5663   verifyFormat(
5664       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5665       "    aaaaaaaaaaaaaa);");
5666   verifyFormat(
5667       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5668       "    aaaaaa->aaaaaaaaaaaa()\n"
5669       "        ->aaaaaaaaaaaaaaaa(\n"
5670       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5671       "        ->aaaaaaaaaaaaaaaaa();");
5672   verifyGoogleFormat(
5673       "void f() {\n"
5674       "  someo->Add((new util::filetools::Handler(dir))\n"
5675       "                 ->OnEvent1(NewPermanentCallback(\n"
5676       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5677       "                 ->OnEvent2(NewPermanentCallback(\n"
5678       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5679       "                 ->OnEvent3(NewPermanentCallback(\n"
5680       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5681       "                 ->OnEvent5(NewPermanentCallback(\n"
5682       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5683       "                 ->OnEvent6(NewPermanentCallback(\n"
5684       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5685       "}");
5686 
5687   verifyFormat(
5688       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5689   verifyFormat("aaaaaaaaaaaaaaa()\n"
5690                "    .aaaaaaaaaaaaaaa()\n"
5691                "    .aaaaaaaaaaaaaaa()\n"
5692                "    .aaaaaaaaaaaaaaa()\n"
5693                "    .aaaaaaaaaaaaaaa();");
5694   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5695                "    .aaaaaaaaaaaaaaa()\n"
5696                "    .aaaaaaaaaaaaaaa()\n"
5697                "    .aaaaaaaaaaaaaaa();");
5698   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5699                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5700                "    .aaaaaaaaaaaaaaa();");
5701   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5702                "    ->aaaaaaaaaaaaaae(0)\n"
5703                "    ->aaaaaaaaaaaaaaa();");
5704 
5705   // Don't linewrap after very short segments.
5706   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5707                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5708                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5709   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5710                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5711                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5712   verifyFormat("aaa()\n"
5713                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5714                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5715                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5716 
5717   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5718                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5719                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5720   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5721                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5722                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5723 
5724   // Prefer not to break after empty parentheses.
5725   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5726                "    First->LastNewlineOffset);");
5727 
5728   // Prefer not to create "hanging" indents.
5729   verifyFormat(
5730       "return !soooooooooooooome_map\n"
5731       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5732       "            .second;");
5733   verifyFormat(
5734       "return aaaaaaaaaaaaaaaa\n"
5735       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5736       "    .aaaa(aaaaaaaaaaaaaa);");
5737   // No hanging indent here.
5738   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5739                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5740   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5741                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5742   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5743                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5744                getLLVMStyleWithColumns(60));
5745   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5746                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5747                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5748                getLLVMStyleWithColumns(59));
5749   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5750                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5751                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5752 
5753   // Dont break if only closing statements before member call
5754   verifyFormat("test() {\n"
5755                "  ([]() -> {\n"
5756                "    int b = 32;\n"
5757                "    return 3;\n"
5758                "  }).foo();\n"
5759                "}");
5760   verifyFormat("test() {\n"
5761                "  (\n"
5762                "      []() -> {\n"
5763                "        int b = 32;\n"
5764                "        return 3;\n"
5765                "      },\n"
5766                "      foo, bar)\n"
5767                "      .foo();\n"
5768                "}");
5769   verifyFormat("test() {\n"
5770                "  ([]() -> {\n"
5771                "    int b = 32;\n"
5772                "    return 3;\n"
5773                "  })\n"
5774                "      .foo()\n"
5775                "      .bar();\n"
5776                "}");
5777   verifyFormat("test() {\n"
5778                "  ([]() -> {\n"
5779                "    int b = 32;\n"
5780                "    return 3;\n"
5781                "  })\n"
5782                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5783                "           \"bbbb\");\n"
5784                "}",
5785                getLLVMStyleWithColumns(30));
5786 }
5787 
5788 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5789   verifyFormat(
5790       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5791       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5792   verifyFormat(
5793       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5794       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5795 
5796   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5797                "    ccccccccccccccccccccccccc) {\n}");
5798   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5799                "    ccccccccccccccccccccccccc) {\n}");
5800 
5801   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5802                "    ccccccccccccccccccccccccc) {\n}");
5803   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5804                "    ccccccccccccccccccccccccc) {\n}");
5805 
5806   verifyFormat(
5807       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
5808       "    ccccccccccccccccccccccccc) {\n}");
5809   verifyFormat(
5810       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
5811       "    ccccccccccccccccccccccccc) {\n}");
5812 
5813   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5814                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
5815                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
5816                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5817   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5818                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
5819                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
5820                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5821 
5822   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5823                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
5824                "    aaaaaaaaaaaaaaa != aa) {\n}");
5825   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5826                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
5827                "    aaaaaaaaaaaaaaa != aa) {\n}");
5828 }
5829 
5830 TEST_F(FormatTest, BreaksAfterAssignments) {
5831   verifyFormat(
5832       "unsigned Cost =\n"
5833       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
5834       "                        SI->getPointerAddressSpaceee());\n");
5835   verifyFormat(
5836       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
5837       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
5838 
5839   verifyFormat(
5840       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
5841       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
5842   verifyFormat("unsigned OriginalStartColumn =\n"
5843                "    SourceMgr.getSpellingColumnNumber(\n"
5844                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
5845                "    1;");
5846 }
5847 
5848 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
5849   FormatStyle Style = getLLVMStyle();
5850   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5851                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
5852                Style);
5853 
5854   Style.PenaltyBreakAssignment = 20;
5855   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5856                "                                 cccccccccccccccccccccccccc;",
5857                Style);
5858 }
5859 
5860 TEST_F(FormatTest, AlignsAfterAssignments) {
5861   verifyFormat(
5862       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5863       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
5864   verifyFormat(
5865       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5866       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
5867   verifyFormat(
5868       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5869       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
5870   verifyFormat(
5871       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5872       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
5873   verifyFormat(
5874       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5875       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5876       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
5877 }
5878 
5879 TEST_F(FormatTest, AlignsAfterReturn) {
5880   verifyFormat(
5881       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5882       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
5883   verifyFormat(
5884       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5885       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
5886   verifyFormat(
5887       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5888       "       aaaaaaaaaaaaaaaaaaaaaa();");
5889   verifyFormat(
5890       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5891       "        aaaaaaaaaaaaaaaaaaaaaa());");
5892   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5893                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5894   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5895                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
5896                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5897   verifyFormat("return\n"
5898                "    // true if code is one of a or b.\n"
5899                "    code == a || code == b;");
5900 }
5901 
5902 TEST_F(FormatTest, AlignsAfterOpenBracket) {
5903   verifyFormat(
5904       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5905       "                                                aaaaaaaaa aaaaaaa) {}");
5906   verifyFormat(
5907       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5908       "                                               aaaaaaaaaaa aaaaaaaaa);");
5909   verifyFormat(
5910       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5911       "                                             aaaaaaaaaaaaaaaaaaaaa));");
5912   FormatStyle Style = getLLVMStyle();
5913   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5914   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5915                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
5916                Style);
5917   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5918                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
5919                Style);
5920   verifyFormat("SomeLongVariableName->someFunction(\n"
5921                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
5922                Style);
5923   verifyFormat(
5924       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5925       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5926       Style);
5927   verifyFormat(
5928       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5929       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5930       Style);
5931   verifyFormat(
5932       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5933       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
5934       Style);
5935 
5936   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
5937                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
5938                "        b));",
5939                Style);
5940 
5941   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5942   Style.BinPackArguments = false;
5943   Style.BinPackParameters = false;
5944   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5945                "    aaaaaaaaaaa aaaaaaaa,\n"
5946                "    aaaaaaaaa aaaaaaa,\n"
5947                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5948                Style);
5949   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5950                "    aaaaaaaaaaa aaaaaaaaa,\n"
5951                "    aaaaaaaaaaa aaaaaaaaa,\n"
5952                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5953                Style);
5954   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
5955                "    aaaaaaaaaaaaaaa,\n"
5956                "    aaaaaaaaaaaaaaaaaaaaa,\n"
5957                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
5958                Style);
5959   verifyFormat(
5960       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
5961       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
5962       Style);
5963   verifyFormat(
5964       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
5965       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
5966       Style);
5967   verifyFormat(
5968       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5969       "    aaaaaaaaaaaaaaaaaaaaa(\n"
5970       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
5971       "    aaaaaaaaaaaaaaaa);",
5972       Style);
5973   verifyFormat(
5974       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5975       "    aaaaaaaaaaaaaaaaaaaaa(\n"
5976       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
5977       "    aaaaaaaaaaaaaaaa);",
5978       Style);
5979 }
5980 
5981 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
5982   FormatStyle Style = getLLVMStyleWithColumns(40);
5983   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5984                "          bbbbbbbbbbbbbbbbbbbbbb);",
5985                Style);
5986   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
5987   Style.AlignOperands = FormatStyle::OAS_DontAlign;
5988   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5989                "          bbbbbbbbbbbbbbbbbbbbbb);",
5990                Style);
5991   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5992   Style.AlignOperands = FormatStyle::OAS_Align;
5993   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5994                "          bbbbbbbbbbbbbbbbbbbbbb);",
5995                Style);
5996   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5997   Style.AlignOperands = FormatStyle::OAS_DontAlign;
5998   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5999                "    bbbbbbbbbbbbbbbbbbbbbb);",
6000                Style);
6001 }
6002 
6003 TEST_F(FormatTest, BreaksConditionalExpressions) {
6004   verifyFormat(
6005       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6006       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6007       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6008   verifyFormat(
6009       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6010       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6011       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6012   verifyFormat(
6013       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6014       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6015   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6016                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6017                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6018   verifyFormat(
6019       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6020       "                                                    : aaaaaaaaaaaaa);");
6021   verifyFormat(
6022       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6023       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6024       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6025       "                   aaaaaaaaaaaaa);");
6026   verifyFormat(
6027       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6028       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6029       "                   aaaaaaaaaaaaa);");
6030   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6031                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6032                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6033                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6034                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6035   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6036                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6037                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6038                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6039                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6040                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6041                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6042   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6043                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6044                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6045                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6046                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6047   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6048                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6049                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6050   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6051                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6052                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6053                "        : aaaaaaaaaaaaaaaa;");
6054   verifyFormat(
6055       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6056       "    ? aaaaaaaaaaaaaaa\n"
6057       "    : aaaaaaaaaaaaaaa;");
6058   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6059                "          aaaaaaaaa\n"
6060                "      ? b\n"
6061                "      : c);");
6062   verifyFormat("return aaaa == bbbb\n"
6063                "           // comment\n"
6064                "           ? aaaa\n"
6065                "           : bbbb;");
6066   verifyFormat("unsigned Indent =\n"
6067                "    format(TheLine.First,\n"
6068                "           IndentForLevel[TheLine.Level] >= 0\n"
6069                "               ? IndentForLevel[TheLine.Level]\n"
6070                "               : TheLine * 2,\n"
6071                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6072                getLLVMStyleWithColumns(60));
6073   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6074                "                  ? aaaaaaaaaaaaaaa\n"
6075                "                  : bbbbbbbbbbbbbbb //\n"
6076                "                        ? ccccccccccccccc\n"
6077                "                        : ddddddddddddddd;");
6078   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6079                "                  ? aaaaaaaaaaaaaaa\n"
6080                "                  : (bbbbbbbbbbbbbbb //\n"
6081                "                         ? ccccccccccccccc\n"
6082                "                         : ddddddddddddddd);");
6083   verifyFormat(
6084       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6085       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6086       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
6087       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
6088       "                                      : aaaaaaaaaa;");
6089   verifyFormat(
6090       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6091       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
6092       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6093 
6094   FormatStyle NoBinPacking = getLLVMStyle();
6095   NoBinPacking.BinPackArguments = false;
6096   verifyFormat(
6097       "void f() {\n"
6098       "  g(aaa,\n"
6099       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6100       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6101       "        ? aaaaaaaaaaaaaaa\n"
6102       "        : aaaaaaaaaaaaaaa);\n"
6103       "}",
6104       NoBinPacking);
6105   verifyFormat(
6106       "void f() {\n"
6107       "  g(aaa,\n"
6108       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6109       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6110       "        ?: aaaaaaaaaaaaaaa);\n"
6111       "}",
6112       NoBinPacking);
6113 
6114   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6115                "             // comment.\n"
6116                "             ccccccccccccccccccccccccccccccccccccccc\n"
6117                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6118                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6119 
6120   // Assignments in conditional expressions. Apparently not uncommon :-(.
6121   verifyFormat("return a != b\n"
6122                "           // comment\n"
6123                "           ? a = b\n"
6124                "           : a = b;");
6125   verifyFormat("return a != b\n"
6126                "           // comment\n"
6127                "           ? a = a != b\n"
6128                "                     // comment\n"
6129                "                     ? a = b\n"
6130                "                     : a\n"
6131                "           : a;\n");
6132   verifyFormat("return a != b\n"
6133                "           // comment\n"
6134                "           ? a\n"
6135                "           : a = a != b\n"
6136                "                     // comment\n"
6137                "                     ? a = b\n"
6138                "                     : a;");
6139 
6140   // Chained conditionals
6141   FormatStyle Style = getLLVMStyle();
6142   Style.ColumnLimit = 70;
6143   Style.AlignOperands = FormatStyle::OAS_Align;
6144   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6145                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6146                "                        : 3333333333333333;",
6147                Style);
6148   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6149                "       : bbbbbbbbbb     ? 2222222222222222\n"
6150                "                        : 3333333333333333;",
6151                Style);
6152   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
6153                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6154                "                          : 3333333333333333;",
6155                Style);
6156   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6157                "       : bbbbbbbbbbbbbb ? 222222\n"
6158                "                        : 333333;",
6159                Style);
6160   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6161                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6162                "       : cccccccccccccc ? 3333333333333333\n"
6163                "                        : 4444444444444444;",
6164                Style);
6165   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6166                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6167                "                        : 3333333333333333;",
6168                Style);
6169   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6170                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6171                "                        : (aaa ? bbb : ccc);",
6172                Style);
6173   verifyFormat(
6174       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6175       "                                             : cccccccccccccccccc)\n"
6176       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6177       "                        : 3333333333333333;",
6178       Style);
6179   verifyFormat(
6180       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6181       "                                             : cccccccccccccccccc)\n"
6182       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6183       "                        : 3333333333333333;",
6184       Style);
6185   verifyFormat(
6186       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6187       "                                             : dddddddddddddddddd)\n"
6188       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6189       "                        : 3333333333333333;",
6190       Style);
6191   verifyFormat(
6192       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6193       "                                             : dddddddddddddddddd)\n"
6194       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6195       "                        : 3333333333333333;",
6196       Style);
6197   verifyFormat(
6198       "return aaaaaaaaa        ? 1111111111111111\n"
6199       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6200       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6201       "                                             : dddddddddddddddddd)\n",
6202       Style);
6203   verifyFormat(
6204       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6205       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6206       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6207       "                                             : cccccccccccccccccc);",
6208       Style);
6209   verifyFormat(
6210       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6211       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6212       "                                             : eeeeeeeeeeeeeeeeee)\n"
6213       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6214       "                        : 3333333333333333;",
6215       Style);
6216   verifyFormat(
6217       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
6218       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6219       "                                             : eeeeeeeeeeeeeeeeee)\n"
6220       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6221       "                        : 3333333333333333;",
6222       Style);
6223   verifyFormat(
6224       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6225       "                           : cccccccccccc    ? dddddddddddddddddd\n"
6226       "                                             : eeeeeeeeeeeeeeeeee)\n"
6227       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6228       "                        : 3333333333333333;",
6229       Style);
6230   verifyFormat(
6231       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6232       "                                             : cccccccccccccccccc\n"
6233       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6234       "                        : 3333333333333333;",
6235       Style);
6236   verifyFormat(
6237       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6238       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
6239       "                                             : eeeeeeeeeeeeeeeeee\n"
6240       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6241       "                        : 3333333333333333;",
6242       Style);
6243   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6244                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
6245                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
6246                "                                   : eeeeeeeeeeeeeeeeee)\n"
6247                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6248                "                             : 3333333333333333;",
6249                Style);
6250   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6251                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6252                "             : cccccccccccccccc ? dddddddddddddddddd\n"
6253                "                                : eeeeeeeeeeeeeeeeee\n"
6254                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6255                "                                 : 3333333333333333;",
6256                Style);
6257 }
6258 
6259 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6260   FormatStyle Style = getLLVMStyle();
6261   Style.BreakBeforeTernaryOperators = false;
6262   Style.ColumnLimit = 70;
6263   verifyFormat(
6264       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6265       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6266       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6267       Style);
6268   verifyFormat(
6269       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6270       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6271       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6272       Style);
6273   verifyFormat(
6274       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6275       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6276       Style);
6277   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6278                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6279                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6280                Style);
6281   verifyFormat(
6282       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6283       "                                                      aaaaaaaaaaaaa);",
6284       Style);
6285   verifyFormat(
6286       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6287       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6288       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6289       "                   aaaaaaaaaaaaa);",
6290       Style);
6291   verifyFormat(
6292       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6293       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6294       "                   aaaaaaaaaaaaa);",
6295       Style);
6296   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6297                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6298                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6299                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6300                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6301                Style);
6302   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6303                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6304                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6305                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6306                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6307                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6308                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6309                Style);
6310   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6311                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6312                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6313                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6314                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6315                Style);
6316   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6317                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6318                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6319                Style);
6320   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6321                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6322                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6323                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6324                Style);
6325   verifyFormat(
6326       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6327       "    aaaaaaaaaaaaaaa :\n"
6328       "    aaaaaaaaaaaaaaa;",
6329       Style);
6330   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6331                "          aaaaaaaaa ?\n"
6332                "      b :\n"
6333                "      c);",
6334                Style);
6335   verifyFormat("unsigned Indent =\n"
6336                "    format(TheLine.First,\n"
6337                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
6338                "               IndentForLevel[TheLine.Level] :\n"
6339                "               TheLine * 2,\n"
6340                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6341                Style);
6342   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6343                "                  aaaaaaaaaaaaaaa :\n"
6344                "                  bbbbbbbbbbbbbbb ? //\n"
6345                "                      ccccccccccccccc :\n"
6346                "                      ddddddddddddddd;",
6347                Style);
6348   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6349                "                  aaaaaaaaaaaaaaa :\n"
6350                "                  (bbbbbbbbbbbbbbb ? //\n"
6351                "                       ccccccccccccccc :\n"
6352                "                       ddddddddddddddd);",
6353                Style);
6354   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6355                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6356                "            ccccccccccccccccccccccccccc;",
6357                Style);
6358   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6359                "           aaaaa :\n"
6360                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
6361                Style);
6362 
6363   // Chained conditionals
6364   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6365                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6366                "                          3333333333333333;",
6367                Style);
6368   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6369                "       bbbbbbbbbb       ? 2222222222222222 :\n"
6370                "                          3333333333333333;",
6371                Style);
6372   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
6373                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6374                "                          3333333333333333;",
6375                Style);
6376   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6377                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
6378                "                          333333;",
6379                Style);
6380   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6381                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6382                "       cccccccccccccccc ? 3333333333333333 :\n"
6383                "                          4444444444444444;",
6384                Style);
6385   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6386                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6387                "                          3333333333333333;",
6388                Style);
6389   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6390                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6391                "                          (aaa ? bbb : ccc);",
6392                Style);
6393   verifyFormat(
6394       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6395       "                                               cccccccccccccccccc) :\n"
6396       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6397       "                          3333333333333333;",
6398       Style);
6399   verifyFormat(
6400       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6401       "                                               cccccccccccccccccc) :\n"
6402       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6403       "                          3333333333333333;",
6404       Style);
6405   verifyFormat(
6406       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6407       "                                               dddddddddddddddddd) :\n"
6408       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6409       "                          3333333333333333;",
6410       Style);
6411   verifyFormat(
6412       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6413       "                                               dddddddddddddddddd) :\n"
6414       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6415       "                          3333333333333333;",
6416       Style);
6417   verifyFormat(
6418       "return aaaaaaaaa        ? 1111111111111111 :\n"
6419       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6420       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6421       "                                               dddddddddddddddddd)\n",
6422       Style);
6423   verifyFormat(
6424       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6425       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6426       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6427       "                                               cccccccccccccccccc);",
6428       Style);
6429   verifyFormat(
6430       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6431       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6432       "                                               eeeeeeeeeeeeeeeeee) :\n"
6433       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6434       "                          3333333333333333;",
6435       Style);
6436   verifyFormat(
6437       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6438       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
6439       "                                               eeeeeeeeeeeeeeeeee) :\n"
6440       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6441       "                          3333333333333333;",
6442       Style);
6443   verifyFormat(
6444       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
6445       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6446       "                                               eeeeeeeeeeeeeeeeee) :\n"
6447       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6448       "                          3333333333333333;",
6449       Style);
6450   verifyFormat(
6451       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6452       "                                               cccccccccccccccccc :\n"
6453       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6454       "                          3333333333333333;",
6455       Style);
6456   verifyFormat(
6457       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6458       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
6459       "                                               eeeeeeeeeeeeeeeeee :\n"
6460       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6461       "                          3333333333333333;",
6462       Style);
6463   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6464                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6465                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
6466                "                                 eeeeeeeeeeeeeeeeee) :\n"
6467                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6468                "                               3333333333333333;",
6469                Style);
6470   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6471                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6472                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
6473                "                                  eeeeeeeeeeeeeeeeee :\n"
6474                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6475                "                               3333333333333333;",
6476                Style);
6477 }
6478 
6479 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6480   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6481                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6482   verifyFormat("bool a = true, b = false;");
6483 
6484   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6485                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6486                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6487                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6488   verifyFormat(
6489       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6490       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6491       "     d = e && f;");
6492   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6493                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6494   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6495                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6496   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6497                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6498 
6499   FormatStyle Style = getGoogleStyle();
6500   Style.PointerAlignment = FormatStyle::PAS_Left;
6501   Style.DerivePointerAlignment = false;
6502   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6503                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6504                "    *b = bbbbbbbbbbbbbbbbbbb;",
6505                Style);
6506   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6507                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6508                Style);
6509   verifyFormat("vector<int*> a, b;", Style);
6510   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6511 }
6512 
6513 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6514   verifyFormat("arr[foo ? bar : baz];");
6515   verifyFormat("f()[foo ? bar : baz];");
6516   verifyFormat("(a + b)[foo ? bar : baz];");
6517   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6518 }
6519 
6520 TEST_F(FormatTest, AlignsStringLiterals) {
6521   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6522                "                                      \"short literal\");");
6523   verifyFormat(
6524       "looooooooooooooooooooooooongFunction(\n"
6525       "    \"short literal\"\n"
6526       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6527   verifyFormat("someFunction(\"Always break between multi-line\"\n"
6528                "             \" string literals\",\n"
6529                "             and, other, parameters);");
6530   EXPECT_EQ("fun + \"1243\" /* comment */\n"
6531             "      \"5678\";",
6532             format("fun + \"1243\" /* comment */\n"
6533                    "    \"5678\";",
6534                    getLLVMStyleWithColumns(28)));
6535   EXPECT_EQ(
6536       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6537       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6538       "         \"aaaaaaaaaaaaaaaa\";",
6539       format("aaaaaa ="
6540              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6541              "aaaaaaaaaaaaaaaaaaaaa\" "
6542              "\"aaaaaaaaaaaaaaaa\";"));
6543   verifyFormat("a = a + \"a\"\n"
6544                "        \"a\"\n"
6545                "        \"a\";");
6546   verifyFormat("f(\"a\", \"b\"\n"
6547                "       \"c\");");
6548 
6549   verifyFormat(
6550       "#define LL_FORMAT \"ll\"\n"
6551       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6552       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6553 
6554   verifyFormat("#define A(X)          \\\n"
6555                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
6556                "  \"ccccc\"",
6557                getLLVMStyleWithColumns(23));
6558   verifyFormat("#define A \"def\"\n"
6559                "f(\"abc\" A \"ghi\"\n"
6560                "  \"jkl\");");
6561 
6562   verifyFormat("f(L\"a\"\n"
6563                "  L\"b\");");
6564   verifyFormat("#define A(X)            \\\n"
6565                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6566                "  L\"ccccc\"",
6567                getLLVMStyleWithColumns(25));
6568 
6569   verifyFormat("f(@\"a\"\n"
6570                "  @\"b\");");
6571   verifyFormat("NSString s = @\"a\"\n"
6572                "             @\"b\"\n"
6573                "             @\"c\";");
6574   verifyFormat("NSString s = @\"a\"\n"
6575                "              \"b\"\n"
6576                "              \"c\";");
6577 }
6578 
6579 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6580   FormatStyle Style = getLLVMStyle();
6581   // No declarations or definitions should be moved to own line.
6582   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6583   verifyFormat("class A {\n"
6584                "  int f() { return 1; }\n"
6585                "  int g();\n"
6586                "};\n"
6587                "int f() { return 1; }\n"
6588                "int g();\n",
6589                Style);
6590 
6591   // All declarations and definitions should have the return type moved to its
6592   // own
6593   // line.
6594   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6595   verifyFormat("class E {\n"
6596                "  int\n"
6597                "  f() {\n"
6598                "    return 1;\n"
6599                "  }\n"
6600                "  int\n"
6601                "  g();\n"
6602                "};\n"
6603                "int\n"
6604                "f() {\n"
6605                "  return 1;\n"
6606                "}\n"
6607                "int\n"
6608                "g();\n",
6609                Style);
6610 
6611   // Top-level definitions, and no kinds of declarations should have the
6612   // return type moved to its own line.
6613   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6614   verifyFormat("class B {\n"
6615                "  int f() { return 1; }\n"
6616                "  int g();\n"
6617                "};\n"
6618                "int\n"
6619                "f() {\n"
6620                "  return 1;\n"
6621                "}\n"
6622                "int g();\n",
6623                Style);
6624 
6625   // Top-level definitions and declarations should have the return type moved
6626   // to its own line.
6627   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6628   verifyFormat("class C {\n"
6629                "  int f() { return 1; }\n"
6630                "  int g();\n"
6631                "};\n"
6632                "int\n"
6633                "f() {\n"
6634                "  return 1;\n"
6635                "}\n"
6636                "int\n"
6637                "g();\n",
6638                Style);
6639 
6640   // All definitions should have the return type moved to its own line, but no
6641   // kinds of declarations.
6642   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6643   verifyFormat("class D {\n"
6644                "  int\n"
6645                "  f() {\n"
6646                "    return 1;\n"
6647                "  }\n"
6648                "  int g();\n"
6649                "};\n"
6650                "int\n"
6651                "f() {\n"
6652                "  return 1;\n"
6653                "}\n"
6654                "int g();\n",
6655                Style);
6656   verifyFormat("const char *\n"
6657                "f(void) {\n" // Break here.
6658                "  return \"\";\n"
6659                "}\n"
6660                "const char *bar(void);\n", // No break here.
6661                Style);
6662   verifyFormat("template <class T>\n"
6663                "T *\n"
6664                "f(T &c) {\n" // Break here.
6665                "  return NULL;\n"
6666                "}\n"
6667                "template <class T> T *f(T &c);\n", // No break here.
6668                Style);
6669   verifyFormat("class C {\n"
6670                "  int\n"
6671                "  operator+() {\n"
6672                "    return 1;\n"
6673                "  }\n"
6674                "  int\n"
6675                "  operator()() {\n"
6676                "    return 1;\n"
6677                "  }\n"
6678                "};\n",
6679                Style);
6680   verifyFormat("void\n"
6681                "A::operator()() {}\n"
6682                "void\n"
6683                "A::operator>>() {}\n"
6684                "void\n"
6685                "A::operator+() {}\n"
6686                "void\n"
6687                "A::operator*() {}\n"
6688                "void\n"
6689                "A::operator->() {}\n"
6690                "void\n"
6691                "A::operator void *() {}\n"
6692                "void\n"
6693                "A::operator void &() {}\n"
6694                "void\n"
6695                "A::operator void &&() {}\n"
6696                "void\n"
6697                "A::operator char *() {}\n"
6698                "void\n"
6699                "A::operator[]() {}\n"
6700                "void\n"
6701                "A::operator!() {}\n"
6702                "void\n"
6703                "A::operator**() {}\n"
6704                "void\n"
6705                "A::operator<Foo> *() {}\n"
6706                "void\n"
6707                "A::operator<Foo> **() {}\n"
6708                "void\n"
6709                "A::operator<Foo> &() {}\n"
6710                "void\n"
6711                "A::operator void **() {}\n",
6712                Style);
6713   verifyFormat("constexpr auto\n"
6714                "operator()() const -> reference {}\n"
6715                "constexpr auto\n"
6716                "operator>>() const -> reference {}\n"
6717                "constexpr auto\n"
6718                "operator+() const -> reference {}\n"
6719                "constexpr auto\n"
6720                "operator*() const -> reference {}\n"
6721                "constexpr auto\n"
6722                "operator->() const -> reference {}\n"
6723                "constexpr auto\n"
6724                "operator++() const -> reference {}\n"
6725                "constexpr auto\n"
6726                "operator void *() const -> reference {}\n"
6727                "constexpr auto\n"
6728                "operator void **() const -> reference {}\n"
6729                "constexpr auto\n"
6730                "operator void *() const -> reference {}\n"
6731                "constexpr auto\n"
6732                "operator void &() const -> reference {}\n"
6733                "constexpr auto\n"
6734                "operator void &&() const -> reference {}\n"
6735                "constexpr auto\n"
6736                "operator char *() const -> reference {}\n"
6737                "constexpr auto\n"
6738                "operator!() const -> reference {}\n"
6739                "constexpr auto\n"
6740                "operator[]() const -> reference {}\n",
6741                Style);
6742   verifyFormat("void *operator new(std::size_t s);", // No break here.
6743                Style);
6744   verifyFormat("void *\n"
6745                "operator new(std::size_t s) {}",
6746                Style);
6747   verifyFormat("void *\n"
6748                "operator delete[](void *ptr) {}",
6749                Style);
6750   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6751   verifyFormat("const char *\n"
6752                "f(void)\n" // Break here.
6753                "{\n"
6754                "  return \"\";\n"
6755                "}\n"
6756                "const char *bar(void);\n", // No break here.
6757                Style);
6758   verifyFormat("template <class T>\n"
6759                "T *\n"     // Problem here: no line break
6760                "f(T &c)\n" // Break here.
6761                "{\n"
6762                "  return NULL;\n"
6763                "}\n"
6764                "template <class T> T *f(T &c);\n", // No break here.
6765                Style);
6766   verifyFormat("int\n"
6767                "foo(A<bool> a)\n"
6768                "{\n"
6769                "  return a;\n"
6770                "}\n",
6771                Style);
6772   verifyFormat("int\n"
6773                "foo(A<8> a)\n"
6774                "{\n"
6775                "  return a;\n"
6776                "}\n",
6777                Style);
6778   verifyFormat("int\n"
6779                "foo(A<B<bool>, 8> a)\n"
6780                "{\n"
6781                "  return a;\n"
6782                "}\n",
6783                Style);
6784   verifyFormat("int\n"
6785                "foo(A<B<8>, bool> a)\n"
6786                "{\n"
6787                "  return a;\n"
6788                "}\n",
6789                Style);
6790   verifyFormat("int\n"
6791                "foo(A<B<bool>, bool> a)\n"
6792                "{\n"
6793                "  return a;\n"
6794                "}\n",
6795                Style);
6796   verifyFormat("int\n"
6797                "foo(A<B<8>, 8> a)\n"
6798                "{\n"
6799                "  return a;\n"
6800                "}\n",
6801                Style);
6802 
6803   Style = getGNUStyle();
6804 
6805   // Test for comments at the end of function declarations.
6806   verifyFormat("void\n"
6807                "foo (int a, /*abc*/ int b) // def\n"
6808                "{\n"
6809                "}\n",
6810                Style);
6811 
6812   verifyFormat("void\n"
6813                "foo (int a, /* abc */ int b) /* def */\n"
6814                "{\n"
6815                "}\n",
6816                Style);
6817 
6818   // Definitions that should not break after return type
6819   verifyFormat("void foo (int a, int b); // def\n", Style);
6820   verifyFormat("void foo (int a, int b); /* def */\n", Style);
6821   verifyFormat("void foo (int a, int b);\n", Style);
6822 }
6823 
6824 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
6825   FormatStyle NoBreak = getLLVMStyle();
6826   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
6827   FormatStyle Break = getLLVMStyle();
6828   Break.AlwaysBreakBeforeMultilineStrings = true;
6829   verifyFormat("aaaa = \"bbbb\"\n"
6830                "       \"cccc\";",
6831                NoBreak);
6832   verifyFormat("aaaa =\n"
6833                "    \"bbbb\"\n"
6834                "    \"cccc\";",
6835                Break);
6836   verifyFormat("aaaa(\"bbbb\"\n"
6837                "     \"cccc\");",
6838                NoBreak);
6839   verifyFormat("aaaa(\n"
6840                "    \"bbbb\"\n"
6841                "    \"cccc\");",
6842                Break);
6843   verifyFormat("aaaa(qqq, \"bbbb\"\n"
6844                "          \"cccc\");",
6845                NoBreak);
6846   verifyFormat("aaaa(qqq,\n"
6847                "     \"bbbb\"\n"
6848                "     \"cccc\");",
6849                Break);
6850   verifyFormat("aaaa(qqq,\n"
6851                "     L\"bbbb\"\n"
6852                "     L\"cccc\");",
6853                Break);
6854   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
6855                "                      \"bbbb\"));",
6856                Break);
6857   verifyFormat("string s = someFunction(\n"
6858                "    \"abc\"\n"
6859                "    \"abc\");",
6860                Break);
6861 
6862   // As we break before unary operators, breaking right after them is bad.
6863   verifyFormat("string foo = abc ? \"x\"\n"
6864                "                   \"blah blah blah blah blah blah\"\n"
6865                "                 : \"y\";",
6866                Break);
6867 
6868   // Don't break if there is no column gain.
6869   verifyFormat("f(\"aaaa\"\n"
6870                "  \"bbbb\");",
6871                Break);
6872 
6873   // Treat literals with escaped newlines like multi-line string literals.
6874   EXPECT_EQ("x = \"a\\\n"
6875             "b\\\n"
6876             "c\";",
6877             format("x = \"a\\\n"
6878                    "b\\\n"
6879                    "c\";",
6880                    NoBreak));
6881   EXPECT_EQ("xxxx =\n"
6882             "    \"a\\\n"
6883             "b\\\n"
6884             "c\";",
6885             format("xxxx = \"a\\\n"
6886                    "b\\\n"
6887                    "c\";",
6888                    Break));
6889 
6890   EXPECT_EQ("NSString *const kString =\n"
6891             "    @\"aaaa\"\n"
6892             "    @\"bbbb\";",
6893             format("NSString *const kString = @\"aaaa\"\n"
6894                    "@\"bbbb\";",
6895                    Break));
6896 
6897   Break.ColumnLimit = 0;
6898   verifyFormat("const char *hello = \"hello llvm\";", Break);
6899 }
6900 
6901 TEST_F(FormatTest, AlignsPipes) {
6902   verifyFormat(
6903       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6904       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6905       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6906   verifyFormat(
6907       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
6908       "                     << aaaaaaaaaaaaaaaaaaaa;");
6909   verifyFormat(
6910       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6911       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6912   verifyFormat(
6913       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
6914       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6915   verifyFormat(
6916       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
6917       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
6918       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
6919   verifyFormat(
6920       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6921       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6922       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6923   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6924                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6925                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6926                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
6927   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
6928                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
6929   verifyFormat(
6930       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6931       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6932   verifyFormat(
6933       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
6934       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
6935 
6936   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
6937                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
6938   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6939                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6940                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
6941                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
6942   verifyFormat("LOG_IF(aaa == //\n"
6943                "       bbb)\n"
6944                "    << a << b;");
6945 
6946   // But sometimes, breaking before the first "<<" is desirable.
6947   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6948                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
6949   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
6950                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6951                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6952   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
6953                "    << BEF << IsTemplate << Description << E->getType();");
6954   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6955                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6956                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6957   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6958                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6959                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6960                "    << aaa;");
6961 
6962   verifyFormat(
6963       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6964       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
6965 
6966   // Incomplete string literal.
6967   EXPECT_EQ("llvm::errs() << \"\n"
6968             "             << a;",
6969             format("llvm::errs() << \"\n<<a;"));
6970 
6971   verifyFormat("void f() {\n"
6972                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
6973                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
6974                "}");
6975 
6976   // Handle 'endl'.
6977   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
6978                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
6979   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
6980 
6981   // Handle '\n'.
6982   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
6983                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
6984   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
6985                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
6986   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
6987                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
6988   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
6989 }
6990 
6991 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
6992   verifyFormat("return out << \"somepacket = {\\n\"\n"
6993                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
6994                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
6995                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
6996                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
6997                "           << \"}\";");
6998 
6999   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7000                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7001                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7002   verifyFormat(
7003       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7004       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7005       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7006       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7007       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7008   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7009                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7010   verifyFormat(
7011       "void f() {\n"
7012       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7013       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7014       "}");
7015 
7016   // Breaking before the first "<<" is generally not desirable.
7017   verifyFormat(
7018       "llvm::errs()\n"
7019       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7020       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7021       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7022       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7023       getLLVMStyleWithColumns(70));
7024   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7025                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7026                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7027                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7028                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7029                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7030                getLLVMStyleWithColumns(70));
7031 
7032   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7033                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7034                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7035   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7036                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7037                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7038   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7039                "           (aaaa + aaaa);",
7040                getLLVMStyleWithColumns(40));
7041   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7042                "                  (aaaaaaa + aaaaa));",
7043                getLLVMStyleWithColumns(40));
7044   verifyFormat(
7045       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7046       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7047       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
7048 }
7049 
7050 TEST_F(FormatTest, UnderstandsEquals) {
7051   verifyFormat(
7052       "aaaaaaaaaaaaaaaaa =\n"
7053       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7054   verifyFormat(
7055       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7056       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7057   verifyFormat(
7058       "if (a) {\n"
7059       "  f();\n"
7060       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7061       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7062       "}");
7063 
7064   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7065                "        100000000 + 10000000) {\n}");
7066 }
7067 
7068 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7069   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7070                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
7071 
7072   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7073                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
7074 
7075   verifyFormat(
7076       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7077       "                                                          Parameter2);");
7078 
7079   verifyFormat(
7080       "ShortObject->shortFunction(\n"
7081       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7082       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7083 
7084   verifyFormat("loooooooooooooongFunction(\n"
7085                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
7086 
7087   verifyFormat(
7088       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7089       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7090 
7091   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7092                "    .WillRepeatedly(Return(SomeValue));");
7093   verifyFormat("void f() {\n"
7094                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7095                "      .Times(2)\n"
7096                "      .WillRepeatedly(Return(SomeValue));\n"
7097                "}");
7098   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7099                "    ccccccccccccccccccccccc);");
7100   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7101                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7102                "          .aaaaa(aaaaa),\n"
7103                "      aaaaaaaaaaaaaaaaaaaaa);");
7104   verifyFormat("void f() {\n"
7105                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7106                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7107                "}");
7108   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7109                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7110                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7111                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7112                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7113   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7114                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7115                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7116                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7117                "}");
7118 
7119   // Here, it is not necessary to wrap at "." or "->".
7120   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7121                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7122   verifyFormat(
7123       "aaaaaaaaaaa->aaaaaaaaa(\n"
7124       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7125       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7126 
7127   verifyFormat(
7128       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7129       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7130   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7131                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7132   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7133                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7134 
7135   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7136                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7137                "    .a();");
7138 
7139   FormatStyle NoBinPacking = getLLVMStyle();
7140   NoBinPacking.BinPackParameters = false;
7141   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7142                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7143                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7144                "                         aaaaaaaaaaaaaaaaaaa,\n"
7145                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7146                NoBinPacking);
7147 
7148   // If there is a subsequent call, change to hanging indentation.
7149   verifyFormat(
7150       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7151       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7152       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7153   verifyFormat(
7154       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7155       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7156   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7157                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7158                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7159   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7160                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7161                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7162 }
7163 
7164 TEST_F(FormatTest, WrapsTemplateDeclarations) {
7165   verifyFormat("template <typename T>\n"
7166                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7167   verifyFormat("template <typename T>\n"
7168                "// T should be one of {A, B}.\n"
7169                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7170   verifyFormat(
7171       "template <typename T>\n"
7172       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7173   verifyFormat("template <typename T>\n"
7174                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7175                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7176   verifyFormat(
7177       "template <typename T>\n"
7178       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7179       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
7180   verifyFormat(
7181       "template <typename T>\n"
7182       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7183       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7184       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7185   verifyFormat("template <typename T>\n"
7186                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7187                "    int aaaaaaaaaaaaaaaaaaaaaa);");
7188   verifyFormat(
7189       "template <typename T1, typename T2 = char, typename T3 = char,\n"
7190       "          typename T4 = char>\n"
7191       "void f();");
7192   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7193                "          template <typename> class cccccccccccccccccccccc,\n"
7194                "          typename ddddddddddddd>\n"
7195                "class C {};");
7196   verifyFormat(
7197       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7198       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7199 
7200   verifyFormat("void f() {\n"
7201                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7202                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7203                "}");
7204 
7205   verifyFormat("template <typename T> class C {};");
7206   verifyFormat("template <typename T> void f();");
7207   verifyFormat("template <typename T> void f() {}");
7208   verifyFormat(
7209       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7210       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7211       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7212       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7213       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7214       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7215       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
7216       getLLVMStyleWithColumns(72));
7217   EXPECT_EQ("static_cast<A< //\n"
7218             "    B> *>(\n"
7219             "\n"
7220             ");",
7221             format("static_cast<A<//\n"
7222                    "    B>*>(\n"
7223                    "\n"
7224                    "    );"));
7225   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7226                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7227 
7228   FormatStyle AlwaysBreak = getLLVMStyle();
7229   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7230   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7231   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7232   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7233   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7234                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7235                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
7236   verifyFormat("template <template <typename> class Fooooooo,\n"
7237                "          template <typename> class Baaaaaaar>\n"
7238                "struct C {};",
7239                AlwaysBreak);
7240   verifyFormat("template <typename T> // T can be A, B or C.\n"
7241                "struct C {};",
7242                AlwaysBreak);
7243   verifyFormat("template <enum E> class A {\n"
7244                "public:\n"
7245                "  E *f();\n"
7246                "};");
7247 
7248   FormatStyle NeverBreak = getLLVMStyle();
7249   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7250   verifyFormat("template <typename T> class C {};", NeverBreak);
7251   verifyFormat("template <typename T> void f();", NeverBreak);
7252   verifyFormat("template <typename T> void f() {}", NeverBreak);
7253   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7254                "bbbbbbbbbbbbbbbbbbbb) {}",
7255                NeverBreak);
7256   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7257                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7258                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
7259                NeverBreak);
7260   verifyFormat("template <template <typename> class Fooooooo,\n"
7261                "          template <typename> class Baaaaaaar>\n"
7262                "struct C {};",
7263                NeverBreak);
7264   verifyFormat("template <typename T> // T can be A, B or C.\n"
7265                "struct C {};",
7266                NeverBreak);
7267   verifyFormat("template <enum E> class A {\n"
7268                "public:\n"
7269                "  E *f();\n"
7270                "};",
7271                NeverBreak);
7272   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7273   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7274                "bbbbbbbbbbbbbbbbbbbb) {}",
7275                NeverBreak);
7276 }
7277 
7278 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7279   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7280   Style.ColumnLimit = 60;
7281   EXPECT_EQ("// Baseline - no comments.\n"
7282             "template <\n"
7283             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7284             "void f() {}",
7285             format("// Baseline - no comments.\n"
7286                    "template <\n"
7287                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7288                    "void f() {}",
7289                    Style));
7290 
7291   EXPECT_EQ("template <\n"
7292             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7293             "void f() {}",
7294             format("template <\n"
7295                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7296                    "void f() {}",
7297                    Style));
7298 
7299   EXPECT_EQ(
7300       "template <\n"
7301       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7302       "void f() {}",
7303       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
7304              "void f() {}",
7305              Style));
7306 
7307   EXPECT_EQ(
7308       "template <\n"
7309       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7310       "                                               // multiline\n"
7311       "void f() {}",
7312       format("template <\n"
7313              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7314              "                                              // multiline\n"
7315              "void f() {}",
7316              Style));
7317 
7318   EXPECT_EQ(
7319       "template <typename aaaaaaaaaa<\n"
7320       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
7321       "void f() {}",
7322       format(
7323           "template <\n"
7324           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7325           "void f() {}",
7326           Style));
7327 }
7328 
7329 TEST_F(FormatTest, WrapsTemplateParameters) {
7330   FormatStyle Style = getLLVMStyle();
7331   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7332   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7333   verifyFormat(
7334       "template <typename... a> struct q {};\n"
7335       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7336       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7337       "    y;",
7338       Style);
7339   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7340   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7341   verifyFormat(
7342       "template <typename... a> struct r {};\n"
7343       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7344       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7345       "    y;",
7346       Style);
7347   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7348   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7349   verifyFormat("template <typename... a> struct s {};\n"
7350                "extern s<\n"
7351                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7352                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7353                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7354                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7355                "    y;",
7356                Style);
7357   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7358   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7359   verifyFormat("template <typename... a> struct t {};\n"
7360                "extern t<\n"
7361                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7362                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7363                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7364                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7365                "    y;",
7366                Style);
7367 }
7368 
7369 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7370   verifyFormat(
7371       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7372       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7373   verifyFormat(
7374       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7375       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7376       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7377 
7378   // FIXME: Should we have the extra indent after the second break?
7379   verifyFormat(
7380       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7381       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7382       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7383 
7384   verifyFormat(
7385       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7386       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
7387 
7388   // Breaking at nested name specifiers is generally not desirable.
7389   verifyFormat(
7390       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7391       "    aaaaaaaaaaaaaaaaaaaaaaa);");
7392 
7393   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7394                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7395                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7396                "                   aaaaaaaaaaaaaaaaaaaaa);",
7397                getLLVMStyleWithColumns(74));
7398 
7399   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7400                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7401                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7402 }
7403 
7404 TEST_F(FormatTest, UnderstandsTemplateParameters) {
7405   verifyFormat("A<int> a;");
7406   verifyFormat("A<A<A<int>>> a;");
7407   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7408   verifyFormat("bool x = a < 1 || 2 > a;");
7409   verifyFormat("bool x = 5 < f<int>();");
7410   verifyFormat("bool x = f<int>() > 5;");
7411   verifyFormat("bool x = 5 < a<int>::x;");
7412   verifyFormat("bool x = a < 4 ? a > 2 : false;");
7413   verifyFormat("bool x = f() ? a < 2 : a > 2;");
7414 
7415   verifyGoogleFormat("A<A<int>> a;");
7416   verifyGoogleFormat("A<A<A<int>>> a;");
7417   verifyGoogleFormat("A<A<A<A<int>>>> a;");
7418   verifyGoogleFormat("A<A<int> > a;");
7419   verifyGoogleFormat("A<A<A<int> > > a;");
7420   verifyGoogleFormat("A<A<A<A<int> > > > a;");
7421   verifyGoogleFormat("A<::A<int>> a;");
7422   verifyGoogleFormat("A<::A> a;");
7423   verifyGoogleFormat("A< ::A> a;");
7424   verifyGoogleFormat("A< ::A<int> > a;");
7425   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7426   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7427   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7428   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7429   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7430             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7431 
7432   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7433 
7434   // template closer followed by a token that starts with > or =
7435   verifyFormat("bool b = a<1> > 1;");
7436   verifyFormat("bool b = a<1> >= 1;");
7437   verifyFormat("int i = a<1> >> 1;");
7438   FormatStyle Style = getLLVMStyle();
7439   Style.SpaceBeforeAssignmentOperators = false;
7440   verifyFormat("bool b= a<1> == 1;", Style);
7441   verifyFormat("a<int> = 1;", Style);
7442   verifyFormat("a<int> >>= 1;", Style);
7443 
7444   verifyFormat("test >> a >> b;");
7445   verifyFormat("test << a >> b;");
7446 
7447   verifyFormat("f<int>();");
7448   verifyFormat("template <typename T> void f() {}");
7449   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7450   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7451                "sizeof(char)>::type>;");
7452   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7453   verifyFormat("f(a.operator()<A>());");
7454   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7455                "      .template operator()<A>());",
7456                getLLVMStyleWithColumns(35));
7457 
7458   // Not template parameters.
7459   verifyFormat("return a < b && c > d;");
7460   verifyFormat("void f() {\n"
7461                "  while (a < b && c > d) {\n"
7462                "  }\n"
7463                "}");
7464   verifyFormat("template <typename... Types>\n"
7465                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7466 
7467   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7468                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7469                getLLVMStyleWithColumns(60));
7470   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7471   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7472   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7473 }
7474 
7475 TEST_F(FormatTest, BitshiftOperatorWidth) {
7476   EXPECT_EQ("int a = 1 << 2; /* foo\n"
7477             "                   bar */",
7478             format("int    a=1<<2;  /* foo\n"
7479                    "                   bar */"));
7480 
7481   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7482             "                     bar */",
7483             format("int  b  =256>>1 ;  /* foo\n"
7484                    "                      bar */"));
7485 }
7486 
7487 TEST_F(FormatTest, UnderstandsBinaryOperators) {
7488   verifyFormat("COMPARE(a, ==, b);");
7489   verifyFormat("auto s = sizeof...(Ts) - 1;");
7490 }
7491 
7492 TEST_F(FormatTest, UnderstandsPointersToMembers) {
7493   verifyFormat("int A::*x;");
7494   verifyFormat("int (S::*func)(void *);");
7495   verifyFormat("void f() { int (S::*func)(void *); }");
7496   verifyFormat("typedef bool *(Class::*Member)() const;");
7497   verifyFormat("void f() {\n"
7498                "  (a->*f)();\n"
7499                "  a->*x;\n"
7500                "  (a.*f)();\n"
7501                "  ((*a).*f)();\n"
7502                "  a.*x;\n"
7503                "}");
7504   verifyFormat("void f() {\n"
7505                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7506                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7507                "}");
7508   verifyFormat(
7509       "(aaaaaaaaaa->*bbbbbbb)(\n"
7510       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7511   FormatStyle Style = getLLVMStyle();
7512   Style.PointerAlignment = FormatStyle::PAS_Left;
7513   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7514 }
7515 
7516 TEST_F(FormatTest, UnderstandsUnaryOperators) {
7517   verifyFormat("int a = -2;");
7518   verifyFormat("f(-1, -2, -3);");
7519   verifyFormat("a[-1] = 5;");
7520   verifyFormat("int a = 5 + -2;");
7521   verifyFormat("if (i == -1) {\n}");
7522   verifyFormat("if (i != -1) {\n}");
7523   verifyFormat("if (i > -1) {\n}");
7524   verifyFormat("if (i < -1) {\n}");
7525   verifyFormat("++(a->f());");
7526   verifyFormat("--(a->f());");
7527   verifyFormat("(a->f())++;");
7528   verifyFormat("a[42]++;");
7529   verifyFormat("if (!(a->f())) {\n}");
7530   verifyFormat("if (!+i) {\n}");
7531   verifyFormat("~&a;");
7532 
7533   verifyFormat("a-- > b;");
7534   verifyFormat("b ? -a : c;");
7535   verifyFormat("n * sizeof char16;");
7536   verifyFormat("n * alignof char16;", getGoogleStyle());
7537   verifyFormat("sizeof(char);");
7538   verifyFormat("alignof(char);", getGoogleStyle());
7539 
7540   verifyFormat("return -1;");
7541   verifyFormat("throw -1;");
7542   verifyFormat("switch (a) {\n"
7543                "case -1:\n"
7544                "  break;\n"
7545                "}");
7546   verifyFormat("#define X -1");
7547   verifyFormat("#define X -kConstant");
7548 
7549   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7550   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7551 
7552   verifyFormat("int a = /* confusing comment */ -1;");
7553   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7554   verifyFormat("int a = i /* confusing comment */++;");
7555 
7556   verifyFormat("co_yield -1;");
7557   verifyFormat("co_return -1;");
7558 }
7559 
7560 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7561   verifyFormat("if (!aaaaaaaaaa( // break\n"
7562                "        aaaaa)) {\n"
7563                "}");
7564   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7565                "    aaaaa));");
7566   verifyFormat("*aaa = aaaaaaa( // break\n"
7567                "    bbbbbb);");
7568 }
7569 
7570 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7571   verifyFormat("bool operator<();");
7572   verifyFormat("bool operator>();");
7573   verifyFormat("bool operator=();");
7574   verifyFormat("bool operator==();");
7575   verifyFormat("bool operator!=();");
7576   verifyFormat("int operator+();");
7577   verifyFormat("int operator++();");
7578   verifyFormat("int operator++(int) volatile noexcept;");
7579   verifyFormat("bool operator,();");
7580   verifyFormat("bool operator();");
7581   verifyFormat("bool operator()();");
7582   verifyFormat("bool operator[]();");
7583   verifyFormat("operator bool();");
7584   verifyFormat("operator int();");
7585   verifyFormat("operator void *();");
7586   verifyFormat("operator SomeType<int>();");
7587   verifyFormat("operator SomeType<int, int>();");
7588   verifyFormat("operator SomeType<SomeType<int>>();");
7589   verifyFormat("void *operator new(std::size_t size);");
7590   verifyFormat("void *operator new[](std::size_t size);");
7591   verifyFormat("void operator delete(void *ptr);");
7592   verifyFormat("void operator delete[](void *ptr);");
7593   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7594                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7595   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7596                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7597 
7598   verifyFormat(
7599       "ostream &operator<<(ostream &OutputStream,\n"
7600       "                    SomeReallyLongType WithSomeReallyLongValue);");
7601   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7602                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7603                "  return left.group < right.group;\n"
7604                "}");
7605   verifyFormat("SomeType &operator=(const SomeType &S);");
7606   verifyFormat("f.template operator()<int>();");
7607 
7608   verifyGoogleFormat("operator void*();");
7609   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7610   verifyGoogleFormat("operator ::A();");
7611 
7612   verifyFormat("using A::operator+;");
7613   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7614                "int i;");
7615 }
7616 
7617 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7618   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7619   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7620   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7621   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7622   verifyFormat("Deleted &operator=(const Deleted &) &;");
7623   verifyFormat("Deleted &operator=(const Deleted &) &&;");
7624   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7625   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7626   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7627   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7628   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7629   verifyFormat("void Fn(T const &) const &;");
7630   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7631   verifyFormat("template <typename T>\n"
7632                "void F(T) && = delete;",
7633                getGoogleStyle());
7634 
7635   FormatStyle AlignLeft = getLLVMStyle();
7636   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7637   verifyFormat("void A::b() && {}", AlignLeft);
7638   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7639   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7640                AlignLeft);
7641   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7642   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7643   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7644   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7645   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7646   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7647   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7648   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7649 
7650   FormatStyle Spaces = getLLVMStyle();
7651   Spaces.SpacesInCStyleCastParentheses = true;
7652   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7653   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7654   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7655   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7656 
7657   Spaces.SpacesInCStyleCastParentheses = false;
7658   Spaces.SpacesInParentheses = true;
7659   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7660   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7661                Spaces);
7662   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7663   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7664 
7665   FormatStyle BreakTemplate = getLLVMStyle();
7666   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7667 
7668   verifyFormat("struct f {\n"
7669                "  template <class T>\n"
7670                "  int &foo(const std::string &str) &noexcept {}\n"
7671                "};",
7672                BreakTemplate);
7673 
7674   verifyFormat("struct f {\n"
7675                "  template <class T>\n"
7676                "  int &foo(const std::string &str) &&noexcept {}\n"
7677                "};",
7678                BreakTemplate);
7679 
7680   verifyFormat("struct f {\n"
7681                "  template <class T>\n"
7682                "  int &foo(const std::string &str) const &noexcept {}\n"
7683                "};",
7684                BreakTemplate);
7685 
7686   verifyFormat("struct f {\n"
7687                "  template <class T>\n"
7688                "  int &foo(const std::string &str) const &noexcept {}\n"
7689                "};",
7690                BreakTemplate);
7691 
7692   verifyFormat("struct f {\n"
7693                "  template <class T>\n"
7694                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
7695                "};",
7696                BreakTemplate);
7697 
7698   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7699   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7700       FormatStyle::BTDS_Yes;
7701   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7702 
7703   verifyFormat("struct f {\n"
7704                "  template <class T>\n"
7705                "  int& foo(const std::string& str) & noexcept {}\n"
7706                "};",
7707                AlignLeftBreakTemplate);
7708 
7709   verifyFormat("struct f {\n"
7710                "  template <class T>\n"
7711                "  int& foo(const std::string& str) && noexcept {}\n"
7712                "};",
7713                AlignLeftBreakTemplate);
7714 
7715   verifyFormat("struct f {\n"
7716                "  template <class T>\n"
7717                "  int& foo(const std::string& str) const& noexcept {}\n"
7718                "};",
7719                AlignLeftBreakTemplate);
7720 
7721   verifyFormat("struct f {\n"
7722                "  template <class T>\n"
7723                "  int& foo(const std::string& str) const&& noexcept {}\n"
7724                "};",
7725                AlignLeftBreakTemplate);
7726 
7727   verifyFormat("struct f {\n"
7728                "  template <class T>\n"
7729                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7730                "};",
7731                AlignLeftBreakTemplate);
7732 
7733   // The `&` in `Type&` should not be confused with a trailing `&` of
7734   // DEPRECATED(reason) member function.
7735   verifyFormat("struct f {\n"
7736                "  template <class T>\n"
7737                "  DEPRECATED(reason)\n"
7738                "  Type &foo(arguments) {}\n"
7739                "};",
7740                BreakTemplate);
7741 
7742   verifyFormat("struct f {\n"
7743                "  template <class T>\n"
7744                "  DEPRECATED(reason)\n"
7745                "  Type& foo(arguments) {}\n"
7746                "};",
7747                AlignLeftBreakTemplate);
7748 
7749   verifyFormat("void (*foopt)(int) = &func;");
7750 }
7751 
7752 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7753   verifyFormat("void f() {\n"
7754                "  A *a = new A;\n"
7755                "  A *a = new (placement) A;\n"
7756                "  delete a;\n"
7757                "  delete (A *)a;\n"
7758                "}");
7759   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7760                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7761   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7762                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7763                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7764   verifyFormat("delete[] h->p;");
7765 }
7766 
7767 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
7768   verifyFormat("int *f(int *a) {}");
7769   verifyFormat("int main(int argc, char **argv) {}");
7770   verifyFormat("Test::Test(int b) : a(b * b) {}");
7771   verifyIndependentOfContext("f(a, *a);");
7772   verifyFormat("void g() { f(*a); }");
7773   verifyIndependentOfContext("int a = b * 10;");
7774   verifyIndependentOfContext("int a = 10 * b;");
7775   verifyIndependentOfContext("int a = b * c;");
7776   verifyIndependentOfContext("int a += b * c;");
7777   verifyIndependentOfContext("int a -= b * c;");
7778   verifyIndependentOfContext("int a *= b * c;");
7779   verifyIndependentOfContext("int a /= b * c;");
7780   verifyIndependentOfContext("int a = *b;");
7781   verifyIndependentOfContext("int a = *b * c;");
7782   verifyIndependentOfContext("int a = b * *c;");
7783   verifyIndependentOfContext("int a = b * (10);");
7784   verifyIndependentOfContext("S << b * (10);");
7785   verifyIndependentOfContext("return 10 * b;");
7786   verifyIndependentOfContext("return *b * *c;");
7787   verifyIndependentOfContext("return a & ~b;");
7788   verifyIndependentOfContext("f(b ? *c : *d);");
7789   verifyIndependentOfContext("int a = b ? *c : *d;");
7790   verifyIndependentOfContext("*b = a;");
7791   verifyIndependentOfContext("a * ~b;");
7792   verifyIndependentOfContext("a * !b;");
7793   verifyIndependentOfContext("a * +b;");
7794   verifyIndependentOfContext("a * -b;");
7795   verifyIndependentOfContext("a * ++b;");
7796   verifyIndependentOfContext("a * --b;");
7797   verifyIndependentOfContext("a[4] * b;");
7798   verifyIndependentOfContext("a[a * a] = 1;");
7799   verifyIndependentOfContext("f() * b;");
7800   verifyIndependentOfContext("a * [self dostuff];");
7801   verifyIndependentOfContext("int x = a * (a + b);");
7802   verifyIndependentOfContext("(a *)(a + b);");
7803   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
7804   verifyIndependentOfContext("int *pa = (int *)&a;");
7805   verifyIndependentOfContext("return sizeof(int **);");
7806   verifyIndependentOfContext("return sizeof(int ******);");
7807   verifyIndependentOfContext("return (int **&)a;");
7808   verifyIndependentOfContext("f((*PointerToArray)[10]);");
7809   verifyFormat("void f(Type (*parameter)[10]) {}");
7810   verifyFormat("void f(Type (&parameter)[10]) {}");
7811   verifyGoogleFormat("return sizeof(int**);");
7812   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
7813   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
7814   verifyFormat("auto a = [](int **&, int ***) {};");
7815   verifyFormat("auto PointerBinding = [](const char *S) {};");
7816   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
7817   verifyFormat("[](const decltype(*a) &value) {}");
7818   verifyFormat("decltype(a * b) F();");
7819   verifyFormat("#define MACRO() [](A *a) { return 1; }");
7820   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
7821   verifyIndependentOfContext("typedef void (*f)(int *a);");
7822   verifyIndependentOfContext("int i{a * b};");
7823   verifyIndependentOfContext("aaa && aaa->f();");
7824   verifyIndependentOfContext("int x = ~*p;");
7825   verifyFormat("Constructor() : a(a), area(width * height) {}");
7826   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
7827   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
7828   verifyFormat("void f() { f(a, c * d); }");
7829   verifyFormat("void f() { f(new a(), c * d); }");
7830   verifyFormat("void f(const MyOverride &override);");
7831   verifyFormat("void f(const MyFinal &final);");
7832   verifyIndependentOfContext("bool a = f() && override.f();");
7833   verifyIndependentOfContext("bool a = f() && final.f();");
7834 
7835   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
7836 
7837   verifyIndependentOfContext("A<int *> a;");
7838   verifyIndependentOfContext("A<int **> a;");
7839   verifyIndependentOfContext("A<int *, int *> a;");
7840   verifyIndependentOfContext("A<int *[]> a;");
7841   verifyIndependentOfContext(
7842       "const char *const p = reinterpret_cast<const char *const>(q);");
7843   verifyIndependentOfContext("A<int **, int **> a;");
7844   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
7845   verifyFormat("for (char **a = b; *a; ++a) {\n}");
7846   verifyFormat("for (; a && b;) {\n}");
7847   verifyFormat("bool foo = true && [] { return false; }();");
7848 
7849   verifyFormat(
7850       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7851       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7852 
7853   verifyGoogleFormat("int const* a = &b;");
7854   verifyGoogleFormat("**outparam = 1;");
7855   verifyGoogleFormat("*outparam = a * b;");
7856   verifyGoogleFormat("int main(int argc, char** argv) {}");
7857   verifyGoogleFormat("A<int*> a;");
7858   verifyGoogleFormat("A<int**> a;");
7859   verifyGoogleFormat("A<int*, int*> a;");
7860   verifyGoogleFormat("A<int**, int**> a;");
7861   verifyGoogleFormat("f(b ? *c : *d);");
7862   verifyGoogleFormat("int a = b ? *c : *d;");
7863   verifyGoogleFormat("Type* t = **x;");
7864   verifyGoogleFormat("Type* t = *++*x;");
7865   verifyGoogleFormat("*++*x;");
7866   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
7867   verifyGoogleFormat("Type* t = x++ * y;");
7868   verifyGoogleFormat(
7869       "const char* const p = reinterpret_cast<const char* const>(q);");
7870   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
7871   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
7872   verifyGoogleFormat("template <typename T>\n"
7873                      "void f(int i = 0, SomeType** temps = NULL);");
7874 
7875   FormatStyle Left = getLLVMStyle();
7876   Left.PointerAlignment = FormatStyle::PAS_Left;
7877   verifyFormat("x = *a(x) = *a(y);", Left);
7878   verifyFormat("for (;; *a = b) {\n}", Left);
7879   verifyFormat("return *this += 1;", Left);
7880   verifyFormat("throw *x;", Left);
7881   verifyFormat("delete *x;", Left);
7882   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
7883   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
7884   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
7885   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
7886   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
7887   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
7888 
7889   verifyIndependentOfContext("a = *(x + y);");
7890   verifyIndependentOfContext("a = &(x + y);");
7891   verifyIndependentOfContext("*(x + y).call();");
7892   verifyIndependentOfContext("&(x + y)->call();");
7893   verifyFormat("void f() { &(*I).first; }");
7894 
7895   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
7896   verifyFormat(
7897       "int *MyValues = {\n"
7898       "    *A, // Operator detection might be confused by the '{'\n"
7899       "    *BB // Operator detection might be confused by previous comment\n"
7900       "};");
7901 
7902   verifyIndependentOfContext("if (int *a = &b)");
7903   verifyIndependentOfContext("if (int &a = *b)");
7904   verifyIndependentOfContext("if (a & b[i])");
7905   verifyIndependentOfContext("if constexpr (a & b[i])");
7906   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
7907   verifyIndependentOfContext("if (a * (b * c))");
7908   verifyIndependentOfContext("if constexpr (a * (b * c))");
7909   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
7910   verifyIndependentOfContext("if (a::b::c::d & b[i])");
7911   verifyIndependentOfContext("if (*b[i])");
7912   verifyIndependentOfContext("if (int *a = (&b))");
7913   verifyIndependentOfContext("while (int *a = &b)");
7914   verifyIndependentOfContext("while (a * (b * c))");
7915   verifyIndependentOfContext("size = sizeof *a;");
7916   verifyIndependentOfContext("if (a && (b = c))");
7917   verifyFormat("void f() {\n"
7918                "  for (const int &v : Values) {\n"
7919                "  }\n"
7920                "}");
7921   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
7922   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
7923   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
7924 
7925   verifyFormat("#define A (!a * b)");
7926   verifyFormat("#define MACRO     \\\n"
7927                "  int *i = a * b; \\\n"
7928                "  void f(a *b);",
7929                getLLVMStyleWithColumns(19));
7930 
7931   verifyIndependentOfContext("A = new SomeType *[Length];");
7932   verifyIndependentOfContext("A = new SomeType *[Length]();");
7933   verifyIndependentOfContext("T **t = new T *;");
7934   verifyIndependentOfContext("T **t = new T *();");
7935   verifyGoogleFormat("A = new SomeType*[Length]();");
7936   verifyGoogleFormat("A = new SomeType*[Length];");
7937   verifyGoogleFormat("T** t = new T*;");
7938   verifyGoogleFormat("T** t = new T*();");
7939 
7940   verifyFormat("STATIC_ASSERT((a & b) == 0);");
7941   verifyFormat("STATIC_ASSERT(0 == (a & b));");
7942   verifyFormat("template <bool a, bool b> "
7943                "typename t::if<x && y>::type f() {}");
7944   verifyFormat("template <int *y> f() {}");
7945   verifyFormat("vector<int *> v;");
7946   verifyFormat("vector<int *const> v;");
7947   verifyFormat("vector<int *const **const *> v;");
7948   verifyFormat("vector<int *volatile> v;");
7949   verifyFormat("vector<a * b> v;");
7950   verifyFormat("foo<b && false>();");
7951   verifyFormat("foo<b & 1>();");
7952   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
7953   verifyFormat(
7954       "template <class T, class = typename std::enable_if<\n"
7955       "                       std::is_integral<T>::value &&\n"
7956       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
7957       "void F();",
7958       getLLVMStyleWithColumns(70));
7959   verifyFormat("template <class T,\n"
7960                "          class = typename std::enable_if<\n"
7961                "              std::is_integral<T>::value &&\n"
7962                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
7963                "          class U>\n"
7964                "void F();",
7965                getLLVMStyleWithColumns(70));
7966   verifyFormat(
7967       "template <class T,\n"
7968       "          class = typename ::std::enable_if<\n"
7969       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
7970       "void F();",
7971       getGoogleStyleWithColumns(68));
7972 
7973   verifyIndependentOfContext("MACRO(int *i);");
7974   verifyIndependentOfContext("MACRO(auto *a);");
7975   verifyIndependentOfContext("MACRO(const A *a);");
7976   verifyIndependentOfContext("MACRO(A *const a);");
7977   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
7978   verifyFormat("void f() { f(float{1}, a * a); }");
7979   // FIXME: Is there a way to make this work?
7980   // verifyIndependentOfContext("MACRO(A *a);");
7981 
7982   verifyFormat("DatumHandle const *operator->() const { return input_; }");
7983   verifyFormat("return options != nullptr && operator==(*options);");
7984 
7985   EXPECT_EQ("#define OP(x)                                    \\\n"
7986             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
7987             "    return s << a.DebugString();                 \\\n"
7988             "  }",
7989             format("#define OP(x) \\\n"
7990                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
7991                    "    return s << a.DebugString(); \\\n"
7992                    "  }",
7993                    getLLVMStyleWithColumns(50)));
7994 
7995   // FIXME: We cannot handle this case yet; we might be able to figure out that
7996   // foo<x> d > v; doesn't make sense.
7997   verifyFormat("foo<a<b && c> d> v;");
7998 
7999   FormatStyle PointerMiddle = getLLVMStyle();
8000   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8001   verifyFormat("delete *x;", PointerMiddle);
8002   verifyFormat("int * x;", PointerMiddle);
8003   verifyFormat("int *[] x;", PointerMiddle);
8004   verifyFormat("template <int * y> f() {}", PointerMiddle);
8005   verifyFormat("int * f(int * a) {}", PointerMiddle);
8006   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8007   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8008   verifyFormat("A<int *> a;", PointerMiddle);
8009   verifyFormat("A<int **> a;", PointerMiddle);
8010   verifyFormat("A<int *, int *> a;", PointerMiddle);
8011   verifyFormat("A<int *[]> a;", PointerMiddle);
8012   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8013   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8014   verifyFormat("T ** t = new T *;", PointerMiddle);
8015 
8016   // Member function reference qualifiers aren't binary operators.
8017   verifyFormat("string // break\n"
8018                "operator()() & {}");
8019   verifyFormat("string // break\n"
8020                "operator()() && {}");
8021   verifyGoogleFormat("template <typename T>\n"
8022                      "auto x() & -> int {}");
8023 }
8024 
8025 TEST_F(FormatTest, UnderstandsAttributes) {
8026   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8027   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8028                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8029   FormatStyle AfterType = getLLVMStyle();
8030   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
8031   verifyFormat("__attribute__((nodebug)) void\n"
8032                "foo() {}\n",
8033                AfterType);
8034 }
8035 
8036 TEST_F(FormatTest, UnderstandsSquareAttributes) {
8037   verifyFormat("SomeType s [[unused]] (InitValue);");
8038   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8039   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8040   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8041   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8042   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8043                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8044   verifyFormat("[[nodiscard]] bool f() { return false; }");
8045   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
8046   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
8047   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
8048 
8049   // Make sure we do not mistake attributes for array subscripts.
8050   verifyFormat("int a() {}\n"
8051                "[[unused]] int b() {}\n");
8052   verifyFormat("NSArray *arr;\n"
8053                "arr[[Foo() bar]];");
8054 
8055   // On the other hand, we still need to correctly find array subscripts.
8056   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8057 
8058   // Make sure that we do not mistake Objective-C method inside array literals
8059   // as attributes, even if those method names are also keywords.
8060   verifyFormat("@[ [foo bar] ];");
8061   verifyFormat("@[ [NSArray class] ];");
8062   verifyFormat("@[ [foo enum] ];");
8063 
8064   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8065 
8066   // Make sure we do not parse attributes as lambda introducers.
8067   FormatStyle MultiLineFunctions = getLLVMStyle();
8068   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8069   verifyFormat("[[unused]] int b() {\n"
8070                "  return 42;\n"
8071                "}\n",
8072                MultiLineFunctions);
8073 }
8074 
8075 TEST_F(FormatTest, AttributeClass) {
8076   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8077   verifyFormat("class S {\n"
8078                "  S(S&&) = default;\n"
8079                "};",
8080                Style);
8081   verifyFormat("class [[nodiscard]] S {\n"
8082                "  S(S&&) = default;\n"
8083                "};",
8084                Style);
8085   verifyFormat("class __attribute((maybeunused)) S {\n"
8086                "  S(S&&) = default;\n"
8087                "};",
8088                Style);
8089   verifyFormat("struct S {\n"
8090                "  S(S&&) = default;\n"
8091                "};",
8092                Style);
8093   verifyFormat("struct [[nodiscard]] S {\n"
8094                "  S(S&&) = default;\n"
8095                "};",
8096                Style);
8097 }
8098 
8099 TEST_F(FormatTest, AttributesAfterMacro) {
8100   FormatStyle Style = getLLVMStyle();
8101   verifyFormat("MACRO;\n"
8102                "__attribute__((maybe_unused)) int foo() {\n"
8103                "  //...\n"
8104                "}");
8105 
8106   verifyFormat("MACRO;\n"
8107                "[[nodiscard]] int foo() {\n"
8108                "  //...\n"
8109                "}");
8110 
8111   EXPECT_EQ("MACRO\n\n"
8112             "__attribute__((maybe_unused)) int foo() {\n"
8113             "  //...\n"
8114             "}",
8115             format("MACRO\n\n"
8116                    "__attribute__((maybe_unused)) int foo() {\n"
8117                    "  //...\n"
8118                    "}"));
8119 
8120   EXPECT_EQ("MACRO\n\n"
8121             "[[nodiscard]] int foo() {\n"
8122             "  //...\n"
8123             "}",
8124             format("MACRO\n\n"
8125                    "[[nodiscard]] int foo() {\n"
8126                    "  //...\n"
8127                    "}"));
8128 }
8129 
8130 TEST_F(FormatTest, AttributePenaltyBreaking) {
8131   FormatStyle Style = getLLVMStyle();
8132   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8133                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8134                Style);
8135   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8136                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8137                Style);
8138   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8139                "shared_ptr<ALongTypeName> &C d) {\n}",
8140                Style);
8141 }
8142 
8143 TEST_F(FormatTest, UnderstandsEllipsis) {
8144   verifyFormat("int printf(const char *fmt, ...);");
8145   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8146   verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
8147 
8148   FormatStyle PointersLeft = getLLVMStyle();
8149   PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
8150   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
8151 }
8152 
8153 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8154   EXPECT_EQ("int *a;\n"
8155             "int *a;\n"
8156             "int *a;",
8157             format("int *a;\n"
8158                    "int* a;\n"
8159                    "int *a;",
8160                    getGoogleStyle()));
8161   EXPECT_EQ("int* a;\n"
8162             "int* a;\n"
8163             "int* a;",
8164             format("int* a;\n"
8165                    "int* a;\n"
8166                    "int *a;",
8167                    getGoogleStyle()));
8168   EXPECT_EQ("int *a;\n"
8169             "int *a;\n"
8170             "int *a;",
8171             format("int *a;\n"
8172                    "int * a;\n"
8173                    "int *  a;",
8174                    getGoogleStyle()));
8175   EXPECT_EQ("auto x = [] {\n"
8176             "  int *a;\n"
8177             "  int *a;\n"
8178             "  int *a;\n"
8179             "};",
8180             format("auto x=[]{int *a;\n"
8181                    "int * a;\n"
8182                    "int *  a;};",
8183                    getGoogleStyle()));
8184 }
8185 
8186 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8187   verifyFormat("int f(int &&a) {}");
8188   verifyFormat("int f(int a, char &&b) {}");
8189   verifyFormat("void f() { int &&a = b; }");
8190   verifyGoogleFormat("int f(int a, char&& b) {}");
8191   verifyGoogleFormat("void f() { int&& a = b; }");
8192 
8193   verifyIndependentOfContext("A<int &&> a;");
8194   verifyIndependentOfContext("A<int &&, int &&> a;");
8195   verifyGoogleFormat("A<int&&> a;");
8196   verifyGoogleFormat("A<int&&, int&&> a;");
8197 
8198   // Not rvalue references:
8199   verifyFormat("template <bool B, bool C> class A {\n"
8200                "  static_assert(B && C, \"Something is wrong\");\n"
8201                "};");
8202   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8203   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8204   verifyFormat("#define A(a, b) (a && b)");
8205 }
8206 
8207 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8208   verifyFormat("void f() {\n"
8209                "  x[aaaaaaaaa -\n"
8210                "    b] = 23;\n"
8211                "}",
8212                getLLVMStyleWithColumns(15));
8213 }
8214 
8215 TEST_F(FormatTest, FormatsCasts) {
8216   verifyFormat("Type *A = static_cast<Type *>(P);");
8217   verifyFormat("Type *A = (Type *)P;");
8218   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8219   verifyFormat("int a = (int)(2.0f);");
8220   verifyFormat("int a = (int)2.0f;");
8221   verifyFormat("x[(int32)y];");
8222   verifyFormat("x = (int32)y;");
8223   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8224   verifyFormat("int a = (int)*b;");
8225   verifyFormat("int a = (int)2.0f;");
8226   verifyFormat("int a = (int)~0;");
8227   verifyFormat("int a = (int)++a;");
8228   verifyFormat("int a = (int)sizeof(int);");
8229   verifyFormat("int a = (int)+2;");
8230   verifyFormat("my_int a = (my_int)2.0f;");
8231   verifyFormat("my_int a = (my_int)sizeof(int);");
8232   verifyFormat("return (my_int)aaa;");
8233   verifyFormat("#define x ((int)-1)");
8234   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8235   verifyFormat("#define p(q) ((int *)&q)");
8236   verifyFormat("fn(a)(b) + 1;");
8237 
8238   verifyFormat("void f() { my_int a = (my_int)*b; }");
8239   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8240   verifyFormat("my_int a = (my_int)~0;");
8241   verifyFormat("my_int a = (my_int)++a;");
8242   verifyFormat("my_int a = (my_int)-2;");
8243   verifyFormat("my_int a = (my_int)1;");
8244   verifyFormat("my_int a = (my_int *)1;");
8245   verifyFormat("my_int a = (const my_int)-1;");
8246   verifyFormat("my_int a = (const my_int *)-1;");
8247   verifyFormat("my_int a = (my_int)(my_int)-1;");
8248   verifyFormat("my_int a = (ns::my_int)-2;");
8249   verifyFormat("case (my_int)ONE:");
8250   verifyFormat("auto x = (X)this;");
8251   // Casts in Obj-C style calls used to not be recognized as such.
8252   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8253 
8254   // FIXME: single value wrapped with paren will be treated as cast.
8255   verifyFormat("void f(int i = (kValue)*kMask) {}");
8256 
8257   verifyFormat("{ (void)F; }");
8258 
8259   // Don't break after a cast's
8260   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8261                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8262                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8263 
8264   // These are not casts.
8265   verifyFormat("void f(int *) {}");
8266   verifyFormat("f(foo)->b;");
8267   verifyFormat("f(foo).b;");
8268   verifyFormat("f(foo)(b);");
8269   verifyFormat("f(foo)[b];");
8270   verifyFormat("[](foo) { return 4; }(bar);");
8271   verifyFormat("(*funptr)(foo)[4];");
8272   verifyFormat("funptrs[4](foo)[4];");
8273   verifyFormat("void f(int *);");
8274   verifyFormat("void f(int *) = 0;");
8275   verifyFormat("void f(SmallVector<int>) {}");
8276   verifyFormat("void f(SmallVector<int>);");
8277   verifyFormat("void f(SmallVector<int>) = 0;");
8278   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8279   verifyFormat("int a = sizeof(int) * b;");
8280   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8281   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8282   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8283   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8284 
8285   // These are not casts, but at some point were confused with casts.
8286   verifyFormat("virtual void foo(int *) override;");
8287   verifyFormat("virtual void foo(char &) const;");
8288   verifyFormat("virtual void foo(int *a, char *) const;");
8289   verifyFormat("int a = sizeof(int *) + b;");
8290   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8291   verifyFormat("bool b = f(g<int>) && c;");
8292   verifyFormat("typedef void (*f)(int i) func;");
8293   verifyFormat("void operator++(int) noexcept;");
8294   verifyFormat("void operator++(int &) noexcept;");
8295   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8296                "&) noexcept;");
8297   verifyFormat(
8298       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8299   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8300   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8301   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8302   verifyFormat("void operator delete(foo &) noexcept;");
8303   verifyFormat("void operator delete(foo) noexcept;");
8304   verifyFormat("void operator delete(int) noexcept;");
8305   verifyFormat("void operator delete(int &) noexcept;");
8306   verifyFormat("void operator delete(int &) volatile noexcept;");
8307   verifyFormat("void operator delete(int &) const");
8308   verifyFormat("void operator delete(int &) = default");
8309   verifyFormat("void operator delete(int &) = delete");
8310   verifyFormat("void operator delete(int &) [[noreturn]]");
8311   verifyFormat("void operator delete(int &) throw();");
8312   verifyFormat("void operator delete(int &) throw(int);");
8313   verifyFormat("auto operator delete(int &) -> int;");
8314   verifyFormat("auto operator delete(int &) override");
8315   verifyFormat("auto operator delete(int &) final");
8316 
8317   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8318                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8319   // FIXME: The indentation here is not ideal.
8320   verifyFormat(
8321       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8322       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8323       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8324 }
8325 
8326 TEST_F(FormatTest, FormatsFunctionTypes) {
8327   verifyFormat("A<bool()> a;");
8328   verifyFormat("A<SomeType()> a;");
8329   verifyFormat("A<void (*)(int, std::string)> a;");
8330   verifyFormat("A<void *(int)>;");
8331   verifyFormat("void *(*a)(int *, SomeType *);");
8332   verifyFormat("int (*func)(void *);");
8333   verifyFormat("void f() { int (*func)(void *); }");
8334   verifyFormat("template <class CallbackClass>\n"
8335                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8336 
8337   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8338   verifyGoogleFormat("void* (*a)(int);");
8339   verifyGoogleFormat(
8340       "template <class CallbackClass>\n"
8341       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8342 
8343   // Other constructs can look somewhat like function types:
8344   verifyFormat("A<sizeof(*x)> a;");
8345   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8346   verifyFormat("some_var = function(*some_pointer_var)[0];");
8347   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8348   verifyFormat("int x = f(&h)();");
8349   verifyFormat("returnsFunction(&param1, &param2)(param);");
8350   verifyFormat("std::function<\n"
8351                "    LooooooooooongTemplatedType<\n"
8352                "        SomeType>*(\n"
8353                "        LooooooooooooooooongType type)>\n"
8354                "    function;",
8355                getGoogleStyleWithColumns(40));
8356 }
8357 
8358 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8359   verifyFormat("A (*foo_)[6];");
8360   verifyFormat("vector<int> (*foo_)[6];");
8361 }
8362 
8363 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8364   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8365                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8366   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8367                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8368   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8369                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8370 
8371   // Different ways of ()-initializiation.
8372   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8373                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8374   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8375                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8376   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8377                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8378   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8379                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8380 
8381   // Lambdas should not confuse the variable declaration heuristic.
8382   verifyFormat("LooooooooooooooooongType\n"
8383                "    variable(nullptr, [](A *a) {});",
8384                getLLVMStyleWithColumns(40));
8385 }
8386 
8387 TEST_F(FormatTest, BreaksLongDeclarations) {
8388   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8389                "    AnotherNameForTheLongType;");
8390   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8391                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8392   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8393                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8394   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8395                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8396   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8397                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8398   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8399                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8400   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8401                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8402   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8403                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8404   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8405                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8406   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8407                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8408   FormatStyle Indented = getLLVMStyle();
8409   Indented.IndentWrappedFunctionNames = true;
8410   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8411                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8412                Indented);
8413   verifyFormat(
8414       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8415       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8416       Indented);
8417   verifyFormat(
8418       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8419       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8420       Indented);
8421   verifyFormat(
8422       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8423       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8424       Indented);
8425 
8426   // FIXME: Without the comment, this breaks after "(".
8427   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8428                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8429                getGoogleStyle());
8430 
8431   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8432                "                  int LoooooooooooooooooooongParam2) {}");
8433   verifyFormat(
8434       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8435       "                                   SourceLocation L, IdentifierIn *II,\n"
8436       "                                   Type *T) {}");
8437   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8438                "ReallyReaaallyLongFunctionName(\n"
8439                "    const std::string &SomeParameter,\n"
8440                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8441                "        &ReallyReallyLongParameterName,\n"
8442                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8443                "        &AnotherLongParameterName) {}");
8444   verifyFormat("template <typename A>\n"
8445                "SomeLoooooooooooooooooooooongType<\n"
8446                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8447                "Function() {}");
8448 
8449   verifyGoogleFormat(
8450       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8451       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8452   verifyGoogleFormat(
8453       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8454       "                                   SourceLocation L) {}");
8455   verifyGoogleFormat(
8456       "some_namespace::LongReturnType\n"
8457       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8458       "    int first_long_parameter, int second_parameter) {}");
8459 
8460   verifyGoogleFormat("template <typename T>\n"
8461                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8462                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8463   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8464                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8465 
8466   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8467                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8468                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8469   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8470                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8471                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8472   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8473                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8474                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8475                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8476 
8477   verifyFormat("template <typename T> // Templates on own line.\n"
8478                "static int            // Some comment.\n"
8479                "MyFunction(int a);",
8480                getLLVMStyle());
8481 }
8482 
8483 TEST_F(FormatTest, FormatsArrays) {
8484   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8485                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8486   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8487                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8488   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8489                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8490   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8491                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8492   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8493                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8494   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8495                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8496                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8497   verifyFormat(
8498       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8499       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8500       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8501   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8502                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8503 
8504   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8505                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8506   verifyFormat(
8507       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8508       "                                  .aaaaaaa[0]\n"
8509       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8510   verifyFormat("a[::b::c];");
8511 
8512   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8513 
8514   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8515   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8516 }
8517 
8518 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8519   verifyFormat("(a)->b();");
8520   verifyFormat("--a;");
8521 }
8522 
8523 TEST_F(FormatTest, HandlesIncludeDirectives) {
8524   verifyFormat("#include <string>\n"
8525                "#include <a/b/c.h>\n"
8526                "#include \"a/b/string\"\n"
8527                "#include \"string.h\"\n"
8528                "#include \"string.h\"\n"
8529                "#include <a-a>\n"
8530                "#include < path with space >\n"
8531                "#include_next <test.h>"
8532                "#include \"abc.h\" // this is included for ABC\n"
8533                "#include \"some long include\" // with a comment\n"
8534                "#include \"some very long include path\"\n"
8535                "#include <some/very/long/include/path>\n",
8536                getLLVMStyleWithColumns(35));
8537   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8538   EXPECT_EQ("#include <a>", format("#include<a>"));
8539 
8540   verifyFormat("#import <string>");
8541   verifyFormat("#import <a/b/c.h>");
8542   verifyFormat("#import \"a/b/string\"");
8543   verifyFormat("#import \"string.h\"");
8544   verifyFormat("#import \"string.h\"");
8545   verifyFormat("#if __has_include(<strstream>)\n"
8546                "#include <strstream>\n"
8547                "#endif");
8548 
8549   verifyFormat("#define MY_IMPORT <a/b>");
8550 
8551   verifyFormat("#if __has_include(<a/b>)");
8552   verifyFormat("#if __has_include_next(<a/b>)");
8553   verifyFormat("#define F __has_include(<a/b>)");
8554   verifyFormat("#define F __has_include_next(<a/b>)");
8555 
8556   // Protocol buffer definition or missing "#".
8557   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8558                getLLVMStyleWithColumns(30));
8559 
8560   FormatStyle Style = getLLVMStyle();
8561   Style.AlwaysBreakBeforeMultilineStrings = true;
8562   Style.ColumnLimit = 0;
8563   verifyFormat("#import \"abc.h\"", Style);
8564 
8565   // But 'import' might also be a regular C++ namespace.
8566   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8567                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8568 }
8569 
8570 //===----------------------------------------------------------------------===//
8571 // Error recovery tests.
8572 //===----------------------------------------------------------------------===//
8573 
8574 TEST_F(FormatTest, IncompleteParameterLists) {
8575   FormatStyle NoBinPacking = getLLVMStyle();
8576   NoBinPacking.BinPackParameters = false;
8577   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8578                "                        double *min_x,\n"
8579                "                        double *max_x,\n"
8580                "                        double *min_y,\n"
8581                "                        double *max_y,\n"
8582                "                        double *min_z,\n"
8583                "                        double *max_z, ) {}",
8584                NoBinPacking);
8585 }
8586 
8587 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8588   verifyFormat("void f() { return; }\n42");
8589   verifyFormat("void f() {\n"
8590                "  if (0)\n"
8591                "    return;\n"
8592                "}\n"
8593                "42");
8594   verifyFormat("void f() { return }\n42");
8595   verifyFormat("void f() {\n"
8596                "  if (0)\n"
8597                "    return\n"
8598                "}\n"
8599                "42");
8600 }
8601 
8602 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
8603   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
8604   EXPECT_EQ("void f() {\n"
8605             "  if (a)\n"
8606             "    return\n"
8607             "}",
8608             format("void  f  (  )  {  if  ( a )  return  }"));
8609   EXPECT_EQ("namespace N {\n"
8610             "void f()\n"
8611             "}",
8612             format("namespace  N  {  void f()  }"));
8613   EXPECT_EQ("namespace N {\n"
8614             "void f() {}\n"
8615             "void g()\n"
8616             "} // namespace N",
8617             format("namespace N  { void f( ) { } void g( ) }"));
8618 }
8619 
8620 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
8621   verifyFormat("int aaaaaaaa =\n"
8622                "    // Overlylongcomment\n"
8623                "    b;",
8624                getLLVMStyleWithColumns(20));
8625   verifyFormat("function(\n"
8626                "    ShortArgument,\n"
8627                "    LoooooooooooongArgument);\n",
8628                getLLVMStyleWithColumns(20));
8629 }
8630 
8631 TEST_F(FormatTest, IncorrectAccessSpecifier) {
8632   verifyFormat("public:");
8633   verifyFormat("class A {\n"
8634                "public\n"
8635                "  void f() {}\n"
8636                "};");
8637   verifyFormat("public\n"
8638                "int qwerty;");
8639   verifyFormat("public\n"
8640                "B {}");
8641   verifyFormat("public\n"
8642                "{}");
8643   verifyFormat("public\n"
8644                "B { int x; }");
8645 }
8646 
8647 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
8648   verifyFormat("{");
8649   verifyFormat("#})");
8650   verifyNoCrash("(/**/[:!] ?[).");
8651 }
8652 
8653 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
8654   // Found by oss-fuzz:
8655   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
8656   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
8657   Style.ColumnLimit = 60;
8658   verifyNoCrash(
8659       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
8660       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
8661       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
8662       Style);
8663 }
8664 
8665 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
8666   verifyFormat("do {\n}");
8667   verifyFormat("do {\n}\n"
8668                "f();");
8669   verifyFormat("do {\n}\n"
8670                "wheeee(fun);");
8671   verifyFormat("do {\n"
8672                "  f();\n"
8673                "}");
8674 }
8675 
8676 TEST_F(FormatTest, IncorrectCodeMissingParens) {
8677   verifyFormat("if {\n  foo;\n  foo();\n}");
8678   verifyFormat("switch {\n  foo;\n  foo();\n}");
8679   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
8680   verifyFormat("while {\n  foo;\n  foo();\n}");
8681   verifyFormat("do {\n  foo;\n  foo();\n} while;");
8682 }
8683 
8684 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
8685   verifyIncompleteFormat("namespace {\n"
8686                          "class Foo { Foo (\n"
8687                          "};\n"
8688                          "} // namespace");
8689 }
8690 
8691 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
8692   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
8693   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
8694   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
8695   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
8696 
8697   EXPECT_EQ("{\n"
8698             "  {\n"
8699             "    breakme(\n"
8700             "        qwe);\n"
8701             "  }\n",
8702             format("{\n"
8703                    "    {\n"
8704                    " breakme(qwe);\n"
8705                    "}\n",
8706                    getLLVMStyleWithColumns(10)));
8707 }
8708 
8709 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
8710   verifyFormat("int x = {\n"
8711                "    avariable,\n"
8712                "    b(alongervariable)};",
8713                getLLVMStyleWithColumns(25));
8714 }
8715 
8716 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
8717   verifyFormat("return (a)(b){1, 2, 3};");
8718 }
8719 
8720 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
8721   verifyFormat("vector<int> x{1, 2, 3, 4};");
8722   verifyFormat("vector<int> x{\n"
8723                "    1,\n"
8724                "    2,\n"
8725                "    3,\n"
8726                "    4,\n"
8727                "};");
8728   verifyFormat("vector<T> x{{}, {}, {}, {}};");
8729   verifyFormat("f({1, 2});");
8730   verifyFormat("auto v = Foo{-1};");
8731   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
8732   verifyFormat("Class::Class : member{1, 2, 3} {}");
8733   verifyFormat("new vector<int>{1, 2, 3};");
8734   verifyFormat("new int[3]{1, 2, 3};");
8735   verifyFormat("new int{1};");
8736   verifyFormat("return {arg1, arg2};");
8737   verifyFormat("return {arg1, SomeType{parameter}};");
8738   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
8739   verifyFormat("new T{arg1, arg2};");
8740   verifyFormat("f(MyMap[{composite, key}]);");
8741   verifyFormat("class Class {\n"
8742                "  T member = {arg1, arg2};\n"
8743                "};");
8744   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
8745   verifyFormat("const struct A a = {.a = 1, .b = 2};");
8746   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
8747   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
8748   verifyFormat("int a = std::is_integral<int>{} + 0;");
8749 
8750   verifyFormat("int foo(int i) { return fo1{}(i); }");
8751   verifyFormat("int foo(int i) { return fo1{}(i); }");
8752   verifyFormat("auto i = decltype(x){};");
8753   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
8754   verifyFormat("Node n{1, Node{1000}, //\n"
8755                "       2};");
8756   verifyFormat("Aaaa aaaaaaa{\n"
8757                "    {\n"
8758                "        aaaa,\n"
8759                "    },\n"
8760                "};");
8761   verifyFormat("class C : public D {\n"
8762                "  SomeClass SC{2};\n"
8763                "};");
8764   verifyFormat("class C : public A {\n"
8765                "  class D : public B {\n"
8766                "    void f() { int i{2}; }\n"
8767                "  };\n"
8768                "};");
8769   verifyFormat("#define A {a, a},");
8770 
8771   // Avoid breaking between equal sign and opening brace
8772   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
8773   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
8774   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
8775                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
8776                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
8777                "     {\"ccccccccccccccccccccc\", 2}};",
8778                AvoidBreakingFirstArgument);
8779 
8780   // Binpacking only if there is no trailing comma
8781   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
8782                "                      cccccccccc, dddddddddd};",
8783                getLLVMStyleWithColumns(50));
8784   verifyFormat("const Aaaaaa aaaaa = {\n"
8785                "    aaaaaaaaaaa,\n"
8786                "    bbbbbbbbbbb,\n"
8787                "    ccccccccccc,\n"
8788                "    ddddddddddd,\n"
8789                "};",
8790                getLLVMStyleWithColumns(50));
8791 
8792   // Cases where distinguising braced lists and blocks is hard.
8793   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
8794   verifyFormat("void f() {\n"
8795                "  return; // comment\n"
8796                "}\n"
8797                "SomeType t;");
8798   verifyFormat("void f() {\n"
8799                "  if (a) {\n"
8800                "    f();\n"
8801                "  }\n"
8802                "}\n"
8803                "SomeType t;");
8804 
8805   // In combination with BinPackArguments = false.
8806   FormatStyle NoBinPacking = getLLVMStyle();
8807   NoBinPacking.BinPackArguments = false;
8808   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
8809                "                      bbbbb,\n"
8810                "                      ccccc,\n"
8811                "                      ddddd,\n"
8812                "                      eeeee,\n"
8813                "                      ffffff,\n"
8814                "                      ggggg,\n"
8815                "                      hhhhhh,\n"
8816                "                      iiiiii,\n"
8817                "                      jjjjjj,\n"
8818                "                      kkkkkk};",
8819                NoBinPacking);
8820   verifyFormat("const Aaaaaa aaaaa = {\n"
8821                "    aaaaa,\n"
8822                "    bbbbb,\n"
8823                "    ccccc,\n"
8824                "    ddddd,\n"
8825                "    eeeee,\n"
8826                "    ffffff,\n"
8827                "    ggggg,\n"
8828                "    hhhhhh,\n"
8829                "    iiiiii,\n"
8830                "    jjjjjj,\n"
8831                "    kkkkkk,\n"
8832                "};",
8833                NoBinPacking);
8834   verifyFormat(
8835       "const Aaaaaa aaaaa = {\n"
8836       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
8837       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
8838       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
8839       "};",
8840       NoBinPacking);
8841 
8842   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
8843   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
8844             "    CDDDP83848_BMCR_REGISTER,\n"
8845             "    CDDDP83848_BMSR_REGISTER,\n"
8846             "    CDDDP83848_RBR_REGISTER};",
8847             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
8848                    "                                CDDDP83848_BMSR_REGISTER,\n"
8849                    "                                CDDDP83848_RBR_REGISTER};",
8850                    NoBinPacking));
8851 
8852   // FIXME: The alignment of these trailing comments might be bad. Then again,
8853   // this might be utterly useless in real code.
8854   verifyFormat("Constructor::Constructor()\n"
8855                "    : some_value{         //\n"
8856                "                 aaaaaaa, //\n"
8857                "                 bbbbbbb} {}");
8858 
8859   // In braced lists, the first comment is always assumed to belong to the
8860   // first element. Thus, it can be moved to the next or previous line as
8861   // appropriate.
8862   EXPECT_EQ("function({// First element:\n"
8863             "          1,\n"
8864             "          // Second element:\n"
8865             "          2});",
8866             format("function({\n"
8867                    "    // First element:\n"
8868                    "    1,\n"
8869                    "    // Second element:\n"
8870                    "    2});"));
8871   EXPECT_EQ("std::vector<int> MyNumbers{\n"
8872             "    // First element:\n"
8873             "    1,\n"
8874             "    // Second element:\n"
8875             "    2};",
8876             format("std::vector<int> MyNumbers{// First element:\n"
8877                    "                           1,\n"
8878                    "                           // Second element:\n"
8879                    "                           2};",
8880                    getLLVMStyleWithColumns(30)));
8881   // A trailing comma should still lead to an enforced line break and no
8882   // binpacking.
8883   EXPECT_EQ("vector<int> SomeVector = {\n"
8884             "    // aaa\n"
8885             "    1,\n"
8886             "    2,\n"
8887             "};",
8888             format("vector<int> SomeVector = { // aaa\n"
8889                    "    1, 2, };"));
8890 
8891   // C++11 brace initializer list l-braces should not be treated any differently
8892   // when breaking before lambda bodies is enabled
8893   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
8894   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
8895   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
8896   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
8897   verifyFormat(
8898       "std::runtime_error{\n"
8899       "    \"Long string which will force a break onto the next line...\"};",
8900       BreakBeforeLambdaBody);
8901 
8902   FormatStyle ExtraSpaces = getLLVMStyle();
8903   ExtraSpaces.Cpp11BracedListStyle = false;
8904   ExtraSpaces.ColumnLimit = 75;
8905   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
8906   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
8907   verifyFormat("f({ 1, 2 });", ExtraSpaces);
8908   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
8909   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
8910   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
8911   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
8912   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
8913   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
8914   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
8915   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
8916   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
8917   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
8918   verifyFormat("class Class {\n"
8919                "  T member = { arg1, arg2 };\n"
8920                "};",
8921                ExtraSpaces);
8922   verifyFormat(
8923       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8924       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
8925       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
8926       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
8927       ExtraSpaces);
8928   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
8929   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
8930                ExtraSpaces);
8931   verifyFormat(
8932       "someFunction(OtherParam,\n"
8933       "             BracedList{ // comment 1 (Forcing interesting break)\n"
8934       "                         param1, param2,\n"
8935       "                         // comment 2\n"
8936       "                         param3, param4 });",
8937       ExtraSpaces);
8938   verifyFormat(
8939       "std::this_thread::sleep_for(\n"
8940       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
8941       ExtraSpaces);
8942   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
8943                "    aaaaaaa,\n"
8944                "    aaaaaaaaaa,\n"
8945                "    aaaaa,\n"
8946                "    aaaaaaaaaaaaaaa,\n"
8947                "    aaa,\n"
8948                "    aaaaaaaaaa,\n"
8949                "    a,\n"
8950                "    aaaaaaaaaaaaaaaaaaaaa,\n"
8951                "    aaaaaaaaaaaa,\n"
8952                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
8953                "    aaaaaaa,\n"
8954                "    a};");
8955   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
8956   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
8957   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
8958 
8959   // Avoid breaking between initializer/equal sign and opening brace
8960   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
8961   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
8962                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
8963                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
8964                "  { \"ccccccccccccccccccccc\", 2 }\n"
8965                "};",
8966                ExtraSpaces);
8967   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
8968                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
8969                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
8970                "  { \"ccccccccccccccccccccc\", 2 }\n"
8971                "};",
8972                ExtraSpaces);
8973 
8974   FormatStyle SpaceBeforeBrace = getLLVMStyle();
8975   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
8976   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
8977   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
8978 
8979   FormatStyle SpaceBetweenBraces = getLLVMStyle();
8980   SpaceBetweenBraces.SpacesInAngles = true;
8981   SpaceBetweenBraces.SpacesInParentheses = true;
8982   SpaceBetweenBraces.SpacesInSquareBrackets = true;
8983   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
8984   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
8985   verifyFormat("vector< int > x{ // comment 1\n"
8986                "                 1, 2, 3, 4 };",
8987                SpaceBetweenBraces);
8988   SpaceBetweenBraces.ColumnLimit = 20;
8989   EXPECT_EQ("vector< int > x{\n"
8990             "    1, 2, 3, 4 };",
8991             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
8992   SpaceBetweenBraces.ColumnLimit = 24;
8993   EXPECT_EQ("vector< int > x{ 1, 2,\n"
8994             "                 3, 4 };",
8995             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
8996   EXPECT_EQ("vector< int > x{\n"
8997             "    1,\n"
8998             "    2,\n"
8999             "    3,\n"
9000             "    4,\n"
9001             "};",
9002             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9003   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9004   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9005   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9006 }
9007 
9008 TEST_F(FormatTest, FormatSpacesInAngles) {
9009   FormatStyle SpaceInAngles = getLLVMStyle();
9010   SpaceInAngles.SpacesInAngles = true;
9011   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9012   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9013   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9014 
9015   SpaceInAngles.SpacesInAngles = false;
9016   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9017   verifyFormat("vector<int> x5;", SpaceInAngles);
9018   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9019   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9020 }
9021 
9022 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9023   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9024                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9025                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9026                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9027                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9028                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9029   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9030                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9031                "                 1, 22, 333, 4444, 55555, //\n"
9032                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9033                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9034   verifyFormat(
9035       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9036       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9037       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9038       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9039       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9040       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9041       "                 7777777};");
9042   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9043                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9044                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9045   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9046                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9047                "    // Separating comment.\n"
9048                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9049   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9050                "    // Leading comment\n"
9051                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9052                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9053   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9054                "                 1, 1, 1, 1};",
9055                getLLVMStyleWithColumns(39));
9056   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9057                "                 1, 1, 1, 1};",
9058                getLLVMStyleWithColumns(38));
9059   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9060                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9061                getLLVMStyleWithColumns(43));
9062   verifyFormat(
9063       "static unsigned SomeValues[10][3] = {\n"
9064       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9065       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9066   verifyFormat("static auto fields = new vector<string>{\n"
9067                "    \"aaaaaaaaaaaaa\",\n"
9068                "    \"aaaaaaaaaaaaa\",\n"
9069                "    \"aaaaaaaaaaaa\",\n"
9070                "    \"aaaaaaaaaaaaaa\",\n"
9071                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9072                "    \"aaaaaaaaaaaa\",\n"
9073                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9074                "};");
9075   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9076   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9077                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9078                "                 3, cccccccccccccccccccccc};",
9079                getLLVMStyleWithColumns(60));
9080 
9081   // Trailing commas.
9082   verifyFormat("vector<int> x = {\n"
9083                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9084                "};",
9085                getLLVMStyleWithColumns(39));
9086   verifyFormat("vector<int> x = {\n"
9087                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9088                "};",
9089                getLLVMStyleWithColumns(39));
9090   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9091                "                 1, 1, 1, 1,\n"
9092                "                 /**/ /**/};",
9093                getLLVMStyleWithColumns(39));
9094 
9095   // Trailing comment in the first line.
9096   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9097                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9098                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9099                "    11111111,   22222222,   333333333,   44444444};");
9100   // Trailing comment in the last line.
9101   verifyFormat("int aaaaa[] = {\n"
9102                "    1, 2, 3, // comment\n"
9103                "    4, 5, 6  // comment\n"
9104                "};");
9105 
9106   // With nested lists, we should either format one item per line or all nested
9107   // lists one on line.
9108   // FIXME: For some nested lists, we can do better.
9109   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9110                "        {aaaaaaaaaaaaaaaaaaa},\n"
9111                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9112                "        {aaaaaaaaaaaaaaaaa}};",
9113                getLLVMStyleWithColumns(60));
9114   verifyFormat(
9115       "SomeStruct my_struct_array = {\n"
9116       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9117       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9118       "    {aaa, aaa},\n"
9119       "    {aaa, aaa},\n"
9120       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9121       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9122       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9123 
9124   // No column layout should be used here.
9125   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9126                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9127 
9128   verifyNoCrash("a<,");
9129 
9130   // No braced initializer here.
9131   verifyFormat("void f() {\n"
9132                "  struct Dummy {};\n"
9133                "  f(v);\n"
9134                "}");
9135 
9136   // Long lists should be formatted in columns even if they are nested.
9137   verifyFormat(
9138       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9139       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9140       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9141       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9142       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9143       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9144 
9145   // Allow "single-column" layout even if that violates the column limit. There
9146   // isn't going to be a better way.
9147   verifyFormat("std::vector<int> a = {\n"
9148                "    aaaaaaaa,\n"
9149                "    aaaaaaaa,\n"
9150                "    aaaaaaaa,\n"
9151                "    aaaaaaaa,\n"
9152                "    aaaaaaaaaa,\n"
9153                "    aaaaaaaa,\n"
9154                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9155                getLLVMStyleWithColumns(30));
9156   verifyFormat("vector<int> aaaa = {\n"
9157                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9158                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9159                "    aaaaaa.aaaaaaa,\n"
9160                "    aaaaaa.aaaaaaa,\n"
9161                "    aaaaaa.aaaaaaa,\n"
9162                "    aaaaaa.aaaaaaa,\n"
9163                "};");
9164 
9165   // Don't create hanging lists.
9166   verifyFormat("someFunction(Param, {List1, List2,\n"
9167                "                     List3});",
9168                getLLVMStyleWithColumns(35));
9169   verifyFormat("someFunction(Param, Param,\n"
9170                "             {List1, List2,\n"
9171                "              List3});",
9172                getLLVMStyleWithColumns(35));
9173   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9174                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9175 }
9176 
9177 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9178   FormatStyle DoNotMerge = getLLVMStyle();
9179   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9180 
9181   verifyFormat("void f() { return 42; }");
9182   verifyFormat("void f() {\n"
9183                "  return 42;\n"
9184                "}",
9185                DoNotMerge);
9186   verifyFormat("void f() {\n"
9187                "  // Comment\n"
9188                "}");
9189   verifyFormat("{\n"
9190                "#error {\n"
9191                "  int a;\n"
9192                "}");
9193   verifyFormat("{\n"
9194                "  int a;\n"
9195                "#error {\n"
9196                "}");
9197   verifyFormat("void f() {} // comment");
9198   verifyFormat("void f() { int a; } // comment");
9199   verifyFormat("void f() {\n"
9200                "} // comment",
9201                DoNotMerge);
9202   verifyFormat("void f() {\n"
9203                "  int a;\n"
9204                "} // comment",
9205                DoNotMerge);
9206   verifyFormat("void f() {\n"
9207                "} // comment",
9208                getLLVMStyleWithColumns(15));
9209 
9210   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9211   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9212 
9213   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9214   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9215   verifyFormat("class C {\n"
9216                "  C()\n"
9217                "      : iiiiiiii(nullptr),\n"
9218                "        kkkkkkk(nullptr),\n"
9219                "        mmmmmmm(nullptr),\n"
9220                "        nnnnnnn(nullptr) {}\n"
9221                "};",
9222                getGoogleStyle());
9223 
9224   FormatStyle NoColumnLimit = getLLVMStyle();
9225   NoColumnLimit.ColumnLimit = 0;
9226   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9227   EXPECT_EQ("class C {\n"
9228             "  A() : b(0) {}\n"
9229             "};",
9230             format("class C{A():b(0){}};", NoColumnLimit));
9231   EXPECT_EQ("A()\n"
9232             "    : b(0) {\n"
9233             "}",
9234             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9235 
9236   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9237   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9238       FormatStyle::SFS_None;
9239   EXPECT_EQ("A()\n"
9240             "    : b(0) {\n"
9241             "}",
9242             format("A():b(0){}", DoNotMergeNoColumnLimit));
9243   EXPECT_EQ("A()\n"
9244             "    : b(0) {\n"
9245             "}",
9246             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9247 
9248   verifyFormat("#define A          \\\n"
9249                "  void f() {       \\\n"
9250                "    int i;         \\\n"
9251                "  }",
9252                getLLVMStyleWithColumns(20));
9253   verifyFormat("#define A           \\\n"
9254                "  void f() { int i; }",
9255                getLLVMStyleWithColumns(21));
9256   verifyFormat("#define A            \\\n"
9257                "  void f() {         \\\n"
9258                "    int i;           \\\n"
9259                "  }                  \\\n"
9260                "  int j;",
9261                getLLVMStyleWithColumns(22));
9262   verifyFormat("#define A             \\\n"
9263                "  void f() { int i; } \\\n"
9264                "  int j;",
9265                getLLVMStyleWithColumns(23));
9266 }
9267 
9268 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9269   FormatStyle MergeEmptyOnly = getLLVMStyle();
9270   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9271   verifyFormat("class C {\n"
9272                "  int f() {}\n"
9273                "};",
9274                MergeEmptyOnly);
9275   verifyFormat("class C {\n"
9276                "  int f() {\n"
9277                "    return 42;\n"
9278                "  }\n"
9279                "};",
9280                MergeEmptyOnly);
9281   verifyFormat("int f() {}", MergeEmptyOnly);
9282   verifyFormat("int f() {\n"
9283                "  return 42;\n"
9284                "}",
9285                MergeEmptyOnly);
9286 
9287   // Also verify behavior when BraceWrapping.AfterFunction = true
9288   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9289   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9290   verifyFormat("int f() {}", MergeEmptyOnly);
9291   verifyFormat("class C {\n"
9292                "  int f() {}\n"
9293                "};",
9294                MergeEmptyOnly);
9295 }
9296 
9297 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9298   FormatStyle MergeInlineOnly = getLLVMStyle();
9299   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9300   verifyFormat("class C {\n"
9301                "  int f() { return 42; }\n"
9302                "};",
9303                MergeInlineOnly);
9304   verifyFormat("int f() {\n"
9305                "  return 42;\n"
9306                "}",
9307                MergeInlineOnly);
9308 
9309   // SFS_Inline implies SFS_Empty
9310   verifyFormat("class C {\n"
9311                "  int f() {}\n"
9312                "};",
9313                MergeInlineOnly);
9314   verifyFormat("int f() {}", MergeInlineOnly);
9315 
9316   // Also verify behavior when BraceWrapping.AfterFunction = true
9317   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9318   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9319   verifyFormat("class C {\n"
9320                "  int f() { return 42; }\n"
9321                "};",
9322                MergeInlineOnly);
9323   verifyFormat("int f()\n"
9324                "{\n"
9325                "  return 42;\n"
9326                "}",
9327                MergeInlineOnly);
9328 
9329   // SFS_Inline implies SFS_Empty
9330   verifyFormat("int f() {}", MergeInlineOnly);
9331   verifyFormat("class C {\n"
9332                "  int f() {}\n"
9333                "};",
9334                MergeInlineOnly);
9335 }
9336 
9337 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9338   FormatStyle MergeInlineOnly = getLLVMStyle();
9339   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9340       FormatStyle::SFS_InlineOnly;
9341   verifyFormat("class C {\n"
9342                "  int f() { return 42; }\n"
9343                "};",
9344                MergeInlineOnly);
9345   verifyFormat("int f() {\n"
9346                "  return 42;\n"
9347                "}",
9348                MergeInlineOnly);
9349 
9350   // SFS_InlineOnly does not imply SFS_Empty
9351   verifyFormat("class C {\n"
9352                "  int f() {}\n"
9353                "};",
9354                MergeInlineOnly);
9355   verifyFormat("int f() {\n"
9356                "}",
9357                MergeInlineOnly);
9358 
9359   // Also verify behavior when BraceWrapping.AfterFunction = true
9360   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9361   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9362   verifyFormat("class C {\n"
9363                "  int f() { return 42; }\n"
9364                "};",
9365                MergeInlineOnly);
9366   verifyFormat("int f()\n"
9367                "{\n"
9368                "  return 42;\n"
9369                "}",
9370                MergeInlineOnly);
9371 
9372   // SFS_InlineOnly does not imply SFS_Empty
9373   verifyFormat("int f()\n"
9374                "{\n"
9375                "}",
9376                MergeInlineOnly);
9377   verifyFormat("class C {\n"
9378                "  int f() {}\n"
9379                "};",
9380                MergeInlineOnly);
9381 }
9382 
9383 TEST_F(FormatTest, SplitEmptyFunction) {
9384   FormatStyle Style = getLLVMStyle();
9385   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9386   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9387   Style.BraceWrapping.AfterFunction = true;
9388   Style.BraceWrapping.SplitEmptyFunction = false;
9389   Style.ColumnLimit = 40;
9390 
9391   verifyFormat("int f()\n"
9392                "{}",
9393                Style);
9394   verifyFormat("int f()\n"
9395                "{\n"
9396                "  return 42;\n"
9397                "}",
9398                Style);
9399   verifyFormat("int f()\n"
9400                "{\n"
9401                "  // some comment\n"
9402                "}",
9403                Style);
9404 
9405   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9406   verifyFormat("int f() {}", Style);
9407   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9408                "{}",
9409                Style);
9410   verifyFormat("int f()\n"
9411                "{\n"
9412                "  return 0;\n"
9413                "}",
9414                Style);
9415 
9416   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9417   verifyFormat("class Foo {\n"
9418                "  int f() {}\n"
9419                "};\n",
9420                Style);
9421   verifyFormat("class Foo {\n"
9422                "  int f() { return 0; }\n"
9423                "};\n",
9424                Style);
9425   verifyFormat("class Foo {\n"
9426                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9427                "  {}\n"
9428                "};\n",
9429                Style);
9430   verifyFormat("class Foo {\n"
9431                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9432                "  {\n"
9433                "    return 0;\n"
9434                "  }\n"
9435                "};\n",
9436                Style);
9437 
9438   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9439   verifyFormat("int f() {}", Style);
9440   verifyFormat("int f() { return 0; }", Style);
9441   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9442                "{}",
9443                Style);
9444   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9445                "{\n"
9446                "  return 0;\n"
9447                "}",
9448                Style);
9449 }
9450 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9451   FormatStyle Style = getLLVMStyle();
9452   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9453   verifyFormat("#ifdef A\n"
9454                "int f() {}\n"
9455                "#else\n"
9456                "int g() {}\n"
9457                "#endif",
9458                Style);
9459 }
9460 
9461 TEST_F(FormatTest, SplitEmptyClass) {
9462   FormatStyle Style = getLLVMStyle();
9463   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9464   Style.BraceWrapping.AfterClass = true;
9465   Style.BraceWrapping.SplitEmptyRecord = false;
9466 
9467   verifyFormat("class Foo\n"
9468                "{};",
9469                Style);
9470   verifyFormat("/* something */ class Foo\n"
9471                "{};",
9472                Style);
9473   verifyFormat("template <typename X> class Foo\n"
9474                "{};",
9475                Style);
9476   verifyFormat("class Foo\n"
9477                "{\n"
9478                "  Foo();\n"
9479                "};",
9480                Style);
9481   verifyFormat("typedef class Foo\n"
9482                "{\n"
9483                "} Foo_t;",
9484                Style);
9485 }
9486 
9487 TEST_F(FormatTest, SplitEmptyStruct) {
9488   FormatStyle Style = getLLVMStyle();
9489   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9490   Style.BraceWrapping.AfterStruct = true;
9491   Style.BraceWrapping.SplitEmptyRecord = false;
9492 
9493   verifyFormat("struct Foo\n"
9494                "{};",
9495                Style);
9496   verifyFormat("/* something */ struct Foo\n"
9497                "{};",
9498                Style);
9499   verifyFormat("template <typename X> struct Foo\n"
9500                "{};",
9501                Style);
9502   verifyFormat("struct Foo\n"
9503                "{\n"
9504                "  Foo();\n"
9505                "};",
9506                Style);
9507   verifyFormat("typedef struct Foo\n"
9508                "{\n"
9509                "} Foo_t;",
9510                Style);
9511   // typedef struct Bar {} Bar_t;
9512 }
9513 
9514 TEST_F(FormatTest, SplitEmptyUnion) {
9515   FormatStyle Style = getLLVMStyle();
9516   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9517   Style.BraceWrapping.AfterUnion = true;
9518   Style.BraceWrapping.SplitEmptyRecord = false;
9519 
9520   verifyFormat("union Foo\n"
9521                "{};",
9522                Style);
9523   verifyFormat("/* something */ union Foo\n"
9524                "{};",
9525                Style);
9526   verifyFormat("union Foo\n"
9527                "{\n"
9528                "  A,\n"
9529                "};",
9530                Style);
9531   verifyFormat("typedef union Foo\n"
9532                "{\n"
9533                "} Foo_t;",
9534                Style);
9535 }
9536 
9537 TEST_F(FormatTest, SplitEmptyNamespace) {
9538   FormatStyle Style = getLLVMStyle();
9539   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9540   Style.BraceWrapping.AfterNamespace = true;
9541   Style.BraceWrapping.SplitEmptyNamespace = false;
9542 
9543   verifyFormat("namespace Foo\n"
9544                "{};",
9545                Style);
9546   verifyFormat("/* something */ namespace Foo\n"
9547                "{};",
9548                Style);
9549   verifyFormat("inline namespace Foo\n"
9550                "{};",
9551                Style);
9552   verifyFormat("/* something */ inline namespace Foo\n"
9553                "{};",
9554                Style);
9555   verifyFormat("export namespace Foo\n"
9556                "{};",
9557                Style);
9558   verifyFormat("namespace Foo\n"
9559                "{\n"
9560                "void Bar();\n"
9561                "};",
9562                Style);
9563 }
9564 
9565 TEST_F(FormatTest, NeverMergeShortRecords) {
9566   FormatStyle Style = getLLVMStyle();
9567 
9568   verifyFormat("class Foo {\n"
9569                "  Foo();\n"
9570                "};",
9571                Style);
9572   verifyFormat("typedef class Foo {\n"
9573                "  Foo();\n"
9574                "} Foo_t;",
9575                Style);
9576   verifyFormat("struct Foo {\n"
9577                "  Foo();\n"
9578                "};",
9579                Style);
9580   verifyFormat("typedef struct Foo {\n"
9581                "  Foo();\n"
9582                "} Foo_t;",
9583                Style);
9584   verifyFormat("union Foo {\n"
9585                "  A,\n"
9586                "};",
9587                Style);
9588   verifyFormat("typedef union Foo {\n"
9589                "  A,\n"
9590                "} Foo_t;",
9591                Style);
9592   verifyFormat("namespace Foo {\n"
9593                "void Bar();\n"
9594                "};",
9595                Style);
9596 
9597   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9598   Style.BraceWrapping.AfterClass = true;
9599   Style.BraceWrapping.AfterStruct = true;
9600   Style.BraceWrapping.AfterUnion = true;
9601   Style.BraceWrapping.AfterNamespace = true;
9602   verifyFormat("class Foo\n"
9603                "{\n"
9604                "  Foo();\n"
9605                "};",
9606                Style);
9607   verifyFormat("typedef class Foo\n"
9608                "{\n"
9609                "  Foo();\n"
9610                "} Foo_t;",
9611                Style);
9612   verifyFormat("struct Foo\n"
9613                "{\n"
9614                "  Foo();\n"
9615                "};",
9616                Style);
9617   verifyFormat("typedef struct Foo\n"
9618                "{\n"
9619                "  Foo();\n"
9620                "} Foo_t;",
9621                Style);
9622   verifyFormat("union Foo\n"
9623                "{\n"
9624                "  A,\n"
9625                "};",
9626                Style);
9627   verifyFormat("typedef union Foo\n"
9628                "{\n"
9629                "  A,\n"
9630                "} Foo_t;",
9631                Style);
9632   verifyFormat("namespace Foo\n"
9633                "{\n"
9634                "void Bar();\n"
9635                "};",
9636                Style);
9637 }
9638 
9639 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
9640   // Elaborate type variable declarations.
9641   verifyFormat("struct foo a = {bar};\nint n;");
9642   verifyFormat("class foo a = {bar};\nint n;");
9643   verifyFormat("union foo a = {bar};\nint n;");
9644 
9645   // Elaborate types inside function definitions.
9646   verifyFormat("struct foo f() {}\nint n;");
9647   verifyFormat("class foo f() {}\nint n;");
9648   verifyFormat("union foo f() {}\nint n;");
9649 
9650   // Templates.
9651   verifyFormat("template <class X> void f() {}\nint n;");
9652   verifyFormat("template <struct X> void f() {}\nint n;");
9653   verifyFormat("template <union X> void f() {}\nint n;");
9654 
9655   // Actual definitions...
9656   verifyFormat("struct {\n} n;");
9657   verifyFormat(
9658       "template <template <class T, class Y>, class Z> class X {\n} n;");
9659   verifyFormat("union Z {\n  int n;\n} x;");
9660   verifyFormat("class MACRO Z {\n} n;");
9661   verifyFormat("class MACRO(X) Z {\n} n;");
9662   verifyFormat("class __attribute__(X) Z {\n} n;");
9663   verifyFormat("class __declspec(X) Z {\n} n;");
9664   verifyFormat("class A##B##C {\n} n;");
9665   verifyFormat("class alignas(16) Z {\n} n;");
9666   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
9667   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
9668 
9669   // Redefinition from nested context:
9670   verifyFormat("class A::B::C {\n} n;");
9671 
9672   // Template definitions.
9673   verifyFormat(
9674       "template <typename F>\n"
9675       "Matcher(const Matcher<F> &Other,\n"
9676       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
9677       "                             !is_same<F, T>::value>::type * = 0)\n"
9678       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
9679 
9680   // FIXME: This is still incorrectly handled at the formatter side.
9681   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
9682   verifyFormat("int i = SomeFunction(a<b, a> b);");
9683 
9684   // FIXME:
9685   // This now gets parsed incorrectly as class definition.
9686   // verifyFormat("class A<int> f() {\n}\nint n;");
9687 
9688   // Elaborate types where incorrectly parsing the structural element would
9689   // break the indent.
9690   verifyFormat("if (true)\n"
9691                "  class X x;\n"
9692                "else\n"
9693                "  f();\n");
9694 
9695   // This is simply incomplete. Formatting is not important, but must not crash.
9696   verifyFormat("class A:");
9697 }
9698 
9699 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
9700   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
9701             format("#error Leave     all         white!!!!! space* alone!\n"));
9702   EXPECT_EQ(
9703       "#warning Leave     all         white!!!!! space* alone!\n",
9704       format("#warning Leave     all         white!!!!! space* alone!\n"));
9705   EXPECT_EQ("#error 1", format("  #  error   1"));
9706   EXPECT_EQ("#warning 1", format("  #  warning 1"));
9707 }
9708 
9709 TEST_F(FormatTest, FormatHashIfExpressions) {
9710   verifyFormat("#if AAAA && BBBB");
9711   verifyFormat("#if (AAAA && BBBB)");
9712   verifyFormat("#elif (AAAA && BBBB)");
9713   // FIXME: Come up with a better indentation for #elif.
9714   verifyFormat(
9715       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
9716       "    defined(BBBBBBBB)\n"
9717       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
9718       "    defined(BBBBBBBB)\n"
9719       "#endif",
9720       getLLVMStyleWithColumns(65));
9721 }
9722 
9723 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
9724   FormatStyle AllowsMergedIf = getGoogleStyle();
9725   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
9726       FormatStyle::SIS_WithoutElse;
9727   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
9728   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
9729   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
9730   EXPECT_EQ("if (true) return 42;",
9731             format("if (true)\nreturn 42;", AllowsMergedIf));
9732   FormatStyle ShortMergedIf = AllowsMergedIf;
9733   ShortMergedIf.ColumnLimit = 25;
9734   verifyFormat("#define A \\\n"
9735                "  if (true) return 42;",
9736                ShortMergedIf);
9737   verifyFormat("#define A \\\n"
9738                "  f();    \\\n"
9739                "  if (true)\n"
9740                "#define B",
9741                ShortMergedIf);
9742   verifyFormat("#define A \\\n"
9743                "  f();    \\\n"
9744                "  if (true)\n"
9745                "g();",
9746                ShortMergedIf);
9747   verifyFormat("{\n"
9748                "#ifdef A\n"
9749                "  // Comment\n"
9750                "  if (true) continue;\n"
9751                "#endif\n"
9752                "  // Comment\n"
9753                "  if (true) continue;\n"
9754                "}",
9755                ShortMergedIf);
9756   ShortMergedIf.ColumnLimit = 33;
9757   verifyFormat("#define A \\\n"
9758                "  if constexpr (true) return 42;",
9759                ShortMergedIf);
9760   verifyFormat("#define A \\\n"
9761                "  if CONSTEXPR (true) return 42;",
9762                ShortMergedIf);
9763   ShortMergedIf.ColumnLimit = 29;
9764   verifyFormat("#define A                   \\\n"
9765                "  if (aaaaaaaaaa) return 1; \\\n"
9766                "  return 2;",
9767                ShortMergedIf);
9768   ShortMergedIf.ColumnLimit = 28;
9769   verifyFormat("#define A         \\\n"
9770                "  if (aaaaaaaaaa) \\\n"
9771                "    return 1;     \\\n"
9772                "  return 2;",
9773                ShortMergedIf);
9774   verifyFormat("#define A                \\\n"
9775                "  if constexpr (aaaaaaa) \\\n"
9776                "    return 1;            \\\n"
9777                "  return 2;",
9778                ShortMergedIf);
9779   verifyFormat("#define A                \\\n"
9780                "  if CONSTEXPR (aaaaaaa) \\\n"
9781                "    return 1;            \\\n"
9782                "  return 2;",
9783                ShortMergedIf);
9784 }
9785 
9786 TEST_F(FormatTest, FormatStarDependingOnContext) {
9787   verifyFormat("void f(int *a);");
9788   verifyFormat("void f() { f(fint * b); }");
9789   verifyFormat("class A {\n  void f(int *a);\n};");
9790   verifyFormat("class A {\n  int *a;\n};");
9791   verifyFormat("namespace a {\n"
9792                "namespace b {\n"
9793                "class A {\n"
9794                "  void f() {}\n"
9795                "  int *a;\n"
9796                "};\n"
9797                "} // namespace b\n"
9798                "} // namespace a");
9799 }
9800 
9801 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
9802   verifyFormat("while");
9803   verifyFormat("operator");
9804 }
9805 
9806 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
9807   // This code would be painfully slow to format if we didn't skip it.
9808   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
9809                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9810                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9811                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9812                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9813                    "A(1, 1)\n"
9814                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
9815                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9816                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9817                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9818                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9819                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9820                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9821                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9822                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9823                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
9824   // Deeply nested part is untouched, rest is formatted.
9825   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
9826             format(std::string("int    i;\n") + Code + "int    j;\n",
9827                    getLLVMStyle(), SC_ExpectIncomplete));
9828 }
9829 
9830 //===----------------------------------------------------------------------===//
9831 // Objective-C tests.
9832 //===----------------------------------------------------------------------===//
9833 
9834 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
9835   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
9836   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
9837             format("-(NSUInteger)indexOfObject:(id)anObject;"));
9838   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
9839   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
9840   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
9841             format("-(NSInteger)Method3:(id)anObject;"));
9842   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
9843             format("-(NSInteger)Method4:(id)anObject;"));
9844   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
9845             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
9846   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
9847             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
9848   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9849             "forAllCells:(BOOL)flag;",
9850             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9851                    "forAllCells:(BOOL)flag;"));
9852 
9853   // Very long objectiveC method declaration.
9854   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
9855                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
9856   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
9857                "                    inRange:(NSRange)range\n"
9858                "                   outRange:(NSRange)out_range\n"
9859                "                  outRange1:(NSRange)out_range1\n"
9860                "                  outRange2:(NSRange)out_range2\n"
9861                "                  outRange3:(NSRange)out_range3\n"
9862                "                  outRange4:(NSRange)out_range4\n"
9863                "                  outRange5:(NSRange)out_range5\n"
9864                "                  outRange6:(NSRange)out_range6\n"
9865                "                  outRange7:(NSRange)out_range7\n"
9866                "                  outRange8:(NSRange)out_range8\n"
9867                "                  outRange9:(NSRange)out_range9;");
9868 
9869   // When the function name has to be wrapped.
9870   FormatStyle Style = getLLVMStyle();
9871   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
9872   // and always indents instead.
9873   Style.IndentWrappedFunctionNames = false;
9874   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9875                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
9876                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
9877                "}",
9878                Style);
9879   Style.IndentWrappedFunctionNames = true;
9880   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9881                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
9882                "               anotherName:(NSString)dddddddddddddd {\n"
9883                "}",
9884                Style);
9885 
9886   verifyFormat("- (int)sum:(vector<int>)numbers;");
9887   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
9888   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
9889   // protocol lists (but not for template classes):
9890   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
9891 
9892   verifyFormat("- (int (*)())foo:(int (*)())f;");
9893   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
9894 
9895   // If there's no return type (very rare in practice!), LLVM and Google style
9896   // agree.
9897   verifyFormat("- foo;");
9898   verifyFormat("- foo:(int)f;");
9899   verifyGoogleFormat("- foo:(int)foo;");
9900 }
9901 
9902 TEST_F(FormatTest, BreaksStringLiterals) {
9903   EXPECT_EQ("\"some text \"\n"
9904             "\"other\";",
9905             format("\"some text other\";", getLLVMStyleWithColumns(12)));
9906   EXPECT_EQ("\"some text \"\n"
9907             "\"other\";",
9908             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
9909   EXPECT_EQ(
9910       "#define A  \\\n"
9911       "  \"some \"  \\\n"
9912       "  \"text \"  \\\n"
9913       "  \"other\";",
9914       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
9915   EXPECT_EQ(
9916       "#define A  \\\n"
9917       "  \"so \"    \\\n"
9918       "  \"text \"  \\\n"
9919       "  \"other\";",
9920       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
9921 
9922   EXPECT_EQ("\"some text\"",
9923             format("\"some text\"", getLLVMStyleWithColumns(1)));
9924   EXPECT_EQ("\"some text\"",
9925             format("\"some text\"", getLLVMStyleWithColumns(11)));
9926   EXPECT_EQ("\"some \"\n"
9927             "\"text\"",
9928             format("\"some text\"", getLLVMStyleWithColumns(10)));
9929   EXPECT_EQ("\"some \"\n"
9930             "\"text\"",
9931             format("\"some text\"", getLLVMStyleWithColumns(7)));
9932   EXPECT_EQ("\"some\"\n"
9933             "\" tex\"\n"
9934             "\"t\"",
9935             format("\"some text\"", getLLVMStyleWithColumns(6)));
9936   EXPECT_EQ("\"some\"\n"
9937             "\" tex\"\n"
9938             "\" and\"",
9939             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
9940   EXPECT_EQ("\"some\"\n"
9941             "\"/tex\"\n"
9942             "\"/and\"",
9943             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
9944 
9945   EXPECT_EQ("variable =\n"
9946             "    \"long string \"\n"
9947             "    \"literal\";",
9948             format("variable = \"long string literal\";",
9949                    getLLVMStyleWithColumns(20)));
9950 
9951   EXPECT_EQ("variable = f(\n"
9952             "    \"long string \"\n"
9953             "    \"literal\",\n"
9954             "    short,\n"
9955             "    loooooooooooooooooooong);",
9956             format("variable = f(\"long string literal\", short, "
9957                    "loooooooooooooooooooong);",
9958                    getLLVMStyleWithColumns(20)));
9959 
9960   EXPECT_EQ(
9961       "f(g(\"long string \"\n"
9962       "    \"literal\"),\n"
9963       "  b);",
9964       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
9965   EXPECT_EQ("f(g(\"long string \"\n"
9966             "    \"literal\",\n"
9967             "    a),\n"
9968             "  b);",
9969             format("f(g(\"long string literal\", a), b);",
9970                    getLLVMStyleWithColumns(20)));
9971   EXPECT_EQ(
9972       "f(\"one two\".split(\n"
9973       "    variable));",
9974       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
9975   EXPECT_EQ("f(\"one two three four five six \"\n"
9976             "  \"seven\".split(\n"
9977             "      really_looooong_variable));",
9978             format("f(\"one two three four five six seven\"."
9979                    "split(really_looooong_variable));",
9980                    getLLVMStyleWithColumns(33)));
9981 
9982   EXPECT_EQ("f(\"some \"\n"
9983             "  \"text\",\n"
9984             "  other);",
9985             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
9986 
9987   // Only break as a last resort.
9988   verifyFormat(
9989       "aaaaaaaaaaaaaaaaaaaa(\n"
9990       "    aaaaaaaaaaaaaaaaaaaa,\n"
9991       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
9992 
9993   EXPECT_EQ("\"splitmea\"\n"
9994             "\"trandomp\"\n"
9995             "\"oint\"",
9996             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
9997 
9998   EXPECT_EQ("\"split/\"\n"
9999             "\"pathat/\"\n"
10000             "\"slashes\"",
10001             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10002 
10003   EXPECT_EQ("\"split/\"\n"
10004             "\"pathat/\"\n"
10005             "\"slashes\"",
10006             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10007   EXPECT_EQ("\"split at \"\n"
10008             "\"spaces/at/\"\n"
10009             "\"slashes.at.any$\"\n"
10010             "\"non-alphanumeric%\"\n"
10011             "\"1111111111characte\"\n"
10012             "\"rs\"",
10013             format("\"split at "
10014                    "spaces/at/"
10015                    "slashes.at."
10016                    "any$non-"
10017                    "alphanumeric%"
10018                    "1111111111characte"
10019                    "rs\"",
10020                    getLLVMStyleWithColumns(20)));
10021 
10022   // Verify that splitting the strings understands
10023   // Style::AlwaysBreakBeforeMultilineStrings.
10024   EXPECT_EQ("aaaaaaaaaaaa(\n"
10025             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10026             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10027             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10028                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10029                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10030                    getGoogleStyle()));
10031   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10032             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10033             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10034                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10035                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10036                    getGoogleStyle()));
10037   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10038             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10039             format("llvm::outs() << "
10040                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10041                    "aaaaaaaaaaaaaaaaaaa\";"));
10042   EXPECT_EQ("ffff(\n"
10043             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10044             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10045             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10046                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10047                    getGoogleStyle()));
10048 
10049   FormatStyle Style = getLLVMStyleWithColumns(12);
10050   Style.BreakStringLiterals = false;
10051   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10052 
10053   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10054   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10055   EXPECT_EQ("#define A \\\n"
10056             "  \"some \" \\\n"
10057             "  \"text \" \\\n"
10058             "  \"other\";",
10059             format("#define A \"some text other\";", AlignLeft));
10060 }
10061 
10062 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10063   EXPECT_EQ("C a = \"some more \"\n"
10064             "      \"text\";",
10065             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10066 }
10067 
10068 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10069   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10070   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10071   EXPECT_EQ("int i = a(b());",
10072             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10073 }
10074 
10075 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10076   EXPECT_EQ(
10077       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10078       "(\n"
10079       "    \"x\t\");",
10080       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10081              "aaaaaaa("
10082              "\"x\t\");"));
10083 }
10084 
10085 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10086   EXPECT_EQ(
10087       "u8\"utf8 string \"\n"
10088       "u8\"literal\";",
10089       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10090   EXPECT_EQ(
10091       "u\"utf16 string \"\n"
10092       "u\"literal\";",
10093       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10094   EXPECT_EQ(
10095       "U\"utf32 string \"\n"
10096       "U\"literal\";",
10097       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10098   EXPECT_EQ("L\"wide string \"\n"
10099             "L\"literal\";",
10100             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10101   EXPECT_EQ("@\"NSString \"\n"
10102             "@\"literal\";",
10103             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10104   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10105 
10106   // This input makes clang-format try to split the incomplete unicode escape
10107   // sequence, which used to lead to a crasher.
10108   verifyNoCrash(
10109       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10110       getLLVMStyleWithColumns(60));
10111 }
10112 
10113 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10114   FormatStyle Style = getGoogleStyleWithColumns(15);
10115   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10116   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10117   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10118   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10119   EXPECT_EQ("u8R\"x(raw literal)x\";",
10120             format("u8R\"x(raw literal)x\";", Style));
10121 }
10122 
10123 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10124   FormatStyle Style = getLLVMStyleWithColumns(20);
10125   EXPECT_EQ(
10126       "_T(\"aaaaaaaaaaaaaa\")\n"
10127       "_T(\"aaaaaaaaaaaaaa\")\n"
10128       "_T(\"aaaaaaaaaaaa\")",
10129       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10130   EXPECT_EQ("f(x,\n"
10131             "  _T(\"aaaaaaaaaaaa\")\n"
10132             "  _T(\"aaa\"),\n"
10133             "  z);",
10134             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10135 
10136   // FIXME: Handle embedded spaces in one iteration.
10137   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10138   //            "_T(\"aaaaaaaaaaaaa\")\n"
10139   //            "_T(\"aaaaaaaaaaaaa\")\n"
10140   //            "_T(\"a\")",
10141   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10142   //                   getLLVMStyleWithColumns(20)));
10143   EXPECT_EQ(
10144       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10145       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10146   EXPECT_EQ("f(\n"
10147             "#if !TEST\n"
10148             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10149             "#endif\n"
10150             ");",
10151             format("f(\n"
10152                    "#if !TEST\n"
10153                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10154                    "#endif\n"
10155                    ");"));
10156   EXPECT_EQ("f(\n"
10157             "\n"
10158             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10159             format("f(\n"
10160                    "\n"
10161                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10162 }
10163 
10164 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10165   // In a function call with two operands, the second can be broken with no line
10166   // break before it.
10167   EXPECT_EQ(
10168       "func(a, \"long long \"\n"
10169       "        \"long long\");",
10170       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10171   // In a function call with three operands, the second must be broken with a
10172   // line break before it.
10173   EXPECT_EQ("func(a,\n"
10174             "     \"long long long \"\n"
10175             "     \"long\",\n"
10176             "     c);",
10177             format("func(a, \"long long long long\", c);",
10178                    getLLVMStyleWithColumns(24)));
10179   // In a function call with three operands, the third must be broken with a
10180   // line break before it.
10181   EXPECT_EQ("func(a, b,\n"
10182             "     \"long long long \"\n"
10183             "     \"long\");",
10184             format("func(a, b, \"long long long long\");",
10185                    getLLVMStyleWithColumns(24)));
10186   // In a function call with three operands, both the second and the third must
10187   // be broken with a line break before them.
10188   EXPECT_EQ("func(a,\n"
10189             "     \"long long long \"\n"
10190             "     \"long\",\n"
10191             "     \"long long long \"\n"
10192             "     \"long\");",
10193             format("func(a, \"long long long long\", \"long long long long\");",
10194                    getLLVMStyleWithColumns(24)));
10195   // In a chain of << with two operands, the second can be broken with no line
10196   // break before it.
10197   EXPECT_EQ("a << \"line line \"\n"
10198             "     \"line\";",
10199             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10200   // In a chain of << with three operands, the second can be broken with no line
10201   // break before it.
10202   EXPECT_EQ(
10203       "abcde << \"line \"\n"
10204       "         \"line line\"\n"
10205       "      << c;",
10206       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10207   // In a chain of << with three operands, the third must be broken with a line
10208   // break before it.
10209   EXPECT_EQ(
10210       "a << b\n"
10211       "  << \"line line \"\n"
10212       "     \"line\";",
10213       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10214   // In a chain of << with three operands, the second can be broken with no line
10215   // break before it and the third must be broken with a line break before it.
10216   EXPECT_EQ("abcd << \"line line \"\n"
10217             "        \"line\"\n"
10218             "     << \"line line \"\n"
10219             "        \"line\";",
10220             format("abcd << \"line line line\" << \"line line line\";",
10221                    getLLVMStyleWithColumns(20)));
10222   // In a chain of binary operators with two operands, the second can be broken
10223   // with no line break before it.
10224   EXPECT_EQ(
10225       "abcd + \"line line \"\n"
10226       "       \"line line\";",
10227       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10228   // In a chain of binary operators with three operands, the second must be
10229   // broken with a line break before it.
10230   EXPECT_EQ("abcd +\n"
10231             "    \"line line \"\n"
10232             "    \"line line\" +\n"
10233             "    e;",
10234             format("abcd + \"line line line line\" + e;",
10235                    getLLVMStyleWithColumns(20)));
10236   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10237   // the first must be broken with a line break before it.
10238   FormatStyle Style = getLLVMStyleWithColumns(25);
10239   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10240   EXPECT_EQ("someFunction(\n"
10241             "    \"long long long \"\n"
10242             "    \"long\",\n"
10243             "    a);",
10244             format("someFunction(\"long long long long\", a);", Style));
10245 }
10246 
10247 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10248   EXPECT_EQ(
10249       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10250       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10251       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10252       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10253              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10254              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10255 }
10256 
10257 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10258   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10259             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10260   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10261             "multiline raw string literal xxxxxxxxxxxxxx\n"
10262             ")x\",\n"
10263             "              a),\n"
10264             "            b);",
10265             format("fffffffffff(g(R\"x(\n"
10266                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10267                    ")x\", a), b);",
10268                    getGoogleStyleWithColumns(20)));
10269   EXPECT_EQ("fffffffffff(\n"
10270             "    g(R\"x(qqq\n"
10271             "multiline raw string literal xxxxxxxxxxxxxx\n"
10272             ")x\",\n"
10273             "      a),\n"
10274             "    b);",
10275             format("fffffffffff(g(R\"x(qqq\n"
10276                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10277                    ")x\", a), b);",
10278                    getGoogleStyleWithColumns(20)));
10279 
10280   EXPECT_EQ("fffffffffff(R\"x(\n"
10281             "multiline raw string literal xxxxxxxxxxxxxx\n"
10282             ")x\");",
10283             format("fffffffffff(R\"x(\n"
10284                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10285                    ")x\");",
10286                    getGoogleStyleWithColumns(20)));
10287   EXPECT_EQ("fffffffffff(R\"x(\n"
10288             "multiline raw string literal xxxxxxxxxxxxxx\n"
10289             ")x\" + bbbbbb);",
10290             format("fffffffffff(R\"x(\n"
10291                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10292                    ")x\" +   bbbbbb);",
10293                    getGoogleStyleWithColumns(20)));
10294   EXPECT_EQ("fffffffffff(\n"
10295             "    R\"x(\n"
10296             "multiline raw string literal xxxxxxxxxxxxxx\n"
10297             ")x\" +\n"
10298             "    bbbbbb);",
10299             format("fffffffffff(\n"
10300                    " R\"x(\n"
10301                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10302                    ")x\" + bbbbbb);",
10303                    getGoogleStyleWithColumns(20)));
10304   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10305             format("fffffffffff(\n"
10306                    " R\"(single line raw string)\" + bbbbbb);"));
10307 }
10308 
10309 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10310   verifyFormat("string a = \"unterminated;");
10311   EXPECT_EQ("function(\"unterminated,\n"
10312             "         OtherParameter);",
10313             format("function(  \"unterminated,\n"
10314                    "    OtherParameter);"));
10315 }
10316 
10317 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10318   FormatStyle Style = getLLVMStyle();
10319   Style.Standard = FormatStyle::LS_Cpp03;
10320   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10321             format("#define x(_a) printf(\"foo\"_a);", Style));
10322 }
10323 
10324 TEST_F(FormatTest, CppLexVersion) {
10325   FormatStyle Style = getLLVMStyle();
10326   // Formatting of x * y differs if x is a type.
10327   verifyFormat("void foo() { MACRO(a * b); }", Style);
10328   verifyFormat("void foo() { MACRO(int *b); }", Style);
10329 
10330   // LLVM style uses latest lexer.
10331   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10332   Style.Standard = FormatStyle::LS_Cpp17;
10333   // But in c++17, char8_t isn't a keyword.
10334   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10335 }
10336 
10337 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10338 
10339 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10340   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10341             "             \"ddeeefff\");",
10342             format("someFunction(\"aaabbbcccdddeeefff\");",
10343                    getLLVMStyleWithColumns(25)));
10344   EXPECT_EQ("someFunction1234567890(\n"
10345             "    \"aaabbbcccdddeeefff\");",
10346             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10347                    getLLVMStyleWithColumns(26)));
10348   EXPECT_EQ("someFunction1234567890(\n"
10349             "    \"aaabbbcccdddeeeff\"\n"
10350             "    \"f\");",
10351             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10352                    getLLVMStyleWithColumns(25)));
10353   EXPECT_EQ("someFunction1234567890(\n"
10354             "    \"aaabbbcccdddeeeff\"\n"
10355             "    \"f\");",
10356             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10357                    getLLVMStyleWithColumns(24)));
10358   EXPECT_EQ("someFunction(\n"
10359             "    \"aaabbbcc ddde \"\n"
10360             "    \"efff\");",
10361             format("someFunction(\"aaabbbcc ddde efff\");",
10362                    getLLVMStyleWithColumns(25)));
10363   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10364             "             \"ddeeefff\");",
10365             format("someFunction(\"aaabbbccc ddeeefff\");",
10366                    getLLVMStyleWithColumns(25)));
10367   EXPECT_EQ("someFunction1234567890(\n"
10368             "    \"aaabb \"\n"
10369             "    \"cccdddeeefff\");",
10370             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10371                    getLLVMStyleWithColumns(25)));
10372   EXPECT_EQ("#define A          \\\n"
10373             "  string s =       \\\n"
10374             "      \"123456789\"  \\\n"
10375             "      \"0\";         \\\n"
10376             "  int i;",
10377             format("#define A string s = \"1234567890\"; int i;",
10378                    getLLVMStyleWithColumns(20)));
10379   EXPECT_EQ("someFunction(\n"
10380             "    \"aaabbbcc \"\n"
10381             "    \"dddeeefff\");",
10382             format("someFunction(\"aaabbbcc dddeeefff\");",
10383                    getLLVMStyleWithColumns(25)));
10384 }
10385 
10386 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10387   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10388   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10389   EXPECT_EQ("\"test\"\n"
10390             "\"\\n\"",
10391             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10392   EXPECT_EQ("\"tes\\\\\"\n"
10393             "\"n\"",
10394             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10395   EXPECT_EQ("\"\\\\\\\\\"\n"
10396             "\"\\n\"",
10397             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10398   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10399   EXPECT_EQ("\"\\uff01\"\n"
10400             "\"test\"",
10401             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10402   EXPECT_EQ("\"\\Uff01ff02\"",
10403             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10404   EXPECT_EQ("\"\\x000000000001\"\n"
10405             "\"next\"",
10406             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10407   EXPECT_EQ("\"\\x000000000001next\"",
10408             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10409   EXPECT_EQ("\"\\x000000000001\"",
10410             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10411   EXPECT_EQ("\"test\"\n"
10412             "\"\\000000\"\n"
10413             "\"000001\"",
10414             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10415   EXPECT_EQ("\"test\\000\"\n"
10416             "\"00000000\"\n"
10417             "\"1\"",
10418             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10419 }
10420 
10421 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10422   verifyFormat("void f() {\n"
10423                "  return g() {}\n"
10424                "  void h() {}");
10425   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10426                "g();\n"
10427                "}");
10428 }
10429 
10430 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10431   verifyFormat(
10432       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10433 }
10434 
10435 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10436   verifyFormat("class X {\n"
10437                "  void f() {\n"
10438                "  }\n"
10439                "};",
10440                getLLVMStyleWithColumns(12));
10441 }
10442 
10443 TEST_F(FormatTest, ConfigurableIndentWidth) {
10444   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10445   EightIndent.IndentWidth = 8;
10446   EightIndent.ContinuationIndentWidth = 8;
10447   verifyFormat("void f() {\n"
10448                "        someFunction();\n"
10449                "        if (true) {\n"
10450                "                f();\n"
10451                "        }\n"
10452                "}",
10453                EightIndent);
10454   verifyFormat("class X {\n"
10455                "        void f() {\n"
10456                "        }\n"
10457                "};",
10458                EightIndent);
10459   verifyFormat("int x[] = {\n"
10460                "        call(),\n"
10461                "        call()};",
10462                EightIndent);
10463 }
10464 
10465 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10466   verifyFormat("double\n"
10467                "f();",
10468                getLLVMStyleWithColumns(8));
10469 }
10470 
10471 TEST_F(FormatTest, ConfigurableUseOfTab) {
10472   FormatStyle Tab = getLLVMStyleWithColumns(42);
10473   Tab.IndentWidth = 8;
10474   Tab.UseTab = FormatStyle::UT_Always;
10475   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10476 
10477   EXPECT_EQ("if (aaaaaaaa && // q\n"
10478             "    bb)\t\t// w\n"
10479             "\t;",
10480             format("if (aaaaaaaa &&// q\n"
10481                    "bb)// w\n"
10482                    ";",
10483                    Tab));
10484   EXPECT_EQ("if (aaa && bbb) // w\n"
10485             "\t;",
10486             format("if(aaa&&bbb)// w\n"
10487                    ";",
10488                    Tab));
10489 
10490   verifyFormat("class X {\n"
10491                "\tvoid f() {\n"
10492                "\t\tsomeFunction(parameter1,\n"
10493                "\t\t\t     parameter2);\n"
10494                "\t}\n"
10495                "};",
10496                Tab);
10497   verifyFormat("#define A                        \\\n"
10498                "\tvoid f() {               \\\n"
10499                "\t\tsomeFunction(    \\\n"
10500                "\t\t    parameter1,  \\\n"
10501                "\t\t    parameter2); \\\n"
10502                "\t}",
10503                Tab);
10504   verifyFormat("int a;\t      // x\n"
10505                "int bbbbbbbb; // x\n",
10506                Tab);
10507 
10508   Tab.TabWidth = 4;
10509   Tab.IndentWidth = 8;
10510   verifyFormat("class TabWidth4Indent8 {\n"
10511                "\t\tvoid f() {\n"
10512                "\t\t\t\tsomeFunction(parameter1,\n"
10513                "\t\t\t\t\t\t\t parameter2);\n"
10514                "\t\t}\n"
10515                "};",
10516                Tab);
10517 
10518   Tab.TabWidth = 4;
10519   Tab.IndentWidth = 4;
10520   verifyFormat("class TabWidth4Indent4 {\n"
10521                "\tvoid f() {\n"
10522                "\t\tsomeFunction(parameter1,\n"
10523                "\t\t\t\t\t parameter2);\n"
10524                "\t}\n"
10525                "};",
10526                Tab);
10527 
10528   Tab.TabWidth = 8;
10529   Tab.IndentWidth = 4;
10530   verifyFormat("class TabWidth8Indent4 {\n"
10531                "    void f() {\n"
10532                "\tsomeFunction(parameter1,\n"
10533                "\t\t     parameter2);\n"
10534                "    }\n"
10535                "};",
10536                Tab);
10537 
10538   Tab.TabWidth = 8;
10539   Tab.IndentWidth = 8;
10540   EXPECT_EQ("/*\n"
10541             "\t      a\t\tcomment\n"
10542             "\t      in multiple lines\n"
10543             "       */",
10544             format("   /*\t \t \n"
10545                    " \t \t a\t\tcomment\t \t\n"
10546                    " \t \t in multiple lines\t\n"
10547                    " \t  */",
10548                    Tab));
10549 
10550   Tab.UseTab = FormatStyle::UT_ForIndentation;
10551   verifyFormat("{\n"
10552                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10553                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10554                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10555                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10556                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10557                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10558                "};",
10559                Tab);
10560   verifyFormat("enum AA {\n"
10561                "\ta1, // Force multiple lines\n"
10562                "\ta2,\n"
10563                "\ta3\n"
10564                "};",
10565                Tab);
10566   EXPECT_EQ("if (aaaaaaaa && // q\n"
10567             "    bb)         // w\n"
10568             "\t;",
10569             format("if (aaaaaaaa &&// q\n"
10570                    "bb)// w\n"
10571                    ";",
10572                    Tab));
10573   verifyFormat("class X {\n"
10574                "\tvoid f() {\n"
10575                "\t\tsomeFunction(parameter1,\n"
10576                "\t\t             parameter2);\n"
10577                "\t}\n"
10578                "};",
10579                Tab);
10580   verifyFormat("{\n"
10581                "\tQ(\n"
10582                "\t    {\n"
10583                "\t\t    int a;\n"
10584                "\t\t    someFunction(aaaaaaaa,\n"
10585                "\t\t                 bbbbbbb);\n"
10586                "\t    },\n"
10587                "\t    p);\n"
10588                "}",
10589                Tab);
10590   EXPECT_EQ("{\n"
10591             "\t/* aaaa\n"
10592             "\t   bbbb */\n"
10593             "}",
10594             format("{\n"
10595                    "/* aaaa\n"
10596                    "   bbbb */\n"
10597                    "}",
10598                    Tab));
10599   EXPECT_EQ("{\n"
10600             "\t/*\n"
10601             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10602             "\t  bbbbbbbbbbbbb\n"
10603             "\t*/\n"
10604             "}",
10605             format("{\n"
10606                    "/*\n"
10607                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10608                    "*/\n"
10609                    "}",
10610                    Tab));
10611   EXPECT_EQ("{\n"
10612             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10613             "\t// bbbbbbbbbbbbb\n"
10614             "}",
10615             format("{\n"
10616                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10617                    "}",
10618                    Tab));
10619   EXPECT_EQ("{\n"
10620             "\t/*\n"
10621             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10622             "\t  bbbbbbbbbbbbb\n"
10623             "\t*/\n"
10624             "}",
10625             format("{\n"
10626                    "\t/*\n"
10627                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10628                    "\t*/\n"
10629                    "}",
10630                    Tab));
10631   EXPECT_EQ("{\n"
10632             "\t/*\n"
10633             "\n"
10634             "\t*/\n"
10635             "}",
10636             format("{\n"
10637                    "\t/*\n"
10638                    "\n"
10639                    "\t*/\n"
10640                    "}",
10641                    Tab));
10642   EXPECT_EQ("{\n"
10643             "\t/*\n"
10644             " asdf\n"
10645             "\t*/\n"
10646             "}",
10647             format("{\n"
10648                    "\t/*\n"
10649                    " asdf\n"
10650                    "\t*/\n"
10651                    "}",
10652                    Tab));
10653 
10654   Tab.UseTab = FormatStyle::UT_Never;
10655   EXPECT_EQ("/*\n"
10656             "              a\t\tcomment\n"
10657             "              in multiple lines\n"
10658             "       */",
10659             format("   /*\t \t \n"
10660                    " \t \t a\t\tcomment\t \t\n"
10661                    " \t \t in multiple lines\t\n"
10662                    " \t  */",
10663                    Tab));
10664   EXPECT_EQ("/* some\n"
10665             "   comment */",
10666             format(" \t \t /* some\n"
10667                    " \t \t    comment */",
10668                    Tab));
10669   EXPECT_EQ("int a; /* some\n"
10670             "   comment */",
10671             format(" \t \t int a; /* some\n"
10672                    " \t \t    comment */",
10673                    Tab));
10674 
10675   EXPECT_EQ("int a; /* some\n"
10676             "comment */",
10677             format(" \t \t int\ta; /* some\n"
10678                    " \t \t    comment */",
10679                    Tab));
10680   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10681             "    comment */",
10682             format(" \t \t f(\"\t\t\"); /* some\n"
10683                    " \t \t    comment */",
10684                    Tab));
10685   EXPECT_EQ("{\n"
10686             "        /*\n"
10687             "         * Comment\n"
10688             "         */\n"
10689             "        int i;\n"
10690             "}",
10691             format("{\n"
10692                    "\t/*\n"
10693                    "\t * Comment\n"
10694                    "\t */\n"
10695                    "\t int i;\n"
10696                    "}",
10697                    Tab));
10698 
10699   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
10700   Tab.TabWidth = 8;
10701   Tab.IndentWidth = 8;
10702   EXPECT_EQ("if (aaaaaaaa && // q\n"
10703             "    bb)         // w\n"
10704             "\t;",
10705             format("if (aaaaaaaa &&// q\n"
10706                    "bb)// w\n"
10707                    ";",
10708                    Tab));
10709   EXPECT_EQ("if (aaa && bbb) // w\n"
10710             "\t;",
10711             format("if(aaa&&bbb)// w\n"
10712                    ";",
10713                    Tab));
10714   verifyFormat("class X {\n"
10715                "\tvoid f() {\n"
10716                "\t\tsomeFunction(parameter1,\n"
10717                "\t\t\t     parameter2);\n"
10718                "\t}\n"
10719                "};",
10720                Tab);
10721   verifyFormat("#define A                        \\\n"
10722                "\tvoid f() {               \\\n"
10723                "\t\tsomeFunction(    \\\n"
10724                "\t\t    parameter1,  \\\n"
10725                "\t\t    parameter2); \\\n"
10726                "\t}",
10727                Tab);
10728   Tab.TabWidth = 4;
10729   Tab.IndentWidth = 8;
10730   verifyFormat("class TabWidth4Indent8 {\n"
10731                "\t\tvoid f() {\n"
10732                "\t\t\t\tsomeFunction(parameter1,\n"
10733                "\t\t\t\t\t\t\t parameter2);\n"
10734                "\t\t}\n"
10735                "};",
10736                Tab);
10737   Tab.TabWidth = 4;
10738   Tab.IndentWidth = 4;
10739   verifyFormat("class TabWidth4Indent4 {\n"
10740                "\tvoid f() {\n"
10741                "\t\tsomeFunction(parameter1,\n"
10742                "\t\t\t\t\t parameter2);\n"
10743                "\t}\n"
10744                "};",
10745                Tab);
10746   Tab.TabWidth = 8;
10747   Tab.IndentWidth = 4;
10748   verifyFormat("class TabWidth8Indent4 {\n"
10749                "    void f() {\n"
10750                "\tsomeFunction(parameter1,\n"
10751                "\t\t     parameter2);\n"
10752                "    }\n"
10753                "};",
10754                Tab);
10755   Tab.TabWidth = 8;
10756   Tab.IndentWidth = 8;
10757   EXPECT_EQ("/*\n"
10758             "\t      a\t\tcomment\n"
10759             "\t      in multiple lines\n"
10760             "       */",
10761             format("   /*\t \t \n"
10762                    " \t \t a\t\tcomment\t \t\n"
10763                    " \t \t in multiple lines\t\n"
10764                    " \t  */",
10765                    Tab));
10766   verifyFormat("{\n"
10767                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10768                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10769                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10770                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10771                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10772                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10773                "};",
10774                Tab);
10775   verifyFormat("enum AA {\n"
10776                "\ta1, // Force multiple lines\n"
10777                "\ta2,\n"
10778                "\ta3\n"
10779                "};",
10780                Tab);
10781   EXPECT_EQ("if (aaaaaaaa && // q\n"
10782             "    bb)         // w\n"
10783             "\t;",
10784             format("if (aaaaaaaa &&// q\n"
10785                    "bb)// w\n"
10786                    ";",
10787                    Tab));
10788   verifyFormat("class X {\n"
10789                "\tvoid f() {\n"
10790                "\t\tsomeFunction(parameter1,\n"
10791                "\t\t\t     parameter2);\n"
10792                "\t}\n"
10793                "};",
10794                Tab);
10795   verifyFormat("{\n"
10796                "\tQ(\n"
10797                "\t    {\n"
10798                "\t\t    int a;\n"
10799                "\t\t    someFunction(aaaaaaaa,\n"
10800                "\t\t\t\t bbbbbbb);\n"
10801                "\t    },\n"
10802                "\t    p);\n"
10803                "}",
10804                Tab);
10805   EXPECT_EQ("{\n"
10806             "\t/* aaaa\n"
10807             "\t   bbbb */\n"
10808             "}",
10809             format("{\n"
10810                    "/* aaaa\n"
10811                    "   bbbb */\n"
10812                    "}",
10813                    Tab));
10814   EXPECT_EQ("{\n"
10815             "\t/*\n"
10816             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10817             "\t  bbbbbbbbbbbbb\n"
10818             "\t*/\n"
10819             "}",
10820             format("{\n"
10821                    "/*\n"
10822                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10823                    "*/\n"
10824                    "}",
10825                    Tab));
10826   EXPECT_EQ("{\n"
10827             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10828             "\t// bbbbbbbbbbbbb\n"
10829             "}",
10830             format("{\n"
10831                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10832                    "}",
10833                    Tab));
10834   EXPECT_EQ("{\n"
10835             "\t/*\n"
10836             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10837             "\t  bbbbbbbbbbbbb\n"
10838             "\t*/\n"
10839             "}",
10840             format("{\n"
10841                    "\t/*\n"
10842                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10843                    "\t*/\n"
10844                    "}",
10845                    Tab));
10846   EXPECT_EQ("{\n"
10847             "\t/*\n"
10848             "\n"
10849             "\t*/\n"
10850             "}",
10851             format("{\n"
10852                    "\t/*\n"
10853                    "\n"
10854                    "\t*/\n"
10855                    "}",
10856                    Tab));
10857   EXPECT_EQ("{\n"
10858             "\t/*\n"
10859             " asdf\n"
10860             "\t*/\n"
10861             "}",
10862             format("{\n"
10863                    "\t/*\n"
10864                    " asdf\n"
10865                    "\t*/\n"
10866                    "}",
10867                    Tab));
10868   EXPECT_EQ("/* some\n"
10869             "   comment */",
10870             format(" \t \t /* some\n"
10871                    " \t \t    comment */",
10872                    Tab));
10873   EXPECT_EQ("int a; /* some\n"
10874             "   comment */",
10875             format(" \t \t int a; /* some\n"
10876                    " \t \t    comment */",
10877                    Tab));
10878   EXPECT_EQ("int a; /* some\n"
10879             "comment */",
10880             format(" \t \t int\ta; /* some\n"
10881                    " \t \t    comment */",
10882                    Tab));
10883   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10884             "    comment */",
10885             format(" \t \t f(\"\t\t\"); /* some\n"
10886                    " \t \t    comment */",
10887                    Tab));
10888   EXPECT_EQ("{\n"
10889             "\t/*\n"
10890             "\t * Comment\n"
10891             "\t */\n"
10892             "\tint i;\n"
10893             "}",
10894             format("{\n"
10895                    "\t/*\n"
10896                    "\t * Comment\n"
10897                    "\t */\n"
10898                    "\t int i;\n"
10899                    "}",
10900                    Tab));
10901   Tab.TabWidth = 2;
10902   Tab.IndentWidth = 2;
10903   EXPECT_EQ("{\n"
10904             "\t/* aaaa\n"
10905             "\t\t bbbb */\n"
10906             "}",
10907             format("{\n"
10908                    "/* aaaa\n"
10909                    "\t bbbb */\n"
10910                    "}",
10911                    Tab));
10912   EXPECT_EQ("{\n"
10913             "\t/*\n"
10914             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10915             "\t\tbbbbbbbbbbbbb\n"
10916             "\t*/\n"
10917             "}",
10918             format("{\n"
10919                    "/*\n"
10920                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10921                    "*/\n"
10922                    "}",
10923                    Tab));
10924   Tab.AlignConsecutiveAssignments = true;
10925   Tab.AlignConsecutiveDeclarations = true;
10926   Tab.TabWidth = 4;
10927   Tab.IndentWidth = 4;
10928   verifyFormat("class Assign {\n"
10929                "\tvoid f() {\n"
10930                "\t\tint         x      = 123;\n"
10931                "\t\tint         random = 4;\n"
10932                "\t\tstd::string alphabet =\n"
10933                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
10934                "\t}\n"
10935                "};",
10936                Tab);
10937 
10938   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
10939   Tab.TabWidth = 8;
10940   Tab.IndentWidth = 8;
10941   EXPECT_EQ("if (aaaaaaaa && // q\n"
10942             "    bb)         // w\n"
10943             "\t;",
10944             format("if (aaaaaaaa &&// q\n"
10945                    "bb)// w\n"
10946                    ";",
10947                    Tab));
10948   EXPECT_EQ("if (aaa && bbb) // w\n"
10949             "\t;",
10950             format("if(aaa&&bbb)// w\n"
10951                    ";",
10952                    Tab));
10953   verifyFormat("class X {\n"
10954                "\tvoid f() {\n"
10955                "\t\tsomeFunction(parameter1,\n"
10956                "\t\t             parameter2);\n"
10957                "\t}\n"
10958                "};",
10959                Tab);
10960   verifyFormat("#define A                        \\\n"
10961                "\tvoid f() {               \\\n"
10962                "\t\tsomeFunction(    \\\n"
10963                "\t\t    parameter1,  \\\n"
10964                "\t\t    parameter2); \\\n"
10965                "\t}",
10966                Tab);
10967   Tab.TabWidth = 4;
10968   Tab.IndentWidth = 8;
10969   verifyFormat("class TabWidth4Indent8 {\n"
10970                "\t\tvoid f() {\n"
10971                "\t\t\t\tsomeFunction(parameter1,\n"
10972                "\t\t\t\t             parameter2);\n"
10973                "\t\t}\n"
10974                "};",
10975                Tab);
10976   Tab.TabWidth = 4;
10977   Tab.IndentWidth = 4;
10978   verifyFormat("class TabWidth4Indent4 {\n"
10979                "\tvoid f() {\n"
10980                "\t\tsomeFunction(parameter1,\n"
10981                "\t\t             parameter2);\n"
10982                "\t}\n"
10983                "};",
10984                Tab);
10985   Tab.TabWidth = 8;
10986   Tab.IndentWidth = 4;
10987   verifyFormat("class TabWidth8Indent4 {\n"
10988                "    void f() {\n"
10989                "\tsomeFunction(parameter1,\n"
10990                "\t             parameter2);\n"
10991                "    }\n"
10992                "};",
10993                Tab);
10994   Tab.TabWidth = 8;
10995   Tab.IndentWidth = 8;
10996   EXPECT_EQ("/*\n"
10997             "              a\t\tcomment\n"
10998             "              in multiple lines\n"
10999             "       */",
11000             format("   /*\t \t \n"
11001                    " \t \t a\t\tcomment\t \t\n"
11002                    " \t \t in multiple lines\t\n"
11003                    " \t  */",
11004                    Tab));
11005   verifyFormat("{\n"
11006                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11007                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11008                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11009                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11010                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11011                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11012                "};",
11013                Tab);
11014   verifyFormat("enum AA {\n"
11015                "\ta1, // Force multiple lines\n"
11016                "\ta2,\n"
11017                "\ta3\n"
11018                "};",
11019                Tab);
11020   EXPECT_EQ("if (aaaaaaaa && // q\n"
11021             "    bb)         // w\n"
11022             "\t;",
11023             format("if (aaaaaaaa &&// q\n"
11024                    "bb)// w\n"
11025                    ";",
11026                    Tab));
11027   verifyFormat("class X {\n"
11028                "\tvoid f() {\n"
11029                "\t\tsomeFunction(parameter1,\n"
11030                "\t\t             parameter2);\n"
11031                "\t}\n"
11032                "};",
11033                Tab);
11034   verifyFormat("{\n"
11035                "\tQ(\n"
11036                "\t    {\n"
11037                "\t\t    int a;\n"
11038                "\t\t    someFunction(aaaaaaaa,\n"
11039                "\t\t                 bbbbbbb);\n"
11040                "\t    },\n"
11041                "\t    p);\n"
11042                "}",
11043                Tab);
11044   EXPECT_EQ("{\n"
11045             "\t/* aaaa\n"
11046             "\t   bbbb */\n"
11047             "}",
11048             format("{\n"
11049                    "/* aaaa\n"
11050                    "   bbbb */\n"
11051                    "}",
11052                    Tab));
11053   EXPECT_EQ("{\n"
11054             "\t/*\n"
11055             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11056             "\t  bbbbbbbbbbbbb\n"
11057             "\t*/\n"
11058             "}",
11059             format("{\n"
11060                    "/*\n"
11061                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11062                    "*/\n"
11063                    "}",
11064                    Tab));
11065   EXPECT_EQ("{\n"
11066             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11067             "\t// bbbbbbbbbbbbb\n"
11068             "}",
11069             format("{\n"
11070                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11071                    "}",
11072                    Tab));
11073   EXPECT_EQ("{\n"
11074             "\t/*\n"
11075             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11076             "\t  bbbbbbbbbbbbb\n"
11077             "\t*/\n"
11078             "}",
11079             format("{\n"
11080                    "\t/*\n"
11081                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11082                    "\t*/\n"
11083                    "}",
11084                    Tab));
11085   EXPECT_EQ("{\n"
11086             "\t/*\n"
11087             "\n"
11088             "\t*/\n"
11089             "}",
11090             format("{\n"
11091                    "\t/*\n"
11092                    "\n"
11093                    "\t*/\n"
11094                    "}",
11095                    Tab));
11096   EXPECT_EQ("{\n"
11097             "\t/*\n"
11098             " asdf\n"
11099             "\t*/\n"
11100             "}",
11101             format("{\n"
11102                    "\t/*\n"
11103                    " asdf\n"
11104                    "\t*/\n"
11105                    "}",
11106                    Tab));
11107   EXPECT_EQ("/* some\n"
11108             "   comment */",
11109             format(" \t \t /* some\n"
11110                    " \t \t    comment */",
11111                    Tab));
11112   EXPECT_EQ("int a; /* some\n"
11113             "   comment */",
11114             format(" \t \t int a; /* some\n"
11115                    " \t \t    comment */",
11116                    Tab));
11117   EXPECT_EQ("int a; /* some\n"
11118             "comment */",
11119             format(" \t \t int\ta; /* some\n"
11120                    " \t \t    comment */",
11121                    Tab));
11122   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11123             "    comment */",
11124             format(" \t \t f(\"\t\t\"); /* some\n"
11125                    " \t \t    comment */",
11126                    Tab));
11127   EXPECT_EQ("{\n"
11128             "\t/*\n"
11129             "\t * Comment\n"
11130             "\t */\n"
11131             "\tint i;\n"
11132             "}",
11133             format("{\n"
11134                    "\t/*\n"
11135                    "\t * Comment\n"
11136                    "\t */\n"
11137                    "\t int i;\n"
11138                    "}",
11139                    Tab));
11140   Tab.TabWidth = 2;
11141   Tab.IndentWidth = 2;
11142   EXPECT_EQ("{\n"
11143             "\t/* aaaa\n"
11144             "\t   bbbb */\n"
11145             "}",
11146             format("{\n"
11147                    "/* aaaa\n"
11148                    "   bbbb */\n"
11149                    "}",
11150                    Tab));
11151   EXPECT_EQ("{\n"
11152             "\t/*\n"
11153             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11154             "\t  bbbbbbbbbbbbb\n"
11155             "\t*/\n"
11156             "}",
11157             format("{\n"
11158                    "/*\n"
11159                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11160                    "*/\n"
11161                    "}",
11162                    Tab));
11163   Tab.AlignConsecutiveAssignments = true;
11164   Tab.AlignConsecutiveDeclarations = true;
11165   Tab.TabWidth = 4;
11166   Tab.IndentWidth = 4;
11167   verifyFormat("class Assign {\n"
11168                "\tvoid f() {\n"
11169                "\t\tint         x      = 123;\n"
11170                "\t\tint         random = 4;\n"
11171                "\t\tstd::string alphabet =\n"
11172                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11173                "\t}\n"
11174                "};",
11175                Tab);
11176 }
11177 
11178 TEST_F(FormatTest, ZeroTabWidth) {
11179   FormatStyle Tab = getLLVMStyleWithColumns(42);
11180   Tab.IndentWidth = 8;
11181   Tab.UseTab = FormatStyle::UT_Never;
11182   Tab.TabWidth = 0;
11183   EXPECT_EQ("void a(){\n"
11184             "    // line starts with '\t'\n"
11185             "};",
11186             format("void a(){\n"
11187                    "\t// line starts with '\t'\n"
11188                    "};",
11189                    Tab));
11190 
11191   EXPECT_EQ("void a(){\n"
11192             "    // line starts with '\t'\n"
11193             "};",
11194             format("void a(){\n"
11195                    "\t\t// line starts with '\t'\n"
11196                    "};",
11197                    Tab));
11198 
11199   Tab.UseTab = FormatStyle::UT_ForIndentation;
11200   EXPECT_EQ("void a(){\n"
11201             "    // line starts with '\t'\n"
11202             "};",
11203             format("void a(){\n"
11204                    "\t// line starts with '\t'\n"
11205                    "};",
11206                    Tab));
11207 
11208   EXPECT_EQ("void a(){\n"
11209             "    // line starts with '\t'\n"
11210             "};",
11211             format("void a(){\n"
11212                    "\t\t// line starts with '\t'\n"
11213                    "};",
11214                    Tab));
11215 
11216   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11217   EXPECT_EQ("void a(){\n"
11218             "    // line starts with '\t'\n"
11219             "};",
11220             format("void a(){\n"
11221                    "\t// line starts with '\t'\n"
11222                    "};",
11223                    Tab));
11224 
11225   EXPECT_EQ("void a(){\n"
11226             "    // line starts with '\t'\n"
11227             "};",
11228             format("void a(){\n"
11229                    "\t\t// line starts with '\t'\n"
11230                    "};",
11231                    Tab));
11232 
11233   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11234   EXPECT_EQ("void a(){\n"
11235             "    // line starts with '\t'\n"
11236             "};",
11237             format("void a(){\n"
11238                    "\t// line starts with '\t'\n"
11239                    "};",
11240                    Tab));
11241 
11242   EXPECT_EQ("void a(){\n"
11243             "    // line starts with '\t'\n"
11244             "};",
11245             format("void a(){\n"
11246                    "\t\t// line starts with '\t'\n"
11247                    "};",
11248                    Tab));
11249 
11250   Tab.UseTab = FormatStyle::UT_Always;
11251   EXPECT_EQ("void a(){\n"
11252             "// line starts with '\t'\n"
11253             "};",
11254             format("void a(){\n"
11255                    "\t// line starts with '\t'\n"
11256                    "};",
11257                    Tab));
11258 
11259   EXPECT_EQ("void a(){\n"
11260             "// line starts with '\t'\n"
11261             "};",
11262             format("void a(){\n"
11263                    "\t\t// line starts with '\t'\n"
11264                    "};",
11265                    Tab));
11266 }
11267 
11268 TEST_F(FormatTest, CalculatesOriginalColumn) {
11269   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11270             "q\"; /* some\n"
11271             "       comment */",
11272             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11273                    "q\"; /* some\n"
11274                    "       comment */",
11275                    getLLVMStyle()));
11276   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11277             "/* some\n"
11278             "   comment */",
11279             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11280                    " /* some\n"
11281                    "    comment */",
11282                    getLLVMStyle()));
11283   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11284             "qqq\n"
11285             "/* some\n"
11286             "   comment */",
11287             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11288                    "qqq\n"
11289                    " /* some\n"
11290                    "    comment */",
11291                    getLLVMStyle()));
11292   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11293             "wwww; /* some\n"
11294             "         comment */",
11295             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11296                    "wwww; /* some\n"
11297                    "         comment */",
11298                    getLLVMStyle()));
11299 }
11300 
11301 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11302   FormatStyle NoSpace = getLLVMStyle();
11303   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11304 
11305   verifyFormat("while(true)\n"
11306                "  continue;",
11307                NoSpace);
11308   verifyFormat("for(;;)\n"
11309                "  continue;",
11310                NoSpace);
11311   verifyFormat("if(true)\n"
11312                "  f();\n"
11313                "else if(true)\n"
11314                "  f();",
11315                NoSpace);
11316   verifyFormat("do {\n"
11317                "  do_something();\n"
11318                "} while(something());",
11319                NoSpace);
11320   verifyFormat("switch(x) {\n"
11321                "default:\n"
11322                "  break;\n"
11323                "}",
11324                NoSpace);
11325   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11326   verifyFormat("size_t x = sizeof(x);", NoSpace);
11327   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11328   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11329   verifyFormat("alignas(128) char a[128];", NoSpace);
11330   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11331   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11332   verifyFormat("int f() throw(Deprecated);", NoSpace);
11333   verifyFormat("typedef void (*cb)(int);", NoSpace);
11334   verifyFormat("T A::operator()();", NoSpace);
11335   verifyFormat("X A::operator++(T);", NoSpace);
11336   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11337 
11338   FormatStyle Space = getLLVMStyle();
11339   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11340 
11341   verifyFormat("int f ();", Space);
11342   verifyFormat("void f (int a, T b) {\n"
11343                "  while (true)\n"
11344                "    continue;\n"
11345                "}",
11346                Space);
11347   verifyFormat("if (true)\n"
11348                "  f ();\n"
11349                "else if (true)\n"
11350                "  f ();",
11351                Space);
11352   verifyFormat("do {\n"
11353                "  do_something ();\n"
11354                "} while (something ());",
11355                Space);
11356   verifyFormat("switch (x) {\n"
11357                "default:\n"
11358                "  break;\n"
11359                "}",
11360                Space);
11361   verifyFormat("A::A () : a (1) {}", Space);
11362   verifyFormat("void f () __attribute__ ((asdf));", Space);
11363   verifyFormat("*(&a + 1);\n"
11364                "&((&a)[1]);\n"
11365                "a[(b + c) * d];\n"
11366                "(((a + 1) * 2) + 3) * 4;",
11367                Space);
11368   verifyFormat("#define A(x) x", Space);
11369   verifyFormat("#define A (x) x", Space);
11370   verifyFormat("#if defined(x)\n"
11371                "#endif",
11372                Space);
11373   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11374   verifyFormat("size_t x = sizeof (x);", Space);
11375   verifyFormat("auto f (int x) -> decltype (x);", Space);
11376   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11377   verifyFormat("alignas (128) char a[128];", Space);
11378   verifyFormat("size_t x = alignof (MyType);", Space);
11379   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11380   verifyFormat("int f () throw (Deprecated);", Space);
11381   verifyFormat("typedef void (*cb) (int);", Space);
11382   verifyFormat("T A::operator() ();", Space);
11383   verifyFormat("X A::operator++ (T);", Space);
11384   verifyFormat("auto lambda = [] () { return 0; };", Space);
11385   verifyFormat("int x = int (y);", Space);
11386 
11387   FormatStyle SomeSpace = getLLVMStyle();
11388   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11389 
11390   verifyFormat("[]() -> float {}", SomeSpace);
11391   verifyFormat("[] (auto foo) {}", SomeSpace);
11392   verifyFormat("[foo]() -> int {}", SomeSpace);
11393   verifyFormat("int f();", SomeSpace);
11394   verifyFormat("void f (int a, T b) {\n"
11395                "  while (true)\n"
11396                "    continue;\n"
11397                "}",
11398                SomeSpace);
11399   verifyFormat("if (true)\n"
11400                "  f();\n"
11401                "else if (true)\n"
11402                "  f();",
11403                SomeSpace);
11404   verifyFormat("do {\n"
11405                "  do_something();\n"
11406                "} while (something());",
11407                SomeSpace);
11408   verifyFormat("switch (x) {\n"
11409                "default:\n"
11410                "  break;\n"
11411                "}",
11412                SomeSpace);
11413   verifyFormat("A::A() : a (1) {}", SomeSpace);
11414   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11415   verifyFormat("*(&a + 1);\n"
11416                "&((&a)[1]);\n"
11417                "a[(b + c) * d];\n"
11418                "(((a + 1) * 2) + 3) * 4;",
11419                SomeSpace);
11420   verifyFormat("#define A(x) x", SomeSpace);
11421   verifyFormat("#define A (x) x", SomeSpace);
11422   verifyFormat("#if defined(x)\n"
11423                "#endif",
11424                SomeSpace);
11425   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11426   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11427   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11428   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11429   verifyFormat("alignas (128) char a[128];", SomeSpace);
11430   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11431   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11432                SomeSpace);
11433   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11434   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11435   verifyFormat("T A::operator()();", SomeSpace);
11436   verifyFormat("X A::operator++ (T);", SomeSpace);
11437   verifyFormat("int x = int (y);", SomeSpace);
11438   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11439 }
11440 
11441 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11442   FormatStyle Spaces = getLLVMStyle();
11443   Spaces.SpaceAfterLogicalNot = true;
11444 
11445   verifyFormat("bool x = ! y", Spaces);
11446   verifyFormat("if (! isFailure())", Spaces);
11447   verifyFormat("if (! (a && b))", Spaces);
11448   verifyFormat("\"Error!\"", Spaces);
11449   verifyFormat("! ! x", Spaces);
11450 }
11451 
11452 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11453   FormatStyle Spaces = getLLVMStyle();
11454 
11455   Spaces.SpacesInParentheses = true;
11456   verifyFormat("do_something( ::globalVar );", Spaces);
11457   verifyFormat("call( x, y, z );", Spaces);
11458   verifyFormat("call();", Spaces);
11459   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11460   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11461                Spaces);
11462   verifyFormat("while ( (bool)1 )\n"
11463                "  continue;",
11464                Spaces);
11465   verifyFormat("for ( ;; )\n"
11466                "  continue;",
11467                Spaces);
11468   verifyFormat("if ( true )\n"
11469                "  f();\n"
11470                "else if ( true )\n"
11471                "  f();",
11472                Spaces);
11473   verifyFormat("do {\n"
11474                "  do_something( (int)i );\n"
11475                "} while ( something() );",
11476                Spaces);
11477   verifyFormat("switch ( x ) {\n"
11478                "default:\n"
11479                "  break;\n"
11480                "}",
11481                Spaces);
11482 
11483   Spaces.SpacesInParentheses = false;
11484   Spaces.SpacesInCStyleCastParentheses = true;
11485   verifyFormat("Type *A = ( Type * )P;", Spaces);
11486   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11487   verifyFormat("x = ( int32 )y;", Spaces);
11488   verifyFormat("int a = ( int )(2.0f);", Spaces);
11489   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11490   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11491   verifyFormat("#define x (( int )-1)", Spaces);
11492 
11493   // Run the first set of tests again with:
11494   Spaces.SpacesInParentheses = false;
11495   Spaces.SpaceInEmptyParentheses = true;
11496   Spaces.SpacesInCStyleCastParentheses = true;
11497   verifyFormat("call(x, y, z);", Spaces);
11498   verifyFormat("call( );", Spaces);
11499   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11500   verifyFormat("while (( bool )1)\n"
11501                "  continue;",
11502                Spaces);
11503   verifyFormat("for (;;)\n"
11504                "  continue;",
11505                Spaces);
11506   verifyFormat("if (true)\n"
11507                "  f( );\n"
11508                "else if (true)\n"
11509                "  f( );",
11510                Spaces);
11511   verifyFormat("do {\n"
11512                "  do_something(( int )i);\n"
11513                "} while (something( ));",
11514                Spaces);
11515   verifyFormat("switch (x) {\n"
11516                "default:\n"
11517                "  break;\n"
11518                "}",
11519                Spaces);
11520 
11521   // Run the first set of tests again with:
11522   Spaces.SpaceAfterCStyleCast = true;
11523   verifyFormat("call(x, y, z);", Spaces);
11524   verifyFormat("call( );", Spaces);
11525   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11526   verifyFormat("while (( bool ) 1)\n"
11527                "  continue;",
11528                Spaces);
11529   verifyFormat("for (;;)\n"
11530                "  continue;",
11531                Spaces);
11532   verifyFormat("if (true)\n"
11533                "  f( );\n"
11534                "else if (true)\n"
11535                "  f( );",
11536                Spaces);
11537   verifyFormat("do {\n"
11538                "  do_something(( int ) i);\n"
11539                "} while (something( ));",
11540                Spaces);
11541   verifyFormat("switch (x) {\n"
11542                "default:\n"
11543                "  break;\n"
11544                "}",
11545                Spaces);
11546 
11547   // Run subset of tests again with:
11548   Spaces.SpacesInCStyleCastParentheses = false;
11549   Spaces.SpaceAfterCStyleCast = true;
11550   verifyFormat("while ((bool) 1)\n"
11551                "  continue;",
11552                Spaces);
11553   verifyFormat("do {\n"
11554                "  do_something((int) i);\n"
11555                "} while (something( ));",
11556                Spaces);
11557 }
11558 
11559 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
11560   verifyFormat("int a[5];");
11561   verifyFormat("a[3] += 42;");
11562 
11563   FormatStyle Spaces = getLLVMStyle();
11564   Spaces.SpacesInSquareBrackets = true;
11565   // Not lambdas.
11566   verifyFormat("int a[ 5 ];", Spaces);
11567   verifyFormat("a[ 3 ] += 42;", Spaces);
11568   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
11569   verifyFormat("double &operator[](int i) { return 0; }\n"
11570                "int i;",
11571                Spaces);
11572   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
11573   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
11574   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
11575   // Lambdas.
11576   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
11577   verifyFormat("return [ i, args... ] {};", Spaces);
11578   verifyFormat("int foo = [ &bar ]() {};", Spaces);
11579   verifyFormat("int foo = [ = ]() {};", Spaces);
11580   verifyFormat("int foo = [ & ]() {};", Spaces);
11581   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
11582   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
11583 }
11584 
11585 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
11586   FormatStyle NoSpaceStyle = getLLVMStyle();
11587   verifyFormat("int a[5];", NoSpaceStyle);
11588   verifyFormat("a[3] += 42;", NoSpaceStyle);
11589 
11590   verifyFormat("int a[1];", NoSpaceStyle);
11591   verifyFormat("int 1 [a];", NoSpaceStyle);
11592   verifyFormat("int a[1][2];", NoSpaceStyle);
11593   verifyFormat("a[7] = 5;", NoSpaceStyle);
11594   verifyFormat("int a = (f())[23];", NoSpaceStyle);
11595   verifyFormat("f([] {})", NoSpaceStyle);
11596 
11597   FormatStyle Space = getLLVMStyle();
11598   Space.SpaceBeforeSquareBrackets = true;
11599   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
11600   verifyFormat("return [i, args...] {};", Space);
11601 
11602   verifyFormat("int a [5];", Space);
11603   verifyFormat("a [3] += 42;", Space);
11604   verifyFormat("constexpr char hello []{\"hello\"};", Space);
11605   verifyFormat("double &operator[](int i) { return 0; }\n"
11606                "int i;",
11607                Space);
11608   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
11609   verifyFormat("int i = a [a][a]->f();", Space);
11610   verifyFormat("int i = (*b) [a]->f();", Space);
11611 
11612   verifyFormat("int a [1];", Space);
11613   verifyFormat("int 1 [a];", Space);
11614   verifyFormat("int a [1][2];", Space);
11615   verifyFormat("a [7] = 5;", Space);
11616   verifyFormat("int a = (f()) [23];", Space);
11617   verifyFormat("f([] {})", Space);
11618 }
11619 
11620 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
11621   verifyFormat("int a = 5;");
11622   verifyFormat("a += 42;");
11623   verifyFormat("a or_eq 8;");
11624 
11625   FormatStyle Spaces = getLLVMStyle();
11626   Spaces.SpaceBeforeAssignmentOperators = false;
11627   verifyFormat("int a= 5;", Spaces);
11628   verifyFormat("a+= 42;", Spaces);
11629   verifyFormat("a or_eq 8;", Spaces);
11630 }
11631 
11632 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
11633   verifyFormat("class Foo : public Bar {};");
11634   verifyFormat("Foo::Foo() : foo(1) {}");
11635   verifyFormat("for (auto a : b) {\n}");
11636   verifyFormat("int x = a ? b : c;");
11637   verifyFormat("{\n"
11638                "label0:\n"
11639                "  int x = 0;\n"
11640                "}");
11641   verifyFormat("switch (x) {\n"
11642                "case 1:\n"
11643                "default:\n"
11644                "}");
11645 
11646   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
11647   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
11648   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
11649   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
11650   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
11651   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
11652   verifyFormat("{\n"
11653                "label1:\n"
11654                "  int x = 0;\n"
11655                "}",
11656                CtorInitializerStyle);
11657   verifyFormat("switch (x) {\n"
11658                "case 1:\n"
11659                "default:\n"
11660                "}",
11661                CtorInitializerStyle);
11662   CtorInitializerStyle.BreakConstructorInitializers =
11663       FormatStyle::BCIS_AfterColon;
11664   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
11665                "    aaaaaaaaaaaaaaaa(1),\n"
11666                "    bbbbbbbbbbbbbbbb(2) {}",
11667                CtorInitializerStyle);
11668   CtorInitializerStyle.BreakConstructorInitializers =
11669       FormatStyle::BCIS_BeforeComma;
11670   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11671                "    : aaaaaaaaaaaaaaaa(1)\n"
11672                "    , bbbbbbbbbbbbbbbb(2) {}",
11673                CtorInitializerStyle);
11674   CtorInitializerStyle.BreakConstructorInitializers =
11675       FormatStyle::BCIS_BeforeColon;
11676   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11677                "    : aaaaaaaaaaaaaaaa(1),\n"
11678                "      bbbbbbbbbbbbbbbb(2) {}",
11679                CtorInitializerStyle);
11680   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
11681   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11682                ": aaaaaaaaaaaaaaaa(1),\n"
11683                "  bbbbbbbbbbbbbbbb(2) {}",
11684                CtorInitializerStyle);
11685 
11686   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
11687   InheritanceStyle.SpaceBeforeInheritanceColon = false;
11688   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
11689   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
11690   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
11691   verifyFormat("int x = a ? b : c;", InheritanceStyle);
11692   verifyFormat("{\n"
11693                "label2:\n"
11694                "  int x = 0;\n"
11695                "}",
11696                InheritanceStyle);
11697   verifyFormat("switch (x) {\n"
11698                "case 1:\n"
11699                "default:\n"
11700                "}",
11701                InheritanceStyle);
11702   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
11703   verifyFormat("class Foooooooooooooooooooooo:\n"
11704                "    public aaaaaaaaaaaaaaaaaa,\n"
11705                "    public bbbbbbbbbbbbbbbbbb {\n"
11706                "}",
11707                InheritanceStyle);
11708   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
11709   verifyFormat("class Foooooooooooooooooooooo\n"
11710                "    : public aaaaaaaaaaaaaaaaaa\n"
11711                "    , public bbbbbbbbbbbbbbbbbb {\n"
11712                "}",
11713                InheritanceStyle);
11714   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
11715   verifyFormat("class Foooooooooooooooooooooo\n"
11716                "    : public aaaaaaaaaaaaaaaaaa,\n"
11717                "      public bbbbbbbbbbbbbbbbbb {\n"
11718                "}",
11719                InheritanceStyle);
11720   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
11721   verifyFormat("class Foooooooooooooooooooooo\n"
11722                ": public aaaaaaaaaaaaaaaaaa,\n"
11723                "  public bbbbbbbbbbbbbbbbbb {}",
11724                InheritanceStyle);
11725 
11726   FormatStyle ForLoopStyle = getLLVMStyle();
11727   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
11728   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
11729   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
11730   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
11731   verifyFormat("int x = a ? b : c;", ForLoopStyle);
11732   verifyFormat("{\n"
11733                "label2:\n"
11734                "  int x = 0;\n"
11735                "}",
11736                ForLoopStyle);
11737   verifyFormat("switch (x) {\n"
11738                "case 1:\n"
11739                "default:\n"
11740                "}",
11741                ForLoopStyle);
11742 
11743   FormatStyle NoSpaceStyle = getLLVMStyle();
11744   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
11745   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
11746   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
11747   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
11748   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
11749   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
11750   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
11751   verifyFormat("{\n"
11752                "label3:\n"
11753                "  int x = 0;\n"
11754                "}",
11755                NoSpaceStyle);
11756   verifyFormat("switch (x) {\n"
11757                "case 1:\n"
11758                "default:\n"
11759                "}",
11760                NoSpaceStyle);
11761 }
11762 
11763 TEST_F(FormatTest, AlignConsecutiveMacros) {
11764   FormatStyle Style = getLLVMStyle();
11765   Style.AlignConsecutiveAssignments = true;
11766   Style.AlignConsecutiveDeclarations = true;
11767   Style.AlignConsecutiveMacros = false;
11768 
11769   verifyFormat("#define a 3\n"
11770                "#define bbbb 4\n"
11771                "#define ccc (5)",
11772                Style);
11773 
11774   verifyFormat("#define f(x) (x * x)\n"
11775                "#define fff(x, y, z) (x * y + z)\n"
11776                "#define ffff(x, y) (x - y)",
11777                Style);
11778 
11779   verifyFormat("#define foo(x, y) (x + y)\n"
11780                "#define bar (5, 6)(2 + 2)",
11781                Style);
11782 
11783   verifyFormat("#define a 3\n"
11784                "#define bbbb 4\n"
11785                "#define ccc (5)\n"
11786                "#define f(x) (x * x)\n"
11787                "#define fff(x, y, z) (x * y + z)\n"
11788                "#define ffff(x, y) (x - y)",
11789                Style);
11790 
11791   Style.AlignConsecutiveMacros = true;
11792   verifyFormat("#define a    3\n"
11793                "#define bbbb 4\n"
11794                "#define ccc  (5)",
11795                Style);
11796 
11797   verifyFormat("#define f(x)         (x * x)\n"
11798                "#define fff(x, y, z) (x * y + z)\n"
11799                "#define ffff(x, y)   (x - y)",
11800                Style);
11801 
11802   verifyFormat("#define foo(x, y) (x + y)\n"
11803                "#define bar       (5, 6)(2 + 2)",
11804                Style);
11805 
11806   verifyFormat("#define a            3\n"
11807                "#define bbbb         4\n"
11808                "#define ccc          (5)\n"
11809                "#define f(x)         (x * x)\n"
11810                "#define fff(x, y, z) (x * y + z)\n"
11811                "#define ffff(x, y)   (x - y)",
11812                Style);
11813 
11814   verifyFormat("#define a         5\n"
11815                "#define foo(x, y) (x + y)\n"
11816                "#define CCC       (6)\n"
11817                "auto lambda = []() {\n"
11818                "  auto  ii = 0;\n"
11819                "  float j  = 0;\n"
11820                "  return 0;\n"
11821                "};\n"
11822                "int   i  = 0;\n"
11823                "float i2 = 0;\n"
11824                "auto  v  = type{\n"
11825                "    i = 1,   //\n"
11826                "    (i = 2), //\n"
11827                "    i = 3    //\n"
11828                "};",
11829                Style);
11830 
11831   Style.AlignConsecutiveMacros = false;
11832   Style.ColumnLimit = 20;
11833 
11834   verifyFormat("#define a          \\\n"
11835                "  \"aabbbbbbbbbbbb\"\n"
11836                "#define D          \\\n"
11837                "  \"aabbbbbbbbbbbb\" \\\n"
11838                "  \"ccddeeeeeeeee\"\n"
11839                "#define B          \\\n"
11840                "  \"QQQQQQQQQQQQQ\"  \\\n"
11841                "  \"FFFFFFFFFFFFF\"  \\\n"
11842                "  \"LLLLLLLL\"\n",
11843                Style);
11844 
11845   Style.AlignConsecutiveMacros = true;
11846   verifyFormat("#define a          \\\n"
11847                "  \"aabbbbbbbbbbbb\"\n"
11848                "#define D          \\\n"
11849                "  \"aabbbbbbbbbbbb\" \\\n"
11850                "  \"ccddeeeeeeeee\"\n"
11851                "#define B          \\\n"
11852                "  \"QQQQQQQQQQQQQ\"  \\\n"
11853                "  \"FFFFFFFFFFFFF\"  \\\n"
11854                "  \"LLLLLLLL\"\n",
11855                Style);
11856 }
11857 
11858 TEST_F(FormatTest, AlignConsecutiveAssignments) {
11859   FormatStyle Alignment = getLLVMStyle();
11860   Alignment.AlignConsecutiveMacros = true;
11861   Alignment.AlignConsecutiveAssignments = false;
11862   verifyFormat("int a = 5;\n"
11863                "int oneTwoThree = 123;",
11864                Alignment);
11865   verifyFormat("int a = 5;\n"
11866                "int oneTwoThree = 123;",
11867                Alignment);
11868 
11869   Alignment.AlignConsecutiveAssignments = true;
11870   verifyFormat("int a           = 5;\n"
11871                "int oneTwoThree = 123;",
11872                Alignment);
11873   verifyFormat("int a           = method();\n"
11874                "int oneTwoThree = 133;",
11875                Alignment);
11876   verifyFormat("a &= 5;\n"
11877                "bcd *= 5;\n"
11878                "ghtyf += 5;\n"
11879                "dvfvdb -= 5;\n"
11880                "a /= 5;\n"
11881                "vdsvsv %= 5;\n"
11882                "sfdbddfbdfbb ^= 5;\n"
11883                "dvsdsv |= 5;\n"
11884                "int dsvvdvsdvvv = 123;",
11885                Alignment);
11886   verifyFormat("int i = 1, j = 10;\n"
11887                "something = 2000;",
11888                Alignment);
11889   verifyFormat("something = 2000;\n"
11890                "int i = 1, j = 10;\n",
11891                Alignment);
11892   verifyFormat("something = 2000;\n"
11893                "another   = 911;\n"
11894                "int i = 1, j = 10;\n"
11895                "oneMore = 1;\n"
11896                "i       = 2;",
11897                Alignment);
11898   verifyFormat("int a   = 5;\n"
11899                "int one = 1;\n"
11900                "method();\n"
11901                "int oneTwoThree = 123;\n"
11902                "int oneTwo      = 12;",
11903                Alignment);
11904   verifyFormat("int oneTwoThree = 123;\n"
11905                "int oneTwo      = 12;\n"
11906                "method();\n",
11907                Alignment);
11908   verifyFormat("int oneTwoThree = 123; // comment\n"
11909                "int oneTwo      = 12;  // comment",
11910                Alignment);
11911 
11912   // Bug 25167
11913   verifyFormat("#if A\n"
11914                "#else\n"
11915                "int aaaaaaaa = 12;\n"
11916                "#endif\n"
11917                "#if B\n"
11918                "#else\n"
11919                "int a = 12;\n"
11920                "#endif\n",
11921                Alignment);
11922   verifyFormat("enum foo {\n"
11923                "#if A\n"
11924                "#else\n"
11925                "  aaaaaaaa = 12;\n"
11926                "#endif\n"
11927                "#if B\n"
11928                "#else\n"
11929                "  a = 12;\n"
11930                "#endif\n"
11931                "};\n",
11932                Alignment);
11933 
11934   EXPECT_EQ("int a = 5;\n"
11935             "\n"
11936             "int oneTwoThree = 123;",
11937             format("int a       = 5;\n"
11938                    "\n"
11939                    "int oneTwoThree= 123;",
11940                    Alignment));
11941   EXPECT_EQ("int a   = 5;\n"
11942             "int one = 1;\n"
11943             "\n"
11944             "int oneTwoThree = 123;",
11945             format("int a = 5;\n"
11946                    "int one = 1;\n"
11947                    "\n"
11948                    "int oneTwoThree = 123;",
11949                    Alignment));
11950   EXPECT_EQ("int a   = 5;\n"
11951             "int one = 1;\n"
11952             "\n"
11953             "int oneTwoThree = 123;\n"
11954             "int oneTwo      = 12;",
11955             format("int a = 5;\n"
11956                    "int one = 1;\n"
11957                    "\n"
11958                    "int oneTwoThree = 123;\n"
11959                    "int oneTwo = 12;",
11960                    Alignment));
11961   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
11962   verifyFormat("#define A \\\n"
11963                "  int aaaa       = 12; \\\n"
11964                "  int b          = 23; \\\n"
11965                "  int ccc        = 234; \\\n"
11966                "  int dddddddddd = 2345;",
11967                Alignment);
11968   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
11969   verifyFormat("#define A               \\\n"
11970                "  int aaaa       = 12;  \\\n"
11971                "  int b          = 23;  \\\n"
11972                "  int ccc        = 234; \\\n"
11973                "  int dddddddddd = 2345;",
11974                Alignment);
11975   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
11976   verifyFormat("#define A                                                      "
11977                "                \\\n"
11978                "  int aaaa       = 12;                                         "
11979                "                \\\n"
11980                "  int b          = 23;                                         "
11981                "                \\\n"
11982                "  int ccc        = 234;                                        "
11983                "                \\\n"
11984                "  int dddddddddd = 2345;",
11985                Alignment);
11986   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
11987                "k = 4, int l = 5,\n"
11988                "                  int m = 6) {\n"
11989                "  int j      = 10;\n"
11990                "  otherThing = 1;\n"
11991                "}",
11992                Alignment);
11993   verifyFormat("void SomeFunction(int parameter = 0) {\n"
11994                "  int i   = 1;\n"
11995                "  int j   = 2;\n"
11996                "  int big = 10000;\n"
11997                "}",
11998                Alignment);
11999   verifyFormat("class C {\n"
12000                "public:\n"
12001                "  int i            = 1;\n"
12002                "  virtual void f() = 0;\n"
12003                "};",
12004                Alignment);
12005   verifyFormat("int i = 1;\n"
12006                "if (SomeType t = getSomething()) {\n"
12007                "}\n"
12008                "int j   = 2;\n"
12009                "int big = 10000;",
12010                Alignment);
12011   verifyFormat("int j = 7;\n"
12012                "for (int k = 0; k < N; ++k) {\n"
12013                "}\n"
12014                "int j   = 2;\n"
12015                "int big = 10000;\n"
12016                "}",
12017                Alignment);
12018   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12019   verifyFormat("int i = 1;\n"
12020                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12021                "    = someLooooooooooooooooongFunction();\n"
12022                "int j = 2;",
12023                Alignment);
12024   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12025   verifyFormat("int i = 1;\n"
12026                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12027                "    someLooooooooooooooooongFunction();\n"
12028                "int j = 2;",
12029                Alignment);
12030 
12031   verifyFormat("auto lambda = []() {\n"
12032                "  auto i = 0;\n"
12033                "  return 0;\n"
12034                "};\n"
12035                "int i  = 0;\n"
12036                "auto v = type{\n"
12037                "    i = 1,   //\n"
12038                "    (i = 2), //\n"
12039                "    i = 3    //\n"
12040                "};",
12041                Alignment);
12042 
12043   verifyFormat(
12044       "int i      = 1;\n"
12045       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12046       "                          loooooooooooooooooooooongParameterB);\n"
12047       "int j      = 2;",
12048       Alignment);
12049 
12050   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12051                "          typename B   = very_long_type_name_1,\n"
12052                "          typename T_2 = very_long_type_name_2>\n"
12053                "auto foo() {}\n",
12054                Alignment);
12055   verifyFormat("int a, b = 1;\n"
12056                "int c  = 2;\n"
12057                "int dd = 3;\n",
12058                Alignment);
12059   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12060                "float b[1][] = {{3.f}};\n",
12061                Alignment);
12062   verifyFormat("for (int i = 0; i < 1; i++)\n"
12063                "  int x = 1;\n",
12064                Alignment);
12065   verifyFormat("for (i = 0; i < 1; i++)\n"
12066                "  x = 1;\n"
12067                "y = 1;\n",
12068                Alignment);
12069 
12070   Alignment.ReflowComments = true;
12071   Alignment.ColumnLimit = 50;
12072   EXPECT_EQ("int x   = 0;\n"
12073             "int yy  = 1; /// specificlennospace\n"
12074             "int zzz = 2;\n",
12075             format("int x   = 0;\n"
12076                    "int yy  = 1; ///specificlennospace\n"
12077                    "int zzz = 2;\n",
12078                    Alignment));
12079 }
12080 
12081 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12082   FormatStyle Alignment = getLLVMStyle();
12083   Alignment.AlignConsecutiveBitFields = true;
12084   verifyFormat("int const a     : 5;\n"
12085                "int oneTwoThree : 23;",
12086                Alignment);
12087 
12088   // Initializers are allowed starting with c++2a
12089   verifyFormat("int const a     : 5 = 1;\n"
12090                "int oneTwoThree : 23 = 0;",
12091                Alignment);
12092 
12093   Alignment.AlignConsecutiveDeclarations = true;
12094   verifyFormat("int const a           : 5;\n"
12095                "int       oneTwoThree : 23;",
12096                Alignment);
12097 
12098   verifyFormat("int const a           : 5;  // comment\n"
12099                "int       oneTwoThree : 23; // comment",
12100                Alignment);
12101 
12102   verifyFormat("int const a           : 5 = 1;\n"
12103                "int       oneTwoThree : 23 = 0;",
12104                Alignment);
12105 
12106   Alignment.AlignConsecutiveAssignments = true;
12107   verifyFormat("int const a           : 5  = 1;\n"
12108                "int       oneTwoThree : 23 = 0;",
12109                Alignment);
12110   verifyFormat("int const a           : 5  = {1};\n"
12111                "int       oneTwoThree : 23 = 0;",
12112                Alignment);
12113 
12114   // Known limitations: ':' is only recognized as a bitfield colon when
12115   // followed by a number.
12116   /*
12117   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12118                "int a           : 5;",
12119                Alignment);
12120   */
12121 }
12122 
12123 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12124   FormatStyle Alignment = getLLVMStyle();
12125   Alignment.AlignConsecutiveMacros = true;
12126   Alignment.AlignConsecutiveDeclarations = false;
12127   verifyFormat("float const a = 5;\n"
12128                "int oneTwoThree = 123;",
12129                Alignment);
12130   verifyFormat("int a = 5;\n"
12131                "float const oneTwoThree = 123;",
12132                Alignment);
12133 
12134   Alignment.AlignConsecutiveDeclarations = true;
12135   verifyFormat("float const a = 5;\n"
12136                "int         oneTwoThree = 123;",
12137                Alignment);
12138   verifyFormat("int         a = method();\n"
12139                "float const oneTwoThree = 133;",
12140                Alignment);
12141   verifyFormat("int i = 1, j = 10;\n"
12142                "something = 2000;",
12143                Alignment);
12144   verifyFormat("something = 2000;\n"
12145                "int i = 1, j = 10;\n",
12146                Alignment);
12147   verifyFormat("float      something = 2000;\n"
12148                "double     another = 911;\n"
12149                "int        i = 1, j = 10;\n"
12150                "const int *oneMore = 1;\n"
12151                "unsigned   i = 2;",
12152                Alignment);
12153   verifyFormat("float a = 5;\n"
12154                "int   one = 1;\n"
12155                "method();\n"
12156                "const double       oneTwoThree = 123;\n"
12157                "const unsigned int oneTwo = 12;",
12158                Alignment);
12159   verifyFormat("int      oneTwoThree{0}; // comment\n"
12160                "unsigned oneTwo;         // comment",
12161                Alignment);
12162   EXPECT_EQ("float const a = 5;\n"
12163             "\n"
12164             "int oneTwoThree = 123;",
12165             format("float const   a = 5;\n"
12166                    "\n"
12167                    "int           oneTwoThree= 123;",
12168                    Alignment));
12169   EXPECT_EQ("float a = 5;\n"
12170             "int   one = 1;\n"
12171             "\n"
12172             "unsigned oneTwoThree = 123;",
12173             format("float    a = 5;\n"
12174                    "int      one = 1;\n"
12175                    "\n"
12176                    "unsigned oneTwoThree = 123;",
12177                    Alignment));
12178   EXPECT_EQ("float a = 5;\n"
12179             "int   one = 1;\n"
12180             "\n"
12181             "unsigned oneTwoThree = 123;\n"
12182             "int      oneTwo = 12;",
12183             format("float    a = 5;\n"
12184                    "int one = 1;\n"
12185                    "\n"
12186                    "unsigned oneTwoThree = 123;\n"
12187                    "int oneTwo = 12;",
12188                    Alignment));
12189   // Function prototype alignment
12190   verifyFormat("int    a();\n"
12191                "double b();",
12192                Alignment);
12193   verifyFormat("int    a(int x);\n"
12194                "double b();",
12195                Alignment);
12196   unsigned OldColumnLimit = Alignment.ColumnLimit;
12197   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12198   // otherwise the function parameters will be re-flowed onto a single line.
12199   Alignment.ColumnLimit = 0;
12200   EXPECT_EQ("int    a(int   x,\n"
12201             "         float y);\n"
12202             "double b(int    x,\n"
12203             "         double y);",
12204             format("int a(int x,\n"
12205                    " float y);\n"
12206                    "double b(int x,\n"
12207                    " double y);",
12208                    Alignment));
12209   // This ensures that function parameters of function declarations are
12210   // correctly indented when their owning functions are indented.
12211   // The failure case here is for 'double y' to not be indented enough.
12212   EXPECT_EQ("double a(int x);\n"
12213             "int    b(int    y,\n"
12214             "         double z);",
12215             format("double a(int x);\n"
12216                    "int b(int y,\n"
12217                    " double z);",
12218                    Alignment));
12219   // Set ColumnLimit low so that we induce wrapping immediately after
12220   // the function name and opening paren.
12221   Alignment.ColumnLimit = 13;
12222   verifyFormat("int function(\n"
12223                "    int  x,\n"
12224                "    bool y);",
12225                Alignment);
12226   Alignment.ColumnLimit = OldColumnLimit;
12227   // Ensure function pointers don't screw up recursive alignment
12228   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12229                "double b();",
12230                Alignment);
12231   Alignment.AlignConsecutiveAssignments = true;
12232   // Ensure recursive alignment is broken by function braces, so that the
12233   // "a = 1" does not align with subsequent assignments inside the function
12234   // body.
12235   verifyFormat("int func(int a = 1) {\n"
12236                "  int b  = 2;\n"
12237                "  int cc = 3;\n"
12238                "}",
12239                Alignment);
12240   verifyFormat("float      something = 2000;\n"
12241                "double     another   = 911;\n"
12242                "int        i = 1, j = 10;\n"
12243                "const int *oneMore = 1;\n"
12244                "unsigned   i       = 2;",
12245                Alignment);
12246   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12247                "unsigned oneTwo      = 0;   // comment",
12248                Alignment);
12249   // Make sure that scope is correctly tracked, in the absence of braces
12250   verifyFormat("for (int i = 0; i < n; i++)\n"
12251                "  j = i;\n"
12252                "double x = 1;\n",
12253                Alignment);
12254   verifyFormat("if (int i = 0)\n"
12255                "  j = i;\n"
12256                "double x = 1;\n",
12257                Alignment);
12258   // Ensure operator[] and operator() are comprehended
12259   verifyFormat("struct test {\n"
12260                "  long long int foo();\n"
12261                "  int           operator[](int a);\n"
12262                "  double        bar();\n"
12263                "};\n",
12264                Alignment);
12265   verifyFormat("struct test {\n"
12266                "  long long int foo();\n"
12267                "  int           operator()(int a);\n"
12268                "  double        bar();\n"
12269                "};\n",
12270                Alignment);
12271   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12272             "  int const i   = 1;\n"
12273             "  int *     j   = 2;\n"
12274             "  int       big = 10000;\n"
12275             "\n"
12276             "  unsigned oneTwoThree = 123;\n"
12277             "  int      oneTwo      = 12;\n"
12278             "  method();\n"
12279             "  float k  = 2;\n"
12280             "  int   ll = 10000;\n"
12281             "}",
12282             format("void SomeFunction(int parameter= 0) {\n"
12283                    " int const  i= 1;\n"
12284                    "  int *j=2;\n"
12285                    " int big  =  10000;\n"
12286                    "\n"
12287                    "unsigned oneTwoThree  =123;\n"
12288                    "int oneTwo = 12;\n"
12289                    "  method();\n"
12290                    "float k= 2;\n"
12291                    "int ll=10000;\n"
12292                    "}",
12293                    Alignment));
12294   Alignment.AlignConsecutiveAssignments = false;
12295   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12296   verifyFormat("#define A \\\n"
12297                "  int       aaaa = 12; \\\n"
12298                "  float     b = 23; \\\n"
12299                "  const int ccc = 234; \\\n"
12300                "  unsigned  dddddddddd = 2345;",
12301                Alignment);
12302   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12303   verifyFormat("#define A              \\\n"
12304                "  int       aaaa = 12; \\\n"
12305                "  float     b = 23;    \\\n"
12306                "  const int ccc = 234; \\\n"
12307                "  unsigned  dddddddddd = 2345;",
12308                Alignment);
12309   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12310   Alignment.ColumnLimit = 30;
12311   verifyFormat("#define A                    \\\n"
12312                "  int       aaaa = 12;       \\\n"
12313                "  float     b = 23;          \\\n"
12314                "  const int ccc = 234;       \\\n"
12315                "  int       dddddddddd = 2345;",
12316                Alignment);
12317   Alignment.ColumnLimit = 80;
12318   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12319                "k = 4, int l = 5,\n"
12320                "                  int m = 6) {\n"
12321                "  const int j = 10;\n"
12322                "  otherThing = 1;\n"
12323                "}",
12324                Alignment);
12325   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12326                "  int const i = 1;\n"
12327                "  int *     j = 2;\n"
12328                "  int       big = 10000;\n"
12329                "}",
12330                Alignment);
12331   verifyFormat("class C {\n"
12332                "public:\n"
12333                "  int          i = 1;\n"
12334                "  virtual void f() = 0;\n"
12335                "};",
12336                Alignment);
12337   verifyFormat("float i = 1;\n"
12338                "if (SomeType t = getSomething()) {\n"
12339                "}\n"
12340                "const unsigned j = 2;\n"
12341                "int            big = 10000;",
12342                Alignment);
12343   verifyFormat("float j = 7;\n"
12344                "for (int k = 0; k < N; ++k) {\n"
12345                "}\n"
12346                "unsigned j = 2;\n"
12347                "int      big = 10000;\n"
12348                "}",
12349                Alignment);
12350   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12351   verifyFormat("float              i = 1;\n"
12352                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12353                "    = someLooooooooooooooooongFunction();\n"
12354                "int j = 2;",
12355                Alignment);
12356   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12357   verifyFormat("int                i = 1;\n"
12358                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12359                "    someLooooooooooooooooongFunction();\n"
12360                "int j = 2;",
12361                Alignment);
12362 
12363   Alignment.AlignConsecutiveAssignments = true;
12364   verifyFormat("auto lambda = []() {\n"
12365                "  auto  ii = 0;\n"
12366                "  float j  = 0;\n"
12367                "  return 0;\n"
12368                "};\n"
12369                "int   i  = 0;\n"
12370                "float i2 = 0;\n"
12371                "auto  v  = type{\n"
12372                "    i = 1,   //\n"
12373                "    (i = 2), //\n"
12374                "    i = 3    //\n"
12375                "};",
12376                Alignment);
12377   Alignment.AlignConsecutiveAssignments = false;
12378 
12379   verifyFormat(
12380       "int      i = 1;\n"
12381       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12382       "                          loooooooooooooooooooooongParameterB);\n"
12383       "int      j = 2;",
12384       Alignment);
12385 
12386   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12387   // We expect declarations and assignments to align, as long as it doesn't
12388   // exceed the column limit, starting a new alignment sequence whenever it
12389   // happens.
12390   Alignment.AlignConsecutiveAssignments = true;
12391   Alignment.ColumnLimit = 30;
12392   verifyFormat("float    ii              = 1;\n"
12393                "unsigned j               = 2;\n"
12394                "int someVerylongVariable = 1;\n"
12395                "AnotherLongType  ll = 123456;\n"
12396                "VeryVeryLongType k  = 2;\n"
12397                "int              myvar = 1;",
12398                Alignment);
12399   Alignment.ColumnLimit = 80;
12400   Alignment.AlignConsecutiveAssignments = false;
12401 
12402   verifyFormat(
12403       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12404       "          typename LongType, typename B>\n"
12405       "auto foo() {}\n",
12406       Alignment);
12407   verifyFormat("float a, b = 1;\n"
12408                "int   c = 2;\n"
12409                "int   dd = 3;\n",
12410                Alignment);
12411   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12412                "float b[1][] = {{3.f}};\n",
12413                Alignment);
12414   Alignment.AlignConsecutiveAssignments = true;
12415   verifyFormat("float a, b = 1;\n"
12416                "int   c  = 2;\n"
12417                "int   dd = 3;\n",
12418                Alignment);
12419   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12420                "float b[1][] = {{3.f}};\n",
12421                Alignment);
12422   Alignment.AlignConsecutiveAssignments = false;
12423 
12424   Alignment.ColumnLimit = 30;
12425   Alignment.BinPackParameters = false;
12426   verifyFormat("void foo(float     a,\n"
12427                "         float     b,\n"
12428                "         int       c,\n"
12429                "         uint32_t *d) {\n"
12430                "  int *  e = 0;\n"
12431                "  float  f = 0;\n"
12432                "  double g = 0;\n"
12433                "}\n"
12434                "void bar(ino_t     a,\n"
12435                "         int       b,\n"
12436                "         uint32_t *c,\n"
12437                "         bool      d) {}\n",
12438                Alignment);
12439   Alignment.BinPackParameters = true;
12440   Alignment.ColumnLimit = 80;
12441 
12442   // Bug 33507
12443   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12444   verifyFormat(
12445       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12446       "  static const Version verVs2017;\n"
12447       "  return true;\n"
12448       "});\n",
12449       Alignment);
12450   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12451 
12452   // See llvm.org/PR35641
12453   Alignment.AlignConsecutiveDeclarations = true;
12454   verifyFormat("int func() { //\n"
12455                "  int      b;\n"
12456                "  unsigned c;\n"
12457                "}",
12458                Alignment);
12459 
12460   // See PR37175
12461   FormatStyle Style = getMozillaStyle();
12462   Style.AlignConsecutiveDeclarations = true;
12463   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12464             "foo(int a);",
12465             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12466 }
12467 
12468 TEST_F(FormatTest, LinuxBraceBreaking) {
12469   FormatStyle LinuxBraceStyle = getLLVMStyle();
12470   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12471   verifyFormat("namespace a\n"
12472                "{\n"
12473                "class A\n"
12474                "{\n"
12475                "  void f()\n"
12476                "  {\n"
12477                "    if (true) {\n"
12478                "      a();\n"
12479                "      b();\n"
12480                "    } else {\n"
12481                "      a();\n"
12482                "    }\n"
12483                "  }\n"
12484                "  void g() { return; }\n"
12485                "};\n"
12486                "struct B {\n"
12487                "  int x;\n"
12488                "};\n"
12489                "} // namespace a\n",
12490                LinuxBraceStyle);
12491   verifyFormat("enum X {\n"
12492                "  Y = 0,\n"
12493                "}\n",
12494                LinuxBraceStyle);
12495   verifyFormat("struct S {\n"
12496                "  int Type;\n"
12497                "  union {\n"
12498                "    int x;\n"
12499                "    double y;\n"
12500                "  } Value;\n"
12501                "  class C\n"
12502                "  {\n"
12503                "    MyFavoriteType Value;\n"
12504                "  } Class;\n"
12505                "}\n",
12506                LinuxBraceStyle);
12507 }
12508 
12509 TEST_F(FormatTest, MozillaBraceBreaking) {
12510   FormatStyle MozillaBraceStyle = getLLVMStyle();
12511   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
12512   MozillaBraceStyle.FixNamespaceComments = false;
12513   verifyFormat("namespace a {\n"
12514                "class A\n"
12515                "{\n"
12516                "  void f()\n"
12517                "  {\n"
12518                "    if (true) {\n"
12519                "      a();\n"
12520                "      b();\n"
12521                "    }\n"
12522                "  }\n"
12523                "  void g() { return; }\n"
12524                "};\n"
12525                "enum E\n"
12526                "{\n"
12527                "  A,\n"
12528                "  // foo\n"
12529                "  B,\n"
12530                "  C\n"
12531                "};\n"
12532                "struct B\n"
12533                "{\n"
12534                "  int x;\n"
12535                "};\n"
12536                "}\n",
12537                MozillaBraceStyle);
12538   verifyFormat("struct S\n"
12539                "{\n"
12540                "  int Type;\n"
12541                "  union\n"
12542                "  {\n"
12543                "    int x;\n"
12544                "    double y;\n"
12545                "  } Value;\n"
12546                "  class C\n"
12547                "  {\n"
12548                "    MyFavoriteType Value;\n"
12549                "  } Class;\n"
12550                "}\n",
12551                MozillaBraceStyle);
12552 }
12553 
12554 TEST_F(FormatTest, StroustrupBraceBreaking) {
12555   FormatStyle StroustrupBraceStyle = getLLVMStyle();
12556   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12557   verifyFormat("namespace a {\n"
12558                "class A {\n"
12559                "  void f()\n"
12560                "  {\n"
12561                "    if (true) {\n"
12562                "      a();\n"
12563                "      b();\n"
12564                "    }\n"
12565                "  }\n"
12566                "  void g() { return; }\n"
12567                "};\n"
12568                "struct B {\n"
12569                "  int x;\n"
12570                "};\n"
12571                "} // namespace a\n",
12572                StroustrupBraceStyle);
12573 
12574   verifyFormat("void foo()\n"
12575                "{\n"
12576                "  if (a) {\n"
12577                "    a();\n"
12578                "  }\n"
12579                "  else {\n"
12580                "    b();\n"
12581                "  }\n"
12582                "}\n",
12583                StroustrupBraceStyle);
12584 
12585   verifyFormat("#ifdef _DEBUG\n"
12586                "int foo(int i = 0)\n"
12587                "#else\n"
12588                "int foo(int i = 5)\n"
12589                "#endif\n"
12590                "{\n"
12591                "  return i;\n"
12592                "}",
12593                StroustrupBraceStyle);
12594 
12595   verifyFormat("void foo() {}\n"
12596                "void bar()\n"
12597                "#ifdef _DEBUG\n"
12598                "{\n"
12599                "  foo();\n"
12600                "}\n"
12601                "#else\n"
12602                "{\n"
12603                "}\n"
12604                "#endif",
12605                StroustrupBraceStyle);
12606 
12607   verifyFormat("void foobar() { int i = 5; }\n"
12608                "#ifdef _DEBUG\n"
12609                "void bar() {}\n"
12610                "#else\n"
12611                "void bar() { foobar(); }\n"
12612                "#endif",
12613                StroustrupBraceStyle);
12614 }
12615 
12616 TEST_F(FormatTest, AllmanBraceBreaking) {
12617   FormatStyle AllmanBraceStyle = getLLVMStyle();
12618   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
12619 
12620   EXPECT_EQ("namespace a\n"
12621             "{\n"
12622             "void f();\n"
12623             "void g();\n"
12624             "} // namespace a\n",
12625             format("namespace a\n"
12626                    "{\n"
12627                    "void f();\n"
12628                    "void g();\n"
12629                    "}\n",
12630                    AllmanBraceStyle));
12631 
12632   verifyFormat("namespace a\n"
12633                "{\n"
12634                "class A\n"
12635                "{\n"
12636                "  void f()\n"
12637                "  {\n"
12638                "    if (true)\n"
12639                "    {\n"
12640                "      a();\n"
12641                "      b();\n"
12642                "    }\n"
12643                "  }\n"
12644                "  void g() { return; }\n"
12645                "};\n"
12646                "struct B\n"
12647                "{\n"
12648                "  int x;\n"
12649                "};\n"
12650                "union C\n"
12651                "{\n"
12652                "};\n"
12653                "} // namespace a",
12654                AllmanBraceStyle);
12655 
12656   verifyFormat("void f()\n"
12657                "{\n"
12658                "  if (true)\n"
12659                "  {\n"
12660                "    a();\n"
12661                "  }\n"
12662                "  else if (false)\n"
12663                "  {\n"
12664                "    b();\n"
12665                "  }\n"
12666                "  else\n"
12667                "  {\n"
12668                "    c();\n"
12669                "  }\n"
12670                "}\n",
12671                AllmanBraceStyle);
12672 
12673   verifyFormat("void f()\n"
12674                "{\n"
12675                "  for (int i = 0; i < 10; ++i)\n"
12676                "  {\n"
12677                "    a();\n"
12678                "  }\n"
12679                "  while (false)\n"
12680                "  {\n"
12681                "    b();\n"
12682                "  }\n"
12683                "  do\n"
12684                "  {\n"
12685                "    c();\n"
12686                "  } while (false)\n"
12687                "}\n",
12688                AllmanBraceStyle);
12689 
12690   verifyFormat("void f(int a)\n"
12691                "{\n"
12692                "  switch (a)\n"
12693                "  {\n"
12694                "  case 0:\n"
12695                "    break;\n"
12696                "  case 1:\n"
12697                "  {\n"
12698                "    break;\n"
12699                "  }\n"
12700                "  case 2:\n"
12701                "  {\n"
12702                "  }\n"
12703                "  break;\n"
12704                "  default:\n"
12705                "    break;\n"
12706                "  }\n"
12707                "}\n",
12708                AllmanBraceStyle);
12709 
12710   verifyFormat("enum X\n"
12711                "{\n"
12712                "  Y = 0,\n"
12713                "}\n",
12714                AllmanBraceStyle);
12715   verifyFormat("enum X\n"
12716                "{\n"
12717                "  Y = 0\n"
12718                "}\n",
12719                AllmanBraceStyle);
12720 
12721   verifyFormat("@interface BSApplicationController ()\n"
12722                "{\n"
12723                "@private\n"
12724                "  id _extraIvar;\n"
12725                "}\n"
12726                "@end\n",
12727                AllmanBraceStyle);
12728 
12729   verifyFormat("#ifdef _DEBUG\n"
12730                "int foo(int i = 0)\n"
12731                "#else\n"
12732                "int foo(int i = 5)\n"
12733                "#endif\n"
12734                "{\n"
12735                "  return i;\n"
12736                "}",
12737                AllmanBraceStyle);
12738 
12739   verifyFormat("void foo() {}\n"
12740                "void bar()\n"
12741                "#ifdef _DEBUG\n"
12742                "{\n"
12743                "  foo();\n"
12744                "}\n"
12745                "#else\n"
12746                "{\n"
12747                "}\n"
12748                "#endif",
12749                AllmanBraceStyle);
12750 
12751   verifyFormat("void foobar() { int i = 5; }\n"
12752                "#ifdef _DEBUG\n"
12753                "void bar() {}\n"
12754                "#else\n"
12755                "void bar() { foobar(); }\n"
12756                "#endif",
12757                AllmanBraceStyle);
12758 
12759   // This shouldn't affect ObjC blocks..
12760   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
12761                "  // ...\n"
12762                "  int i;\n"
12763                "}];",
12764                AllmanBraceStyle);
12765   verifyFormat("void (^block)(void) = ^{\n"
12766                "  // ...\n"
12767                "  int i;\n"
12768                "};",
12769                AllmanBraceStyle);
12770   // .. or dict literals.
12771   verifyFormat("void f()\n"
12772                "{\n"
12773                "  // ...\n"
12774                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
12775                "}",
12776                AllmanBraceStyle);
12777   verifyFormat("void f()\n"
12778                "{\n"
12779                "  // ...\n"
12780                "  [object someMethod:@{a : @\"b\"}];\n"
12781                "}",
12782                AllmanBraceStyle);
12783   verifyFormat("int f()\n"
12784                "{ // comment\n"
12785                "  return 42;\n"
12786                "}",
12787                AllmanBraceStyle);
12788 
12789   AllmanBraceStyle.ColumnLimit = 19;
12790   verifyFormat("void f() { int i; }", AllmanBraceStyle);
12791   AllmanBraceStyle.ColumnLimit = 18;
12792   verifyFormat("void f()\n"
12793                "{\n"
12794                "  int i;\n"
12795                "}",
12796                AllmanBraceStyle);
12797   AllmanBraceStyle.ColumnLimit = 80;
12798 
12799   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
12800   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
12801       FormatStyle::SIS_WithoutElse;
12802   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
12803   verifyFormat("void f(bool b)\n"
12804                "{\n"
12805                "  if (b)\n"
12806                "  {\n"
12807                "    return;\n"
12808                "  }\n"
12809                "}\n",
12810                BreakBeforeBraceShortIfs);
12811   verifyFormat("void f(bool b)\n"
12812                "{\n"
12813                "  if constexpr (b)\n"
12814                "  {\n"
12815                "    return;\n"
12816                "  }\n"
12817                "}\n",
12818                BreakBeforeBraceShortIfs);
12819   verifyFormat("void f(bool b)\n"
12820                "{\n"
12821                "  if CONSTEXPR (b)\n"
12822                "  {\n"
12823                "    return;\n"
12824                "  }\n"
12825                "}\n",
12826                BreakBeforeBraceShortIfs);
12827   verifyFormat("void f(bool b)\n"
12828                "{\n"
12829                "  if (b) return;\n"
12830                "}\n",
12831                BreakBeforeBraceShortIfs);
12832   verifyFormat("void f(bool b)\n"
12833                "{\n"
12834                "  if constexpr (b) return;\n"
12835                "}\n",
12836                BreakBeforeBraceShortIfs);
12837   verifyFormat("void f(bool b)\n"
12838                "{\n"
12839                "  if CONSTEXPR (b) return;\n"
12840                "}\n",
12841                BreakBeforeBraceShortIfs);
12842   verifyFormat("void f(bool b)\n"
12843                "{\n"
12844                "  while (b)\n"
12845                "  {\n"
12846                "    return;\n"
12847                "  }\n"
12848                "}\n",
12849                BreakBeforeBraceShortIfs);
12850 }
12851 
12852 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
12853   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
12854   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
12855 
12856   // Make a few changes to the style for testing purposes
12857   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
12858       FormatStyle::SFS_Empty;
12859   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
12860   WhitesmithsBraceStyle.ColumnLimit = 0;
12861 
12862   // FIXME: this test case can't decide whether there should be a blank line
12863   // after the ~D() line or not. It adds one if one doesn't exist in the test
12864   // and it removes the line if one exists.
12865   /*
12866   verifyFormat("class A;\n"
12867                "namespace B\n"
12868                "  {\n"
12869                "class C;\n"
12870                "// Comment\n"
12871                "class D\n"
12872                "  {\n"
12873                "public:\n"
12874                "  D();\n"
12875                "  ~D() {}\n"
12876                "private:\n"
12877                "  enum E\n"
12878                "    {\n"
12879                "    F\n"
12880                "    }\n"
12881                "  };\n"
12882                "  } // namespace B\n",
12883                WhitesmithsBraceStyle);
12884   */
12885 
12886   verifyFormat("namespace a\n"
12887                "  {\n"
12888                "class A\n"
12889                "  {\n"
12890                "  void f()\n"
12891                "    {\n"
12892                "    if (true)\n"
12893                "      {\n"
12894                "      a();\n"
12895                "      b();\n"
12896                "      }\n"
12897                "    }\n"
12898                "  void g()\n"
12899                "    {\n"
12900                "    return;\n"
12901                "    }\n"
12902                "  };\n"
12903                "struct B\n"
12904                "  {\n"
12905                "  int x;\n"
12906                "  };\n"
12907                "  } // namespace a",
12908                WhitesmithsBraceStyle);
12909 
12910   verifyFormat("void f()\n"
12911                "  {\n"
12912                "  if (true)\n"
12913                "    {\n"
12914                "    a();\n"
12915                "    }\n"
12916                "  else if (false)\n"
12917                "    {\n"
12918                "    b();\n"
12919                "    }\n"
12920                "  else\n"
12921                "    {\n"
12922                "    c();\n"
12923                "    }\n"
12924                "  }\n",
12925                WhitesmithsBraceStyle);
12926 
12927   verifyFormat("void f()\n"
12928                "  {\n"
12929                "  for (int i = 0; i < 10; ++i)\n"
12930                "    {\n"
12931                "    a();\n"
12932                "    }\n"
12933                "  while (false)\n"
12934                "    {\n"
12935                "    b();\n"
12936                "    }\n"
12937                "  do\n"
12938                "    {\n"
12939                "    c();\n"
12940                "    } while (false)\n"
12941                "  }\n",
12942                WhitesmithsBraceStyle);
12943 
12944   // FIXME: the block and the break under case 2 in this test don't get indented
12945   // correctly
12946   /*
12947   verifyFormat("void switchTest1(int a)\n"
12948                "  {\n"
12949                "  switch (a)\n"
12950                "    {\n"
12951                "    case 2:\n"
12952                "      {\n"
12953                "      }\n"
12954                "      break;\n"
12955                "    }\n"
12956                "  }\n",
12957                WhitesmithsBraceStyle);
12958   */
12959 
12960   // FIXME: the block and the break under case 2 in this test don't get indented
12961   // correctly
12962   /*
12963   verifyFormat("void switchTest2(int a)\n"
12964                "  {\n"
12965                "  switch (a)\n"
12966                "    {\n"
12967                "  case 0:\n"
12968                "    break;\n"
12969                "  case 1:\n"
12970                "    {\n"
12971                "    break;\n"
12972                "    }\n"
12973                "  case 2:\n"
12974                "    {\n"
12975                "    }\n"
12976                "    break;\n"
12977                "  default:\n"
12978                "    break;\n"
12979                "    }\n"
12980                "  }\n",
12981                WhitesmithsBraceStyle);
12982   */
12983 
12984   verifyFormat("enum X\n"
12985                "  {\n"
12986                "  Y = 0, // testing\n"
12987                "  }\n",
12988                WhitesmithsBraceStyle);
12989 
12990   verifyFormat("enum X\n"
12991                "  {\n"
12992                "  Y = 0\n"
12993                "  }\n",
12994                WhitesmithsBraceStyle);
12995   verifyFormat("enum X\n"
12996                "  {\n"
12997                "  Y = 0,\n"
12998                "  Z = 1\n"
12999                "  };\n",
13000                WhitesmithsBraceStyle);
13001 
13002   verifyFormat("@interface BSApplicationController ()\n"
13003                "  {\n"
13004                "@private\n"
13005                "  id _extraIvar;\n"
13006                "  }\n"
13007                "@end\n",
13008                WhitesmithsBraceStyle);
13009 
13010   verifyFormat("#ifdef _DEBUG\n"
13011                "int foo(int i = 0)\n"
13012                "#else\n"
13013                "int foo(int i = 5)\n"
13014                "#endif\n"
13015                "  {\n"
13016                "  return i;\n"
13017                "  }",
13018                WhitesmithsBraceStyle);
13019 
13020   verifyFormat("void foo() {}\n"
13021                "void bar()\n"
13022                "#ifdef _DEBUG\n"
13023                "  {\n"
13024                "  foo();\n"
13025                "  }\n"
13026                "#else\n"
13027                "  {\n"
13028                "  }\n"
13029                "#endif",
13030                WhitesmithsBraceStyle);
13031 
13032   verifyFormat("void foobar()\n"
13033                "  {\n"
13034                "  int i = 5;\n"
13035                "  }\n"
13036                "#ifdef _DEBUG\n"
13037                "void bar()\n"
13038                "  {\n"
13039                "  }\n"
13040                "#else\n"
13041                "void bar()\n"
13042                "  {\n"
13043                "  foobar();\n"
13044                "  }\n"
13045                "#endif",
13046                WhitesmithsBraceStyle);
13047 
13048   // This shouldn't affect ObjC blocks..
13049   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13050                "  // ...\n"
13051                "  int i;\n"
13052                "}];",
13053                WhitesmithsBraceStyle);
13054   verifyFormat("void (^block)(void) = ^{\n"
13055                "  // ...\n"
13056                "  int i;\n"
13057                "};",
13058                WhitesmithsBraceStyle);
13059   // .. or dict literals.
13060   verifyFormat("void f()\n"
13061                "  {\n"
13062                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13063                "  }",
13064                WhitesmithsBraceStyle);
13065 
13066   verifyFormat("int f()\n"
13067                "  { // comment\n"
13068                "  return 42;\n"
13069                "  }",
13070                WhitesmithsBraceStyle);
13071 
13072   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13073   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13074       FormatStyle::SIS_Always;
13075   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13076   verifyFormat("void f(bool b)\n"
13077                "  {\n"
13078                "  if (b)\n"
13079                "    {\n"
13080                "    return;\n"
13081                "    }\n"
13082                "  }\n",
13083                BreakBeforeBraceShortIfs);
13084   verifyFormat("void f(bool b)\n"
13085                "  {\n"
13086                "  if (b) return;\n"
13087                "  }\n",
13088                BreakBeforeBraceShortIfs);
13089   verifyFormat("void f(bool b)\n"
13090                "  {\n"
13091                "  while (b)\n"
13092                "    {\n"
13093                "    return;\n"
13094                "    }\n"
13095                "  }\n",
13096                BreakBeforeBraceShortIfs);
13097 }
13098 
13099 TEST_F(FormatTest, GNUBraceBreaking) {
13100   FormatStyle GNUBraceStyle = getLLVMStyle();
13101   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13102   verifyFormat("namespace a\n"
13103                "{\n"
13104                "class A\n"
13105                "{\n"
13106                "  void f()\n"
13107                "  {\n"
13108                "    int a;\n"
13109                "    {\n"
13110                "      int b;\n"
13111                "    }\n"
13112                "    if (true)\n"
13113                "      {\n"
13114                "        a();\n"
13115                "        b();\n"
13116                "      }\n"
13117                "  }\n"
13118                "  void g() { return; }\n"
13119                "}\n"
13120                "} // namespace a",
13121                GNUBraceStyle);
13122 
13123   verifyFormat("void f()\n"
13124                "{\n"
13125                "  if (true)\n"
13126                "    {\n"
13127                "      a();\n"
13128                "    }\n"
13129                "  else if (false)\n"
13130                "    {\n"
13131                "      b();\n"
13132                "    }\n"
13133                "  else\n"
13134                "    {\n"
13135                "      c();\n"
13136                "    }\n"
13137                "}\n",
13138                GNUBraceStyle);
13139 
13140   verifyFormat("void f()\n"
13141                "{\n"
13142                "  for (int i = 0; i < 10; ++i)\n"
13143                "    {\n"
13144                "      a();\n"
13145                "    }\n"
13146                "  while (false)\n"
13147                "    {\n"
13148                "      b();\n"
13149                "    }\n"
13150                "  do\n"
13151                "    {\n"
13152                "      c();\n"
13153                "    }\n"
13154                "  while (false);\n"
13155                "}\n",
13156                GNUBraceStyle);
13157 
13158   verifyFormat("void f(int a)\n"
13159                "{\n"
13160                "  switch (a)\n"
13161                "    {\n"
13162                "    case 0:\n"
13163                "      break;\n"
13164                "    case 1:\n"
13165                "      {\n"
13166                "        break;\n"
13167                "      }\n"
13168                "    case 2:\n"
13169                "      {\n"
13170                "      }\n"
13171                "      break;\n"
13172                "    default:\n"
13173                "      break;\n"
13174                "    }\n"
13175                "}\n",
13176                GNUBraceStyle);
13177 
13178   verifyFormat("enum X\n"
13179                "{\n"
13180                "  Y = 0,\n"
13181                "}\n",
13182                GNUBraceStyle);
13183 
13184   verifyFormat("@interface BSApplicationController ()\n"
13185                "{\n"
13186                "@private\n"
13187                "  id _extraIvar;\n"
13188                "}\n"
13189                "@end\n",
13190                GNUBraceStyle);
13191 
13192   verifyFormat("#ifdef _DEBUG\n"
13193                "int foo(int i = 0)\n"
13194                "#else\n"
13195                "int foo(int i = 5)\n"
13196                "#endif\n"
13197                "{\n"
13198                "  return i;\n"
13199                "}",
13200                GNUBraceStyle);
13201 
13202   verifyFormat("void foo() {}\n"
13203                "void bar()\n"
13204                "#ifdef _DEBUG\n"
13205                "{\n"
13206                "  foo();\n"
13207                "}\n"
13208                "#else\n"
13209                "{\n"
13210                "}\n"
13211                "#endif",
13212                GNUBraceStyle);
13213 
13214   verifyFormat("void foobar() { int i = 5; }\n"
13215                "#ifdef _DEBUG\n"
13216                "void bar() {}\n"
13217                "#else\n"
13218                "void bar() { foobar(); }\n"
13219                "#endif",
13220                GNUBraceStyle);
13221 }
13222 
13223 TEST_F(FormatTest, WebKitBraceBreaking) {
13224   FormatStyle WebKitBraceStyle = getLLVMStyle();
13225   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13226   WebKitBraceStyle.FixNamespaceComments = false;
13227   verifyFormat("namespace a {\n"
13228                "class A {\n"
13229                "  void f()\n"
13230                "  {\n"
13231                "    if (true) {\n"
13232                "      a();\n"
13233                "      b();\n"
13234                "    }\n"
13235                "  }\n"
13236                "  void g() { return; }\n"
13237                "};\n"
13238                "enum E {\n"
13239                "  A,\n"
13240                "  // foo\n"
13241                "  B,\n"
13242                "  C\n"
13243                "};\n"
13244                "struct B {\n"
13245                "  int x;\n"
13246                "};\n"
13247                "}\n",
13248                WebKitBraceStyle);
13249   verifyFormat("struct S {\n"
13250                "  int Type;\n"
13251                "  union {\n"
13252                "    int x;\n"
13253                "    double y;\n"
13254                "  } Value;\n"
13255                "  class C {\n"
13256                "    MyFavoriteType Value;\n"
13257                "  } Class;\n"
13258                "};\n",
13259                WebKitBraceStyle);
13260 }
13261 
13262 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13263   verifyFormat("void f() {\n"
13264                "  try {\n"
13265                "  } catch (const Exception &e) {\n"
13266                "  }\n"
13267                "}\n",
13268                getLLVMStyle());
13269 }
13270 
13271 TEST_F(FormatTest, UnderstandsPragmas) {
13272   verifyFormat("#pragma omp reduction(| : var)");
13273   verifyFormat("#pragma omp reduction(+ : var)");
13274 
13275   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13276             "(including parentheses).",
13277             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13278                    "(including parentheses)."));
13279 }
13280 
13281 TEST_F(FormatTest, UnderstandPragmaOption) {
13282   verifyFormat("#pragma option -C -A");
13283 
13284   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13285 }
13286 
13287 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13288   FormatStyle Style = getLLVMStyle();
13289   Style.ColumnLimit = 20;
13290 
13291   // See PR41213
13292   EXPECT_EQ("/*\n"
13293             " *\t9012345\n"
13294             " * /8901\n"
13295             " */",
13296             format("/*\n"
13297                    " *\t9012345 /8901\n"
13298                    " */",
13299                    Style));
13300   EXPECT_EQ("/*\n"
13301             " *345678\n"
13302             " *\t/8901\n"
13303             " */",
13304             format("/*\n"
13305                    " *345678\t/8901\n"
13306                    " */",
13307                    Style));
13308 
13309   verifyFormat("int a; // the\n"
13310                "       // comment",
13311                Style);
13312   EXPECT_EQ("int a; /* first line\n"
13313             "        * second\n"
13314             "        * line third\n"
13315             "        * line\n"
13316             "        */",
13317             format("int a; /* first line\n"
13318                    "        * second\n"
13319                    "        * line third\n"
13320                    "        * line\n"
13321                    "        */",
13322                    Style));
13323   EXPECT_EQ("int a; // first line\n"
13324             "       // second\n"
13325             "       // line third\n"
13326             "       // line",
13327             format("int a; // first line\n"
13328                    "       // second line\n"
13329                    "       // third line",
13330                    Style));
13331 
13332   Style.PenaltyExcessCharacter = 90;
13333   verifyFormat("int a; // the comment", Style);
13334   EXPECT_EQ("int a; // the comment\n"
13335             "       // aaa",
13336             format("int a; // the comment aaa", Style));
13337   EXPECT_EQ("int a; /* first line\n"
13338             "        * second line\n"
13339             "        * third line\n"
13340             "        */",
13341             format("int a; /* first line\n"
13342                    "        * second line\n"
13343                    "        * third line\n"
13344                    "        */",
13345                    Style));
13346   EXPECT_EQ("int a; // first line\n"
13347             "       // second line\n"
13348             "       // third line",
13349             format("int a; // first line\n"
13350                    "       // second line\n"
13351                    "       // third line",
13352                    Style));
13353   // FIXME: Investigate why this is not getting the same layout as the test
13354   // above.
13355   EXPECT_EQ("int a; /* first line\n"
13356             "        * second line\n"
13357             "        * third line\n"
13358             "        */",
13359             format("int a; /* first line second line third line"
13360                    "\n*/",
13361                    Style));
13362 
13363   EXPECT_EQ("// foo bar baz bazfoo\n"
13364             "// foo bar foo bar\n",
13365             format("// foo bar baz bazfoo\n"
13366                    "// foo bar foo           bar\n",
13367                    Style));
13368   EXPECT_EQ("// foo bar baz bazfoo\n"
13369             "// foo bar foo bar\n",
13370             format("// foo bar baz      bazfoo\n"
13371                    "// foo            bar foo bar\n",
13372                    Style));
13373 
13374   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13375   // next one.
13376   EXPECT_EQ("// foo bar baz bazfoo\n"
13377             "// bar foo bar\n",
13378             format("// foo bar baz      bazfoo bar\n"
13379                    "// foo            bar\n",
13380                    Style));
13381 
13382   EXPECT_EQ("// foo bar baz bazfoo\n"
13383             "// foo bar baz bazfoo\n"
13384             "// bar foo bar\n",
13385             format("// foo bar baz      bazfoo\n"
13386                    "// foo bar baz      bazfoo bar\n"
13387                    "// foo bar\n",
13388                    Style));
13389 
13390   EXPECT_EQ("// foo bar baz bazfoo\n"
13391             "// foo bar baz bazfoo\n"
13392             "// bar foo bar\n",
13393             format("// foo bar baz      bazfoo\n"
13394                    "// foo bar baz      bazfoo bar\n"
13395                    "// foo           bar\n",
13396                    Style));
13397 
13398   // Make sure we do not keep protruding characters if strict mode reflow is
13399   // cheaper than keeping protruding characters.
13400   Style.ColumnLimit = 21;
13401   EXPECT_EQ(
13402       "// foo foo foo foo\n"
13403       "// foo foo foo foo\n"
13404       "// foo foo foo foo\n",
13405       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13406 
13407   EXPECT_EQ("int a = /* long block\n"
13408             "           comment */\n"
13409             "    42;",
13410             format("int a = /* long block comment */ 42;", Style));
13411 }
13412 
13413 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13414   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13415   EXPECT_EQ(Styles[0], Styles[i])                                              \
13416       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13417 
13418 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13419   SmallVector<FormatStyle, 3> Styles;
13420   Styles.resize(3);
13421 
13422   Styles[0] = getLLVMStyle();
13423   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13424   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13425   EXPECT_ALL_STYLES_EQUAL(Styles);
13426 
13427   Styles[0] = getGoogleStyle();
13428   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13429   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13430   EXPECT_ALL_STYLES_EQUAL(Styles);
13431 
13432   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13433   EXPECT_TRUE(
13434       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13435   EXPECT_TRUE(
13436       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13437   EXPECT_ALL_STYLES_EQUAL(Styles);
13438 
13439   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13440   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13441   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
13442   EXPECT_ALL_STYLES_EQUAL(Styles);
13443 
13444   Styles[0] = getMozillaStyle();
13445   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
13446   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
13447   EXPECT_ALL_STYLES_EQUAL(Styles);
13448 
13449   Styles[0] = getWebKitStyle();
13450   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
13451   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
13452   EXPECT_ALL_STYLES_EQUAL(Styles);
13453 
13454   Styles[0] = getGNUStyle();
13455   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
13456   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
13457   EXPECT_ALL_STYLES_EQUAL(Styles);
13458 
13459   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
13460 }
13461 
13462 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
13463   SmallVector<FormatStyle, 8> Styles;
13464   Styles.resize(2);
13465 
13466   Styles[0] = getGoogleStyle();
13467   Styles[1] = getLLVMStyle();
13468   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13469   EXPECT_ALL_STYLES_EQUAL(Styles);
13470 
13471   Styles.resize(5);
13472   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13473   Styles[1] = getLLVMStyle();
13474   Styles[1].Language = FormatStyle::LK_JavaScript;
13475   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13476 
13477   Styles[2] = getLLVMStyle();
13478   Styles[2].Language = FormatStyle::LK_JavaScript;
13479   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
13480                                   "BasedOnStyle: Google",
13481                                   &Styles[2])
13482                    .value());
13483 
13484   Styles[3] = getLLVMStyle();
13485   Styles[3].Language = FormatStyle::LK_JavaScript;
13486   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
13487                                   "Language: JavaScript",
13488                                   &Styles[3])
13489                    .value());
13490 
13491   Styles[4] = getLLVMStyle();
13492   Styles[4].Language = FormatStyle::LK_JavaScript;
13493   EXPECT_EQ(0, parseConfiguration("---\n"
13494                                   "BasedOnStyle: LLVM\n"
13495                                   "IndentWidth: 123\n"
13496                                   "---\n"
13497                                   "BasedOnStyle: Google\n"
13498                                   "Language: JavaScript",
13499                                   &Styles[4])
13500                    .value());
13501   EXPECT_ALL_STYLES_EQUAL(Styles);
13502 }
13503 
13504 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
13505   Style.FIELD = false;                                                         \
13506   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
13507   EXPECT_TRUE(Style.FIELD);                                                    \
13508   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
13509   EXPECT_FALSE(Style.FIELD);
13510 
13511 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
13512 
13513 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
13514   Style.STRUCT.FIELD = false;                                                  \
13515   EXPECT_EQ(0,                                                                 \
13516             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
13517                 .value());                                                     \
13518   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
13519   EXPECT_EQ(0,                                                                 \
13520             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
13521                 .value());                                                     \
13522   EXPECT_FALSE(Style.STRUCT.FIELD);
13523 
13524 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
13525   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
13526 
13527 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
13528   EXPECT_NE(VALUE, Style.FIELD);                                               \
13529   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
13530   EXPECT_EQ(VALUE, Style.FIELD)
13531 
13532 TEST_F(FormatTest, ParsesConfigurationBools) {
13533   FormatStyle Style = {};
13534   Style.Language = FormatStyle::LK_Cpp;
13535   CHECK_PARSE_BOOL(AlignTrailingComments);
13536   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
13537   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
13538   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
13539   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
13540   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
13541   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
13542   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
13543   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
13544   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
13545   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
13546   CHECK_PARSE_BOOL(BinPackArguments);
13547   CHECK_PARSE_BOOL(BinPackParameters);
13548   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
13549   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
13550   CHECK_PARSE_BOOL(BreakStringLiterals);
13551   CHECK_PARSE_BOOL(CompactNamespaces);
13552   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
13553   CHECK_PARSE_BOOL(DeriveLineEnding);
13554   CHECK_PARSE_BOOL(DerivePointerAlignment);
13555   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
13556   CHECK_PARSE_BOOL(DisableFormat);
13557   CHECK_PARSE_BOOL(IndentCaseLabels);
13558   CHECK_PARSE_BOOL(IndentCaseBlocks);
13559   CHECK_PARSE_BOOL(IndentGotoLabels);
13560   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
13561   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
13562   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
13563   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
13564   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
13565   CHECK_PARSE_BOOL(ReflowComments);
13566   CHECK_PARSE_BOOL(SortIncludes);
13567   CHECK_PARSE_BOOL(SortUsingDeclarations);
13568   CHECK_PARSE_BOOL(SpacesInParentheses);
13569   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
13570   CHECK_PARSE_BOOL(SpacesInAngles);
13571   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
13572   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
13573   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
13574   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
13575   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
13576   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
13577   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
13578   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
13579   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
13580   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
13581   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
13582   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
13583   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
13584   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
13585   CHECK_PARSE_BOOL(UseCRLF);
13586 
13587   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
13588   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
13589   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
13590   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
13591   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
13592   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
13593   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
13594   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
13595   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
13596   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
13597   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
13598   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
13599   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
13600   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
13601   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
13602   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
13603   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
13604 }
13605 
13606 #undef CHECK_PARSE_BOOL
13607 
13608 TEST_F(FormatTest, ParsesConfiguration) {
13609   FormatStyle Style = {};
13610   Style.Language = FormatStyle::LK_Cpp;
13611   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
13612   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
13613               ConstructorInitializerIndentWidth, 1234u);
13614   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
13615   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
13616   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
13617   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
13618   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
13619               PenaltyBreakBeforeFirstCallParameter, 1234u);
13620   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
13621               PenaltyBreakTemplateDeclaration, 1234u);
13622   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
13623   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
13624               PenaltyReturnTypeOnItsOwnLine, 1234u);
13625   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
13626               SpacesBeforeTrailingComments, 1234u);
13627   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
13628   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
13629   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
13630 
13631   Style.PointerAlignment = FormatStyle::PAS_Middle;
13632   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
13633               FormatStyle::PAS_Left);
13634   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
13635               FormatStyle::PAS_Right);
13636   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
13637               FormatStyle::PAS_Middle);
13638   // For backward compatibility:
13639   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
13640               FormatStyle::PAS_Left);
13641   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
13642               FormatStyle::PAS_Right);
13643   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
13644               FormatStyle::PAS_Middle);
13645 
13646   Style.Standard = FormatStyle::LS_Auto;
13647   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
13648   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
13649   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
13650   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
13651   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
13652   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
13653   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
13654   // Legacy aliases:
13655   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
13656   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
13657   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
13658   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
13659 
13660   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13661   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
13662               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
13663   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
13664               FormatStyle::BOS_None);
13665   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
13666               FormatStyle::BOS_All);
13667   // For backward compatibility:
13668   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
13669               FormatStyle::BOS_None);
13670   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
13671               FormatStyle::BOS_All);
13672 
13673   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
13674   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
13675               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13676   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
13677               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
13678   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
13679               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
13680   // For backward compatibility:
13681   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
13682               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13683 
13684   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
13685   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
13686               FormatStyle::BILS_BeforeComma);
13687   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
13688               FormatStyle::BILS_AfterColon);
13689   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
13690               FormatStyle::BILS_BeforeColon);
13691   // For backward compatibility:
13692   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
13693               FormatStyle::BILS_BeforeComma);
13694 
13695   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
13696   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
13697               FormatStyle::BAS_Align);
13698   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
13699               FormatStyle::BAS_DontAlign);
13700   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
13701               FormatStyle::BAS_AlwaysBreak);
13702   // For backward compatibility:
13703   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
13704               FormatStyle::BAS_DontAlign);
13705   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
13706               FormatStyle::BAS_Align);
13707 
13708   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13709   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
13710               FormatStyle::ENAS_DontAlign);
13711   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
13712               FormatStyle::ENAS_Left);
13713   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
13714               FormatStyle::ENAS_Right);
13715   // For backward compatibility:
13716   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
13717               FormatStyle::ENAS_Left);
13718   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
13719               FormatStyle::ENAS_Right);
13720 
13721   Style.AlignOperands = FormatStyle::OAS_Align;
13722   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
13723               FormatStyle::OAS_DontAlign);
13724   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
13725   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
13726               FormatStyle::OAS_AlignAfterOperator);
13727   // For backward compatibility:
13728   CHECK_PARSE("AlignOperands: false", AlignOperands,
13729               FormatStyle::OAS_DontAlign);
13730   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
13731 
13732   Style.UseTab = FormatStyle::UT_ForIndentation;
13733   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
13734   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
13735   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
13736   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
13737               FormatStyle::UT_ForContinuationAndIndentation);
13738   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
13739               FormatStyle::UT_AlignWithSpaces);
13740   // For backward compatibility:
13741   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
13742   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
13743 
13744   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
13745   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
13746               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13747   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
13748               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
13749   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
13750               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13751   // For backward compatibility:
13752   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
13753               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13754   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
13755               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13756 
13757   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
13758   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
13759               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13760   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
13761               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
13762   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
13763               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
13764   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
13765               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13766   // For backward compatibility:
13767   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
13768               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13769   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
13770               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13771 
13772   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
13773   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
13774               FormatStyle::SBPO_Never);
13775   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
13776               FormatStyle::SBPO_Always);
13777   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
13778               FormatStyle::SBPO_ControlStatements);
13779   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
13780               FormatStyle::SBPO_NonEmptyParentheses);
13781   // For backward compatibility:
13782   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
13783               FormatStyle::SBPO_Never);
13784   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
13785               FormatStyle::SBPO_ControlStatements);
13786 
13787   Style.ColumnLimit = 123;
13788   FormatStyle BaseStyle = getLLVMStyle();
13789   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
13790   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
13791 
13792   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
13793   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
13794               FormatStyle::BS_Attach);
13795   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
13796               FormatStyle::BS_Linux);
13797   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
13798               FormatStyle::BS_Mozilla);
13799   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
13800               FormatStyle::BS_Stroustrup);
13801   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
13802               FormatStyle::BS_Allman);
13803   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
13804               FormatStyle::BS_Whitesmiths);
13805   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
13806   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
13807               FormatStyle::BS_WebKit);
13808   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
13809               FormatStyle::BS_Custom);
13810 
13811   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
13812   CHECK_PARSE("BraceWrapping:\n"
13813               "  AfterControlStatement: MultiLine",
13814               BraceWrapping.AfterControlStatement,
13815               FormatStyle::BWACS_MultiLine);
13816   CHECK_PARSE("BraceWrapping:\n"
13817               "  AfterControlStatement: Always",
13818               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13819   CHECK_PARSE("BraceWrapping:\n"
13820               "  AfterControlStatement: Never",
13821               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13822   // For backward compatibility:
13823   CHECK_PARSE("BraceWrapping:\n"
13824               "  AfterControlStatement: true",
13825               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13826   CHECK_PARSE("BraceWrapping:\n"
13827               "  AfterControlStatement: false",
13828               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13829 
13830   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
13831   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
13832               FormatStyle::RTBS_None);
13833   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
13834               FormatStyle::RTBS_All);
13835   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
13836               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
13837   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
13838               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
13839   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
13840               AlwaysBreakAfterReturnType,
13841               FormatStyle::RTBS_TopLevelDefinitions);
13842 
13843   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
13844   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
13845               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
13846   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
13847               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
13848   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
13849               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
13850   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
13851               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
13852   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
13853               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
13854 
13855   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
13856   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
13857               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
13858   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
13859               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
13860   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
13861               AlwaysBreakAfterDefinitionReturnType,
13862               FormatStyle::DRTBS_TopLevel);
13863 
13864   Style.NamespaceIndentation = FormatStyle::NI_All;
13865   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
13866               FormatStyle::NI_None);
13867   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
13868               FormatStyle::NI_Inner);
13869   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
13870               FormatStyle::NI_All);
13871 
13872   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
13873   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
13874               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
13875   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
13876               AllowShortIfStatementsOnASingleLine,
13877               FormatStyle::SIS_WithoutElse);
13878   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
13879               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
13880   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
13881               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
13882   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
13883               AllowShortIfStatementsOnASingleLine,
13884               FormatStyle::SIS_WithoutElse);
13885 
13886   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
13887   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
13888               FormatStyle::IEBS_AfterExternBlock);
13889   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
13890               FormatStyle::IEBS_Indent);
13891   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
13892               FormatStyle::IEBS_NoIndent);
13893   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
13894               FormatStyle::IEBS_Indent);
13895   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
13896               FormatStyle::IEBS_NoIndent);
13897 
13898   // FIXME: This is required because parsing a configuration simply overwrites
13899   // the first N elements of the list instead of resetting it.
13900   Style.ForEachMacros.clear();
13901   std::vector<std::string> BoostForeach;
13902   BoostForeach.push_back("BOOST_FOREACH");
13903   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
13904   std::vector<std::string> BoostAndQForeach;
13905   BoostAndQForeach.push_back("BOOST_FOREACH");
13906   BoostAndQForeach.push_back("Q_FOREACH");
13907   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
13908               BoostAndQForeach);
13909 
13910   Style.StatementMacros.clear();
13911   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
13912               std::vector<std::string>{"QUNUSED"});
13913   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
13914               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
13915 
13916   Style.NamespaceMacros.clear();
13917   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
13918               std::vector<std::string>{"TESTSUITE"});
13919   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
13920               std::vector<std::string>({"TESTSUITE", "SUITE"}));
13921 
13922   Style.IncludeStyle.IncludeCategories.clear();
13923   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
13924       {"abc/.*", 2, 0}, {".*", 1, 0}};
13925   CHECK_PARSE("IncludeCategories:\n"
13926               "  - Regex: abc/.*\n"
13927               "    Priority: 2\n"
13928               "  - Regex: .*\n"
13929               "    Priority: 1",
13930               IncludeStyle.IncludeCategories, ExpectedCategories);
13931   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
13932               "abc$");
13933   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
13934               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
13935 
13936   Style.RawStringFormats.clear();
13937   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
13938       {
13939           FormatStyle::LK_TextProto,
13940           {"pb", "proto"},
13941           {"PARSE_TEXT_PROTO"},
13942           /*CanonicalDelimiter=*/"",
13943           "llvm",
13944       },
13945       {
13946           FormatStyle::LK_Cpp,
13947           {"cc", "cpp"},
13948           {"C_CODEBLOCK", "CPPEVAL"},
13949           /*CanonicalDelimiter=*/"cc",
13950           /*BasedOnStyle=*/"",
13951       },
13952   };
13953 
13954   CHECK_PARSE("RawStringFormats:\n"
13955               "  - Language: TextProto\n"
13956               "    Delimiters:\n"
13957               "      - 'pb'\n"
13958               "      - 'proto'\n"
13959               "    EnclosingFunctions:\n"
13960               "      - 'PARSE_TEXT_PROTO'\n"
13961               "    BasedOnStyle: llvm\n"
13962               "  - Language: Cpp\n"
13963               "    Delimiters:\n"
13964               "      - 'cc'\n"
13965               "      - 'cpp'\n"
13966               "    EnclosingFunctions:\n"
13967               "      - 'C_CODEBLOCK'\n"
13968               "      - 'CPPEVAL'\n"
13969               "    CanonicalDelimiter: 'cc'",
13970               RawStringFormats, ExpectedRawStringFormats);
13971 }
13972 
13973 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
13974   FormatStyle Style = {};
13975   Style.Language = FormatStyle::LK_Cpp;
13976   CHECK_PARSE("Language: Cpp\n"
13977               "IndentWidth: 12",
13978               IndentWidth, 12u);
13979   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
13980                                "IndentWidth: 34",
13981                                &Style),
13982             ParseError::Unsuitable);
13983   FormatStyle BinPackedTCS = {};
13984   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
13985   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
13986                                "InsertTrailingCommas: Wrapped",
13987                                &BinPackedTCS),
13988             ParseError::BinPackTrailingCommaConflict);
13989   EXPECT_EQ(12u, Style.IndentWidth);
13990   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
13991   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
13992 
13993   Style.Language = FormatStyle::LK_JavaScript;
13994   CHECK_PARSE("Language: JavaScript\n"
13995               "IndentWidth: 12",
13996               IndentWidth, 12u);
13997   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
13998   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
13999                                "IndentWidth: 34",
14000                                &Style),
14001             ParseError::Unsuitable);
14002   EXPECT_EQ(23u, Style.IndentWidth);
14003   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14004   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14005 
14006   CHECK_PARSE("BasedOnStyle: LLVM\n"
14007               "IndentWidth: 67",
14008               IndentWidth, 67u);
14009 
14010   CHECK_PARSE("---\n"
14011               "Language: JavaScript\n"
14012               "IndentWidth: 12\n"
14013               "---\n"
14014               "Language: Cpp\n"
14015               "IndentWidth: 34\n"
14016               "...\n",
14017               IndentWidth, 12u);
14018 
14019   Style.Language = FormatStyle::LK_Cpp;
14020   CHECK_PARSE("---\n"
14021               "Language: JavaScript\n"
14022               "IndentWidth: 12\n"
14023               "---\n"
14024               "Language: Cpp\n"
14025               "IndentWidth: 34\n"
14026               "...\n",
14027               IndentWidth, 34u);
14028   CHECK_PARSE("---\n"
14029               "IndentWidth: 78\n"
14030               "---\n"
14031               "Language: JavaScript\n"
14032               "IndentWidth: 56\n"
14033               "...\n",
14034               IndentWidth, 78u);
14035 
14036   Style.ColumnLimit = 123;
14037   Style.IndentWidth = 234;
14038   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14039   Style.TabWidth = 345;
14040   EXPECT_FALSE(parseConfiguration("---\n"
14041                                   "IndentWidth: 456\n"
14042                                   "BreakBeforeBraces: Allman\n"
14043                                   "---\n"
14044                                   "Language: JavaScript\n"
14045                                   "IndentWidth: 111\n"
14046                                   "TabWidth: 111\n"
14047                                   "---\n"
14048                                   "Language: Cpp\n"
14049                                   "BreakBeforeBraces: Stroustrup\n"
14050                                   "TabWidth: 789\n"
14051                                   "...\n",
14052                                   &Style));
14053   EXPECT_EQ(123u, Style.ColumnLimit);
14054   EXPECT_EQ(456u, Style.IndentWidth);
14055   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14056   EXPECT_EQ(789u, Style.TabWidth);
14057 
14058   EXPECT_EQ(parseConfiguration("---\n"
14059                                "Language: JavaScript\n"
14060                                "IndentWidth: 56\n"
14061                                "---\n"
14062                                "IndentWidth: 78\n"
14063                                "...\n",
14064                                &Style),
14065             ParseError::Error);
14066   EXPECT_EQ(parseConfiguration("---\n"
14067                                "Language: JavaScript\n"
14068                                "IndentWidth: 56\n"
14069                                "---\n"
14070                                "Language: JavaScript\n"
14071                                "IndentWidth: 78\n"
14072                                "...\n",
14073                                &Style),
14074             ParseError::Error);
14075 
14076   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14077 }
14078 
14079 #undef CHECK_PARSE
14080 
14081 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14082   FormatStyle Style = {};
14083   Style.Language = FormatStyle::LK_JavaScript;
14084   Style.BreakBeforeTernaryOperators = true;
14085   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14086   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14087 
14088   Style.BreakBeforeTernaryOperators = true;
14089   EXPECT_EQ(0, parseConfiguration("---\n"
14090                                   "BasedOnStyle: Google\n"
14091                                   "---\n"
14092                                   "Language: JavaScript\n"
14093                                   "IndentWidth: 76\n"
14094                                   "...\n",
14095                                   &Style)
14096                    .value());
14097   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14098   EXPECT_EQ(76u, Style.IndentWidth);
14099   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14100 }
14101 
14102 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14103   FormatStyle Style = getLLVMStyle();
14104   std::string YAML = configurationAsText(Style);
14105   FormatStyle ParsedStyle = {};
14106   ParsedStyle.Language = FormatStyle::LK_Cpp;
14107   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14108   EXPECT_EQ(Style, ParsedStyle);
14109 }
14110 
14111 TEST_F(FormatTest, WorksFor8bitEncodings) {
14112   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14113             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14114             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14115             "\"\xef\xee\xf0\xf3...\"",
14116             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14117                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14118                    "\xef\xee\xf0\xf3...\"",
14119                    getLLVMStyleWithColumns(12)));
14120 }
14121 
14122 TEST_F(FormatTest, HandlesUTF8BOM) {
14123   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14124   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14125             format("\xef\xbb\xbf#include <iostream>"));
14126   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14127             format("\xef\xbb\xbf\n#include <iostream>"));
14128 }
14129 
14130 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14131 #if !defined(_MSC_VER)
14132 
14133 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14134   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14135                getLLVMStyleWithColumns(35));
14136   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14137                getLLVMStyleWithColumns(31));
14138   verifyFormat("// Однажды в студёную зимнюю пору...",
14139                getLLVMStyleWithColumns(36));
14140   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14141   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14142                getLLVMStyleWithColumns(39));
14143   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14144                getLLVMStyleWithColumns(35));
14145 }
14146 
14147 TEST_F(FormatTest, SplitsUTF8Strings) {
14148   // Non-printable characters' width is currently considered to be the length in
14149   // bytes in UTF8. The characters can be displayed in very different manner
14150   // (zero-width, single width with a substitution glyph, expanded to their code
14151   // (e.g. "<8d>"), so there's no single correct way to handle them.
14152   EXPECT_EQ("\"aaaaÄ\"\n"
14153             "\"\xc2\x8d\";",
14154             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14155   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14156             "\"\xc2\x8d\";",
14157             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14158   EXPECT_EQ("\"Однажды, в \"\n"
14159             "\"студёную \"\n"
14160             "\"зимнюю \"\n"
14161             "\"пору,\"",
14162             format("\"Однажды, в студёную зимнюю пору,\"",
14163                    getLLVMStyleWithColumns(13)));
14164   EXPECT_EQ(
14165       "\"一 二 三 \"\n"
14166       "\"四 五六 \"\n"
14167       "\"七 八 九 \"\n"
14168       "\"十\"",
14169       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14170   EXPECT_EQ("\"一\t\"\n"
14171             "\"二 \t\"\n"
14172             "\"三 四 \"\n"
14173             "\"五\t\"\n"
14174             "\"六 \t\"\n"
14175             "\"七 \"\n"
14176             "\"八九十\tqq\"",
14177             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14178                    getLLVMStyleWithColumns(11)));
14179 
14180   // UTF8 character in an escape sequence.
14181   EXPECT_EQ("\"aaaaaa\"\n"
14182             "\"\\\xC2\x8D\"",
14183             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14184 }
14185 
14186 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14187   EXPECT_EQ("const char *sssss =\n"
14188             "    \"一二三四五六七八\\\n"
14189             " 九 十\";",
14190             format("const char *sssss = \"一二三四五六七八\\\n"
14191                    " 九 十\";",
14192                    getLLVMStyleWithColumns(30)));
14193 }
14194 
14195 TEST_F(FormatTest, SplitsUTF8LineComments) {
14196   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14197             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14198   EXPECT_EQ("// Я из лесу\n"
14199             "// вышел; был\n"
14200             "// сильный\n"
14201             "// мороз.",
14202             format("// Я из лесу вышел; был сильный мороз.",
14203                    getLLVMStyleWithColumns(13)));
14204   EXPECT_EQ("// 一二三\n"
14205             "// 四五六七\n"
14206             "// 八  九\n"
14207             "// 十",
14208             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14209 }
14210 
14211 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14212   EXPECT_EQ("/* Гляжу,\n"
14213             " * поднимается\n"
14214             " * медленно в\n"
14215             " * гору\n"
14216             " * Лошадка,\n"
14217             " * везущая\n"
14218             " * хворосту\n"
14219             " * воз. */",
14220             format("/* Гляжу, поднимается медленно в гору\n"
14221                    " * Лошадка, везущая хворосту воз. */",
14222                    getLLVMStyleWithColumns(13)));
14223   EXPECT_EQ(
14224       "/* 一二三\n"
14225       " * 四五六七\n"
14226       " * 八  九\n"
14227       " * 十  */",
14228       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14229   EXPECT_EQ("/* �������� ��������\n"
14230             " * ��������\n"
14231             " * ������-�� */",
14232             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14233 }
14234 
14235 #endif // _MSC_VER
14236 
14237 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14238   FormatStyle Style = getLLVMStyle();
14239 
14240   Style.ConstructorInitializerIndentWidth = 4;
14241   verifyFormat(
14242       "SomeClass::Constructor()\n"
14243       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14244       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14245       Style);
14246 
14247   Style.ConstructorInitializerIndentWidth = 2;
14248   verifyFormat(
14249       "SomeClass::Constructor()\n"
14250       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14251       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14252       Style);
14253 
14254   Style.ConstructorInitializerIndentWidth = 0;
14255   verifyFormat(
14256       "SomeClass::Constructor()\n"
14257       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14258       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14259       Style);
14260   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14261   verifyFormat(
14262       "SomeLongTemplateVariableName<\n"
14263       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14264       Style);
14265   verifyFormat("bool smaller = 1 < "
14266                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14267                "                       "
14268                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14269                Style);
14270 
14271   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14272   verifyFormat("SomeClass::Constructor() :\n"
14273                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14274                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14275                Style);
14276 }
14277 
14278 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14279   FormatStyle Style = getLLVMStyle();
14280   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14281   Style.ConstructorInitializerIndentWidth = 4;
14282   verifyFormat("SomeClass::Constructor()\n"
14283                "    : a(a)\n"
14284                "    , b(b)\n"
14285                "    , c(c) {}",
14286                Style);
14287   verifyFormat("SomeClass::Constructor()\n"
14288                "    : a(a) {}",
14289                Style);
14290 
14291   Style.ColumnLimit = 0;
14292   verifyFormat("SomeClass::Constructor()\n"
14293                "    : a(a) {}",
14294                Style);
14295   verifyFormat("SomeClass::Constructor() noexcept\n"
14296                "    : a(a) {}",
14297                Style);
14298   verifyFormat("SomeClass::Constructor()\n"
14299                "    : a(a)\n"
14300                "    , b(b)\n"
14301                "    , c(c) {}",
14302                Style);
14303   verifyFormat("SomeClass::Constructor()\n"
14304                "    : a(a) {\n"
14305                "  foo();\n"
14306                "  bar();\n"
14307                "}",
14308                Style);
14309 
14310   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14311   verifyFormat("SomeClass::Constructor()\n"
14312                "    : a(a)\n"
14313                "    , b(b)\n"
14314                "    , c(c) {\n}",
14315                Style);
14316   verifyFormat("SomeClass::Constructor()\n"
14317                "    : a(a) {\n}",
14318                Style);
14319 
14320   Style.ColumnLimit = 80;
14321   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14322   Style.ConstructorInitializerIndentWidth = 2;
14323   verifyFormat("SomeClass::Constructor()\n"
14324                "  : a(a)\n"
14325                "  , b(b)\n"
14326                "  , c(c) {}",
14327                Style);
14328 
14329   Style.ConstructorInitializerIndentWidth = 0;
14330   verifyFormat("SomeClass::Constructor()\n"
14331                ": a(a)\n"
14332                ", b(b)\n"
14333                ", c(c) {}",
14334                Style);
14335 
14336   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14337   Style.ConstructorInitializerIndentWidth = 4;
14338   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14339   verifyFormat(
14340       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14341       Style);
14342   verifyFormat(
14343       "SomeClass::Constructor()\n"
14344       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14345       Style);
14346   Style.ConstructorInitializerIndentWidth = 4;
14347   Style.ColumnLimit = 60;
14348   verifyFormat("SomeClass::Constructor()\n"
14349                "    : aaaaaaaa(aaaaaaaa)\n"
14350                "    , aaaaaaaa(aaaaaaaa)\n"
14351                "    , aaaaaaaa(aaaaaaaa) {}",
14352                Style);
14353 }
14354 
14355 TEST_F(FormatTest, Destructors) {
14356   verifyFormat("void F(int &i) { i.~int(); }");
14357   verifyFormat("void F(int &i) { i->~int(); }");
14358 }
14359 
14360 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14361   FormatStyle Style = getWebKitStyle();
14362 
14363   // Don't indent in outer namespaces.
14364   verifyFormat("namespace outer {\n"
14365                "int i;\n"
14366                "namespace inner {\n"
14367                "    int i;\n"
14368                "} // namespace inner\n"
14369                "} // namespace outer\n"
14370                "namespace other_outer {\n"
14371                "int i;\n"
14372                "}",
14373                Style);
14374 
14375   // Don't indent case labels.
14376   verifyFormat("switch (variable) {\n"
14377                "case 1:\n"
14378                "case 2:\n"
14379                "    doSomething();\n"
14380                "    break;\n"
14381                "default:\n"
14382                "    ++variable;\n"
14383                "}",
14384                Style);
14385 
14386   // Wrap before binary operators.
14387   EXPECT_EQ("void f()\n"
14388             "{\n"
14389             "    if (aaaaaaaaaaaaaaaa\n"
14390             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14391             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14392             "        return;\n"
14393             "}",
14394             format("void f() {\n"
14395                    "if (aaaaaaaaaaaaaaaa\n"
14396                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
14397                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14398                    "return;\n"
14399                    "}",
14400                    Style));
14401 
14402   // Allow functions on a single line.
14403   verifyFormat("void f() { return; }", Style);
14404 
14405   // Allow empty blocks on a single line and insert a space in empty blocks.
14406   EXPECT_EQ("void f() { }", format("void f() {}", Style));
14407   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
14408   // However, don't merge non-empty short loops.
14409   EXPECT_EQ("while (true) {\n"
14410             "    continue;\n"
14411             "}",
14412             format("while (true) { continue; }", Style));
14413 
14414   // Constructor initializers are formatted one per line with the "," on the
14415   // new line.
14416   verifyFormat("Constructor()\n"
14417                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
14418                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
14419                "          aaaaaaaaaaaaaa)\n"
14420                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
14421                "{\n"
14422                "}",
14423                Style);
14424   verifyFormat("SomeClass::Constructor()\n"
14425                "    : a(a)\n"
14426                "{\n"
14427                "}",
14428                Style);
14429   EXPECT_EQ("SomeClass::Constructor()\n"
14430             "    : a(a)\n"
14431             "{\n"
14432             "}",
14433             format("SomeClass::Constructor():a(a){}", Style));
14434   verifyFormat("SomeClass::Constructor()\n"
14435                "    : a(a)\n"
14436                "    , b(b)\n"
14437                "    , c(c)\n"
14438                "{\n"
14439                "}",
14440                Style);
14441   verifyFormat("SomeClass::Constructor()\n"
14442                "    : a(a)\n"
14443                "{\n"
14444                "    foo();\n"
14445                "    bar();\n"
14446                "}",
14447                Style);
14448 
14449   // Access specifiers should be aligned left.
14450   verifyFormat("class C {\n"
14451                "public:\n"
14452                "    int i;\n"
14453                "};",
14454                Style);
14455 
14456   // Do not align comments.
14457   verifyFormat("int a; // Do not\n"
14458                "double b; // align comments.",
14459                Style);
14460 
14461   // Do not align operands.
14462   EXPECT_EQ("ASSERT(aaaa\n"
14463             "    || bbbb);",
14464             format("ASSERT ( aaaa\n||bbbb);", Style));
14465 
14466   // Accept input's line breaks.
14467   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
14468             "    || bbbbbbbbbbbbbbb) {\n"
14469             "    i++;\n"
14470             "}",
14471             format("if (aaaaaaaaaaaaaaa\n"
14472                    "|| bbbbbbbbbbbbbbb) { i++; }",
14473                    Style));
14474   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
14475             "    i++;\n"
14476             "}",
14477             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
14478 
14479   // Don't automatically break all macro definitions (llvm.org/PR17842).
14480   verifyFormat("#define aNumber 10", Style);
14481   // However, generally keep the line breaks that the user authored.
14482   EXPECT_EQ("#define aNumber \\\n"
14483             "    10",
14484             format("#define aNumber \\\n"
14485                    " 10",
14486                    Style));
14487 
14488   // Keep empty and one-element array literals on a single line.
14489   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
14490             "                                  copyItems:YES];",
14491             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
14492                    "copyItems:YES];",
14493                    Style));
14494   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
14495             "                                  copyItems:YES];",
14496             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
14497                    "             copyItems:YES];",
14498                    Style));
14499   // FIXME: This does not seem right, there should be more indentation before
14500   // the array literal's entries. Nested blocks have the same problem.
14501   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14502             "    @\"a\",\n"
14503             "    @\"a\"\n"
14504             "]\n"
14505             "                                  copyItems:YES];",
14506             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14507                    "     @\"a\",\n"
14508                    "     @\"a\"\n"
14509                    "     ]\n"
14510                    "       copyItems:YES];",
14511                    Style));
14512   EXPECT_EQ(
14513       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14514       "                                  copyItems:YES];",
14515       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14516              "   copyItems:YES];",
14517              Style));
14518 
14519   verifyFormat("[self.a b:c c:d];", Style);
14520   EXPECT_EQ("[self.a b:c\n"
14521             "        c:d];",
14522             format("[self.a b:c\n"
14523                    "c:d];",
14524                    Style));
14525 }
14526 
14527 TEST_F(FormatTest, FormatsLambdas) {
14528   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
14529   verifyFormat(
14530       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
14531   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
14532   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
14533   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
14534   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
14535   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
14536   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
14537   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
14538   verifyFormat("int x = f(*+[] {});");
14539   verifyFormat("void f() {\n"
14540                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
14541                "}\n");
14542   verifyFormat("void f() {\n"
14543                "  other(x.begin(), //\n"
14544                "        x.end(),   //\n"
14545                "        [&](int, int) { return 1; });\n"
14546                "}\n");
14547   verifyFormat("void f() {\n"
14548                "  other.other.other.other.other(\n"
14549                "      x.begin(), x.end(),\n"
14550                "      [something, rather](int, int, int, int, int, int, int) { "
14551                "return 1; });\n"
14552                "}\n");
14553   verifyFormat(
14554       "void f() {\n"
14555       "  other.other.other.other.other(\n"
14556       "      x.begin(), x.end(),\n"
14557       "      [something, rather](int, int, int, int, int, int, int) {\n"
14558       "        //\n"
14559       "      });\n"
14560       "}\n");
14561   verifyFormat("SomeFunction([]() { // A cool function...\n"
14562                "  return 43;\n"
14563                "});");
14564   EXPECT_EQ("SomeFunction([]() {\n"
14565             "#define A a\n"
14566             "  return 43;\n"
14567             "});",
14568             format("SomeFunction([](){\n"
14569                    "#define A a\n"
14570                    "return 43;\n"
14571                    "});"));
14572   verifyFormat("void f() {\n"
14573                "  SomeFunction([](decltype(x), A *a) {});\n"
14574                "}");
14575   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14576                "    [](const aaaaaaaaaa &a) { return a; });");
14577   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
14578                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
14579                "});");
14580   verifyFormat("Constructor()\n"
14581                "    : Field([] { // comment\n"
14582                "        int i;\n"
14583                "      }) {}");
14584   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
14585                "  return some_parameter.size();\n"
14586                "};");
14587   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
14588                "    [](const string &s) { return s; };");
14589   verifyFormat("int i = aaaaaa ? 1 //\n"
14590                "               : [] {\n"
14591                "                   return 2; //\n"
14592                "                 }();");
14593   verifyFormat("llvm::errs() << \"number of twos is \"\n"
14594                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
14595                "                  return x == 2; // force break\n"
14596                "                });");
14597   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14598                "    [=](int iiiiiiiiiiii) {\n"
14599                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
14600                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
14601                "    });",
14602                getLLVMStyleWithColumns(60));
14603   verifyFormat("SomeFunction({[&] {\n"
14604                "                // comment\n"
14605                "              },\n"
14606                "              [&] {\n"
14607                "                // comment\n"
14608                "              }});");
14609   verifyFormat("SomeFunction({[&] {\n"
14610                "  // comment\n"
14611                "}});");
14612   verifyFormat(
14613       "virtual aaaaaaaaaaaaaaaa(\n"
14614       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
14615       "    aaaaa aaaaaaaaa);");
14616 
14617   // Lambdas with return types.
14618   verifyFormat("int c = []() -> int { return 2; }();\n");
14619   verifyFormat("int c = []() -> int * { return 2; }();\n");
14620   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
14621   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
14622   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
14623   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
14624   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
14625   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
14626   verifyFormat("[a, a]() -> a<1> {};");
14627   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
14628   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
14629   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
14630   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
14631   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
14632   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
14633   verifyFormat("[]() -> foo<!5> { return {}; };");
14634   verifyFormat("[]() -> foo<~5> { return {}; };");
14635   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
14636   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
14637   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
14638   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
14639   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
14640   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
14641   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
14642   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
14643   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
14644   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
14645   verifyFormat("namespace bar {\n"
14646                "// broken:\n"
14647                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
14648                "} // namespace bar");
14649   verifyFormat("namespace bar {\n"
14650                "// broken:\n"
14651                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
14652                "} // namespace bar");
14653   verifyFormat("namespace bar {\n"
14654                "// broken:\n"
14655                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
14656                "} // namespace bar");
14657   verifyFormat("namespace bar {\n"
14658                "// broken:\n"
14659                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
14660                "} // namespace bar");
14661   verifyFormat("namespace bar {\n"
14662                "// broken:\n"
14663                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
14664                "} // namespace bar");
14665   verifyFormat("namespace bar {\n"
14666                "// broken:\n"
14667                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
14668                "} // namespace bar");
14669   verifyFormat("namespace bar {\n"
14670                "// broken:\n"
14671                "auto foo{[]() -> foo<!5> { return {}; }};\n"
14672                "} // namespace bar");
14673   verifyFormat("namespace bar {\n"
14674                "// broken:\n"
14675                "auto foo{[]() -> foo<~5> { return {}; }};\n"
14676                "} // namespace bar");
14677   verifyFormat("namespace bar {\n"
14678                "// broken:\n"
14679                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
14680                "} // namespace bar");
14681   verifyFormat("namespace bar {\n"
14682                "// broken:\n"
14683                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
14684                "} // namespace bar");
14685   verifyFormat("namespace bar {\n"
14686                "// broken:\n"
14687                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
14688                "} // namespace bar");
14689   verifyFormat("namespace bar {\n"
14690                "// broken:\n"
14691                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
14692                "} // namespace bar");
14693   verifyFormat("namespace bar {\n"
14694                "// broken:\n"
14695                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
14696                "} // namespace bar");
14697   verifyFormat("namespace bar {\n"
14698                "// broken:\n"
14699                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
14700                "} // namespace bar");
14701   verifyFormat("namespace bar {\n"
14702                "// broken:\n"
14703                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
14704                "} // namespace bar");
14705   verifyFormat("namespace bar {\n"
14706                "// broken:\n"
14707                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
14708                "} // namespace bar");
14709   verifyFormat("namespace bar {\n"
14710                "// broken:\n"
14711                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
14712                "} // namespace bar");
14713   verifyFormat("namespace bar {\n"
14714                "// broken:\n"
14715                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
14716                "} // namespace bar");
14717   verifyFormat("[]() -> a<1> {};");
14718   verifyFormat("[]() -> a<1> { ; };");
14719   verifyFormat("[]() -> a<1> { ; }();");
14720   verifyFormat("[a, a]() -> a<true> {};");
14721   verifyFormat("[]() -> a<true> {};");
14722   verifyFormat("[]() -> a<true> { ; };");
14723   verifyFormat("[]() -> a<true> { ; }();");
14724   verifyFormat("[a, a]() -> a<false> {};");
14725   verifyFormat("[]() -> a<false> {};");
14726   verifyFormat("[]() -> a<false> { ; };");
14727   verifyFormat("[]() -> a<false> { ; }();");
14728   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
14729   verifyFormat("namespace bar {\n"
14730                "auto foo{[]() -> foo<false> { ; }};\n"
14731                "} // namespace bar");
14732   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
14733                "                   int j) -> int {\n"
14734                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
14735                "};");
14736   verifyFormat(
14737       "aaaaaaaaaaaaaaaaaaaaaa(\n"
14738       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
14739       "      return aaaaaaaaaaaaaaaaa;\n"
14740       "    });",
14741       getLLVMStyleWithColumns(70));
14742   verifyFormat("[]() //\n"
14743                "    -> int {\n"
14744                "  return 1; //\n"
14745                "};");
14746   verifyFormat("[]() -> Void<T...> {};");
14747   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
14748 
14749   // Lambdas with explicit template argument lists.
14750   verifyFormat(
14751       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
14752 
14753   // Multiple lambdas in the same parentheses change indentation rules. These
14754   // lambdas are forced to start on new lines.
14755   verifyFormat("SomeFunction(\n"
14756                "    []() {\n"
14757                "      //\n"
14758                "    },\n"
14759                "    []() {\n"
14760                "      //\n"
14761                "    });");
14762 
14763   // A lambda passed as arg0 is always pushed to the next line.
14764   verifyFormat("SomeFunction(\n"
14765                "    [this] {\n"
14766                "      //\n"
14767                "    },\n"
14768                "    1);\n");
14769 
14770   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
14771   // the arg0 case above.
14772   auto Style = getGoogleStyle();
14773   Style.BinPackArguments = false;
14774   verifyFormat("SomeFunction(\n"
14775                "    a,\n"
14776                "    [this] {\n"
14777                "      //\n"
14778                "    },\n"
14779                "    b);\n",
14780                Style);
14781   verifyFormat("SomeFunction(\n"
14782                "    a,\n"
14783                "    [this] {\n"
14784                "      //\n"
14785                "    },\n"
14786                "    b);\n");
14787 
14788   // A lambda with a very long line forces arg0 to be pushed out irrespective of
14789   // the BinPackArguments value (as long as the code is wide enough).
14790   verifyFormat(
14791       "something->SomeFunction(\n"
14792       "    a,\n"
14793       "    [this] {\n"
14794       "      "
14795       "D0000000000000000000000000000000000000000000000000000000000001();\n"
14796       "    },\n"
14797       "    b);\n");
14798 
14799   // A multi-line lambda is pulled up as long as the introducer fits on the
14800   // previous line and there are no further args.
14801   verifyFormat("function(1, [this, that] {\n"
14802                "  //\n"
14803                "});\n");
14804   verifyFormat("function([this, that] {\n"
14805                "  //\n"
14806                "});\n");
14807   // FIXME: this format is not ideal and we should consider forcing the first
14808   // arg onto its own line.
14809   verifyFormat("function(a, b, c, //\n"
14810                "         d, [this, that] {\n"
14811                "           //\n"
14812                "         });\n");
14813 
14814   // Multiple lambdas are treated correctly even when there is a short arg0.
14815   verifyFormat("SomeFunction(\n"
14816                "    1,\n"
14817                "    [this] {\n"
14818                "      //\n"
14819                "    },\n"
14820                "    [this] {\n"
14821                "      //\n"
14822                "    },\n"
14823                "    1);\n");
14824 
14825   // More complex introducers.
14826   verifyFormat("return [i, args...] {};");
14827 
14828   // Not lambdas.
14829   verifyFormat("constexpr char hello[]{\"hello\"};");
14830   verifyFormat("double &operator[](int i) { return 0; }\n"
14831                "int i;");
14832   verifyFormat("std::unique_ptr<int[]> foo() {}");
14833   verifyFormat("int i = a[a][a]->f();");
14834   verifyFormat("int i = (*b)[a]->f();");
14835 
14836   // Other corner cases.
14837   verifyFormat("void f() {\n"
14838                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
14839                "  );\n"
14840                "}");
14841 
14842   // Lambdas created through weird macros.
14843   verifyFormat("void f() {\n"
14844                "  MACRO((const AA &a) { return 1; });\n"
14845                "  MACRO((AA &a) { return 1; });\n"
14846                "}");
14847 
14848   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
14849                "      doo_dah();\n"
14850                "      doo_dah();\n"
14851                "    })) {\n"
14852                "}");
14853   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
14854                "                doo_dah();\n"
14855                "                doo_dah();\n"
14856                "              })) {\n"
14857                "}");
14858   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
14859                "                doo_dah();\n"
14860                "                doo_dah();\n"
14861                "              })) {\n"
14862                "}");
14863   verifyFormat("auto lambda = []() {\n"
14864                "  int a = 2\n"
14865                "#if A\n"
14866                "          + 2\n"
14867                "#endif\n"
14868                "      ;\n"
14869                "};");
14870 
14871   // Lambdas with complex multiline introducers.
14872   verifyFormat(
14873       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14874       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
14875       "        -> ::std::unordered_set<\n"
14876       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
14877       "      //\n"
14878       "    });");
14879 
14880   FormatStyle DoNotMerge = getLLVMStyle();
14881   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
14882   verifyFormat("auto c = []() {\n"
14883                "  return b;\n"
14884                "};",
14885                "auto c = []() { return b; };", DoNotMerge);
14886   verifyFormat("auto c = []() {\n"
14887                "};",
14888                " auto c = []() {};", DoNotMerge);
14889 
14890   FormatStyle MergeEmptyOnly = getLLVMStyle();
14891   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
14892   verifyFormat("auto c = []() {\n"
14893                "  return b;\n"
14894                "};",
14895                "auto c = []() {\n"
14896                "  return b;\n"
14897                " };",
14898                MergeEmptyOnly);
14899   verifyFormat("auto c = []() {};",
14900                "auto c = []() {\n"
14901                "};",
14902                MergeEmptyOnly);
14903 
14904   FormatStyle MergeInline = getLLVMStyle();
14905   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
14906   verifyFormat("auto c = []() {\n"
14907                "  return b;\n"
14908                "};",
14909                "auto c = []() { return b; };", MergeInline);
14910   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
14911                MergeInline);
14912   verifyFormat("function([]() { return b; }, a)",
14913                "function([]() { return b; }, a)", MergeInline);
14914   verifyFormat("function(a, []() { return b; })",
14915                "function(a, []() { return b; })", MergeInline);
14916 
14917   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
14918   // AllowShortLambdasOnASingleLine
14919   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
14920   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
14921   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
14922   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
14923       FormatStyle::ShortLambdaStyle::SLS_None;
14924   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
14925                "    []()\n"
14926                "    {\n"
14927                "      return 17;\n"
14928                "    });",
14929                LLVMWithBeforeLambdaBody);
14930   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
14931                "    []()\n"
14932                "    {\n"
14933                "    });",
14934                LLVMWithBeforeLambdaBody);
14935   verifyFormat("auto fct_SLS_None = []()\n"
14936                "{\n"
14937                "  return 17;\n"
14938                "};",
14939                LLVMWithBeforeLambdaBody);
14940   verifyFormat("TwoNestedLambdas_SLS_None(\n"
14941                "    []()\n"
14942                "    {\n"
14943                "      return Call(\n"
14944                "          []()\n"
14945                "          {\n"
14946                "            return 17;\n"
14947                "          });\n"
14948                "    });",
14949                LLVMWithBeforeLambdaBody);
14950   verifyFormat("void Fct()\n"
14951                "{\n"
14952                "  return {[]()\n"
14953                "          {\n"
14954                "            return 17;\n"
14955                "          }};\n"
14956                "}",
14957                LLVMWithBeforeLambdaBody);
14958 
14959   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
14960       FormatStyle::ShortLambdaStyle::SLS_Empty;
14961   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
14962                "    []()\n"
14963                "    {\n"
14964                "      return 17;\n"
14965                "    });",
14966                LLVMWithBeforeLambdaBody);
14967   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
14968                LLVMWithBeforeLambdaBody);
14969   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
14970                "ongFunctionName_SLS_Empty(\n"
14971                "    []() {});",
14972                LLVMWithBeforeLambdaBody);
14973   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
14974                "                                []()\n"
14975                "                                {\n"
14976                "                                  return 17;\n"
14977                "                                });",
14978                LLVMWithBeforeLambdaBody);
14979   verifyFormat("auto fct_SLS_Empty = []()\n"
14980                "{\n"
14981                "  return 17;\n"
14982                "};",
14983                LLVMWithBeforeLambdaBody);
14984   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
14985                "    []()\n"
14986                "    {\n"
14987                "      return Call([]() {});\n"
14988                "    });",
14989                LLVMWithBeforeLambdaBody);
14990   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
14991                "                           []()\n"
14992                "                           {\n"
14993                "                             return Call([]() {});\n"
14994                "                           });",
14995                LLVMWithBeforeLambdaBody);
14996   verifyFormat(
14997       "FctWithLongLineInLambda_SLS_Empty(\n"
14998       "    []()\n"
14999       "    {\n"
15000       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15001       "                               AndShouldNotBeConsiderAsInline,\n"
15002       "                               LambdaBodyMustBeBreak);\n"
15003       "    });",
15004       LLVMWithBeforeLambdaBody);
15005 
15006   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15007       FormatStyle::ShortLambdaStyle::SLS_Inline;
15008   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15009                LLVMWithBeforeLambdaBody);
15010   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15011                LLVMWithBeforeLambdaBody);
15012   verifyFormat("auto fct_SLS_Inline = []()\n"
15013                "{\n"
15014                "  return 17;\n"
15015                "};",
15016                LLVMWithBeforeLambdaBody);
15017   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15018                "17; }); });",
15019                LLVMWithBeforeLambdaBody);
15020   verifyFormat(
15021       "FctWithLongLineInLambda_SLS_Inline(\n"
15022       "    []()\n"
15023       "    {\n"
15024       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15025       "                               AndShouldNotBeConsiderAsInline,\n"
15026       "                               LambdaBodyMustBeBreak);\n"
15027       "    });",
15028       LLVMWithBeforeLambdaBody);
15029   verifyFormat("FctWithMultipleParams_SLS_Inline("
15030                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15031                "                                 []() { return 17; });",
15032                LLVMWithBeforeLambdaBody);
15033   verifyFormat(
15034       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15035       LLVMWithBeforeLambdaBody);
15036 
15037   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15038       FormatStyle::ShortLambdaStyle::SLS_All;
15039   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15040                LLVMWithBeforeLambdaBody);
15041   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15042                LLVMWithBeforeLambdaBody);
15043   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15044                LLVMWithBeforeLambdaBody);
15045   verifyFormat("FctWithOneParam_SLS_All(\n"
15046                "    []()\n"
15047                "    {\n"
15048                "      // A cool function...\n"
15049                "      return 43;\n"
15050                "    });",
15051                LLVMWithBeforeLambdaBody);
15052   verifyFormat("FctWithMultipleParams_SLS_All("
15053                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15054                "                              []() { return 17; });",
15055                LLVMWithBeforeLambdaBody);
15056   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15057                LLVMWithBeforeLambdaBody);
15058   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15059                LLVMWithBeforeLambdaBody);
15060   verifyFormat(
15061       "FctWithLongLineInLambda_SLS_All(\n"
15062       "    []()\n"
15063       "    {\n"
15064       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15065       "                               AndShouldNotBeConsiderAsInline,\n"
15066       "                               LambdaBodyMustBeBreak);\n"
15067       "    });",
15068       LLVMWithBeforeLambdaBody);
15069   verifyFormat(
15070       "auto fct_SLS_All = []()\n"
15071       "{\n"
15072       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15073       "                           AndShouldNotBeConsiderAsInline,\n"
15074       "                           LambdaBodyMustBeBreak);\n"
15075       "};",
15076       LLVMWithBeforeLambdaBody);
15077   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15078   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15079                LLVMWithBeforeLambdaBody);
15080   verifyFormat(
15081       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15082       "                                FirstParam,\n"
15083       "                                SecondParam,\n"
15084       "                                ThirdParam,\n"
15085       "                                FourthParam);",
15086       LLVMWithBeforeLambdaBody);
15087   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15088                "    []() { return "
15089                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15090                "    FirstParam,\n"
15091                "    SecondParam,\n"
15092                "    ThirdParam,\n"
15093                "    FourthParam);",
15094                LLVMWithBeforeLambdaBody);
15095   verifyFormat(
15096       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15097       "                                SecondParam,\n"
15098       "                                ThirdParam,\n"
15099       "                                FourthParam,\n"
15100       "                                []() { return SomeValueNotSoLong; });",
15101       LLVMWithBeforeLambdaBody);
15102   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15103                "    []()\n"
15104                "    {\n"
15105                "      return "
15106                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15107                "eConsiderAsInline;\n"
15108                "    });",
15109                LLVMWithBeforeLambdaBody);
15110   verifyFormat(
15111       "FctWithLongLineInLambda_SLS_All(\n"
15112       "    []()\n"
15113       "    {\n"
15114       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15115       "                               AndShouldNotBeConsiderAsInline,\n"
15116       "                               LambdaBodyMustBeBreak);\n"
15117       "    });",
15118       LLVMWithBeforeLambdaBody);
15119   verifyFormat("FctWithTwoParams_SLS_All(\n"
15120                "    []()\n"
15121                "    {\n"
15122                "      // A cool function...\n"
15123                "      return 43;\n"
15124                "    },\n"
15125                "    87);",
15126                LLVMWithBeforeLambdaBody);
15127   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15128                LLVMWithBeforeLambdaBody);
15129   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15130                LLVMWithBeforeLambdaBody);
15131   verifyFormat(
15132       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15133       LLVMWithBeforeLambdaBody);
15134   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15135                "}); }, x);",
15136                LLVMWithBeforeLambdaBody);
15137   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15138                "    []()\n"
15139                "    {\n"
15140                "      // A cool function...\n"
15141                "      return Call([]() { return 17; });\n"
15142                "    });",
15143                LLVMWithBeforeLambdaBody);
15144   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15145                "    []()\n"
15146                "    {\n"
15147                "      return Call(\n"
15148                "          []()\n"
15149                "          {\n"
15150                "            // A cool function...\n"
15151                "            return 17;\n"
15152                "          });\n"
15153                "    });",
15154                LLVMWithBeforeLambdaBody);
15155 }
15156 
15157 TEST_F(FormatTest, LambdaWithLineComments) {
15158   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15159   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15160   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15161   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15162       FormatStyle::ShortLambdaStyle::SLS_All;
15163 
15164   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15165   verifyFormat("auto k = []() // comment\n"
15166                "{ return; }",
15167                LLVMWithBeforeLambdaBody);
15168   verifyFormat("auto k = []() /* comment */ { return; }",
15169                LLVMWithBeforeLambdaBody);
15170   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15171                LLVMWithBeforeLambdaBody);
15172   verifyFormat("auto k = []() // X\n"
15173                "{ return; }",
15174                LLVMWithBeforeLambdaBody);
15175   verifyFormat(
15176       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15177       "{ return; }",
15178       LLVMWithBeforeLambdaBody);
15179 }
15180 
15181 TEST_F(FormatTest, EmptyLinesInLambdas) {
15182   verifyFormat("auto lambda = []() {\n"
15183                "  x(); //\n"
15184                "};",
15185                "auto lambda = []() {\n"
15186                "\n"
15187                "  x(); //\n"
15188                "\n"
15189                "};");
15190 }
15191 
15192 TEST_F(FormatTest, FormatsBlocks) {
15193   FormatStyle ShortBlocks = getLLVMStyle();
15194   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15195   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15196   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15197   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15198   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15199   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15200   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15201 
15202   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15203   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15204   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15205 
15206   verifyFormat("[operation setCompletionBlock:^{\n"
15207                "  [self onOperationDone];\n"
15208                "}];");
15209   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15210                "  [self onOperationDone];\n"
15211                "}]};");
15212   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15213                "  f();\n"
15214                "}];");
15215   verifyFormat("int a = [operation block:^int(int *i) {\n"
15216                "  return 1;\n"
15217                "}];");
15218   verifyFormat("[myObject doSomethingWith:arg1\n"
15219                "                      aaa:^int(int *a) {\n"
15220                "                        return 1;\n"
15221                "                      }\n"
15222                "                      bbb:f(a * bbbbbbbb)];");
15223 
15224   verifyFormat("[operation setCompletionBlock:^{\n"
15225                "  [self.delegate newDataAvailable];\n"
15226                "}];",
15227                getLLVMStyleWithColumns(60));
15228   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15229                "  NSString *path = [self sessionFilePath];\n"
15230                "  if (path) {\n"
15231                "    // ...\n"
15232                "  }\n"
15233                "});");
15234   verifyFormat("[[SessionService sharedService]\n"
15235                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15236                "      if (window) {\n"
15237                "        [self windowDidLoad:window];\n"
15238                "      } else {\n"
15239                "        [self errorLoadingWindow];\n"
15240                "      }\n"
15241                "    }];");
15242   verifyFormat("void (^largeBlock)(void) = ^{\n"
15243                "  // ...\n"
15244                "};\n",
15245                getLLVMStyleWithColumns(40));
15246   verifyFormat("[[SessionService sharedService]\n"
15247                "    loadWindowWithCompletionBlock: //\n"
15248                "        ^(SessionWindow *window) {\n"
15249                "          if (window) {\n"
15250                "            [self windowDidLoad:window];\n"
15251                "          } else {\n"
15252                "            [self errorLoadingWindow];\n"
15253                "          }\n"
15254                "        }];",
15255                getLLVMStyleWithColumns(60));
15256   verifyFormat("[myObject doSomethingWith:arg1\n"
15257                "    firstBlock:^(Foo *a) {\n"
15258                "      // ...\n"
15259                "      int i;\n"
15260                "    }\n"
15261                "    secondBlock:^(Bar *b) {\n"
15262                "      // ...\n"
15263                "      int i;\n"
15264                "    }\n"
15265                "    thirdBlock:^Foo(Bar *b) {\n"
15266                "      // ...\n"
15267                "      int i;\n"
15268                "    }];");
15269   verifyFormat("[myObject doSomethingWith:arg1\n"
15270                "               firstBlock:-1\n"
15271                "              secondBlock:^(Bar *b) {\n"
15272                "                // ...\n"
15273                "                int i;\n"
15274                "              }];");
15275 
15276   verifyFormat("f(^{\n"
15277                "  @autoreleasepool {\n"
15278                "    if (a) {\n"
15279                "      g();\n"
15280                "    }\n"
15281                "  }\n"
15282                "});");
15283   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15284   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15285                "};");
15286 
15287   FormatStyle FourIndent = getLLVMStyle();
15288   FourIndent.ObjCBlockIndentWidth = 4;
15289   verifyFormat("[operation setCompletionBlock:^{\n"
15290                "    [self onOperationDone];\n"
15291                "}];",
15292                FourIndent);
15293 }
15294 
15295 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15296   FormatStyle ZeroColumn = getLLVMStyle();
15297   ZeroColumn.ColumnLimit = 0;
15298 
15299   verifyFormat("[[SessionService sharedService] "
15300                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15301                "  if (window) {\n"
15302                "    [self windowDidLoad:window];\n"
15303                "  } else {\n"
15304                "    [self errorLoadingWindow];\n"
15305                "  }\n"
15306                "}];",
15307                ZeroColumn);
15308   EXPECT_EQ("[[SessionService sharedService]\n"
15309             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15310             "      if (window) {\n"
15311             "        [self windowDidLoad:window];\n"
15312             "      } else {\n"
15313             "        [self errorLoadingWindow];\n"
15314             "      }\n"
15315             "    }];",
15316             format("[[SessionService sharedService]\n"
15317                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15318                    "                if (window) {\n"
15319                    "    [self windowDidLoad:window];\n"
15320                    "  } else {\n"
15321                    "    [self errorLoadingWindow];\n"
15322                    "  }\n"
15323                    "}];",
15324                    ZeroColumn));
15325   verifyFormat("[myObject doSomethingWith:arg1\n"
15326                "    firstBlock:^(Foo *a) {\n"
15327                "      // ...\n"
15328                "      int i;\n"
15329                "    }\n"
15330                "    secondBlock:^(Bar *b) {\n"
15331                "      // ...\n"
15332                "      int i;\n"
15333                "    }\n"
15334                "    thirdBlock:^Foo(Bar *b) {\n"
15335                "      // ...\n"
15336                "      int i;\n"
15337                "    }];",
15338                ZeroColumn);
15339   verifyFormat("f(^{\n"
15340                "  @autoreleasepool {\n"
15341                "    if (a) {\n"
15342                "      g();\n"
15343                "    }\n"
15344                "  }\n"
15345                "});",
15346                ZeroColumn);
15347   verifyFormat("void (^largeBlock)(void) = ^{\n"
15348                "  // ...\n"
15349                "};",
15350                ZeroColumn);
15351 
15352   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15353   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15354             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15355   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15356   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15357             "  int i;\n"
15358             "};",
15359             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15360 }
15361 
15362 TEST_F(FormatTest, SupportsCRLF) {
15363   EXPECT_EQ("int a;\r\n"
15364             "int b;\r\n"
15365             "int c;\r\n",
15366             format("int a;\r\n"
15367                    "  int b;\r\n"
15368                    "    int c;\r\n",
15369                    getLLVMStyle()));
15370   EXPECT_EQ("int a;\r\n"
15371             "int b;\r\n"
15372             "int c;\r\n",
15373             format("int a;\r\n"
15374                    "  int b;\n"
15375                    "    int c;\r\n",
15376                    getLLVMStyle()));
15377   EXPECT_EQ("int a;\n"
15378             "int b;\n"
15379             "int c;\n",
15380             format("int a;\r\n"
15381                    "  int b;\n"
15382                    "    int c;\n",
15383                    getLLVMStyle()));
15384   EXPECT_EQ("\"aaaaaaa \"\r\n"
15385             "\"bbbbbbb\";\r\n",
15386             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15387   EXPECT_EQ("#define A \\\r\n"
15388             "  b;      \\\r\n"
15389             "  c;      \\\r\n"
15390             "  d;\r\n",
15391             format("#define A \\\r\n"
15392                    "  b; \\\r\n"
15393                    "  c; d; \r\n",
15394                    getGoogleStyle()));
15395 
15396   EXPECT_EQ("/*\r\n"
15397             "multi line block comments\r\n"
15398             "should not introduce\r\n"
15399             "an extra carriage return\r\n"
15400             "*/\r\n",
15401             format("/*\r\n"
15402                    "multi line block comments\r\n"
15403                    "should not introduce\r\n"
15404                    "an extra carriage return\r\n"
15405                    "*/\r\n"));
15406   EXPECT_EQ("/*\r\n"
15407             "\r\n"
15408             "*/",
15409             format("/*\r\n"
15410                    "    \r\r\r\n"
15411                    "*/"));
15412 
15413   FormatStyle style = getLLVMStyle();
15414 
15415   style.DeriveLineEnding = true;
15416   style.UseCRLF = false;
15417   EXPECT_EQ("union FooBarBazQux {\n"
15418             "  int foo;\n"
15419             "  int bar;\n"
15420             "  int baz;\n"
15421             "};",
15422             format("union FooBarBazQux {\r\n"
15423                    "  int foo;\n"
15424                    "  int bar;\r\n"
15425                    "  int baz;\n"
15426                    "};",
15427                    style));
15428   style.UseCRLF = true;
15429   EXPECT_EQ("union FooBarBazQux {\r\n"
15430             "  int foo;\r\n"
15431             "  int bar;\r\n"
15432             "  int baz;\r\n"
15433             "};",
15434             format("union FooBarBazQux {\r\n"
15435                    "  int foo;\n"
15436                    "  int bar;\r\n"
15437                    "  int baz;\n"
15438                    "};",
15439                    style));
15440 
15441   style.DeriveLineEnding = false;
15442   style.UseCRLF = false;
15443   EXPECT_EQ("union FooBarBazQux {\n"
15444             "  int foo;\n"
15445             "  int bar;\n"
15446             "  int baz;\n"
15447             "  int qux;\n"
15448             "};",
15449             format("union FooBarBazQux {\r\n"
15450                    "  int foo;\n"
15451                    "  int bar;\r\n"
15452                    "  int baz;\n"
15453                    "  int qux;\r\n"
15454                    "};",
15455                    style));
15456   style.UseCRLF = true;
15457   EXPECT_EQ("union FooBarBazQux {\r\n"
15458             "  int foo;\r\n"
15459             "  int bar;\r\n"
15460             "  int baz;\r\n"
15461             "  int qux;\r\n"
15462             "};",
15463             format("union FooBarBazQux {\r\n"
15464                    "  int foo;\n"
15465                    "  int bar;\r\n"
15466                    "  int baz;\n"
15467                    "  int qux;\n"
15468                    "};",
15469                    style));
15470 
15471   style.DeriveLineEnding = true;
15472   style.UseCRLF = false;
15473   EXPECT_EQ("union FooBarBazQux {\r\n"
15474             "  int foo;\r\n"
15475             "  int bar;\r\n"
15476             "  int baz;\r\n"
15477             "  int qux;\r\n"
15478             "};",
15479             format("union FooBarBazQux {\r\n"
15480                    "  int foo;\n"
15481                    "  int bar;\r\n"
15482                    "  int baz;\n"
15483                    "  int qux;\r\n"
15484                    "};",
15485                    style));
15486   style.UseCRLF = true;
15487   EXPECT_EQ("union FooBarBazQux {\n"
15488             "  int foo;\n"
15489             "  int bar;\n"
15490             "  int baz;\n"
15491             "  int qux;\n"
15492             "};",
15493             format("union FooBarBazQux {\r\n"
15494                    "  int foo;\n"
15495                    "  int bar;\r\n"
15496                    "  int baz;\n"
15497                    "  int qux;\n"
15498                    "};",
15499                    style));
15500 }
15501 
15502 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
15503   verifyFormat("MY_CLASS(C) {\n"
15504                "  int i;\n"
15505                "  int j;\n"
15506                "};");
15507 }
15508 
15509 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
15510   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
15511   TwoIndent.ContinuationIndentWidth = 2;
15512 
15513   EXPECT_EQ("int i =\n"
15514             "  longFunction(\n"
15515             "    arg);",
15516             format("int i = longFunction(arg);", TwoIndent));
15517 
15518   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
15519   SixIndent.ContinuationIndentWidth = 6;
15520 
15521   EXPECT_EQ("int i =\n"
15522             "      longFunction(\n"
15523             "            arg);",
15524             format("int i = longFunction(arg);", SixIndent));
15525 }
15526 
15527 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
15528   FormatStyle Style = getLLVMStyle();
15529   verifyFormat("int Foo::getter(\n"
15530                "    //\n"
15531                ") const {\n"
15532                "  return foo;\n"
15533                "}",
15534                Style);
15535   verifyFormat("void Foo::setter(\n"
15536                "    //\n"
15537                ") {\n"
15538                "  foo = 1;\n"
15539                "}",
15540                Style);
15541 }
15542 
15543 TEST_F(FormatTest, SpacesInAngles) {
15544   FormatStyle Spaces = getLLVMStyle();
15545   Spaces.SpacesInAngles = true;
15546 
15547   verifyFormat("static_cast< int >(arg);", Spaces);
15548   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
15549   verifyFormat("f< int, float >();", Spaces);
15550   verifyFormat("template <> g() {}", Spaces);
15551   verifyFormat("template < std::vector< int > > f() {}", Spaces);
15552   verifyFormat("std::function< void(int, int) > fct;", Spaces);
15553   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
15554                Spaces);
15555 
15556   Spaces.Standard = FormatStyle::LS_Cpp03;
15557   Spaces.SpacesInAngles = true;
15558   verifyFormat("A< A< int > >();", Spaces);
15559 
15560   Spaces.SpacesInAngles = false;
15561   verifyFormat("A<A<int> >();", Spaces);
15562 
15563   Spaces.Standard = FormatStyle::LS_Cpp11;
15564   Spaces.SpacesInAngles = true;
15565   verifyFormat("A< A< int > >();", Spaces);
15566 
15567   Spaces.SpacesInAngles = false;
15568   verifyFormat("A<A<int>>();", Spaces);
15569 }
15570 
15571 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
15572   FormatStyle Style = getLLVMStyle();
15573   Style.SpaceAfterTemplateKeyword = false;
15574   verifyFormat("template<int> void foo();", Style);
15575 }
15576 
15577 TEST_F(FormatTest, TripleAngleBrackets) {
15578   verifyFormat("f<<<1, 1>>>();");
15579   verifyFormat("f<<<1, 1, 1, s>>>();");
15580   verifyFormat("f<<<a, b, c, d>>>();");
15581   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
15582   verifyFormat("f<param><<<1, 1>>>();");
15583   verifyFormat("f<1><<<1, 1>>>();");
15584   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
15585   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15586                "aaaaaaaaaaa<<<\n    1, 1>>>();");
15587   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
15588                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
15589 }
15590 
15591 TEST_F(FormatTest, MergeLessLessAtEnd) {
15592   verifyFormat("<<");
15593   EXPECT_EQ("< < <", format("\\\n<<<"));
15594   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15595                "aaallvm::outs() <<");
15596   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15597                "aaaallvm::outs()\n    <<");
15598 }
15599 
15600 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
15601   std::string code = "#if A\n"
15602                      "#if B\n"
15603                      "a.\n"
15604                      "#endif\n"
15605                      "    a = 1;\n"
15606                      "#else\n"
15607                      "#endif\n"
15608                      "#if C\n"
15609                      "#else\n"
15610                      "#endif\n";
15611   EXPECT_EQ(code, format(code));
15612 }
15613 
15614 TEST_F(FormatTest, HandleConflictMarkers) {
15615   // Git/SVN conflict markers.
15616   EXPECT_EQ("int a;\n"
15617             "void f() {\n"
15618             "  callme(some(parameter1,\n"
15619             "<<<<<<< text by the vcs\n"
15620             "              parameter2),\n"
15621             "||||||| text by the vcs\n"
15622             "              parameter2),\n"
15623             "         parameter3,\n"
15624             "======= text by the vcs\n"
15625             "              parameter2, parameter3),\n"
15626             ">>>>>>> text by the vcs\n"
15627             "         otherparameter);\n",
15628             format("int a;\n"
15629                    "void f() {\n"
15630                    "  callme(some(parameter1,\n"
15631                    "<<<<<<< text by the vcs\n"
15632                    "  parameter2),\n"
15633                    "||||||| text by the vcs\n"
15634                    "  parameter2),\n"
15635                    "  parameter3,\n"
15636                    "======= text by the vcs\n"
15637                    "  parameter2,\n"
15638                    "  parameter3),\n"
15639                    ">>>>>>> text by the vcs\n"
15640                    "  otherparameter);\n"));
15641 
15642   // Perforce markers.
15643   EXPECT_EQ("void f() {\n"
15644             "  function(\n"
15645             ">>>> text by the vcs\n"
15646             "      parameter,\n"
15647             "==== text by the vcs\n"
15648             "      parameter,\n"
15649             "==== text by the vcs\n"
15650             "      parameter,\n"
15651             "<<<< text by the vcs\n"
15652             "      parameter);\n",
15653             format("void f() {\n"
15654                    "  function(\n"
15655                    ">>>> text by the vcs\n"
15656                    "  parameter,\n"
15657                    "==== text by the vcs\n"
15658                    "  parameter,\n"
15659                    "==== text by the vcs\n"
15660                    "  parameter,\n"
15661                    "<<<< text by the vcs\n"
15662                    "  parameter);\n"));
15663 
15664   EXPECT_EQ("<<<<<<<\n"
15665             "|||||||\n"
15666             "=======\n"
15667             ">>>>>>>",
15668             format("<<<<<<<\n"
15669                    "|||||||\n"
15670                    "=======\n"
15671                    ">>>>>>>"));
15672 
15673   EXPECT_EQ("<<<<<<<\n"
15674             "|||||||\n"
15675             "int i;\n"
15676             "=======\n"
15677             ">>>>>>>",
15678             format("<<<<<<<\n"
15679                    "|||||||\n"
15680                    "int i;\n"
15681                    "=======\n"
15682                    ">>>>>>>"));
15683 
15684   // FIXME: Handle parsing of macros around conflict markers correctly:
15685   EXPECT_EQ("#define Macro \\\n"
15686             "<<<<<<<\n"
15687             "Something \\\n"
15688             "|||||||\n"
15689             "Else \\\n"
15690             "=======\n"
15691             "Other \\\n"
15692             ">>>>>>>\n"
15693             "    End int i;\n",
15694             format("#define Macro \\\n"
15695                    "<<<<<<<\n"
15696                    "  Something \\\n"
15697                    "|||||||\n"
15698                    "  Else \\\n"
15699                    "=======\n"
15700                    "  Other \\\n"
15701                    ">>>>>>>\n"
15702                    "  End\n"
15703                    "int i;\n"));
15704 }
15705 
15706 TEST_F(FormatTest, DisableRegions) {
15707   EXPECT_EQ("int i;\n"
15708             "// clang-format off\n"
15709             "  int j;\n"
15710             "// clang-format on\n"
15711             "int k;",
15712             format(" int  i;\n"
15713                    "   // clang-format off\n"
15714                    "  int j;\n"
15715                    " // clang-format on\n"
15716                    "   int   k;"));
15717   EXPECT_EQ("int i;\n"
15718             "/* clang-format off */\n"
15719             "  int j;\n"
15720             "/* clang-format on */\n"
15721             "int k;",
15722             format(" int  i;\n"
15723                    "   /* clang-format off */\n"
15724                    "  int j;\n"
15725                    " /* clang-format on */\n"
15726                    "   int   k;"));
15727 
15728   // Don't reflow comments within disabled regions.
15729   EXPECT_EQ("// clang-format off\n"
15730             "// long long long long long long line\n"
15731             "/* clang-format on */\n"
15732             "/* long long long\n"
15733             " * long long long\n"
15734             " * line */\n"
15735             "int i;\n"
15736             "/* clang-format off */\n"
15737             "/* long long long long long long line */\n",
15738             format("// clang-format off\n"
15739                    "// long long long long long long line\n"
15740                    "/* clang-format on */\n"
15741                    "/* long long long long long long line */\n"
15742                    "int i;\n"
15743                    "/* clang-format off */\n"
15744                    "/* long long long long long long line */\n",
15745                    getLLVMStyleWithColumns(20)));
15746 }
15747 
15748 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
15749   format("? ) =");
15750   verifyNoCrash("#define a\\\n /**/}");
15751 }
15752 
15753 TEST_F(FormatTest, FormatsTableGenCode) {
15754   FormatStyle Style = getLLVMStyle();
15755   Style.Language = FormatStyle::LK_TableGen;
15756   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
15757 }
15758 
15759 TEST_F(FormatTest, ArrayOfTemplates) {
15760   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
15761             format("auto a = new unique_ptr<int > [ 10];"));
15762 
15763   FormatStyle Spaces = getLLVMStyle();
15764   Spaces.SpacesInSquareBrackets = true;
15765   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
15766             format("auto a = new unique_ptr<int > [10];", Spaces));
15767 }
15768 
15769 TEST_F(FormatTest, ArrayAsTemplateType) {
15770   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
15771             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
15772 
15773   FormatStyle Spaces = getLLVMStyle();
15774   Spaces.SpacesInSquareBrackets = true;
15775   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
15776             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
15777 }
15778 
15779 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
15780 
15781 TEST(FormatStyle, GetStyleWithEmptyFileName) {
15782   llvm::vfs::InMemoryFileSystem FS;
15783   auto Style1 = getStyle("file", "", "Google", "", &FS);
15784   ASSERT_TRUE((bool)Style1);
15785   ASSERT_EQ(*Style1, getGoogleStyle());
15786 }
15787 
15788 TEST(FormatStyle, GetStyleOfFile) {
15789   llvm::vfs::InMemoryFileSystem FS;
15790   // Test 1: format file in the same directory.
15791   ASSERT_TRUE(
15792       FS.addFile("/a/.clang-format", 0,
15793                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
15794   ASSERT_TRUE(
15795       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15796   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
15797   ASSERT_TRUE((bool)Style1);
15798   ASSERT_EQ(*Style1, getLLVMStyle());
15799 
15800   // Test 2.1: fallback to default.
15801   ASSERT_TRUE(
15802       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15803   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
15804   ASSERT_TRUE((bool)Style2);
15805   ASSERT_EQ(*Style2, getMozillaStyle());
15806 
15807   // Test 2.2: no format on 'none' fallback style.
15808   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
15809   ASSERT_TRUE((bool)Style2);
15810   ASSERT_EQ(*Style2, getNoStyle());
15811 
15812   // Test 2.3: format if config is found with no based style while fallback is
15813   // 'none'.
15814   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
15815                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
15816   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
15817   ASSERT_TRUE((bool)Style2);
15818   ASSERT_EQ(*Style2, getLLVMStyle());
15819 
15820   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
15821   Style2 = getStyle("{}", "a.h", "none", "", &FS);
15822   ASSERT_TRUE((bool)Style2);
15823   ASSERT_EQ(*Style2, getLLVMStyle());
15824 
15825   // Test 3: format file in parent directory.
15826   ASSERT_TRUE(
15827       FS.addFile("/c/.clang-format", 0,
15828                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
15829   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
15830                          llvm::MemoryBuffer::getMemBuffer("int i;")));
15831   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
15832   ASSERT_TRUE((bool)Style3);
15833   ASSERT_EQ(*Style3, getGoogleStyle());
15834 
15835   // Test 4: error on invalid fallback style
15836   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
15837   ASSERT_FALSE((bool)Style4);
15838   llvm::consumeError(Style4.takeError());
15839 
15840   // Test 5: error on invalid yaml on command line
15841   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
15842   ASSERT_FALSE((bool)Style5);
15843   llvm::consumeError(Style5.takeError());
15844 
15845   // Test 6: error on invalid style
15846   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
15847   ASSERT_FALSE((bool)Style6);
15848   llvm::consumeError(Style6.takeError());
15849 
15850   // Test 7: found config file, error on parsing it
15851   ASSERT_TRUE(
15852       FS.addFile("/d/.clang-format", 0,
15853                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
15854                                                   "InvalidKey: InvalidValue")));
15855   ASSERT_TRUE(
15856       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15857   auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
15858   ASSERT_FALSE((bool)Style7);
15859   llvm::consumeError(Style7.takeError());
15860 
15861   // Test 8: inferred per-language defaults apply.
15862   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
15863   ASSERT_TRUE((bool)StyleTd);
15864   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
15865 }
15866 
15867 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
15868   // Column limit is 20.
15869   std::string Code = "Type *a =\n"
15870                      "    new Type();\n"
15871                      "g(iiiii, 0, jjjjj,\n"
15872                      "  0, kkkkk, 0, mm);\n"
15873                      "int  bad     = format   ;";
15874   std::string Expected = "auto a = new Type();\n"
15875                          "g(iiiii, nullptr,\n"
15876                          "  jjjjj, nullptr,\n"
15877                          "  kkkkk, nullptr,\n"
15878                          "  mm);\n"
15879                          "int  bad     = format   ;";
15880   FileID ID = Context.createInMemoryFile("format.cpp", Code);
15881   tooling::Replacements Replaces = toReplacements(
15882       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
15883                             "auto "),
15884        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
15885                             "nullptr"),
15886        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
15887                             "nullptr"),
15888        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
15889                             "nullptr")});
15890 
15891   format::FormatStyle Style = format::getLLVMStyle();
15892   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
15893   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
15894   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
15895       << llvm::toString(FormattedReplaces.takeError()) << "\n";
15896   auto Result = applyAllReplacements(Code, *FormattedReplaces);
15897   EXPECT_TRUE(static_cast<bool>(Result));
15898   EXPECT_EQ(Expected, *Result);
15899 }
15900 
15901 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
15902   std::string Code = "#include \"a.h\"\n"
15903                      "#include \"c.h\"\n"
15904                      "\n"
15905                      "int main() {\n"
15906                      "  return 0;\n"
15907                      "}";
15908   std::string Expected = "#include \"a.h\"\n"
15909                          "#include \"b.h\"\n"
15910                          "#include \"c.h\"\n"
15911                          "\n"
15912                          "int main() {\n"
15913                          "  return 0;\n"
15914                          "}";
15915   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
15916   tooling::Replacements Replaces = toReplacements(
15917       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
15918                             "#include \"b.h\"\n")});
15919 
15920   format::FormatStyle Style = format::getLLVMStyle();
15921   Style.SortIncludes = true;
15922   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
15923   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
15924       << llvm::toString(FormattedReplaces.takeError()) << "\n";
15925   auto Result = applyAllReplacements(Code, *FormattedReplaces);
15926   EXPECT_TRUE(static_cast<bool>(Result));
15927   EXPECT_EQ(Expected, *Result);
15928 }
15929 
15930 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
15931   EXPECT_EQ("using std::cin;\n"
15932             "using std::cout;",
15933             format("using std::cout;\n"
15934                    "using std::cin;",
15935                    getGoogleStyle()));
15936 }
15937 
15938 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
15939   format::FormatStyle Style = format::getLLVMStyle();
15940   Style.Standard = FormatStyle::LS_Cpp03;
15941   // cpp03 recognize this string as identifier u8 and literal character 'a'
15942   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
15943 }
15944 
15945 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
15946   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
15947   // all modes, including C++11, C++14 and C++17
15948   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
15949 }
15950 
15951 TEST_F(FormatTest, DoNotFormatLikelyXml) {
15952   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
15953   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
15954 }
15955 
15956 TEST_F(FormatTest, StructuredBindings) {
15957   // Structured bindings is a C++17 feature.
15958   // all modes, including C++11, C++14 and C++17
15959   verifyFormat("auto [a, b] = f();");
15960   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
15961   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
15962   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
15963   EXPECT_EQ("auto const volatile [a, b] = f();",
15964             format("auto  const   volatile[a, b] = f();"));
15965   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
15966   EXPECT_EQ("auto &[a, b, c] = f();",
15967             format("auto   &[  a  ,  b,c   ] = f();"));
15968   EXPECT_EQ("auto &&[a, b, c] = f();",
15969             format("auto   &&[  a  ,  b,c   ] = f();"));
15970   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
15971   EXPECT_EQ("auto const volatile &&[a, b] = f();",
15972             format("auto  const  volatile  &&[a, b] = f();"));
15973   EXPECT_EQ("auto const &&[a, b] = f();",
15974             format("auto  const   &&  [a, b] = f();"));
15975   EXPECT_EQ("const auto &[a, b] = f();",
15976             format("const  auto  &  [a, b] = f();"));
15977   EXPECT_EQ("const auto volatile &&[a, b] = f();",
15978             format("const  auto   volatile  &&[a, b] = f();"));
15979   EXPECT_EQ("volatile const auto &&[a, b] = f();",
15980             format("volatile  const  auto   &&[a, b] = f();"));
15981   EXPECT_EQ("const auto &&[a, b] = f();",
15982             format("const  auto  &&  [a, b] = f();"));
15983 
15984   // Make sure we don't mistake structured bindings for lambdas.
15985   FormatStyle PointerMiddle = getLLVMStyle();
15986   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
15987   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
15988   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
15989   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
15990   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
15991   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
15992   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
15993   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
15994   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
15995   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
15996   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
15997   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
15998   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
15999 
16000   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16001             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16002   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16003             format("for (const auto   &   [a, b] : some_range) {\n}"));
16004   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16005             format("for (const auto[a, b] : some_range) {\n}"));
16006   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16007   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16008   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16009   EXPECT_EQ("auto const &[x, y](expr);",
16010             format("auto  const  &  [x,y]  (expr);"));
16011   EXPECT_EQ("auto const &&[x, y](expr);",
16012             format("auto  const  &&  [x,y]  (expr);"));
16013   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16014   EXPECT_EQ("auto const &[x, y]{expr};",
16015             format("auto  const  &  [x,y]  {expr};"));
16016   EXPECT_EQ("auto const &&[x, y]{expr};",
16017             format("auto  const  &&  [x,y]  {expr};"));
16018 
16019   format::FormatStyle Spaces = format::getLLVMStyle();
16020   Spaces.SpacesInSquareBrackets = true;
16021   verifyFormat("auto [ a, b ] = f();", Spaces);
16022   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16023   verifyFormat("auto &[ a, b ] = f();", Spaces);
16024   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16025   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16026 }
16027 
16028 TEST_F(FormatTest, FileAndCode) {
16029   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16030   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16031   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16032   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16033   EXPECT_EQ(FormatStyle::LK_ObjC,
16034             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16035   EXPECT_EQ(
16036       FormatStyle::LK_ObjC,
16037       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16038   EXPECT_EQ(FormatStyle::LK_ObjC,
16039             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16040   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16041   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16042   EXPECT_EQ(FormatStyle::LK_ObjC,
16043             guessLanguage("foo", "@interface Foo\n@end\n"));
16044   EXPECT_EQ(FormatStyle::LK_ObjC,
16045             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16046   EXPECT_EQ(
16047       FormatStyle::LK_ObjC,
16048       guessLanguage("foo.h",
16049                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16050   EXPECT_EQ(
16051       FormatStyle::LK_Cpp,
16052       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16053 }
16054 
16055 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16056   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16057   EXPECT_EQ(FormatStyle::LK_ObjC,
16058             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16059   EXPECT_EQ(FormatStyle::LK_Cpp,
16060             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16061   EXPECT_EQ(
16062       FormatStyle::LK_Cpp,
16063       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16064   EXPECT_EQ(FormatStyle::LK_ObjC,
16065             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16066   EXPECT_EQ(FormatStyle::LK_Cpp,
16067             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16068   EXPECT_EQ(FormatStyle::LK_ObjC,
16069             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16070   EXPECT_EQ(FormatStyle::LK_Cpp,
16071             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16072   EXPECT_EQ(FormatStyle::LK_Cpp,
16073             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16074   EXPECT_EQ(FormatStyle::LK_ObjC,
16075             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16076   EXPECT_EQ(FormatStyle::LK_Cpp,
16077             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16078   EXPECT_EQ(
16079       FormatStyle::LK_Cpp,
16080       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16081   EXPECT_EQ(
16082       FormatStyle::LK_Cpp,
16083       guessLanguage("foo.h",
16084                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16085   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16086 }
16087 
16088 TEST_F(FormatTest, GuessLanguageWithCaret) {
16089   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16090   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16091   EXPECT_EQ(FormatStyle::LK_ObjC,
16092             guessLanguage("foo.h", "int(^)(char, float);"));
16093   EXPECT_EQ(FormatStyle::LK_ObjC,
16094             guessLanguage("foo.h", "int(^foo)(char, float);"));
16095   EXPECT_EQ(FormatStyle::LK_ObjC,
16096             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16097   EXPECT_EQ(FormatStyle::LK_ObjC,
16098             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16099   EXPECT_EQ(
16100       FormatStyle::LK_ObjC,
16101       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16102 }
16103 
16104 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16105   // ASM symbolic names are identifiers that must be surrounded by [] without
16106   // space in between:
16107   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16108 
16109   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16110   verifyFormat(R"(//
16111 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16112 )");
16113 
16114   // A list of several ASM symbolic names.
16115   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16116 
16117   // ASM symbolic names in inline ASM with inputs and outputs.
16118   verifyFormat(R"(//
16119 asm("cmoveq %1, %2, %[result]"
16120     : [result] "=r"(result)
16121     : "r"(test), "r"(new), "[result]"(old));
16122 )");
16123 
16124   // ASM symbolic names in inline ASM with no outputs.
16125   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16126 }
16127 
16128 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
16129   EXPECT_EQ(FormatStyle::LK_Cpp,
16130             guessLanguage("foo.h", "void f() {\n"
16131                                    "  asm (\"mov %[e], %[d]\"\n"
16132                                    "     : [d] \"=rm\" (d)\n"
16133                                    "       [e] \"rm\" (*e));\n"
16134                                    "}"));
16135   EXPECT_EQ(FormatStyle::LK_Cpp,
16136             guessLanguage("foo.h", "void f() {\n"
16137                                    "  _asm (\"mov %[e], %[d]\"\n"
16138                                    "     : [d] \"=rm\" (d)\n"
16139                                    "       [e] \"rm\" (*e));\n"
16140                                    "}"));
16141   EXPECT_EQ(FormatStyle::LK_Cpp,
16142             guessLanguage("foo.h", "void f() {\n"
16143                                    "  __asm (\"mov %[e], %[d]\"\n"
16144                                    "     : [d] \"=rm\" (d)\n"
16145                                    "       [e] \"rm\" (*e));\n"
16146                                    "}"));
16147   EXPECT_EQ(FormatStyle::LK_Cpp,
16148             guessLanguage("foo.h", "void f() {\n"
16149                                    "  __asm__ (\"mov %[e], %[d]\"\n"
16150                                    "     : [d] \"=rm\" (d)\n"
16151                                    "       [e] \"rm\" (*e));\n"
16152                                    "}"));
16153   EXPECT_EQ(FormatStyle::LK_Cpp,
16154             guessLanguage("foo.h", "void f() {\n"
16155                                    "  asm (\"mov %[e], %[d]\"\n"
16156                                    "     : [d] \"=rm\" (d),\n"
16157                                    "       [e] \"rm\" (*e));\n"
16158                                    "}"));
16159   EXPECT_EQ(FormatStyle::LK_Cpp,
16160             guessLanguage("foo.h", "void f() {\n"
16161                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16162                                    "     : [d] \"=rm\" (d)\n"
16163                                    "       [e] \"rm\" (*e));\n"
16164                                    "}"));
16165 }
16166 
16167 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16168   EXPECT_EQ(FormatStyle::LK_Cpp,
16169             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16170   EXPECT_EQ(FormatStyle::LK_ObjC,
16171             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16172   EXPECT_EQ(
16173       FormatStyle::LK_Cpp,
16174       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16175   EXPECT_EQ(
16176       FormatStyle::LK_ObjC,
16177       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16178 }
16179 
16180 TEST_F(FormatTest, TypenameMacros) {
16181   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16182 
16183   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16184   FormatStyle Google = getGoogleStyleWithColumns(0);
16185   Google.TypenameMacros = TypenameMacros;
16186   verifyFormat("struct foo {\n"
16187                "  int bar;\n"
16188                "  TAILQ_ENTRY(a) bleh;\n"
16189                "};",
16190                Google);
16191 
16192   FormatStyle Macros = getLLVMStyle();
16193   Macros.TypenameMacros = TypenameMacros;
16194 
16195   verifyFormat("STACK_OF(int) a;", Macros);
16196   verifyFormat("STACK_OF(int) *a;", Macros);
16197   verifyFormat("STACK_OF(int const *) *a;", Macros);
16198   verifyFormat("STACK_OF(int *const) *a;", Macros);
16199   verifyFormat("STACK_OF(int, string) a;", Macros);
16200   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16201   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16202   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16203   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16204 
16205   Macros.PointerAlignment = FormatStyle::PAS_Left;
16206   verifyFormat("STACK_OF(int)* a;", Macros);
16207   verifyFormat("STACK_OF(int*)* a;", Macros);
16208 }
16209 
16210 TEST_F(FormatTest, AmbersandInLamda) {
16211   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16212   FormatStyle AlignStyle = getLLVMStyle();
16213   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16214   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16215   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16216   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16217 }
16218 
16219 TEST_F(FormatTest, SpacesInConditionalStatement) {
16220   FormatStyle Spaces = getLLVMStyle();
16221   Spaces.SpacesInConditionalStatement = true;
16222   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16223   verifyFormat("if ( !a )\n  return;", Spaces);
16224   verifyFormat("if ( a )\n  return;", Spaces);
16225   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16226   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16227   verifyFormat("while ( a )\n  return;", Spaces);
16228   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16229   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16230   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16231   // Check that space on the left of "::" is inserted as expected at beginning
16232   // of condition.
16233   verifyFormat("while ( ::func() )\n  return;", Spaces);
16234 }
16235 
16236 TEST_F(FormatTest, AlternativeOperators) {
16237   // Test case for ensuring alternate operators are not
16238   // combined with their right most neighbour.
16239   verifyFormat("int a and b;");
16240   verifyFormat("int a and_eq b;");
16241   verifyFormat("int a bitand b;");
16242   verifyFormat("int a bitor b;");
16243   verifyFormat("int a compl b;");
16244   verifyFormat("int a not b;");
16245   verifyFormat("int a not_eq b;");
16246   verifyFormat("int a or b;");
16247   verifyFormat("int a xor b;");
16248   verifyFormat("int a xor_eq b;");
16249   verifyFormat("return this not_eq bitand other;");
16250   verifyFormat("bool operator not_eq(const X bitand other)");
16251 
16252   verifyFormat("int a and 5;");
16253   verifyFormat("int a and_eq 5;");
16254   verifyFormat("int a bitand 5;");
16255   verifyFormat("int a bitor 5;");
16256   verifyFormat("int a compl 5;");
16257   verifyFormat("int a not 5;");
16258   verifyFormat("int a not_eq 5;");
16259   verifyFormat("int a or 5;");
16260   verifyFormat("int a xor 5;");
16261   verifyFormat("int a xor_eq 5;");
16262 
16263   verifyFormat("int a compl(5);");
16264   verifyFormat("int a not(5);");
16265 
16266   /* FIXME handle alternate tokens
16267    * https://en.cppreference.com/w/cpp/language/operator_alternative
16268   // alternative tokens
16269   verifyFormat("compl foo();");     //  ~foo();
16270   verifyFormat("foo() <%%>;");      // foo();
16271   verifyFormat("void foo() <%%>;"); // void foo(){}
16272   verifyFormat("int a <:1:>;");     // int a[1];[
16273   verifyFormat("%:define ABC abc"); // #define ABC abc
16274   verifyFormat("%:%:");             // ##
16275   */
16276 }
16277 
16278 TEST_F(FormatTest, STLWhileNotDefineChed) {
16279   verifyFormat("#if defined(while)\n"
16280                "#define while EMIT WARNING C4005\n"
16281                "#endif // while");
16282 }
16283 
16284 TEST_F(FormatTest, OperatorSpacing) {
16285   FormatStyle Style = getLLVMStyle();
16286   Style.PointerAlignment = FormatStyle::PAS_Right;
16287   verifyFormat("Foo::operator*();", Style);
16288   verifyFormat("Foo::operator void *();", Style);
16289   verifyFormat("Foo::operator void **();", Style);
16290   verifyFormat("Foo::operator void *&();", Style);
16291   verifyFormat("Foo::operator void *&&();", Style);
16292   verifyFormat("Foo::operator()(void *);", Style);
16293   verifyFormat("Foo::operator*(void *);", Style);
16294   verifyFormat("Foo::operator*();", Style);
16295   verifyFormat("Foo::operator**();", Style);
16296   verifyFormat("Foo::operator&();", Style);
16297   verifyFormat("Foo::operator<int> *();", Style);
16298   verifyFormat("Foo::operator<Foo> *();", Style);
16299   verifyFormat("Foo::operator<int> **();", Style);
16300   verifyFormat("Foo::operator<Foo> **();", Style);
16301   verifyFormat("Foo::operator<int> &();", Style);
16302   verifyFormat("Foo::operator<Foo> &();", Style);
16303   verifyFormat("Foo::operator<int> &&();", Style);
16304   verifyFormat("Foo::operator<Foo> &&();", Style);
16305   verifyFormat("Foo::operator<int> *&();", Style);
16306   verifyFormat("Foo::operator<Foo> *&();", Style);
16307   verifyFormat("Foo::operator<int> *&&();", Style);
16308   verifyFormat("Foo::operator<Foo> *&&();", Style);
16309   verifyFormat("operator*(int (*)(), class Foo);", Style);
16310 
16311   verifyFormat("Foo::operator&();", Style);
16312   verifyFormat("Foo::operator void &();", Style);
16313   verifyFormat("Foo::operator()(void &);", Style);
16314   verifyFormat("Foo::operator&(void &);", Style);
16315   verifyFormat("Foo::operator&();", Style);
16316   verifyFormat("operator&(int (&)(), class Foo);", Style);
16317 
16318   verifyFormat("Foo::operator&&();", Style);
16319   verifyFormat("Foo::operator**();", Style);
16320   verifyFormat("Foo::operator void &&();", Style);
16321   verifyFormat("Foo::operator()(void &&);", Style);
16322   verifyFormat("Foo::operator&&(void &&);", Style);
16323   verifyFormat("Foo::operator&&();", Style);
16324   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16325   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16326   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16327                Style);
16328   verifyFormat("operator void **()", Style);
16329   verifyFormat("operator const FooRight<Object> &()", Style);
16330   verifyFormat("operator const FooRight<Object> *()", Style);
16331   verifyFormat("operator const FooRight<Object> **()", Style);
16332   verifyFormat("operator const FooRight<Object> *&()", Style);
16333   verifyFormat("operator const FooRight<Object> *&&()", Style);
16334 
16335   Style.PointerAlignment = FormatStyle::PAS_Left;
16336   verifyFormat("Foo::operator*();", Style);
16337   verifyFormat("Foo::operator**();", Style);
16338   verifyFormat("Foo::operator void*();", Style);
16339   verifyFormat("Foo::operator void**();", Style);
16340   verifyFormat("Foo::operator void*&();", Style);
16341   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16342   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16343   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16344   verifyFormat("Foo::operator()(void*);", Style);
16345   verifyFormat("Foo::operator*(void*);", Style);
16346   verifyFormat("Foo::operator*();", Style);
16347   verifyFormat("Foo::operator<int>*();", Style);
16348   verifyFormat("Foo::operator<Foo>*();", Style);
16349   verifyFormat("Foo::operator<int>**();", Style);
16350   verifyFormat("Foo::operator<Foo>**();", Style);
16351   verifyFormat("Foo::operator<Foo>*&();", Style);
16352   verifyFormat("Foo::operator<int>&();", Style);
16353   verifyFormat("Foo::operator<Foo>&();", Style);
16354   verifyFormat("Foo::operator<int>&&();", Style);
16355   verifyFormat("Foo::operator<Foo>&&();", Style);
16356   verifyFormat("Foo::operator<int>*&();", Style);
16357   verifyFormat("Foo::operator<Foo>*&();", Style);
16358   verifyFormat("operator*(int (*)(), class Foo);", Style);
16359 
16360   verifyFormat("Foo::operator&();", Style);
16361   verifyFormat("Foo::operator void&();", Style);
16362   verifyFormat("Foo::operator/*comment*/ void&();", Style);
16363   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
16364   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
16365   verifyFormat("Foo::operator()(void&);", Style);
16366   verifyFormat("Foo::operator&(void&);", Style);
16367   verifyFormat("Foo::operator&();", Style);
16368   verifyFormat("operator&(int (&)(), class Foo);", Style);
16369 
16370   verifyFormat("Foo::operator&&();", Style);
16371   verifyFormat("Foo::operator void&&();", Style);
16372   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
16373   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
16374   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
16375   verifyFormat("Foo::operator()(void&&);", Style);
16376   verifyFormat("Foo::operator&&(void&&);", Style);
16377   verifyFormat("Foo::operator&&();", Style);
16378   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16379   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
16380   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
16381                Style);
16382   verifyFormat("operator void**()", Style);
16383   verifyFormat("operator const FooLeft<Object>&()", Style);
16384   verifyFormat("operator const FooLeft<Object>*()", Style);
16385   verifyFormat("operator const FooLeft<Object>**()", Style);
16386   verifyFormat("operator const FooLeft<Object>*&()", Style);
16387   verifyFormat("operator const FooLeft<Object>*&&()", Style);
16388 
16389   // PR45107
16390   verifyFormat("operator Vector<String>&();", Style);
16391   verifyFormat("operator const Vector<String>&();", Style);
16392   verifyFormat("operator foo::Bar*();", Style);
16393   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
16394   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
16395                Style);
16396 
16397   Style.PointerAlignment = FormatStyle::PAS_Middle;
16398   verifyFormat("Foo::operator*();", Style);
16399   verifyFormat("Foo::operator void *();", Style);
16400   verifyFormat("Foo::operator()(void *);", Style);
16401   verifyFormat("Foo::operator*(void *);", Style);
16402   verifyFormat("Foo::operator*();", Style);
16403   verifyFormat("operator*(int (*)(), class Foo);", Style);
16404 
16405   verifyFormat("Foo::operator&();", Style);
16406   verifyFormat("Foo::operator void &();", Style);
16407   verifyFormat("Foo::operator()(void &);", Style);
16408   verifyFormat("Foo::operator&(void &);", Style);
16409   verifyFormat("Foo::operator&();", Style);
16410   verifyFormat("operator&(int (&)(), class Foo);", Style);
16411 
16412   verifyFormat("Foo::operator&&();", Style);
16413   verifyFormat("Foo::operator void &&();", Style);
16414   verifyFormat("Foo::operator()(void &&);", Style);
16415   verifyFormat("Foo::operator&&(void &&);", Style);
16416   verifyFormat("Foo::operator&&();", Style);
16417   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16418 }
16419 
16420 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
16421   // These tests are not in NamespaceFixer because that doesn't
16422   // test its interaction with line wrapping
16423   FormatStyle Style = getLLVMStyle();
16424   Style.ColumnLimit = 80;
16425   verifyFormat("namespace {\n"
16426                "int i;\n"
16427                "int j;\n"
16428                "} // namespace",
16429                Style);
16430 
16431   verifyFormat("namespace AAA {\n"
16432                "int i;\n"
16433                "int j;\n"
16434                "} // namespace AAA",
16435                Style);
16436 
16437   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
16438             "int i;\n"
16439             "int j;\n"
16440             "} // namespace Averyveryveryverylongnamespace",
16441             format("namespace Averyveryveryverylongnamespace {\n"
16442                    "int i;\n"
16443                    "int j;\n"
16444                    "}",
16445                    Style));
16446 
16447   EXPECT_EQ(
16448       "namespace "
16449       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16450       "    went::mad::now {\n"
16451       "int i;\n"
16452       "int j;\n"
16453       "} // namespace\n"
16454       "  // "
16455       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16456       "went::mad::now",
16457       format("namespace "
16458              "would::it::save::you::a::lot::of::time::if_::i::"
16459              "just::gave::up::and_::went::mad::now {\n"
16460              "int i;\n"
16461              "int j;\n"
16462              "}",
16463              Style));
16464 
16465   // This used to duplicate the comment again and again on subsequent runs
16466   EXPECT_EQ(
16467       "namespace "
16468       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16469       "    went::mad::now {\n"
16470       "int i;\n"
16471       "int j;\n"
16472       "} // namespace\n"
16473       "  // "
16474       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16475       "went::mad::now",
16476       format("namespace "
16477              "would::it::save::you::a::lot::of::time::if_::i::"
16478              "just::gave::up::and_::went::mad::now {\n"
16479              "int i;\n"
16480              "int j;\n"
16481              "} // namespace\n"
16482              "  // "
16483              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
16484              "and_::went::mad::now",
16485              Style));
16486 }
16487 
16488 TEST_F(FormatTest, LikelyUnlikely) {
16489   FormatStyle Style = getLLVMStyle();
16490 
16491   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16492                "  return 29;\n"
16493                "}",
16494                Style);
16495 
16496   verifyFormat("if (argc > 5) [[likely]] {\n"
16497                "  return 29;\n"
16498                "}",
16499                Style);
16500 
16501   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16502                "  return 29;\n"
16503                "} else [[likely]] {\n"
16504                "  return 42;\n"
16505                "}\n",
16506                Style);
16507 
16508   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16509                "  return 29;\n"
16510                "} else if (argc > 10) [[likely]] {\n"
16511                "  return 99;\n"
16512                "} else {\n"
16513                "  return 42;\n"
16514                "}\n",
16515                Style);
16516 
16517   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
16518                "  return 29;\n"
16519                "}",
16520                Style);
16521 }
16522 
16523 TEST_F(FormatTest, LLVMDefaultStyle) {
16524   FormatStyle Style = getLLVMStyle();
16525   verifyFormat("extern \"C\" {\n"
16526                "int foo();\n"
16527                "}",
16528                Style);
16529 }
16530 TEST_F(FormatTest, GNUDefaultStyle) {
16531   FormatStyle Style = getGNUStyle();
16532   verifyFormat("extern \"C\"\n"
16533                "{\n"
16534                "  int foo ();\n"
16535                "}",
16536                Style);
16537 }
16538 TEST_F(FormatTest, MozillaDefaultStyle) {
16539   FormatStyle Style = getMozillaStyle();
16540   verifyFormat("extern \"C\"\n"
16541                "{\n"
16542                "  int foo();\n"
16543                "}",
16544                Style);
16545 }
16546 TEST_F(FormatTest, GoogleDefaultStyle) {
16547   FormatStyle Style = getGoogleStyle();
16548   verifyFormat("extern \"C\" {\n"
16549                "int foo();\n"
16550                "}",
16551                Style);
16552 }
16553 TEST_F(FormatTest, ChromiumDefaultStyle) {
16554   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
16555   verifyFormat("extern \"C\" {\n"
16556                "int foo();\n"
16557                "}",
16558                Style);
16559 }
16560 TEST_F(FormatTest, MicrosoftDefaultStyle) {
16561   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
16562   verifyFormat("extern \"C\"\n"
16563                "{\n"
16564                "    int foo();\n"
16565                "}",
16566                Style);
16567 }
16568 TEST_F(FormatTest, WebKitDefaultStyle) {
16569   FormatStyle Style = getWebKitStyle();
16570   verifyFormat("extern \"C\" {\n"
16571                "int foo();\n"
16572                "}",
16573                Style);
16574 }
16575 } // namespace
16576 } // namespace format
16577 } // namespace clang
16578