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, FormatTryAsAVariable) {
2668   verifyFormat("int try;");
2669   verifyFormat("int try, size;");
2670   verifyFormat("try = foo();");
2671   verifyFormat("if (try < size) {\n  return true;\n}");
2672 
2673   verifyFormat("int catch;");
2674   verifyFormat("int catch, size;");
2675   verifyFormat("catch = foo();");
2676   verifyFormat("if (catch < size) {\n  return true;\n}");
2677 }
2678 
2679 TEST_F(FormatTest, FormatSEHTryCatch) {
2680   verifyFormat("__try {\n"
2681                "  int a = b * c;\n"
2682                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2683                "  // Do nothing.\n"
2684                "}");
2685 
2686   verifyFormat("__try {\n"
2687                "  int a = b * c;\n"
2688                "} __finally {\n"
2689                "  // Do nothing.\n"
2690                "}");
2691 
2692   verifyFormat("DEBUG({\n"
2693                "  __try {\n"
2694                "  } __finally {\n"
2695                "  }\n"
2696                "});\n");
2697 }
2698 
2699 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2700   verifyFormat("try {\n"
2701                "  f();\n"
2702                "} catch {\n"
2703                "  g();\n"
2704                "}");
2705   verifyFormat("try {\n"
2706                "  f();\n"
2707                "} catch (A a) MACRO(x) {\n"
2708                "  g();\n"
2709                "} catch (B b) MACRO(x) {\n"
2710                "  g();\n"
2711                "}");
2712 }
2713 
2714 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2715   FormatStyle Style = getLLVMStyle();
2716   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2717                           FormatStyle::BS_WebKit}) {
2718     Style.BreakBeforeBraces = BraceStyle;
2719     verifyFormat("try {\n"
2720                  "  // something\n"
2721                  "} catch (...) {\n"
2722                  "  // something\n"
2723                  "}",
2724                  Style);
2725   }
2726   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2727   verifyFormat("try {\n"
2728                "  // something\n"
2729                "}\n"
2730                "catch (...) {\n"
2731                "  // something\n"
2732                "}",
2733                Style);
2734   verifyFormat("__try {\n"
2735                "  // something\n"
2736                "}\n"
2737                "__finally {\n"
2738                "  // something\n"
2739                "}",
2740                Style);
2741   verifyFormat("@try {\n"
2742                "  // something\n"
2743                "}\n"
2744                "@finally {\n"
2745                "  // something\n"
2746                "}",
2747                Style);
2748   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2749   verifyFormat("try\n"
2750                "{\n"
2751                "  // something\n"
2752                "}\n"
2753                "catch (...)\n"
2754                "{\n"
2755                "  // something\n"
2756                "}",
2757                Style);
2758   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2759   verifyFormat("try\n"
2760                "  {\n"
2761                "  // something white\n"
2762                "  }\n"
2763                "catch (...)\n"
2764                "  {\n"
2765                "  // something white\n"
2766                "  }",
2767                Style);
2768   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2769   verifyFormat("try\n"
2770                "  {\n"
2771                "    // something\n"
2772                "  }\n"
2773                "catch (...)\n"
2774                "  {\n"
2775                "    // something\n"
2776                "  }",
2777                Style);
2778   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2779   Style.BraceWrapping.BeforeCatch = true;
2780   verifyFormat("try {\n"
2781                "  // something\n"
2782                "}\n"
2783                "catch (...) {\n"
2784                "  // something\n"
2785                "}",
2786                Style);
2787 }
2788 
2789 TEST_F(FormatTest, StaticInitializers) {
2790   verifyFormat("static SomeClass SC = {1, 'a'};");
2791 
2792   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2793                "    100000000, "
2794                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2795 
2796   // Here, everything other than the "}" would fit on a line.
2797   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2798                "    10000000000000000000000000};");
2799   EXPECT_EQ("S s = {a,\n"
2800             "\n"
2801             "       b};",
2802             format("S s = {\n"
2803                    "  a,\n"
2804                    "\n"
2805                    "  b\n"
2806                    "};"));
2807 
2808   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2809   // line. However, the formatting looks a bit off and this probably doesn't
2810   // happen often in practice.
2811   verifyFormat("static int Variable[1] = {\n"
2812                "    {1000000000000000000000000000000000000}};",
2813                getLLVMStyleWithColumns(40));
2814 }
2815 
2816 TEST_F(FormatTest, DesignatedInitializers) {
2817   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2818   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2819                "                    .bbbbbbbbbb = 2,\n"
2820                "                    .cccccccccc = 3,\n"
2821                "                    .dddddddddd = 4,\n"
2822                "                    .eeeeeeeeee = 5};");
2823   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2824                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2825                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2826                "    .ccccccccccccccccccccccccccc = 3,\n"
2827                "    .ddddddddddddddddddddddddddd = 4,\n"
2828                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2829 
2830   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2831 
2832   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2833   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2834                "                    [2] = bbbbbbbbbb,\n"
2835                "                    [3] = cccccccccc,\n"
2836                "                    [4] = dddddddddd,\n"
2837                "                    [5] = eeeeeeeeee};");
2838   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2839                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2840                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2841                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2842                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2843                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2844 }
2845 
2846 TEST_F(FormatTest, NestedStaticInitializers) {
2847   verifyFormat("static A x = {{{}}};\n");
2848   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2849                "               {init1, init2, init3, init4}}};",
2850                getLLVMStyleWithColumns(50));
2851 
2852   verifyFormat("somes Status::global_reps[3] = {\n"
2853                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2854                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2855                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2856                getLLVMStyleWithColumns(60));
2857   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2858                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2859                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2860                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2861   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2862                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
2863                "rect.fTop}};");
2864 
2865   verifyFormat(
2866       "SomeArrayOfSomeType a = {\n"
2867       "    {{1, 2, 3},\n"
2868       "     {1, 2, 3},\n"
2869       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
2870       "      333333333333333333333333333333},\n"
2871       "     {1, 2, 3},\n"
2872       "     {1, 2, 3}}};");
2873   verifyFormat(
2874       "SomeArrayOfSomeType a = {\n"
2875       "    {{1, 2, 3}},\n"
2876       "    {{1, 2, 3}},\n"
2877       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2878       "      333333333333333333333333333333}},\n"
2879       "    {{1, 2, 3}},\n"
2880       "    {{1, 2, 3}}};");
2881 
2882   verifyFormat("struct {\n"
2883                "  unsigned bit;\n"
2884                "  const char *const name;\n"
2885                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2886                "                 {kOsWin, \"Windows\"},\n"
2887                "                 {kOsLinux, \"Linux\"},\n"
2888                "                 {kOsCrOS, \"Chrome OS\"}};");
2889   verifyFormat("struct {\n"
2890                "  unsigned bit;\n"
2891                "  const char *const name;\n"
2892                "} kBitsToOs[] = {\n"
2893                "    {kOsMac, \"Mac\"},\n"
2894                "    {kOsWin, \"Windows\"},\n"
2895                "    {kOsLinux, \"Linux\"},\n"
2896                "    {kOsCrOS, \"Chrome OS\"},\n"
2897                "};");
2898 }
2899 
2900 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2901   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2902                "                      \\\n"
2903                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2904 }
2905 
2906 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
2907   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2908                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
2909 
2910   // Do break defaulted and deleted functions.
2911   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2912                "    default;",
2913                getLLVMStyleWithColumns(40));
2914   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2915                "    delete;",
2916                getLLVMStyleWithColumns(40));
2917 }
2918 
2919 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2920   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2921                getLLVMStyleWithColumns(40));
2922   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2923                getLLVMStyleWithColumns(40));
2924   EXPECT_EQ("#define Q                              \\\n"
2925             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
2926             "  \"aaaaaaaa.cpp\"",
2927             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2928                    getLLVMStyleWithColumns(40)));
2929 }
2930 
2931 TEST_F(FormatTest, UnderstandsLinePPDirective) {
2932   EXPECT_EQ("# 123 \"A string literal\"",
2933             format("   #     123    \"A string literal\""));
2934 }
2935 
2936 TEST_F(FormatTest, LayoutUnknownPPDirective) {
2937   EXPECT_EQ("#;", format("#;"));
2938   verifyFormat("#\n;\n;\n;");
2939 }
2940 
2941 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
2942   EXPECT_EQ("#line 42 \"test\"\n",
2943             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
2944   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
2945                                     getLLVMStyleWithColumns(12)));
2946 }
2947 
2948 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
2949   EXPECT_EQ("#line 42 \"test\"",
2950             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
2951   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
2952 }
2953 
2954 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
2955   verifyFormat("#define A \\x20");
2956   verifyFormat("#define A \\ x20");
2957   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
2958   verifyFormat("#define A ''");
2959   verifyFormat("#define A ''qqq");
2960   verifyFormat("#define A `qqq");
2961   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
2962   EXPECT_EQ("const char *c = STRINGIFY(\n"
2963             "\\na : b);",
2964             format("const char * c = STRINGIFY(\n"
2965                    "\\na : b);"));
2966 
2967   verifyFormat("a\r\\");
2968   verifyFormat("a\v\\");
2969   verifyFormat("a\f\\");
2970 }
2971 
2972 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
2973   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
2974   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
2975   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
2976   // FIXME: We never break before the macro name.
2977   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
2978 
2979   verifyFormat("#define A A\n#define A A");
2980   verifyFormat("#define A(X) A\n#define A A");
2981 
2982   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
2983   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
2984 }
2985 
2986 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
2987   EXPECT_EQ("// somecomment\n"
2988             "#include \"a.h\"\n"
2989             "#define A(  \\\n"
2990             "    A, B)\n"
2991             "#include \"b.h\"\n"
2992             "// somecomment\n",
2993             format("  // somecomment\n"
2994                    "  #include \"a.h\"\n"
2995                    "#define A(A,\\\n"
2996                    "    B)\n"
2997                    "    #include \"b.h\"\n"
2998                    " // somecomment\n",
2999                    getLLVMStyleWithColumns(13)));
3000 }
3001 
3002 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
3003 
3004 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
3005   EXPECT_EQ("#define A    \\\n"
3006             "  c;         \\\n"
3007             "  e;\n"
3008             "f;",
3009             format("#define A c; e;\n"
3010                    "f;",
3011                    getLLVMStyleWithColumns(14)));
3012 }
3013 
3014 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
3015 
3016 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
3017   EXPECT_EQ("int x,\n"
3018             "#define A\n"
3019             "    y;",
3020             format("int x,\n#define A\ny;"));
3021 }
3022 
3023 TEST_F(FormatTest, HashInMacroDefinition) {
3024   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
3025   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
3026   verifyFormat("#define A  \\\n"
3027                "  {        \\\n"
3028                "    f(#c); \\\n"
3029                "  }",
3030                getLLVMStyleWithColumns(11));
3031 
3032   verifyFormat("#define A(X)         \\\n"
3033                "  void function##X()",
3034                getLLVMStyleWithColumns(22));
3035 
3036   verifyFormat("#define A(a, b, c)   \\\n"
3037                "  void a##b##c()",
3038                getLLVMStyleWithColumns(22));
3039 
3040   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
3041 }
3042 
3043 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
3044   EXPECT_EQ("#define A (x)", format("#define A (x)"));
3045   EXPECT_EQ("#define A(x)", format("#define A(x)"));
3046 
3047   FormatStyle Style = getLLVMStyle();
3048   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
3049   verifyFormat("#define true ((foo)1)", Style);
3050   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
3051   verifyFormat("#define false((foo)0)", Style);
3052 }
3053 
3054 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
3055   EXPECT_EQ("#define A b;", format("#define A \\\n"
3056                                    "          \\\n"
3057                                    "  b;",
3058                                    getLLVMStyleWithColumns(25)));
3059   EXPECT_EQ("#define A \\\n"
3060             "          \\\n"
3061             "  a;      \\\n"
3062             "  b;",
3063             format("#define A \\\n"
3064                    "          \\\n"
3065                    "  a;      \\\n"
3066                    "  b;",
3067                    getLLVMStyleWithColumns(11)));
3068   EXPECT_EQ("#define A \\\n"
3069             "  a;      \\\n"
3070             "          \\\n"
3071             "  b;",
3072             format("#define A \\\n"
3073                    "  a;      \\\n"
3074                    "          \\\n"
3075                    "  b;",
3076                    getLLVMStyleWithColumns(11)));
3077 }
3078 
3079 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
3080   verifyIncompleteFormat("#define A :");
3081   verifyFormat("#define SOMECASES  \\\n"
3082                "  case 1:          \\\n"
3083                "  case 2\n",
3084                getLLVMStyleWithColumns(20));
3085   verifyFormat("#define MACRO(a) \\\n"
3086                "  if (a)         \\\n"
3087                "    f();         \\\n"
3088                "  else           \\\n"
3089                "    g()",
3090                getLLVMStyleWithColumns(18));
3091   verifyFormat("#define A template <typename T>");
3092   verifyIncompleteFormat("#define STR(x) #x\n"
3093                          "f(STR(this_is_a_string_literal{));");
3094   verifyFormat("#pragma omp threadprivate( \\\n"
3095                "    y)), // expected-warning",
3096                getLLVMStyleWithColumns(28));
3097   verifyFormat("#d, = };");
3098   verifyFormat("#if \"a");
3099   verifyIncompleteFormat("({\n"
3100                          "#define b     \\\n"
3101                          "  }           \\\n"
3102                          "  a\n"
3103                          "a",
3104                          getLLVMStyleWithColumns(15));
3105   verifyFormat("#define A     \\\n"
3106                "  {           \\\n"
3107                "    {\n"
3108                "#define B     \\\n"
3109                "  }           \\\n"
3110                "  }",
3111                getLLVMStyleWithColumns(15));
3112   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
3113   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
3114   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
3115   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
3116 }
3117 
3118 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
3119   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
3120   EXPECT_EQ("class A : public QObject {\n"
3121             "  Q_OBJECT\n"
3122             "\n"
3123             "  A() {}\n"
3124             "};",
3125             format("class A  :  public QObject {\n"
3126                    "     Q_OBJECT\n"
3127                    "\n"
3128                    "  A() {\n}\n"
3129                    "}  ;"));
3130   EXPECT_EQ("MACRO\n"
3131             "/*static*/ int i;",
3132             format("MACRO\n"
3133                    " /*static*/ int   i;"));
3134   EXPECT_EQ("SOME_MACRO\n"
3135             "namespace {\n"
3136             "void f();\n"
3137             "} // namespace",
3138             format("SOME_MACRO\n"
3139                    "  namespace    {\n"
3140                    "void   f(  );\n"
3141                    "} // namespace"));
3142   // Only if the identifier contains at least 5 characters.
3143   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
3144   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
3145   // Only if everything is upper case.
3146   EXPECT_EQ("class A : public QObject {\n"
3147             "  Q_Object A() {}\n"
3148             "};",
3149             format("class A  :  public QObject {\n"
3150                    "     Q_Object\n"
3151                    "  A() {\n}\n"
3152                    "}  ;"));
3153 
3154   // Only if the next line can actually start an unwrapped line.
3155   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
3156             format("SOME_WEIRD_LOG_MACRO\n"
3157                    "<< SomeThing;"));
3158 
3159   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3160                "(n, buffers))\n",
3161                getChromiumStyle(FormatStyle::LK_Cpp));
3162 
3163   // See PR41483
3164   EXPECT_EQ("/**/ FOO(a)\n"
3165             "FOO(b)",
3166             format("/**/ FOO(a)\n"
3167                    "FOO(b)"));
3168 }
3169 
3170 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
3171   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3172             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3173             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3174             "class X {};\n"
3175             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3176             "int *createScopDetectionPass() { return 0; }",
3177             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3178                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3179                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3180                    "  class X {};\n"
3181                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3182                    "  int *createScopDetectionPass() { return 0; }"));
3183   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
3184   // braces, so that inner block is indented one level more.
3185   EXPECT_EQ("int q() {\n"
3186             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3187             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3188             "  IPC_END_MESSAGE_MAP()\n"
3189             "}",
3190             format("int q() {\n"
3191                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3192                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3193                    "  IPC_END_MESSAGE_MAP()\n"
3194                    "}"));
3195 
3196   // Same inside macros.
3197   EXPECT_EQ("#define LIST(L) \\\n"
3198             "  L(A)          \\\n"
3199             "  L(B)          \\\n"
3200             "  L(C)",
3201             format("#define LIST(L) \\\n"
3202                    "  L(A) \\\n"
3203                    "  L(B) \\\n"
3204                    "  L(C)",
3205                    getGoogleStyle()));
3206 
3207   // These must not be recognized as macros.
3208   EXPECT_EQ("int q() {\n"
3209             "  f(x);\n"
3210             "  f(x) {}\n"
3211             "  f(x)->g();\n"
3212             "  f(x)->*g();\n"
3213             "  f(x).g();\n"
3214             "  f(x) = x;\n"
3215             "  f(x) += x;\n"
3216             "  f(x) -= x;\n"
3217             "  f(x) *= x;\n"
3218             "  f(x) /= x;\n"
3219             "  f(x) %= x;\n"
3220             "  f(x) &= x;\n"
3221             "  f(x) |= x;\n"
3222             "  f(x) ^= x;\n"
3223             "  f(x) >>= x;\n"
3224             "  f(x) <<= x;\n"
3225             "  f(x)[y].z();\n"
3226             "  LOG(INFO) << x;\n"
3227             "  ifstream(x) >> x;\n"
3228             "}\n",
3229             format("int q() {\n"
3230                    "  f(x)\n;\n"
3231                    "  f(x)\n {}\n"
3232                    "  f(x)\n->g();\n"
3233                    "  f(x)\n->*g();\n"
3234                    "  f(x)\n.g();\n"
3235                    "  f(x)\n = x;\n"
3236                    "  f(x)\n += x;\n"
3237                    "  f(x)\n -= x;\n"
3238                    "  f(x)\n *= x;\n"
3239                    "  f(x)\n /= x;\n"
3240                    "  f(x)\n %= x;\n"
3241                    "  f(x)\n &= x;\n"
3242                    "  f(x)\n |= x;\n"
3243                    "  f(x)\n ^= x;\n"
3244                    "  f(x)\n >>= x;\n"
3245                    "  f(x)\n <<= x;\n"
3246                    "  f(x)\n[y].z();\n"
3247                    "  LOG(INFO)\n << x;\n"
3248                    "  ifstream(x)\n >> x;\n"
3249                    "}\n"));
3250   EXPECT_EQ("int q() {\n"
3251             "  F(x)\n"
3252             "  if (1) {\n"
3253             "  }\n"
3254             "  F(x)\n"
3255             "  while (1) {\n"
3256             "  }\n"
3257             "  F(x)\n"
3258             "  G(x);\n"
3259             "  F(x)\n"
3260             "  try {\n"
3261             "    Q();\n"
3262             "  } catch (...) {\n"
3263             "  }\n"
3264             "}\n",
3265             format("int q() {\n"
3266                    "F(x)\n"
3267                    "if (1) {}\n"
3268                    "F(x)\n"
3269                    "while (1) {}\n"
3270                    "F(x)\n"
3271                    "G(x);\n"
3272                    "F(x)\n"
3273                    "try { Q(); } catch (...) {}\n"
3274                    "}\n"));
3275   EXPECT_EQ("class A {\n"
3276             "  A() : t(0) {}\n"
3277             "  A(int i) noexcept() : {}\n"
3278             "  A(X x)\n" // FIXME: function-level try blocks are broken.
3279             "  try : t(0) {\n"
3280             "  } catch (...) {\n"
3281             "  }\n"
3282             "};",
3283             format("class A {\n"
3284                    "  A()\n : t(0) {}\n"
3285                    "  A(int i)\n noexcept() : {}\n"
3286                    "  A(X x)\n"
3287                    "  try : t(0) {} catch (...) {}\n"
3288                    "};"));
3289   FormatStyle Style = getLLVMStyle();
3290   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3291   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3292   Style.BraceWrapping.AfterFunction = true;
3293   EXPECT_EQ("void f()\n"
3294             "try\n"
3295             "{\n"
3296             "}",
3297             format("void f() try {\n"
3298                    "}",
3299                    Style));
3300   EXPECT_EQ("class SomeClass {\n"
3301             "public:\n"
3302             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3303             "};",
3304             format("class SomeClass {\n"
3305                    "public:\n"
3306                    "  SomeClass()\n"
3307                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3308                    "};"));
3309   EXPECT_EQ("class SomeClass {\n"
3310             "public:\n"
3311             "  SomeClass()\n"
3312             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3313             "};",
3314             format("class SomeClass {\n"
3315                    "public:\n"
3316                    "  SomeClass()\n"
3317                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3318                    "};",
3319                    getLLVMStyleWithColumns(40)));
3320 
3321   verifyFormat("MACRO(>)");
3322 
3323   // Some macros contain an implicit semicolon.
3324   Style = getLLVMStyle();
3325   Style.StatementMacros.push_back("FOO");
3326   verifyFormat("FOO(a) int b = 0;");
3327   verifyFormat("FOO(a)\n"
3328                "int b = 0;",
3329                Style);
3330   verifyFormat("FOO(a);\n"
3331                "int b = 0;",
3332                Style);
3333   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3334                "int b = 0;",
3335                Style);
3336   verifyFormat("FOO()\n"
3337                "int b = 0;",
3338                Style);
3339   verifyFormat("FOO\n"
3340                "int b = 0;",
3341                Style);
3342   verifyFormat("void f() {\n"
3343                "  FOO(a)\n"
3344                "  return a;\n"
3345                "}",
3346                Style);
3347   verifyFormat("FOO(a)\n"
3348                "FOO(b)",
3349                Style);
3350   verifyFormat("int a = 0;\n"
3351                "FOO(b)\n"
3352                "int c = 0;",
3353                Style);
3354   verifyFormat("int a = 0;\n"
3355                "int x = FOO(a)\n"
3356                "int b = 0;",
3357                Style);
3358   verifyFormat("void foo(int a) { FOO(a) }\n"
3359                "uint32_t bar() {}",
3360                Style);
3361 }
3362 
3363 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3364   verifyFormat("#define A \\\n"
3365                "  f({     \\\n"
3366                "    g();  \\\n"
3367                "  });",
3368                getLLVMStyleWithColumns(11));
3369 }
3370 
3371 TEST_F(FormatTest, IndentPreprocessorDirectives) {
3372   FormatStyle Style = getLLVMStyle();
3373   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3374   Style.ColumnLimit = 40;
3375   verifyFormat("#ifdef _WIN32\n"
3376                "#define A 0\n"
3377                "#ifdef VAR2\n"
3378                "#define B 1\n"
3379                "#include <someheader.h>\n"
3380                "#define MACRO                          \\\n"
3381                "  some_very_long_func_aaaaaaaaaa();\n"
3382                "#endif\n"
3383                "#else\n"
3384                "#define A 1\n"
3385                "#endif",
3386                Style);
3387   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3388   verifyFormat("#ifdef _WIN32\n"
3389                "#  define A 0\n"
3390                "#  ifdef VAR2\n"
3391                "#    define B 1\n"
3392                "#    include <someheader.h>\n"
3393                "#    define MACRO                      \\\n"
3394                "      some_very_long_func_aaaaaaaaaa();\n"
3395                "#  endif\n"
3396                "#else\n"
3397                "#  define A 1\n"
3398                "#endif",
3399                Style);
3400   verifyFormat("#if A\n"
3401                "#  define MACRO                        \\\n"
3402                "    void a(int x) {                    \\\n"
3403                "      b();                             \\\n"
3404                "      c();                             \\\n"
3405                "      d();                             \\\n"
3406                "      e();                             \\\n"
3407                "      f();                             \\\n"
3408                "    }\n"
3409                "#endif",
3410                Style);
3411   // Comments before include guard.
3412   verifyFormat("// file comment\n"
3413                "// file comment\n"
3414                "#ifndef HEADER_H\n"
3415                "#define HEADER_H\n"
3416                "code();\n"
3417                "#endif",
3418                Style);
3419   // Test with include guards.
3420   verifyFormat("#ifndef HEADER_H\n"
3421                "#define HEADER_H\n"
3422                "code();\n"
3423                "#endif",
3424                Style);
3425   // Include guards must have a #define with the same variable immediately
3426   // after #ifndef.
3427   verifyFormat("#ifndef NOT_GUARD\n"
3428                "#  define FOO\n"
3429                "code();\n"
3430                "#endif",
3431                Style);
3432 
3433   // Include guards must cover the entire file.
3434   verifyFormat("code();\n"
3435                "code();\n"
3436                "#ifndef NOT_GUARD\n"
3437                "#  define NOT_GUARD\n"
3438                "code();\n"
3439                "#endif",
3440                Style);
3441   verifyFormat("#ifndef NOT_GUARD\n"
3442                "#  define NOT_GUARD\n"
3443                "code();\n"
3444                "#endif\n"
3445                "code();",
3446                Style);
3447   // Test with trailing blank lines.
3448   verifyFormat("#ifndef HEADER_H\n"
3449                "#define HEADER_H\n"
3450                "code();\n"
3451                "#endif\n",
3452                Style);
3453   // Include guards don't have #else.
3454   verifyFormat("#ifndef NOT_GUARD\n"
3455                "#  define NOT_GUARD\n"
3456                "code();\n"
3457                "#else\n"
3458                "#endif",
3459                Style);
3460   verifyFormat("#ifndef NOT_GUARD\n"
3461                "#  define NOT_GUARD\n"
3462                "code();\n"
3463                "#elif FOO\n"
3464                "#endif",
3465                Style);
3466   // Non-identifier #define after potential include guard.
3467   verifyFormat("#ifndef FOO\n"
3468                "#  define 1\n"
3469                "#endif\n",
3470                Style);
3471   // #if closes past last non-preprocessor line.
3472   verifyFormat("#ifndef FOO\n"
3473                "#define FOO\n"
3474                "#if 1\n"
3475                "int i;\n"
3476                "#  define A 0\n"
3477                "#endif\n"
3478                "#endif\n",
3479                Style);
3480   // Don't crash if there is an #elif directive without a condition.
3481   verifyFormat("#if 1\n"
3482                "int x;\n"
3483                "#elif\n"
3484                "int y;\n"
3485                "#else\n"
3486                "int z;\n"
3487                "#endif",
3488                Style);
3489   // FIXME: This doesn't handle the case where there's code between the
3490   // #ifndef and #define but all other conditions hold. This is because when
3491   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3492   // previous code line yet, so we can't detect it.
3493   EXPECT_EQ("#ifndef NOT_GUARD\n"
3494             "code();\n"
3495             "#define NOT_GUARD\n"
3496             "code();\n"
3497             "#endif",
3498             format("#ifndef NOT_GUARD\n"
3499                    "code();\n"
3500                    "#  define NOT_GUARD\n"
3501                    "code();\n"
3502                    "#endif",
3503                    Style));
3504   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3505   // be outside an include guard. Examples are #pragma once and
3506   // #pragma GCC diagnostic, or anything else that does not change the meaning
3507   // of the file if it's included multiple times.
3508   EXPECT_EQ("#ifdef WIN32\n"
3509             "#  pragma once\n"
3510             "#endif\n"
3511             "#ifndef HEADER_H\n"
3512             "#  define HEADER_H\n"
3513             "code();\n"
3514             "#endif",
3515             format("#ifdef WIN32\n"
3516                    "#  pragma once\n"
3517                    "#endif\n"
3518                    "#ifndef HEADER_H\n"
3519                    "#define HEADER_H\n"
3520                    "code();\n"
3521                    "#endif",
3522                    Style));
3523   // FIXME: This does not detect when there is a single non-preprocessor line
3524   // in front of an include-guard-like structure where other conditions hold
3525   // because ScopedLineState hides the line.
3526   EXPECT_EQ("code();\n"
3527             "#ifndef HEADER_H\n"
3528             "#define HEADER_H\n"
3529             "code();\n"
3530             "#endif",
3531             format("code();\n"
3532                    "#ifndef HEADER_H\n"
3533                    "#  define HEADER_H\n"
3534                    "code();\n"
3535                    "#endif",
3536                    Style));
3537   // Keep comments aligned with #, otherwise indent comments normally. These
3538   // tests cannot use verifyFormat because messUp manipulates leading
3539   // whitespace.
3540   {
3541     const char *Expected = ""
3542                            "void f() {\n"
3543                            "#if 1\n"
3544                            "// Preprocessor aligned.\n"
3545                            "#  define A 0\n"
3546                            "  // Code. Separated by blank line.\n"
3547                            "\n"
3548                            "#  define B 0\n"
3549                            "  // Code. Not aligned with #\n"
3550                            "#  define C 0\n"
3551                            "#endif";
3552     const char *ToFormat = ""
3553                            "void f() {\n"
3554                            "#if 1\n"
3555                            "// Preprocessor aligned.\n"
3556                            "#  define A 0\n"
3557                            "// Code. Separated by blank line.\n"
3558                            "\n"
3559                            "#  define B 0\n"
3560                            "   // Code. Not aligned with #\n"
3561                            "#  define C 0\n"
3562                            "#endif";
3563     EXPECT_EQ(Expected, format(ToFormat, Style));
3564     EXPECT_EQ(Expected, format(Expected, Style));
3565   }
3566   // Keep block quotes aligned.
3567   {
3568     const char *Expected = ""
3569                            "void f() {\n"
3570                            "#if 1\n"
3571                            "/* Preprocessor aligned. */\n"
3572                            "#  define A 0\n"
3573                            "  /* Code. Separated by blank line. */\n"
3574                            "\n"
3575                            "#  define B 0\n"
3576                            "  /* Code. Not aligned with # */\n"
3577                            "#  define C 0\n"
3578                            "#endif";
3579     const char *ToFormat = ""
3580                            "void f() {\n"
3581                            "#if 1\n"
3582                            "/* Preprocessor aligned. */\n"
3583                            "#  define A 0\n"
3584                            "/* Code. Separated by blank line. */\n"
3585                            "\n"
3586                            "#  define B 0\n"
3587                            "   /* Code. Not aligned with # */\n"
3588                            "#  define C 0\n"
3589                            "#endif";
3590     EXPECT_EQ(Expected, format(ToFormat, Style));
3591     EXPECT_EQ(Expected, format(Expected, Style));
3592   }
3593   // Keep comments aligned with un-indented directives.
3594   {
3595     const char *Expected = ""
3596                            "void f() {\n"
3597                            "// Preprocessor aligned.\n"
3598                            "#define A 0\n"
3599                            "  // Code. Separated by blank line.\n"
3600                            "\n"
3601                            "#define B 0\n"
3602                            "  // Code. Not aligned with #\n"
3603                            "#define C 0\n";
3604     const char *ToFormat = ""
3605                            "void f() {\n"
3606                            "// Preprocessor aligned.\n"
3607                            "#define A 0\n"
3608                            "// Code. Separated by blank line.\n"
3609                            "\n"
3610                            "#define B 0\n"
3611                            "   // Code. Not aligned with #\n"
3612                            "#define C 0\n";
3613     EXPECT_EQ(Expected, format(ToFormat, Style));
3614     EXPECT_EQ(Expected, format(Expected, Style));
3615   }
3616   // Test AfterHash with tabs.
3617   {
3618     FormatStyle Tabbed = Style;
3619     Tabbed.UseTab = FormatStyle::UT_Always;
3620     Tabbed.IndentWidth = 8;
3621     Tabbed.TabWidth = 8;
3622     verifyFormat("#ifdef _WIN32\n"
3623                  "#\tdefine A 0\n"
3624                  "#\tifdef VAR2\n"
3625                  "#\t\tdefine B 1\n"
3626                  "#\t\tinclude <someheader.h>\n"
3627                  "#\t\tdefine MACRO          \\\n"
3628                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3629                  "#\tendif\n"
3630                  "#else\n"
3631                  "#\tdefine A 1\n"
3632                  "#endif",
3633                  Tabbed);
3634   }
3635 
3636   // Regression test: Multiline-macro inside include guards.
3637   verifyFormat("#ifndef HEADER_H\n"
3638                "#define HEADER_H\n"
3639                "#define A()        \\\n"
3640                "  int i;           \\\n"
3641                "  int j;\n"
3642                "#endif // HEADER_H",
3643                getLLVMStyleWithColumns(20));
3644 
3645   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3646   // Basic before hash indent tests
3647   verifyFormat("#ifdef _WIN32\n"
3648                "  #define A 0\n"
3649                "  #ifdef VAR2\n"
3650                "    #define B 1\n"
3651                "    #include <someheader.h>\n"
3652                "    #define MACRO                      \\\n"
3653                "      some_very_long_func_aaaaaaaaaa();\n"
3654                "  #endif\n"
3655                "#else\n"
3656                "  #define A 1\n"
3657                "#endif",
3658                Style);
3659   verifyFormat("#if A\n"
3660                "  #define MACRO                        \\\n"
3661                "    void a(int x) {                    \\\n"
3662                "      b();                             \\\n"
3663                "      c();                             \\\n"
3664                "      d();                             \\\n"
3665                "      e();                             \\\n"
3666                "      f();                             \\\n"
3667                "    }\n"
3668                "#endif",
3669                Style);
3670   // Keep comments aligned with indented directives. These
3671   // tests cannot use verifyFormat because messUp manipulates leading
3672   // whitespace.
3673   {
3674     const char *Expected = "void f() {\n"
3675                            "// Aligned to preprocessor.\n"
3676                            "#if 1\n"
3677                            "  // Aligned to code.\n"
3678                            "  int a;\n"
3679                            "  #if 1\n"
3680                            "    // Aligned to preprocessor.\n"
3681                            "    #define A 0\n"
3682                            "  // Aligned to code.\n"
3683                            "  int b;\n"
3684                            "  #endif\n"
3685                            "#endif\n"
3686                            "}";
3687     const char *ToFormat = "void f() {\n"
3688                            "// Aligned to preprocessor.\n"
3689                            "#if 1\n"
3690                            "// Aligned to code.\n"
3691                            "int a;\n"
3692                            "#if 1\n"
3693                            "// Aligned to preprocessor.\n"
3694                            "#define A 0\n"
3695                            "// Aligned to code.\n"
3696                            "int b;\n"
3697                            "#endif\n"
3698                            "#endif\n"
3699                            "}";
3700     EXPECT_EQ(Expected, format(ToFormat, Style));
3701     EXPECT_EQ(Expected, format(Expected, Style));
3702   }
3703   {
3704     const char *Expected = "void f() {\n"
3705                            "/* Aligned to preprocessor. */\n"
3706                            "#if 1\n"
3707                            "  /* Aligned to code. */\n"
3708                            "  int a;\n"
3709                            "  #if 1\n"
3710                            "    /* Aligned to preprocessor. */\n"
3711                            "    #define A 0\n"
3712                            "  /* Aligned to code. */\n"
3713                            "  int b;\n"
3714                            "  #endif\n"
3715                            "#endif\n"
3716                            "}";
3717     const char *ToFormat = "void f() {\n"
3718                            "/* Aligned to preprocessor. */\n"
3719                            "#if 1\n"
3720                            "/* Aligned to code. */\n"
3721                            "int a;\n"
3722                            "#if 1\n"
3723                            "/* Aligned to preprocessor. */\n"
3724                            "#define A 0\n"
3725                            "/* Aligned to code. */\n"
3726                            "int b;\n"
3727                            "#endif\n"
3728                            "#endif\n"
3729                            "}";
3730     EXPECT_EQ(Expected, format(ToFormat, Style));
3731     EXPECT_EQ(Expected, format(Expected, Style));
3732   }
3733 
3734   // Test single comment before preprocessor
3735   verifyFormat("// Comment\n"
3736                "\n"
3737                "#if 1\n"
3738                "#endif",
3739                Style);
3740 }
3741 
3742 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3743   verifyFormat("{\n  { a #c; }\n}");
3744 }
3745 
3746 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3747   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
3748             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3749   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
3750             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3751 }
3752 
3753 TEST_F(FormatTest, EscapedNewlines) {
3754   FormatStyle Narrow = getLLVMStyleWithColumns(11);
3755   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
3756             format("#define A \\\nint i;\\\n  int j;", Narrow));
3757   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3758   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3759   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
3760   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3761 
3762   FormatStyle AlignLeft = getLLVMStyle();
3763   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3764   EXPECT_EQ("#define MACRO(x) \\\n"
3765             "private:         \\\n"
3766             "  int x(int a);\n",
3767             format("#define MACRO(x) \\\n"
3768                    "private:         \\\n"
3769                    "  int x(int a);\n",
3770                    AlignLeft));
3771 
3772   // CRLF line endings
3773   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
3774             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
3775   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3776   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3777   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
3778   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3779   EXPECT_EQ("#define MACRO(x) \\\r\n"
3780             "private:         \\\r\n"
3781             "  int x(int a);\r\n",
3782             format("#define MACRO(x) \\\r\n"
3783                    "private:         \\\r\n"
3784                    "  int x(int a);\r\n",
3785                    AlignLeft));
3786 
3787   FormatStyle DontAlign = getLLVMStyle();
3788   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3789   DontAlign.MaxEmptyLinesToKeep = 3;
3790   // FIXME: can't use verifyFormat here because the newline before
3791   // "public:" is not inserted the first time it's reformatted
3792   EXPECT_EQ("#define A \\\n"
3793             "  class Foo { \\\n"
3794             "    void bar(); \\\n"
3795             "\\\n"
3796             "\\\n"
3797             "\\\n"
3798             "  public: \\\n"
3799             "    void baz(); \\\n"
3800             "  };",
3801             format("#define A \\\n"
3802                    "  class Foo { \\\n"
3803                    "    void bar(); \\\n"
3804                    "\\\n"
3805                    "\\\n"
3806                    "\\\n"
3807                    "  public: \\\n"
3808                    "    void baz(); \\\n"
3809                    "  };",
3810                    DontAlign));
3811 }
3812 
3813 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3814   verifyFormat("#define A \\\n"
3815                "  int v(  \\\n"
3816                "      a); \\\n"
3817                "  int i;",
3818                getLLVMStyleWithColumns(11));
3819 }
3820 
3821 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3822   EXPECT_EQ(
3823       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3824       "                      \\\n"
3825       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3826       "\n"
3827       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3828       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3829       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
3830              "\\\n"
3831              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3832              "  \n"
3833              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3834              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3835 }
3836 
3837 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3838   EXPECT_EQ("int\n"
3839             "#define A\n"
3840             "    a;",
3841             format("int\n#define A\na;"));
3842   verifyFormat("functionCallTo(\n"
3843                "    someOtherFunction(\n"
3844                "        withSomeParameters, whichInSequence,\n"
3845                "        areLongerThanALine(andAnotherCall,\n"
3846                "#define A B\n"
3847                "                           withMoreParamters,\n"
3848                "                           whichStronglyInfluenceTheLayout),\n"
3849                "        andMoreParameters),\n"
3850                "    trailing);",
3851                getLLVMStyleWithColumns(69));
3852   verifyFormat("Foo::Foo()\n"
3853                "#ifdef BAR\n"
3854                "    : baz(0)\n"
3855                "#endif\n"
3856                "{\n"
3857                "}");
3858   verifyFormat("void f() {\n"
3859                "  if (true)\n"
3860                "#ifdef A\n"
3861                "    f(42);\n"
3862                "  x();\n"
3863                "#else\n"
3864                "    g();\n"
3865                "  x();\n"
3866                "#endif\n"
3867                "}");
3868   verifyFormat("void f(param1, param2,\n"
3869                "       param3,\n"
3870                "#ifdef A\n"
3871                "       param4(param5,\n"
3872                "#ifdef A1\n"
3873                "              param6,\n"
3874                "#ifdef A2\n"
3875                "              param7),\n"
3876                "#else\n"
3877                "              param8),\n"
3878                "       param9,\n"
3879                "#endif\n"
3880                "       param10,\n"
3881                "#endif\n"
3882                "       param11)\n"
3883                "#else\n"
3884                "       param12)\n"
3885                "#endif\n"
3886                "{\n"
3887                "  x();\n"
3888                "}",
3889                getLLVMStyleWithColumns(28));
3890   verifyFormat("#if 1\n"
3891                "int i;");
3892   verifyFormat("#if 1\n"
3893                "#endif\n"
3894                "#if 1\n"
3895                "#else\n"
3896                "#endif\n");
3897   verifyFormat("DEBUG({\n"
3898                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3899                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
3900                "});\n"
3901                "#if a\n"
3902                "#else\n"
3903                "#endif");
3904 
3905   verifyIncompleteFormat("void f(\n"
3906                          "#if A\n"
3907                          ");\n"
3908                          "#else\n"
3909                          "#endif");
3910 }
3911 
3912 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
3913   verifyFormat("#endif\n"
3914                "#if B");
3915 }
3916 
3917 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
3918   FormatStyle SingleLine = getLLVMStyle();
3919   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
3920   verifyFormat("#if 0\n"
3921                "#elif 1\n"
3922                "#endif\n"
3923                "void foo() {\n"
3924                "  if (test) foo2();\n"
3925                "}",
3926                SingleLine);
3927 }
3928 
3929 TEST_F(FormatTest, LayoutBlockInsideParens) {
3930   verifyFormat("functionCall({ int i; });");
3931   verifyFormat("functionCall({\n"
3932                "  int i;\n"
3933                "  int j;\n"
3934                "});");
3935   verifyFormat("functionCall(\n"
3936                "    {\n"
3937                "      int i;\n"
3938                "      int j;\n"
3939                "    },\n"
3940                "    aaaa, bbbb, cccc);");
3941   verifyFormat("functionA(functionB({\n"
3942                "            int i;\n"
3943                "            int j;\n"
3944                "          }),\n"
3945                "          aaaa, bbbb, cccc);");
3946   verifyFormat("functionCall(\n"
3947                "    {\n"
3948                "      int i;\n"
3949                "      int j;\n"
3950                "    },\n"
3951                "    aaaa, bbbb, // comment\n"
3952                "    cccc);");
3953   verifyFormat("functionA(functionB({\n"
3954                "            int i;\n"
3955                "            int j;\n"
3956                "          }),\n"
3957                "          aaaa, bbbb, // comment\n"
3958                "          cccc);");
3959   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
3960   verifyFormat("functionCall(aaaa, bbbb, {\n"
3961                "  int i;\n"
3962                "  int j;\n"
3963                "});");
3964   verifyFormat(
3965       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
3966       "    {\n"
3967       "      int i; // break\n"
3968       "    },\n"
3969       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
3970       "                                     ccccccccccccccccc));");
3971   verifyFormat("DEBUG({\n"
3972                "  if (a)\n"
3973                "    f();\n"
3974                "});");
3975 }
3976 
3977 TEST_F(FormatTest, LayoutBlockInsideStatement) {
3978   EXPECT_EQ("SOME_MACRO { int i; }\n"
3979             "int i;",
3980             format("  SOME_MACRO  {int i;}  int i;"));
3981 }
3982 
3983 TEST_F(FormatTest, LayoutNestedBlocks) {
3984   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
3985                "  struct s {\n"
3986                "    int i;\n"
3987                "  };\n"
3988                "  s kBitsToOs[] = {{10}};\n"
3989                "  for (int i = 0; i < 10; ++i)\n"
3990                "    return;\n"
3991                "}");
3992   verifyFormat("call(parameter, {\n"
3993                "  something();\n"
3994                "  // Comment using all columns.\n"
3995                "  somethingelse();\n"
3996                "});",
3997                getLLVMStyleWithColumns(40));
3998   verifyFormat("DEBUG( //\n"
3999                "    { f(); }, a);");
4000   verifyFormat("DEBUG( //\n"
4001                "    {\n"
4002                "      f(); //\n"
4003                "    },\n"
4004                "    a);");
4005 
4006   EXPECT_EQ("call(parameter, {\n"
4007             "  something();\n"
4008             "  // Comment too\n"
4009             "  // looooooooooong.\n"
4010             "  somethingElse();\n"
4011             "});",
4012             format("call(parameter, {\n"
4013                    "  something();\n"
4014                    "  // Comment too looooooooooong.\n"
4015                    "  somethingElse();\n"
4016                    "});",
4017                    getLLVMStyleWithColumns(29)));
4018   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
4019   EXPECT_EQ("DEBUG({ // comment\n"
4020             "  int i;\n"
4021             "});",
4022             format("DEBUG({ // comment\n"
4023                    "int  i;\n"
4024                    "});"));
4025   EXPECT_EQ("DEBUG({\n"
4026             "  int i;\n"
4027             "\n"
4028             "  // comment\n"
4029             "  int j;\n"
4030             "});",
4031             format("DEBUG({\n"
4032                    "  int  i;\n"
4033                    "\n"
4034                    "  // comment\n"
4035                    "  int  j;\n"
4036                    "});"));
4037 
4038   verifyFormat("DEBUG({\n"
4039                "  if (a)\n"
4040                "    return;\n"
4041                "});");
4042   verifyGoogleFormat("DEBUG({\n"
4043                      "  if (a) return;\n"
4044                      "});");
4045   FormatStyle Style = getGoogleStyle();
4046   Style.ColumnLimit = 45;
4047   verifyFormat("Debug(\n"
4048                "    aaaaa,\n"
4049                "    {\n"
4050                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
4051                "    },\n"
4052                "    a);",
4053                Style);
4054 
4055   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
4056 
4057   verifyNoCrash("^{v^{a}}");
4058 }
4059 
4060 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
4061   EXPECT_EQ("#define MACRO()                     \\\n"
4062             "  Debug(aaa, /* force line break */ \\\n"
4063             "        {                           \\\n"
4064             "          int i;                    \\\n"
4065             "          int j;                    \\\n"
4066             "        })",
4067             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
4068                    "          {  int   i;  int  j;   })",
4069                    getGoogleStyle()));
4070 
4071   EXPECT_EQ("#define A                                       \\\n"
4072             "  [] {                                          \\\n"
4073             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
4074             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
4075             "  }",
4076             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4077                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
4078                    getGoogleStyle()));
4079 }
4080 
4081 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
4082   EXPECT_EQ("{}", format("{}"));
4083   verifyFormat("enum E {};");
4084   verifyFormat("enum E {}");
4085   FormatStyle Style = getLLVMStyle();
4086   Style.SpaceInEmptyBlock = true;
4087   EXPECT_EQ("void f() { }", format("void f() {}", Style));
4088   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
4089   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4090 }
4091 
4092 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
4093   FormatStyle Style = getLLVMStyle();
4094   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
4095   Style.MacroBlockEnd = "^[A-Z_]+_END$";
4096   verifyFormat("FOO_BEGIN\n"
4097                "  FOO_ENTRY\n"
4098                "FOO_END",
4099                Style);
4100   verifyFormat("FOO_BEGIN\n"
4101                "  NESTED_FOO_BEGIN\n"
4102                "    NESTED_FOO_ENTRY\n"
4103                "  NESTED_FOO_END\n"
4104                "FOO_END",
4105                Style);
4106   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
4107                "  int x;\n"
4108                "  x = 1;\n"
4109                "FOO_END(Baz)",
4110                Style);
4111 }
4112 
4113 //===----------------------------------------------------------------------===//
4114 // Line break tests.
4115 //===----------------------------------------------------------------------===//
4116 
4117 TEST_F(FormatTest, PreventConfusingIndents) {
4118   verifyFormat(
4119       "void f() {\n"
4120       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
4121       "                         parameter, parameter, parameter)),\n"
4122       "                     SecondLongCall(parameter));\n"
4123       "}");
4124   verifyFormat(
4125       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4126       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4127       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4128       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
4129   verifyFormat(
4130       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4131       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
4132       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4133       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
4134   verifyFormat(
4135       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
4136       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
4137       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
4138       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
4139   verifyFormat("int a = bbbb && ccc &&\n"
4140                "        fffff(\n"
4141                "#define A Just forcing a new line\n"
4142                "            ddd);");
4143 }
4144 
4145 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
4146   verifyFormat(
4147       "bool aaaaaaa =\n"
4148       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
4149       "    bbbbbbbb();");
4150   verifyFormat(
4151       "bool aaaaaaa =\n"
4152       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
4153       "    bbbbbbbb();");
4154 
4155   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4156                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
4157                "    ccccccccc == ddddddddddd;");
4158   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4159                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
4160                "    ccccccccc == ddddddddddd;");
4161   verifyFormat(
4162       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
4163       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
4164       "    ccccccccc == ddddddddddd;");
4165 
4166   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4167                "                 aaaaaa) &&\n"
4168                "         bbbbbb && cccccc;");
4169   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4170                "                 aaaaaa) >>\n"
4171                "         bbbbbb;");
4172   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
4173                "    SourceMgr.getSpellingColumnNumber(\n"
4174                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
4175                "    1);");
4176 
4177   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4178                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
4179                "    cccccc) {\n}");
4180   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4181                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4182                "              cccccc) {\n}");
4183   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4184                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4185                "              cccccc) {\n}");
4186   verifyFormat("b = a &&\n"
4187                "    // Comment\n"
4188                "    b.c && d;");
4189 
4190   // If the LHS of a comparison is not a binary expression itself, the
4191   // additional linebreak confuses many people.
4192   verifyFormat(
4193       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4194       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
4195       "}");
4196   verifyFormat(
4197       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4198       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4199       "}");
4200   verifyFormat(
4201       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
4202       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4203       "}");
4204   verifyFormat(
4205       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4206       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
4207       "}");
4208   // Even explicit parentheses stress the precedence enough to make the
4209   // additional break unnecessary.
4210   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4211                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4212                "}");
4213   // This cases is borderline, but with the indentation it is still readable.
4214   verifyFormat(
4215       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4216       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4217       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4218       "}",
4219       getLLVMStyleWithColumns(75));
4220 
4221   // If the LHS is a binary expression, we should still use the additional break
4222   // as otherwise the formatting hides the operator precedence.
4223   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4224                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4225                "    5) {\n"
4226                "}");
4227   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4228                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4229                "    5) {\n"
4230                "}");
4231 
4232   FormatStyle OnePerLine = getLLVMStyle();
4233   OnePerLine.BinPackParameters = false;
4234   verifyFormat(
4235       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4236       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4237       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4238       OnePerLine);
4239 
4240   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4241                "                .aaa(aaaaaaaaaaaaa) *\n"
4242                "            aaaaaaa +\n"
4243                "        aaaaaaa;",
4244                getLLVMStyleWithColumns(40));
4245 }
4246 
4247 TEST_F(FormatTest, ExpressionIndentation) {
4248   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4249                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4250                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4251                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4252                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4253                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4254                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4255                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4256                "                 ccccccccccccccccccccccccccccccccccccccccc;");
4257   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4258                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4259                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4260                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4261   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4262                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4263                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4264                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4265   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4266                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4267                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4268                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4269   verifyFormat("if () {\n"
4270                "} else if (aaaaa && bbbbb > // break\n"
4271                "                        ccccc) {\n"
4272                "}");
4273   verifyFormat("if () {\n"
4274                "} else if constexpr (aaaaa && bbbbb > // break\n"
4275                "                                  ccccc) {\n"
4276                "}");
4277   verifyFormat("if () {\n"
4278                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4279                "                                  ccccc) {\n"
4280                "}");
4281   verifyFormat("if () {\n"
4282                "} else if (aaaaa &&\n"
4283                "           bbbbb > // break\n"
4284                "               ccccc &&\n"
4285                "           ddddd) {\n"
4286                "}");
4287 
4288   // Presence of a trailing comment used to change indentation of b.
4289   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4290                "       b;\n"
4291                "return aaaaaaaaaaaaaaaaaaa +\n"
4292                "       b; //",
4293                getLLVMStyleWithColumns(30));
4294 }
4295 
4296 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4297   // Not sure what the best system is here. Like this, the LHS can be found
4298   // immediately above an operator (everything with the same or a higher
4299   // indent). The RHS is aligned right of the operator and so compasses
4300   // everything until something with the same indent as the operator is found.
4301   // FIXME: Is this a good system?
4302   FormatStyle Style = getLLVMStyle();
4303   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4304   verifyFormat(
4305       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4306       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4307       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4308       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4309       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4310       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4311       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4312       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4313       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
4314       Style);
4315   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4316                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4317                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4318                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4319                Style);
4320   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4321                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4322                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4323                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4324                Style);
4325   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4326                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4327                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4328                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4329                Style);
4330   verifyFormat("if () {\n"
4331                "} else if (aaaaa\n"
4332                "           && bbbbb // break\n"
4333                "                  > ccccc) {\n"
4334                "}",
4335                Style);
4336   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4337                "       && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4338                Style);
4339   verifyFormat("return (a)\n"
4340                "       // comment\n"
4341                "       + b;",
4342                Style);
4343   verifyFormat(
4344       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4345       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4346       "             + cc;",
4347       Style);
4348 
4349   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4350                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4351                Style);
4352 
4353   // Forced by comments.
4354   verifyFormat(
4355       "unsigned ContentSize =\n"
4356       "    sizeof(int16_t)   // DWARF ARange version number\n"
4357       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4358       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4359       "    + sizeof(int8_t); // Segment Size (in bytes)");
4360 
4361   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4362                "       == boost::fusion::at_c<1>(iiii).second;",
4363                Style);
4364 
4365   Style.ColumnLimit = 60;
4366   verifyFormat("zzzzzzzzzz\n"
4367                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4368                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4369                Style);
4370 
4371   Style.ColumnLimit = 80;
4372   Style.IndentWidth = 4;
4373   Style.TabWidth = 4;
4374   Style.UseTab = FormatStyle::UT_Always;
4375   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4376   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4377   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4378             "\t&& (someOtherLongishConditionPart1\n"
4379             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4380             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4381                    "(someOtherLongishConditionPart1 || "
4382                    "someOtherEvenLongerNestedConditionPart2);",
4383                    Style));
4384 }
4385 
4386 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
4387   FormatStyle Style = getLLVMStyle();
4388   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4389   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
4390 
4391   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4392                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4393                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4394                "              == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4395                "                         * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4396                "                     + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4397                "          && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4398                "                     * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4399                "                 > ccccccccccccccccccccccccccccccccccccccccc;",
4400                Style);
4401   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4402                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4403                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4404                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4405                Style);
4406   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4407                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4408                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4409                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4410                Style);
4411   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4412                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4413                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4414                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4415                Style);
4416   verifyFormat("if () {\n"
4417                "} else if (aaaaa\n"
4418                "           && bbbbb // break\n"
4419                "                  > ccccc) {\n"
4420                "}",
4421                Style);
4422   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4423                "    && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4424                Style);
4425   verifyFormat("return (a)\n"
4426                "     // comment\n"
4427                "     + b;",
4428                Style);
4429   verifyFormat(
4430       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4431       "               * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4432       "           + cc;",
4433       Style);
4434   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
4435                "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4436                "                        : 3333333333333333;",
4437                Style);
4438   verifyFormat(
4439       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
4440       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
4441       "                                             : eeeeeeeeeeeeeeeeee)\n"
4442       "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4443       "                        : 3333333333333333;",
4444       Style);
4445   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4446                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4447                Style);
4448 
4449   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4450                "    == boost::fusion::at_c<1>(iiii).second;",
4451                Style);
4452 
4453   Style.ColumnLimit = 60;
4454   verifyFormat("zzzzzzzzzzzzz\n"
4455                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4456                "   >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4457                Style);
4458 
4459   // Forced by comments.
4460   Style.ColumnLimit = 80;
4461   verifyFormat(
4462       "unsigned ContentSize\n"
4463       "    = sizeof(int16_t) // DWARF ARange version number\n"
4464       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4465       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4466       "    + sizeof(int8_t); // Segment Size (in bytes)",
4467       Style);
4468 
4469   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4470   verifyFormat(
4471       "unsigned ContentSize =\n"
4472       "    sizeof(int16_t)   // DWARF ARange version number\n"
4473       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4474       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4475       "    + sizeof(int8_t); // Segment Size (in bytes)",
4476       Style);
4477 
4478   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4479   verifyFormat(
4480       "unsigned ContentSize =\n"
4481       "    sizeof(int16_t)   // DWARF ARange version number\n"
4482       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4483       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4484       "    + sizeof(int8_t); // Segment Size (in bytes)",
4485       Style);
4486 }
4487 
4488 TEST_F(FormatTest, EnforcedOperatorWraps) {
4489   // Here we'd like to wrap after the || operators, but a comment is forcing an
4490   // earlier wrap.
4491   verifyFormat("bool x = aaaaa //\n"
4492                "         || bbbbb\n"
4493                "         //\n"
4494                "         || cccc;");
4495 }
4496 
4497 TEST_F(FormatTest, NoOperandAlignment) {
4498   FormatStyle Style = getLLVMStyle();
4499   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4500   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4501                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4502                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4503                Style);
4504   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4505   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4506                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4507                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4508                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4509                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4510                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4511                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4512                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4513                "        > ccccccccccccccccccccccccccccccccccccccccc;",
4514                Style);
4515 
4516   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4517                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4518                "    + cc;",
4519                Style);
4520   verifyFormat("int a = aa\n"
4521                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4522                "        * cccccccccccccccccccccccccccccccccccc;\n",
4523                Style);
4524 
4525   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4526   verifyFormat("return (a > b\n"
4527                "    // comment1\n"
4528                "    // comment2\n"
4529                "    || c);",
4530                Style);
4531 }
4532 
4533 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4534   FormatStyle Style = getLLVMStyle();
4535   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4536   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4537                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4538                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4539                Style);
4540 }
4541 
4542 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4543   FormatStyle Style = getLLVMStyle();
4544   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4545   Style.BinPackArguments = false;
4546   Style.ColumnLimit = 40;
4547   verifyFormat("void test() {\n"
4548                "  someFunction(\n"
4549                "      this + argument + is + quite\n"
4550                "      + long + so + it + gets + wrapped\n"
4551                "      + but + remains + bin - packed);\n"
4552                "}",
4553                Style);
4554   verifyFormat("void test() {\n"
4555                "  someFunction(arg1,\n"
4556                "               this + argument + is\n"
4557                "                   + quite + long + so\n"
4558                "                   + it + gets + wrapped\n"
4559                "                   + but + remains + bin\n"
4560                "                   - packed,\n"
4561                "               arg3);\n"
4562                "}",
4563                Style);
4564   verifyFormat("void test() {\n"
4565                "  someFunction(\n"
4566                "      arg1,\n"
4567                "      this + argument + has\n"
4568                "          + anotherFunc(nested,\n"
4569                "                        calls + whose\n"
4570                "                            + arguments\n"
4571                "                            + are + also\n"
4572                "                            + wrapped,\n"
4573                "                        in + addition)\n"
4574                "          + to + being + bin - packed,\n"
4575                "      arg3);\n"
4576                "}",
4577                Style);
4578 
4579   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4580   verifyFormat("void test() {\n"
4581                "  someFunction(\n"
4582                "      arg1,\n"
4583                "      this + argument + has +\n"
4584                "          anotherFunc(nested,\n"
4585                "                      calls + whose +\n"
4586                "                          arguments +\n"
4587                "                          are + also +\n"
4588                "                          wrapped,\n"
4589                "                      in + addition) +\n"
4590                "          to + being + bin - packed,\n"
4591                "      arg3);\n"
4592                "}",
4593                Style);
4594 }
4595 
4596 TEST_F(FormatTest, ConstructorInitializers) {
4597   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4598   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4599                getLLVMStyleWithColumns(45));
4600   verifyFormat("Constructor()\n"
4601                "    : Inttializer(FitsOnTheLine) {}",
4602                getLLVMStyleWithColumns(44));
4603   verifyFormat("Constructor()\n"
4604                "    : Inttializer(FitsOnTheLine) {}",
4605                getLLVMStyleWithColumns(43));
4606 
4607   verifyFormat("template <typename T>\n"
4608                "Constructor() : Initializer(FitsOnTheLine) {}",
4609                getLLVMStyleWithColumns(45));
4610 
4611   verifyFormat(
4612       "SomeClass::Constructor()\n"
4613       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4614 
4615   verifyFormat(
4616       "SomeClass::Constructor()\n"
4617       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4618       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4619   verifyFormat(
4620       "SomeClass::Constructor()\n"
4621       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4622       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4623   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4624                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4625                "    : aaaaaaaaaa(aaaaaa) {}");
4626 
4627   verifyFormat("Constructor()\n"
4628                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4629                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4630                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4631                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
4632 
4633   verifyFormat("Constructor()\n"
4634                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4635                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4636 
4637   verifyFormat("Constructor(int Parameter = 0)\n"
4638                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4639                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4640   verifyFormat("Constructor()\n"
4641                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4642                "}",
4643                getLLVMStyleWithColumns(60));
4644   verifyFormat("Constructor()\n"
4645                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4646                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4647 
4648   // Here a line could be saved by splitting the second initializer onto two
4649   // lines, but that is not desirable.
4650   verifyFormat("Constructor()\n"
4651                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4652                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
4653                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4654 
4655   FormatStyle OnePerLine = getLLVMStyle();
4656   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4657   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4658   verifyFormat("SomeClass::Constructor()\n"
4659                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4660                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4661                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4662                OnePerLine);
4663   verifyFormat("SomeClass::Constructor()\n"
4664                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4665                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4666                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4667                OnePerLine);
4668   verifyFormat("MyClass::MyClass(int var)\n"
4669                "    : some_var_(var),            // 4 space indent\n"
4670                "      some_other_var_(var + 1) { // lined up\n"
4671                "}",
4672                OnePerLine);
4673   verifyFormat("Constructor()\n"
4674                "    : aaaaa(aaaaaa),\n"
4675                "      aaaaa(aaaaaa),\n"
4676                "      aaaaa(aaaaaa),\n"
4677                "      aaaaa(aaaaaa),\n"
4678                "      aaaaa(aaaaaa) {}",
4679                OnePerLine);
4680   verifyFormat("Constructor()\n"
4681                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4682                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
4683                OnePerLine);
4684   OnePerLine.BinPackParameters = false;
4685   verifyFormat(
4686       "Constructor()\n"
4687       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4688       "          aaaaaaaaaaa().aaa(),\n"
4689       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4690       OnePerLine);
4691   OnePerLine.ColumnLimit = 60;
4692   verifyFormat("Constructor()\n"
4693                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4694                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4695                OnePerLine);
4696 
4697   EXPECT_EQ("Constructor()\n"
4698             "    : // Comment forcing unwanted break.\n"
4699             "      aaaa(aaaa) {}",
4700             format("Constructor() :\n"
4701                    "    // Comment forcing unwanted break.\n"
4702                    "    aaaa(aaaa) {}"));
4703 }
4704 
4705 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4706   FormatStyle Style = getLLVMStyle();
4707   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4708   Style.ColumnLimit = 60;
4709   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4710   Style.AllowAllConstructorInitializersOnNextLine = true;
4711   Style.BinPackParameters = false;
4712 
4713   for (int i = 0; i < 4; ++i) {
4714     // Test all combinations of parameters that should not have an effect.
4715     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4716     Style.AllowAllArgumentsOnNextLine = i & 2;
4717 
4718     Style.AllowAllConstructorInitializersOnNextLine = true;
4719     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4720     verifyFormat("Constructor()\n"
4721                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4722                  Style);
4723     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4724 
4725     Style.AllowAllConstructorInitializersOnNextLine = false;
4726     verifyFormat("Constructor()\n"
4727                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4728                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4729                  Style);
4730     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4731 
4732     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4733     Style.AllowAllConstructorInitializersOnNextLine = true;
4734     verifyFormat("Constructor()\n"
4735                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4736                  Style);
4737 
4738     Style.AllowAllConstructorInitializersOnNextLine = false;
4739     verifyFormat("Constructor()\n"
4740                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4741                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4742                  Style);
4743 
4744     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4745     Style.AllowAllConstructorInitializersOnNextLine = true;
4746     verifyFormat("Constructor() :\n"
4747                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4748                  Style);
4749 
4750     Style.AllowAllConstructorInitializersOnNextLine = false;
4751     verifyFormat("Constructor() :\n"
4752                  "    aaaaaaaaaaaaaaaaaa(a),\n"
4753                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4754                  Style);
4755   }
4756 
4757   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4758   // AllowAllConstructorInitializersOnNextLine in all
4759   // BreakConstructorInitializers modes
4760   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4761   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4762   Style.AllowAllConstructorInitializersOnNextLine = false;
4763   verifyFormat("SomeClassWithALongName::Constructor(\n"
4764                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4765                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4766                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4767                Style);
4768 
4769   Style.AllowAllConstructorInitializersOnNextLine = true;
4770   verifyFormat("SomeClassWithALongName::Constructor(\n"
4771                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4772                "    int bbbbbbbbbbbbb,\n"
4773                "    int cccccccccccccccc)\n"
4774                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4775                Style);
4776 
4777   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4778   Style.AllowAllConstructorInitializersOnNextLine = false;
4779   verifyFormat("SomeClassWithALongName::Constructor(\n"
4780                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4781                "    int bbbbbbbbbbbbb)\n"
4782                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4783                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4784                Style);
4785 
4786   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4787 
4788   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4789   verifyFormat("SomeClassWithALongName::Constructor(\n"
4790                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4791                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4792                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4793                Style);
4794 
4795   Style.AllowAllConstructorInitializersOnNextLine = true;
4796   verifyFormat("SomeClassWithALongName::Constructor(\n"
4797                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4798                "    int bbbbbbbbbbbbb,\n"
4799                "    int cccccccccccccccc)\n"
4800                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4801                Style);
4802 
4803   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4804   Style.AllowAllConstructorInitializersOnNextLine = false;
4805   verifyFormat("SomeClassWithALongName::Constructor(\n"
4806                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4807                "    int bbbbbbbbbbbbb)\n"
4808                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4809                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4810                Style);
4811 
4812   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4813   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4814   verifyFormat("SomeClassWithALongName::Constructor(\n"
4815                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4816                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4817                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4818                Style);
4819 
4820   Style.AllowAllConstructorInitializersOnNextLine = true;
4821   verifyFormat("SomeClassWithALongName::Constructor(\n"
4822                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4823                "    int bbbbbbbbbbbbb,\n"
4824                "    int cccccccccccccccc) :\n"
4825                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4826                Style);
4827 
4828   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4829   Style.AllowAllConstructorInitializersOnNextLine = false;
4830   verifyFormat("SomeClassWithALongName::Constructor(\n"
4831                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4832                "    int bbbbbbbbbbbbb) :\n"
4833                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4834                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4835                Style);
4836 }
4837 
4838 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4839   FormatStyle Style = getLLVMStyle();
4840   Style.ColumnLimit = 60;
4841   Style.BinPackArguments = false;
4842   for (int i = 0; i < 4; ++i) {
4843     // Test all combinations of parameters that should not have an effect.
4844     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4845     Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4846 
4847     Style.AllowAllArgumentsOnNextLine = true;
4848     verifyFormat("void foo() {\n"
4849                  "  FunctionCallWithReallyLongName(\n"
4850                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4851                  "}",
4852                  Style);
4853     Style.AllowAllArgumentsOnNextLine = false;
4854     verifyFormat("void foo() {\n"
4855                  "  FunctionCallWithReallyLongName(\n"
4856                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4857                  "      bbbbbbbbbbbb);\n"
4858                  "}",
4859                  Style);
4860 
4861     Style.AllowAllArgumentsOnNextLine = true;
4862     verifyFormat("void foo() {\n"
4863                  "  auto VariableWithReallyLongName = {\n"
4864                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4865                  "}",
4866                  Style);
4867     Style.AllowAllArgumentsOnNextLine = false;
4868     verifyFormat("void foo() {\n"
4869                  "  auto VariableWithReallyLongName = {\n"
4870                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4871                  "      bbbbbbbbbbbb};\n"
4872                  "}",
4873                  Style);
4874   }
4875 
4876   // This parameter should not affect declarations.
4877   Style.BinPackParameters = false;
4878   Style.AllowAllArgumentsOnNextLine = false;
4879   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4880   verifyFormat("void FunctionCallWithReallyLongName(\n"
4881                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
4882                Style);
4883   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4884   verifyFormat("void FunctionCallWithReallyLongName(\n"
4885                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
4886                "    int bbbbbbbbbbbb);",
4887                Style);
4888 }
4889 
4890 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
4891   FormatStyle Style = getLLVMStyle();
4892   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4893 
4894   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4895   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
4896                getStyleWithColumns(Style, 45));
4897   verifyFormat("Constructor() :\n"
4898                "    Initializer(FitsOnTheLine) {}",
4899                getStyleWithColumns(Style, 44));
4900   verifyFormat("Constructor() :\n"
4901                "    Initializer(FitsOnTheLine) {}",
4902                getStyleWithColumns(Style, 43));
4903 
4904   verifyFormat("template <typename T>\n"
4905                "Constructor() : Initializer(FitsOnTheLine) {}",
4906                getStyleWithColumns(Style, 50));
4907   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4908   verifyFormat(
4909       "SomeClass::Constructor() :\n"
4910       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4911       Style);
4912 
4913   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
4914   verifyFormat(
4915       "SomeClass::Constructor() :\n"
4916       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4917       Style);
4918 
4919   verifyFormat(
4920       "SomeClass::Constructor() :\n"
4921       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4922       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4923       Style);
4924   verifyFormat(
4925       "SomeClass::Constructor() :\n"
4926       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4927       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4928       Style);
4929   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4930                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4931                "    aaaaaaaaaa(aaaaaa) {}",
4932                Style);
4933 
4934   verifyFormat("Constructor() :\n"
4935                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4936                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4937                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4938                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
4939                Style);
4940 
4941   verifyFormat("Constructor() :\n"
4942                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4943                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4944                Style);
4945 
4946   verifyFormat("Constructor(int Parameter = 0) :\n"
4947                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4948                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
4949                Style);
4950   verifyFormat("Constructor() :\n"
4951                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4952                "}",
4953                getStyleWithColumns(Style, 60));
4954   verifyFormat("Constructor() :\n"
4955                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4956                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
4957                Style);
4958 
4959   // Here a line could be saved by splitting the second initializer onto two
4960   // lines, but that is not desirable.
4961   verifyFormat("Constructor() :\n"
4962                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4963                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
4964                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4965                Style);
4966 
4967   FormatStyle OnePerLine = Style;
4968   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4969   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
4970   verifyFormat("SomeClass::Constructor() :\n"
4971                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4972                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4973                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4974                OnePerLine);
4975   verifyFormat("SomeClass::Constructor() :\n"
4976                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4977                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4978                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4979                OnePerLine);
4980   verifyFormat("MyClass::MyClass(int var) :\n"
4981                "    some_var_(var),            // 4 space indent\n"
4982                "    some_other_var_(var + 1) { // lined up\n"
4983                "}",
4984                OnePerLine);
4985   verifyFormat("Constructor() :\n"
4986                "    aaaaa(aaaaaa),\n"
4987                "    aaaaa(aaaaaa),\n"
4988                "    aaaaa(aaaaaa),\n"
4989                "    aaaaa(aaaaaa),\n"
4990                "    aaaaa(aaaaaa) {}",
4991                OnePerLine);
4992   verifyFormat("Constructor() :\n"
4993                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4994                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
4995                OnePerLine);
4996   OnePerLine.BinPackParameters = false;
4997   verifyFormat("Constructor() :\n"
4998                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4999                "        aaaaaaaaaaa().aaa(),\n"
5000                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5001                OnePerLine);
5002   OnePerLine.ColumnLimit = 60;
5003   verifyFormat("Constructor() :\n"
5004                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
5005                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
5006                OnePerLine);
5007 
5008   EXPECT_EQ("Constructor() :\n"
5009             "    // Comment forcing unwanted break.\n"
5010             "    aaaa(aaaa) {}",
5011             format("Constructor() :\n"
5012                    "    // Comment forcing unwanted break.\n"
5013                    "    aaaa(aaaa) {}",
5014                    Style));
5015 
5016   Style.ColumnLimit = 0;
5017   verifyFormat("SomeClass::Constructor() :\n"
5018                "    a(a) {}",
5019                Style);
5020   verifyFormat("SomeClass::Constructor() noexcept :\n"
5021                "    a(a) {}",
5022                Style);
5023   verifyFormat("SomeClass::Constructor() :\n"
5024                "    a(a), b(b), c(c) {}",
5025                Style);
5026   verifyFormat("SomeClass::Constructor() :\n"
5027                "    a(a) {\n"
5028                "  foo();\n"
5029                "  bar();\n"
5030                "}",
5031                Style);
5032 
5033   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5034   verifyFormat("SomeClass::Constructor() :\n"
5035                "    a(a), b(b), c(c) {\n"
5036                "}",
5037                Style);
5038   verifyFormat("SomeClass::Constructor() :\n"
5039                "    a(a) {\n"
5040                "}",
5041                Style);
5042 
5043   Style.ColumnLimit = 80;
5044   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5045   Style.ConstructorInitializerIndentWidth = 2;
5046   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5047   verifyFormat("SomeClass::Constructor() :\n"
5048                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5049                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5050                Style);
5051 
5052   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5053   // well
5054   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5055   verifyFormat(
5056       "class SomeClass\n"
5057       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5058       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5059       Style);
5060   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5061   verifyFormat(
5062       "class SomeClass\n"
5063       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5064       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5065       Style);
5066   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5067   verifyFormat(
5068       "class SomeClass :\n"
5069       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5070       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5071       Style);
5072 }
5073 
5074 #ifndef EXPENSIVE_CHECKS
5075 // Expensive checks enables libstdc++ checking which includes validating the
5076 // state of ranges used in std::priority_queue - this blows out the
5077 // runtime/scalability of the function and makes this test unacceptably slow.
5078 TEST_F(FormatTest, MemoizationTests) {
5079   // This breaks if the memoization lookup does not take \c Indent and
5080   // \c LastSpace into account.
5081   verifyFormat(
5082       "extern CFRunLoopTimerRef\n"
5083       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5084       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
5085       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
5086       "                     CFRunLoopTimerContext *context) {}");
5087 
5088   // Deep nesting somewhat works around our memoization.
5089   verifyFormat(
5090       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5091       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5092       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5093       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5094       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
5095       getLLVMStyleWithColumns(65));
5096   verifyFormat(
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(\n"
5110       "                            aaaaa,\n"
5111       "                            aaaaa(\n"
5112       "                                aaaaa,\n"
5113       "                                aaaaa(\n"
5114       "                                    aaaaa,\n"
5115       "                                    aaaaa(\n"
5116       "                                        aaaaa,\n"
5117       "                                        aaaaa(\n"
5118       "                                            aaaaa,\n"
5119       "                                            aaaaa(\n"
5120       "                                                aaaaa,\n"
5121       "                                                aaaaa))))))))))));",
5122       getLLVMStyleWithColumns(65));
5123   verifyFormat(
5124       "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"
5125       "                                  a),\n"
5126       "                                a),\n"
5127       "                              a),\n"
5128       "                            a),\n"
5129       "                          a),\n"
5130       "                        a),\n"
5131       "                      a),\n"
5132       "                    a),\n"
5133       "                  a),\n"
5134       "                a),\n"
5135       "              a),\n"
5136       "            a),\n"
5137       "          a),\n"
5138       "        a),\n"
5139       "      a),\n"
5140       "    a),\n"
5141       "  a)",
5142       getLLVMStyleWithColumns(65));
5143 
5144   // This test takes VERY long when memoization is broken.
5145   FormatStyle OnePerLine = getLLVMStyle();
5146   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5147   OnePerLine.BinPackParameters = false;
5148   std::string input = "Constructor()\n"
5149                       "    : aaaa(a,\n";
5150   for (unsigned i = 0, e = 80; i != e; ++i) {
5151     input += "           a,\n";
5152   }
5153   input += "           a) {}";
5154   verifyFormat(input, OnePerLine);
5155 }
5156 #endif
5157 
5158 TEST_F(FormatTest, BreaksAsHighAsPossible) {
5159   verifyFormat(
5160       "void f() {\n"
5161       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5162       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5163       "    f();\n"
5164       "}");
5165   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5166                "    Intervals[i - 1].getRange().getLast()) {\n}");
5167 }
5168 
5169 TEST_F(FormatTest, BreaksFunctionDeclarations) {
5170   // Principially, we break function declarations in a certain order:
5171   // 1) break amongst arguments.
5172   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5173                "                              Cccccccccccccc cccccccccccccc);");
5174   verifyFormat("template <class TemplateIt>\n"
5175                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5176                "                            TemplateIt *stop) {}");
5177 
5178   // 2) break after return type.
5179   verifyFormat(
5180       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5181       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5182       getGoogleStyle());
5183 
5184   // 3) break after (.
5185   verifyFormat(
5186       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5187       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5188       getGoogleStyle());
5189 
5190   // 4) break before after nested name specifiers.
5191   verifyFormat(
5192       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5193       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5194       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5195       getGoogleStyle());
5196 
5197   // However, there are exceptions, if a sufficient amount of lines can be
5198   // saved.
5199   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5200   // more adjusting.
5201   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5202                "                                  Cccccccccccccc cccccccccc,\n"
5203                "                                  Cccccccccccccc cccccccccc,\n"
5204                "                                  Cccccccccccccc cccccccccc,\n"
5205                "                                  Cccccccccccccc cccccccccc);");
5206   verifyFormat(
5207       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5208       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5209       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5210       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5211       getGoogleStyle());
5212   verifyFormat(
5213       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5214       "                                          Cccccccccccccc cccccccccc,\n"
5215       "                                          Cccccccccccccc cccccccccc,\n"
5216       "                                          Cccccccccccccc cccccccccc,\n"
5217       "                                          Cccccccccccccc cccccccccc,\n"
5218       "                                          Cccccccccccccc cccccccccc,\n"
5219       "                                          Cccccccccccccc cccccccccc);");
5220   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5221                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5222                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5223                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5224                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5225 
5226   // Break after multi-line parameters.
5227   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5228                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5229                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5230                "    bbbb bbbb);");
5231   verifyFormat("void SomeLoooooooooooongFunction(\n"
5232                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5233                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5234                "    int bbbbbbbbbbbbb);");
5235 
5236   // Treat overloaded operators like other functions.
5237   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5238                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5239   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5240                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5241   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5242                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5243   verifyGoogleFormat(
5244       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5245       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5246   verifyGoogleFormat(
5247       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5248       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5249   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5250                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5251   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5252                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5253   verifyGoogleFormat(
5254       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5255       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5256       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5257   verifyGoogleFormat("template <typename T>\n"
5258                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5259                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5260                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5261 
5262   FormatStyle Style = getLLVMStyle();
5263   Style.PointerAlignment = FormatStyle::PAS_Left;
5264   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5265                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5266                Style);
5267   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5268                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5269                Style);
5270 }
5271 
5272 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5273   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5274   // Prefer keeping `::` followed by `operator` together.
5275   EXPECT_EQ("const aaaa::bbbbbbb &\n"
5276             "ccccccccc::operator++() {\n"
5277             "  stuff();\n"
5278             "}",
5279             format("const aaaa::bbbbbbb\n"
5280                    "&ccccccccc::operator++() { stuff(); }",
5281                    getLLVMStyleWithColumns(40)));
5282 }
5283 
5284 TEST_F(FormatTest, TrailingReturnType) {
5285   verifyFormat("auto foo() -> int;\n");
5286   // correct trailing return type spacing
5287   verifyFormat("auto operator->() -> int;\n");
5288   verifyFormat("auto operator++(int) -> int;\n");
5289 
5290   verifyFormat("struct S {\n"
5291                "  auto bar() const -> int;\n"
5292                "};");
5293   verifyFormat("template <size_t Order, typename T>\n"
5294                "auto load_img(const std::string &filename)\n"
5295                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
5296   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5297                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5298   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5299   verifyFormat("template <typename T>\n"
5300                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5301                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5302 
5303   // Not trailing return types.
5304   verifyFormat("void f() { auto a = b->c(); }");
5305 }
5306 
5307 TEST_F(FormatTest, DeductionGuides) {
5308   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5309   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5310   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5311   verifyFormat(
5312       "template <class... T>\n"
5313       "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5314   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5315   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5316   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5317   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5318   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5319   verifyFormat("template <class T> x() -> x<1>;");
5320   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5321 
5322   // Ensure not deduction guides.
5323   verifyFormat("c()->f<int>();");
5324   verifyFormat("x()->foo<1>;");
5325   verifyFormat("x = p->foo<3>();");
5326   verifyFormat("x()->x<1>();");
5327   verifyFormat("x()->x<1>;");
5328 }
5329 
5330 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5331   // Avoid breaking before trailing 'const' or other trailing annotations, if
5332   // they are not function-like.
5333   FormatStyle Style = getGoogleStyle();
5334   Style.ColumnLimit = 47;
5335   verifyFormat("void someLongFunction(\n"
5336                "    int someLoooooooooooooongParameter) const {\n}",
5337                getLLVMStyleWithColumns(47));
5338   verifyFormat("LoooooongReturnType\n"
5339                "someLoooooooongFunction() const {}",
5340                getLLVMStyleWithColumns(47));
5341   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5342                "    const {}",
5343                Style);
5344   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5345                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5346   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5347                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5348   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5349                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5350   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5351                "                   aaaaaaaaaaa aaaaa) const override;");
5352   verifyGoogleFormat(
5353       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5354       "    const override;");
5355 
5356   // Even if the first parameter has to be wrapped.
5357   verifyFormat("void someLongFunction(\n"
5358                "    int someLongParameter) const {}",
5359                getLLVMStyleWithColumns(46));
5360   verifyFormat("void someLongFunction(\n"
5361                "    int someLongParameter) const {}",
5362                Style);
5363   verifyFormat("void someLongFunction(\n"
5364                "    int someLongParameter) override {}",
5365                Style);
5366   verifyFormat("void someLongFunction(\n"
5367                "    int someLongParameter) OVERRIDE {}",
5368                Style);
5369   verifyFormat("void someLongFunction(\n"
5370                "    int someLongParameter) final {}",
5371                Style);
5372   verifyFormat("void someLongFunction(\n"
5373                "    int someLongParameter) FINAL {}",
5374                Style);
5375   verifyFormat("void someLongFunction(\n"
5376                "    int parameter) const override {}",
5377                Style);
5378 
5379   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5380   verifyFormat("void someLongFunction(\n"
5381                "    int someLongParameter) const\n"
5382                "{\n"
5383                "}",
5384                Style);
5385 
5386   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5387   verifyFormat("void someLongFunction(\n"
5388                "    int someLongParameter) const\n"
5389                "  {\n"
5390                "  }",
5391                Style);
5392 
5393   // Unless these are unknown annotations.
5394   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5395                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5396                "    LONG_AND_UGLY_ANNOTATION;");
5397 
5398   // Breaking before function-like trailing annotations is fine to keep them
5399   // close to their arguments.
5400   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5401                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5402   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5403                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5404   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5405                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5406   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5407                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5408   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5409 
5410   verifyFormat(
5411       "void aaaaaaaaaaaaaaaaaa()\n"
5412       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5413       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5414   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5415                "    __attribute__((unused));");
5416   verifyGoogleFormat(
5417       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5418       "    GUARDED_BY(aaaaaaaaaaaa);");
5419   verifyGoogleFormat(
5420       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5421       "    GUARDED_BY(aaaaaaaaaaaa);");
5422   verifyGoogleFormat(
5423       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5424       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5425   verifyGoogleFormat(
5426       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5427       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5428 }
5429 
5430 TEST_F(FormatTest, FunctionAnnotations) {
5431   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5432                "int OldFunction(const string &parameter) {}");
5433   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5434                "string OldFunction(const string &parameter) {}");
5435   verifyFormat("template <typename T>\n"
5436                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5437                "string OldFunction(const string &parameter) {}");
5438 
5439   // Not function annotations.
5440   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5441                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5442   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5443                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5444   verifyFormat("MACRO(abc).function() // wrap\n"
5445                "    << abc;");
5446   verifyFormat("MACRO(abc)->function() // wrap\n"
5447                "    << abc;");
5448   verifyFormat("MACRO(abc)::function() // wrap\n"
5449                "    << abc;");
5450 }
5451 
5452 TEST_F(FormatTest, BreaksDesireably) {
5453   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5454                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5455                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5456   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5457                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5458                "}");
5459 
5460   verifyFormat(
5461       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5462       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5463 
5464   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5465                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5466                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5467 
5468   verifyFormat(
5469       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5470       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5471       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5472       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5473       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5474 
5475   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5476                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5477 
5478   verifyFormat(
5479       "void f() {\n"
5480       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5481       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5482       "}");
5483   verifyFormat(
5484       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5485       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5486   verifyFormat(
5487       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5488       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5489   verifyFormat(
5490       "aaaaaa(aaa,\n"
5491       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5492       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5493       "       aaaa);");
5494   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5495                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5496                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5497 
5498   // Indent consistently independent of call expression and unary operator.
5499   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5500                "    dddddddddddddddddddddddddddddd));");
5501   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5502                "    dddddddddddddddddddddddddddddd));");
5503   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5504                "    dddddddddddddddddddddddddddddd));");
5505 
5506   // This test case breaks on an incorrect memoization, i.e. an optimization not
5507   // taking into account the StopAt value.
5508   verifyFormat(
5509       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5510       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5511       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5512       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5513 
5514   verifyFormat("{\n  {\n    {\n"
5515                "      Annotation.SpaceRequiredBefore =\n"
5516                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5517                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5518                "    }\n  }\n}");
5519 
5520   // Break on an outer level if there was a break on an inner level.
5521   EXPECT_EQ("f(g(h(a, // comment\n"
5522             "      b, c),\n"
5523             "    d, e),\n"
5524             "  x, y);",
5525             format("f(g(h(a, // comment\n"
5526                    "    b, c), d, e), x, y);"));
5527 
5528   // Prefer breaking similar line breaks.
5529   verifyFormat(
5530       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5531       "                             NSTrackingMouseEnteredAndExited |\n"
5532       "                             NSTrackingActiveAlways;");
5533 }
5534 
5535 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5536   FormatStyle NoBinPacking = getGoogleStyle();
5537   NoBinPacking.BinPackParameters = false;
5538   NoBinPacking.BinPackArguments = true;
5539   verifyFormat("void f() {\n"
5540                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5541                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5542                "}",
5543                NoBinPacking);
5544   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5545                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5546                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5547                NoBinPacking);
5548 
5549   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5550   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5551                "                        vector<int> bbbbbbbbbbbbbbb);",
5552                NoBinPacking);
5553   // FIXME: This behavior difference is probably not wanted. However, currently
5554   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5555   // template arguments from BreakBeforeParameter being set because of the
5556   // one-per-line formatting.
5557   verifyFormat(
5558       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5559       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5560       NoBinPacking);
5561   verifyFormat(
5562       "void fffffffffff(\n"
5563       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5564       "        aaaaaaaaaa);");
5565 }
5566 
5567 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5568   FormatStyle NoBinPacking = getGoogleStyle();
5569   NoBinPacking.BinPackParameters = false;
5570   NoBinPacking.BinPackArguments = false;
5571   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5572                "  aaaaaaaaaaaaaaaaaaaa,\n"
5573                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5574                NoBinPacking);
5575   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5576                "        aaaaaaaaaaaaa,\n"
5577                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5578                NoBinPacking);
5579   verifyFormat(
5580       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5581       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5582       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5583       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5584       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5585       NoBinPacking);
5586   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5587                "    .aaaaaaaaaaaaaaaaaa();",
5588                NoBinPacking);
5589   verifyFormat("void f() {\n"
5590                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5591                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5592                "}",
5593                NoBinPacking);
5594 
5595   verifyFormat(
5596       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5597       "             aaaaaaaaaaaa,\n"
5598       "             aaaaaaaaaaaa);",
5599       NoBinPacking);
5600   verifyFormat(
5601       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5602       "                               ddddddddddddddddddddddddddddd),\n"
5603       "             test);",
5604       NoBinPacking);
5605 
5606   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5607                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5608                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5609                "    aaaaaaaaaaaaaaaaaa;",
5610                NoBinPacking);
5611   verifyFormat("a(\"a\"\n"
5612                "  \"a\",\n"
5613                "  a);");
5614 
5615   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5616   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5617                "                aaaaaaaaa,\n"
5618                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5619                NoBinPacking);
5620   verifyFormat(
5621       "void f() {\n"
5622       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5623       "      .aaaaaaa();\n"
5624       "}",
5625       NoBinPacking);
5626   verifyFormat(
5627       "template <class SomeType, class SomeOtherType>\n"
5628       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5629       NoBinPacking);
5630 }
5631 
5632 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5633   FormatStyle Style = getLLVMStyleWithColumns(15);
5634   Style.ExperimentalAutoDetectBinPacking = true;
5635   EXPECT_EQ("aaa(aaaa,\n"
5636             "    aaaa,\n"
5637             "    aaaa);\n"
5638             "aaa(aaaa,\n"
5639             "    aaaa,\n"
5640             "    aaaa);",
5641             format("aaa(aaaa,\n" // one-per-line
5642                    "  aaaa,\n"
5643                    "    aaaa  );\n"
5644                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5645                    Style));
5646   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5647             "    aaaa);\n"
5648             "aaa(aaaa, aaaa,\n"
5649             "    aaaa);",
5650             format("aaa(aaaa,  aaaa,\n" // bin-packed
5651                    "    aaaa  );\n"
5652                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5653                    Style));
5654 }
5655 
5656 TEST_F(FormatTest, FormatsBuilderPattern) {
5657   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5658                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5659                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5660                "    .StartsWith(\".init\", ORDER_INIT)\n"
5661                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5662                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5663                "    .Default(ORDER_TEXT);\n");
5664 
5665   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5666                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5667   verifyFormat("aaaaaaa->aaaaaaa\n"
5668                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5669                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5670                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5671   verifyFormat(
5672       "aaaaaaa->aaaaaaa\n"
5673       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5674       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5675   verifyFormat(
5676       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5677       "    aaaaaaaaaaaaaa);");
5678   verifyFormat(
5679       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5680       "    aaaaaa->aaaaaaaaaaaa()\n"
5681       "        ->aaaaaaaaaaaaaaaa(\n"
5682       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5683       "        ->aaaaaaaaaaaaaaaaa();");
5684   verifyGoogleFormat(
5685       "void f() {\n"
5686       "  someo->Add((new util::filetools::Handler(dir))\n"
5687       "                 ->OnEvent1(NewPermanentCallback(\n"
5688       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5689       "                 ->OnEvent2(NewPermanentCallback(\n"
5690       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5691       "                 ->OnEvent3(NewPermanentCallback(\n"
5692       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5693       "                 ->OnEvent5(NewPermanentCallback(\n"
5694       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5695       "                 ->OnEvent6(NewPermanentCallback(\n"
5696       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5697       "}");
5698 
5699   verifyFormat(
5700       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5701   verifyFormat("aaaaaaaaaaaaaaa()\n"
5702                "    .aaaaaaaaaaaaaaa()\n"
5703                "    .aaaaaaaaaaaaaaa()\n"
5704                "    .aaaaaaaaaaaaaaa()\n"
5705                "    .aaaaaaaaaaaaaaa();");
5706   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5707                "    .aaaaaaaaaaaaaaa()\n"
5708                "    .aaaaaaaaaaaaaaa()\n"
5709                "    .aaaaaaaaaaaaaaa();");
5710   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5711                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5712                "    .aaaaaaaaaaaaaaa();");
5713   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5714                "    ->aaaaaaaaaaaaaae(0)\n"
5715                "    ->aaaaaaaaaaaaaaa();");
5716 
5717   // Don't linewrap after very short segments.
5718   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5719                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5720                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5721   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5722                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5723                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5724   verifyFormat("aaa()\n"
5725                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5726                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5727                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5728 
5729   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5730                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5731                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5732   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5733                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5734                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5735 
5736   // Prefer not to break after empty parentheses.
5737   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5738                "    First->LastNewlineOffset);");
5739 
5740   // Prefer not to create "hanging" indents.
5741   verifyFormat(
5742       "return !soooooooooooooome_map\n"
5743       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5744       "            .second;");
5745   verifyFormat(
5746       "return aaaaaaaaaaaaaaaa\n"
5747       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5748       "    .aaaa(aaaaaaaaaaaaaa);");
5749   // No hanging indent here.
5750   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5751                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5752   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5753                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5754   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5755                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5756                getLLVMStyleWithColumns(60));
5757   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5758                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5759                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5760                getLLVMStyleWithColumns(59));
5761   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5762                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5763                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5764 
5765   // Dont break if only closing statements before member call
5766   verifyFormat("test() {\n"
5767                "  ([]() -> {\n"
5768                "    int b = 32;\n"
5769                "    return 3;\n"
5770                "  }).foo();\n"
5771                "}");
5772   verifyFormat("test() {\n"
5773                "  (\n"
5774                "      []() -> {\n"
5775                "        int b = 32;\n"
5776                "        return 3;\n"
5777                "      },\n"
5778                "      foo, bar)\n"
5779                "      .foo();\n"
5780                "}");
5781   verifyFormat("test() {\n"
5782                "  ([]() -> {\n"
5783                "    int b = 32;\n"
5784                "    return 3;\n"
5785                "  })\n"
5786                "      .foo()\n"
5787                "      .bar();\n"
5788                "}");
5789   verifyFormat("test() {\n"
5790                "  ([]() -> {\n"
5791                "    int b = 32;\n"
5792                "    return 3;\n"
5793                "  })\n"
5794                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5795                "           \"bbbb\");\n"
5796                "}",
5797                getLLVMStyleWithColumns(30));
5798 }
5799 
5800 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5801   verifyFormat(
5802       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5803       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5804   verifyFormat(
5805       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5806       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5807 
5808   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5809                "    ccccccccccccccccccccccccc) {\n}");
5810   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5811                "    ccccccccccccccccccccccccc) {\n}");
5812 
5813   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5814                "    ccccccccccccccccccccccccc) {\n}");
5815   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5816                "    ccccccccccccccccccccccccc) {\n}");
5817 
5818   verifyFormat(
5819       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
5820       "    ccccccccccccccccccccccccc) {\n}");
5821   verifyFormat(
5822       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
5823       "    ccccccccccccccccccccccccc) {\n}");
5824 
5825   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5826                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
5827                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
5828                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5829   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5830                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
5831                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
5832                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5833 
5834   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5835                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
5836                "    aaaaaaaaaaaaaaa != aa) {\n}");
5837   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5838                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
5839                "    aaaaaaaaaaaaaaa != aa) {\n}");
5840 }
5841 
5842 TEST_F(FormatTest, BreaksAfterAssignments) {
5843   verifyFormat(
5844       "unsigned Cost =\n"
5845       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
5846       "                        SI->getPointerAddressSpaceee());\n");
5847   verifyFormat(
5848       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
5849       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
5850 
5851   verifyFormat(
5852       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
5853       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
5854   verifyFormat("unsigned OriginalStartColumn =\n"
5855                "    SourceMgr.getSpellingColumnNumber(\n"
5856                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
5857                "    1;");
5858 }
5859 
5860 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
5861   FormatStyle Style = getLLVMStyle();
5862   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5863                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
5864                Style);
5865 
5866   Style.PenaltyBreakAssignment = 20;
5867   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5868                "                                 cccccccccccccccccccccccccc;",
5869                Style);
5870 }
5871 
5872 TEST_F(FormatTest, AlignsAfterAssignments) {
5873   verifyFormat(
5874       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5875       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
5876   verifyFormat(
5877       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5878       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
5879   verifyFormat(
5880       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5881       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
5882   verifyFormat(
5883       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5884       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
5885   verifyFormat(
5886       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5887       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5888       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
5889 }
5890 
5891 TEST_F(FormatTest, AlignsAfterReturn) {
5892   verifyFormat(
5893       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5894       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
5895   verifyFormat(
5896       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5897       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
5898   verifyFormat(
5899       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5900       "       aaaaaaaaaaaaaaaaaaaaaa();");
5901   verifyFormat(
5902       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5903       "        aaaaaaaaaaaaaaaaaaaaaa());");
5904   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5905                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5906   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5907                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
5908                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5909   verifyFormat("return\n"
5910                "    // true if code is one of a or b.\n"
5911                "    code == a || code == b;");
5912 }
5913 
5914 TEST_F(FormatTest, AlignsAfterOpenBracket) {
5915   verifyFormat(
5916       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5917       "                                                aaaaaaaaa aaaaaaa) {}");
5918   verifyFormat(
5919       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5920       "                                               aaaaaaaaaaa aaaaaaaaa);");
5921   verifyFormat(
5922       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5923       "                                             aaaaaaaaaaaaaaaaaaaaa));");
5924   FormatStyle Style = getLLVMStyle();
5925   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5926   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5927                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
5928                Style);
5929   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5930                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
5931                Style);
5932   verifyFormat("SomeLongVariableName->someFunction(\n"
5933                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
5934                Style);
5935   verifyFormat(
5936       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5937       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5938       Style);
5939   verifyFormat(
5940       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5941       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5942       Style);
5943   verifyFormat(
5944       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5945       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
5946       Style);
5947 
5948   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
5949                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
5950                "        b));",
5951                Style);
5952 
5953   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5954   Style.BinPackArguments = false;
5955   Style.BinPackParameters = false;
5956   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5957                "    aaaaaaaaaaa aaaaaaaa,\n"
5958                "    aaaaaaaaa aaaaaaa,\n"
5959                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5960                Style);
5961   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5962                "    aaaaaaaaaaa aaaaaaaaa,\n"
5963                "    aaaaaaaaaaa aaaaaaaaa,\n"
5964                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5965                Style);
5966   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
5967                "    aaaaaaaaaaaaaaa,\n"
5968                "    aaaaaaaaaaaaaaaaaaaaa,\n"
5969                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
5970                Style);
5971   verifyFormat(
5972       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
5973       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
5974       Style);
5975   verifyFormat(
5976       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
5977       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
5978       Style);
5979   verifyFormat(
5980       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5981       "    aaaaaaaaaaaaaaaaaaaaa(\n"
5982       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
5983       "    aaaaaaaaaaaaaaaa);",
5984       Style);
5985   verifyFormat(
5986       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5987       "    aaaaaaaaaaaaaaaaaaaaa(\n"
5988       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
5989       "    aaaaaaaaaaaaaaaa);",
5990       Style);
5991 }
5992 
5993 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
5994   FormatStyle Style = getLLVMStyleWithColumns(40);
5995   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5996                "          bbbbbbbbbbbbbbbbbbbbbb);",
5997                Style);
5998   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
5999   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6000   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6001                "          bbbbbbbbbbbbbbbbbbbbbb);",
6002                Style);
6003   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6004   Style.AlignOperands = FormatStyle::OAS_Align;
6005   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6006                "          bbbbbbbbbbbbbbbbbbbbbb);",
6007                Style);
6008   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6009   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6010   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6011                "    bbbbbbbbbbbbbbbbbbbbbb);",
6012                Style);
6013 }
6014 
6015 TEST_F(FormatTest, BreaksConditionalExpressions) {
6016   verifyFormat(
6017       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6018       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6019       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6020   verifyFormat(
6021       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6022       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6023       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6024   verifyFormat(
6025       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6026       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6027   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6028                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6029                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6030   verifyFormat(
6031       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6032       "                                                    : aaaaaaaaaaaaa);");
6033   verifyFormat(
6034       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6035       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6036       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6037       "                   aaaaaaaaaaaaa);");
6038   verifyFormat(
6039       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6040       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6041       "                   aaaaaaaaaaaaa);");
6042   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6043                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6044                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6045                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6046                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6047   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6048                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6049                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6050                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6051                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6052                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6053                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6054   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6055                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6056                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6057                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6058                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6059   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6060                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6061                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6062   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6063                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6064                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6065                "        : aaaaaaaaaaaaaaaa;");
6066   verifyFormat(
6067       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6068       "    ? aaaaaaaaaaaaaaa\n"
6069       "    : aaaaaaaaaaaaaaa;");
6070   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6071                "          aaaaaaaaa\n"
6072                "      ? b\n"
6073                "      : c);");
6074   verifyFormat("return aaaa == bbbb\n"
6075                "           // comment\n"
6076                "           ? aaaa\n"
6077                "           : bbbb;");
6078   verifyFormat("unsigned Indent =\n"
6079                "    format(TheLine.First,\n"
6080                "           IndentForLevel[TheLine.Level] >= 0\n"
6081                "               ? IndentForLevel[TheLine.Level]\n"
6082                "               : TheLine * 2,\n"
6083                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6084                getLLVMStyleWithColumns(60));
6085   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6086                "                  ? aaaaaaaaaaaaaaa\n"
6087                "                  : bbbbbbbbbbbbbbb //\n"
6088                "                        ? ccccccccccccccc\n"
6089                "                        : ddddddddddddddd;");
6090   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6091                "                  ? aaaaaaaaaaaaaaa\n"
6092                "                  : (bbbbbbbbbbbbbbb //\n"
6093                "                         ? ccccccccccccccc\n"
6094                "                         : ddddddddddddddd);");
6095   verifyFormat(
6096       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6097       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6098       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
6099       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
6100       "                                      : aaaaaaaaaa;");
6101   verifyFormat(
6102       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6103       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
6104       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6105 
6106   FormatStyle NoBinPacking = getLLVMStyle();
6107   NoBinPacking.BinPackArguments = false;
6108   verifyFormat(
6109       "void f() {\n"
6110       "  g(aaa,\n"
6111       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6112       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6113       "        ? aaaaaaaaaaaaaaa\n"
6114       "        : aaaaaaaaaaaaaaa);\n"
6115       "}",
6116       NoBinPacking);
6117   verifyFormat(
6118       "void f() {\n"
6119       "  g(aaa,\n"
6120       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6121       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6122       "        ?: aaaaaaaaaaaaaaa);\n"
6123       "}",
6124       NoBinPacking);
6125 
6126   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6127                "             // comment.\n"
6128                "             ccccccccccccccccccccccccccccccccccccccc\n"
6129                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6130                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6131 
6132   // Assignments in conditional expressions. Apparently not uncommon :-(.
6133   verifyFormat("return a != b\n"
6134                "           // comment\n"
6135                "           ? a = b\n"
6136                "           : a = b;");
6137   verifyFormat("return a != b\n"
6138                "           // comment\n"
6139                "           ? a = a != b\n"
6140                "                     // comment\n"
6141                "                     ? a = b\n"
6142                "                     : a\n"
6143                "           : a;\n");
6144   verifyFormat("return a != b\n"
6145                "           // comment\n"
6146                "           ? a\n"
6147                "           : a = a != b\n"
6148                "                     // comment\n"
6149                "                     ? a = b\n"
6150                "                     : a;");
6151 
6152   // Chained conditionals
6153   FormatStyle Style = getLLVMStyle();
6154   Style.ColumnLimit = 70;
6155   Style.AlignOperands = FormatStyle::OAS_Align;
6156   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6157                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6158                "                        : 3333333333333333;",
6159                Style);
6160   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6161                "       : bbbbbbbbbb     ? 2222222222222222\n"
6162                "                        : 3333333333333333;",
6163                Style);
6164   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
6165                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6166                "                          : 3333333333333333;",
6167                Style);
6168   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6169                "       : bbbbbbbbbbbbbb ? 222222\n"
6170                "                        : 333333;",
6171                Style);
6172   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6173                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6174                "       : cccccccccccccc ? 3333333333333333\n"
6175                "                        : 4444444444444444;",
6176                Style);
6177   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6178                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6179                "                        : 3333333333333333;",
6180                Style);
6181   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6182                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6183                "                        : (aaa ? bbb : ccc);",
6184                Style);
6185   verifyFormat(
6186       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6187       "                                             : cccccccccccccccccc)\n"
6188       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6189       "                        : 3333333333333333;",
6190       Style);
6191   verifyFormat(
6192       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6193       "                                             : cccccccccccccccccc)\n"
6194       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6195       "                        : 3333333333333333;",
6196       Style);
6197   verifyFormat(
6198       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6199       "                                             : dddddddddddddddddd)\n"
6200       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6201       "                        : 3333333333333333;",
6202       Style);
6203   verifyFormat(
6204       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6205       "                                             : dddddddddddddddddd)\n"
6206       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6207       "                        : 3333333333333333;",
6208       Style);
6209   verifyFormat(
6210       "return aaaaaaaaa        ? 1111111111111111\n"
6211       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6212       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6213       "                                             : dddddddddddddddddd)\n",
6214       Style);
6215   verifyFormat(
6216       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6217       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6218       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6219       "                                             : cccccccccccccccccc);",
6220       Style);
6221   verifyFormat(
6222       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6223       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6224       "                                             : eeeeeeeeeeeeeeeeee)\n"
6225       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6226       "                        : 3333333333333333;",
6227       Style);
6228   verifyFormat(
6229       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
6230       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6231       "                                             : eeeeeeeeeeeeeeeeee)\n"
6232       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6233       "                        : 3333333333333333;",
6234       Style);
6235   verifyFormat(
6236       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6237       "                           : cccccccccccc    ? dddddddddddddddddd\n"
6238       "                                             : eeeeeeeeeeeeeeeeee)\n"
6239       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6240       "                        : 3333333333333333;",
6241       Style);
6242   verifyFormat(
6243       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6244       "                                             : cccccccccccccccccc\n"
6245       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6246       "                        : 3333333333333333;",
6247       Style);
6248   verifyFormat(
6249       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6250       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
6251       "                                             : eeeeeeeeeeeeeeeeee\n"
6252       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6253       "                        : 3333333333333333;",
6254       Style);
6255   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6256                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
6257                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
6258                "                                   : eeeeeeeeeeeeeeeeee)\n"
6259                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6260                "                             : 3333333333333333;",
6261                Style);
6262   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6263                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6264                "             : cccccccccccccccc ? dddddddddddddddddd\n"
6265                "                                : eeeeeeeeeeeeeeeeee\n"
6266                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6267                "                                 : 3333333333333333;",
6268                Style);
6269 }
6270 
6271 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6272   FormatStyle Style = getLLVMStyle();
6273   Style.BreakBeforeTernaryOperators = false;
6274   Style.ColumnLimit = 70;
6275   verifyFormat(
6276       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6277       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6278       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6279       Style);
6280   verifyFormat(
6281       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6282       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6283       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6284       Style);
6285   verifyFormat(
6286       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6287       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6288       Style);
6289   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6290                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6291                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6292                Style);
6293   verifyFormat(
6294       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6295       "                                                      aaaaaaaaaaaaa);",
6296       Style);
6297   verifyFormat(
6298       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6299       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6300       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6301       "                   aaaaaaaaaaaaa);",
6302       Style);
6303   verifyFormat(
6304       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6305       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6306       "                   aaaaaaaaaaaaa);",
6307       Style);
6308   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6309                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6310                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6311                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6312                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6313                Style);
6314   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6315                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6316                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6317                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6318                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6319                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6320                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6321                Style);
6322   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6323                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6324                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6325                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6326                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6327                Style);
6328   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6329                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6330                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6331                Style);
6332   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6333                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6334                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6335                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6336                Style);
6337   verifyFormat(
6338       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6339       "    aaaaaaaaaaaaaaa :\n"
6340       "    aaaaaaaaaaaaaaa;",
6341       Style);
6342   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6343                "          aaaaaaaaa ?\n"
6344                "      b :\n"
6345                "      c);",
6346                Style);
6347   verifyFormat("unsigned Indent =\n"
6348                "    format(TheLine.First,\n"
6349                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
6350                "               IndentForLevel[TheLine.Level] :\n"
6351                "               TheLine * 2,\n"
6352                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6353                Style);
6354   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6355                "                  aaaaaaaaaaaaaaa :\n"
6356                "                  bbbbbbbbbbbbbbb ? //\n"
6357                "                      ccccccccccccccc :\n"
6358                "                      ddddddddddddddd;",
6359                Style);
6360   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6361                "                  aaaaaaaaaaaaaaa :\n"
6362                "                  (bbbbbbbbbbbbbbb ? //\n"
6363                "                       ccccccccccccccc :\n"
6364                "                       ddddddddddddddd);",
6365                Style);
6366   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6367                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6368                "            ccccccccccccccccccccccccccc;",
6369                Style);
6370   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6371                "           aaaaa :\n"
6372                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
6373                Style);
6374 
6375   // Chained conditionals
6376   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6377                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6378                "                          3333333333333333;",
6379                Style);
6380   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6381                "       bbbbbbbbbb       ? 2222222222222222 :\n"
6382                "                          3333333333333333;",
6383                Style);
6384   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
6385                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6386                "                          3333333333333333;",
6387                Style);
6388   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6389                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
6390                "                          333333;",
6391                Style);
6392   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6393                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6394                "       cccccccccccccccc ? 3333333333333333 :\n"
6395                "                          4444444444444444;",
6396                Style);
6397   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6398                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6399                "                          3333333333333333;",
6400                Style);
6401   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6402                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6403                "                          (aaa ? bbb : ccc);",
6404                Style);
6405   verifyFormat(
6406       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6407       "                                               cccccccccccccccccc) :\n"
6408       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6409       "                          3333333333333333;",
6410       Style);
6411   verifyFormat(
6412       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6413       "                                               cccccccccccccccccc) :\n"
6414       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6415       "                          3333333333333333;",
6416       Style);
6417   verifyFormat(
6418       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6419       "                                               dddddddddddddddddd) :\n"
6420       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6421       "                          3333333333333333;",
6422       Style);
6423   verifyFormat(
6424       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6425       "                                               dddddddddddddddddd) :\n"
6426       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6427       "                          3333333333333333;",
6428       Style);
6429   verifyFormat(
6430       "return aaaaaaaaa        ? 1111111111111111 :\n"
6431       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6432       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6433       "                                               dddddddddddddddddd)\n",
6434       Style);
6435   verifyFormat(
6436       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6437       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6438       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6439       "                                               cccccccccccccccccc);",
6440       Style);
6441   verifyFormat(
6442       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6443       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6444       "                                               eeeeeeeeeeeeeeeeee) :\n"
6445       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6446       "                          3333333333333333;",
6447       Style);
6448   verifyFormat(
6449       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6450       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
6451       "                                               eeeeeeeeeeeeeeeeee) :\n"
6452       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6453       "                          3333333333333333;",
6454       Style);
6455   verifyFormat(
6456       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
6457       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6458       "                                               eeeeeeeeeeeeeeeeee) :\n"
6459       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6460       "                          3333333333333333;",
6461       Style);
6462   verifyFormat(
6463       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6464       "                                               cccccccccccccccccc :\n"
6465       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6466       "                          3333333333333333;",
6467       Style);
6468   verifyFormat(
6469       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6470       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
6471       "                                               eeeeeeeeeeeeeeeeee :\n"
6472       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6473       "                          3333333333333333;",
6474       Style);
6475   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6476                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6477                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
6478                "                                 eeeeeeeeeeeeeeeeee) :\n"
6479                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6480                "                               3333333333333333;",
6481                Style);
6482   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6483                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6484                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
6485                "                                  eeeeeeeeeeeeeeeeee :\n"
6486                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6487                "                               3333333333333333;",
6488                Style);
6489 }
6490 
6491 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6492   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6493                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6494   verifyFormat("bool a = true, b = false;");
6495 
6496   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6497                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6498                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6499                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6500   verifyFormat(
6501       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6502       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6503       "     d = e && f;");
6504   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6505                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6506   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6507                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6508   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6509                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6510 
6511   FormatStyle Style = getGoogleStyle();
6512   Style.PointerAlignment = FormatStyle::PAS_Left;
6513   Style.DerivePointerAlignment = false;
6514   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6515                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6516                "    *b = bbbbbbbbbbbbbbbbbbb;",
6517                Style);
6518   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6519                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6520                Style);
6521   verifyFormat("vector<int*> a, b;", Style);
6522   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6523 }
6524 
6525 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6526   verifyFormat("arr[foo ? bar : baz];");
6527   verifyFormat("f()[foo ? bar : baz];");
6528   verifyFormat("(a + b)[foo ? bar : baz];");
6529   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6530 }
6531 
6532 TEST_F(FormatTest, AlignsStringLiterals) {
6533   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6534                "                                      \"short literal\");");
6535   verifyFormat(
6536       "looooooooooooooooooooooooongFunction(\n"
6537       "    \"short literal\"\n"
6538       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6539   verifyFormat("someFunction(\"Always break between multi-line\"\n"
6540                "             \" string literals\",\n"
6541                "             and, other, parameters);");
6542   EXPECT_EQ("fun + \"1243\" /* comment */\n"
6543             "      \"5678\";",
6544             format("fun + \"1243\" /* comment */\n"
6545                    "    \"5678\";",
6546                    getLLVMStyleWithColumns(28)));
6547   EXPECT_EQ(
6548       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6549       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6550       "         \"aaaaaaaaaaaaaaaa\";",
6551       format("aaaaaa ="
6552              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6553              "aaaaaaaaaaaaaaaaaaaaa\" "
6554              "\"aaaaaaaaaaaaaaaa\";"));
6555   verifyFormat("a = a + \"a\"\n"
6556                "        \"a\"\n"
6557                "        \"a\";");
6558   verifyFormat("f(\"a\", \"b\"\n"
6559                "       \"c\");");
6560 
6561   verifyFormat(
6562       "#define LL_FORMAT \"ll\"\n"
6563       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6564       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6565 
6566   verifyFormat("#define A(X)          \\\n"
6567                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
6568                "  \"ccccc\"",
6569                getLLVMStyleWithColumns(23));
6570   verifyFormat("#define A \"def\"\n"
6571                "f(\"abc\" A \"ghi\"\n"
6572                "  \"jkl\");");
6573 
6574   verifyFormat("f(L\"a\"\n"
6575                "  L\"b\");");
6576   verifyFormat("#define A(X)            \\\n"
6577                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6578                "  L\"ccccc\"",
6579                getLLVMStyleWithColumns(25));
6580 
6581   verifyFormat("f(@\"a\"\n"
6582                "  @\"b\");");
6583   verifyFormat("NSString s = @\"a\"\n"
6584                "             @\"b\"\n"
6585                "             @\"c\";");
6586   verifyFormat("NSString s = @\"a\"\n"
6587                "              \"b\"\n"
6588                "              \"c\";");
6589 }
6590 
6591 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6592   FormatStyle Style = getLLVMStyle();
6593   // No declarations or definitions should be moved to own line.
6594   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6595   verifyFormat("class A {\n"
6596                "  int f() { return 1; }\n"
6597                "  int g();\n"
6598                "};\n"
6599                "int f() { return 1; }\n"
6600                "int g();\n",
6601                Style);
6602 
6603   // All declarations and definitions should have the return type moved to its
6604   // own
6605   // line.
6606   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6607   verifyFormat("class E {\n"
6608                "  int\n"
6609                "  f() {\n"
6610                "    return 1;\n"
6611                "  }\n"
6612                "  int\n"
6613                "  g();\n"
6614                "};\n"
6615                "int\n"
6616                "f() {\n"
6617                "  return 1;\n"
6618                "}\n"
6619                "int\n"
6620                "g();\n",
6621                Style);
6622 
6623   // Top-level definitions, and no kinds of declarations should have the
6624   // return type moved to its own line.
6625   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6626   verifyFormat("class B {\n"
6627                "  int f() { return 1; }\n"
6628                "  int g();\n"
6629                "};\n"
6630                "int\n"
6631                "f() {\n"
6632                "  return 1;\n"
6633                "}\n"
6634                "int g();\n",
6635                Style);
6636 
6637   // Top-level definitions and declarations should have the return type moved
6638   // to its own line.
6639   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6640   verifyFormat("class C {\n"
6641                "  int f() { return 1; }\n"
6642                "  int g();\n"
6643                "};\n"
6644                "int\n"
6645                "f() {\n"
6646                "  return 1;\n"
6647                "}\n"
6648                "int\n"
6649                "g();\n",
6650                Style);
6651 
6652   // All definitions should have the return type moved to its own line, but no
6653   // kinds of declarations.
6654   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6655   verifyFormat("class D {\n"
6656                "  int\n"
6657                "  f() {\n"
6658                "    return 1;\n"
6659                "  }\n"
6660                "  int g();\n"
6661                "};\n"
6662                "int\n"
6663                "f() {\n"
6664                "  return 1;\n"
6665                "}\n"
6666                "int g();\n",
6667                Style);
6668   verifyFormat("const char *\n"
6669                "f(void) {\n" // Break here.
6670                "  return \"\";\n"
6671                "}\n"
6672                "const char *bar(void);\n", // No break here.
6673                Style);
6674   verifyFormat("template <class T>\n"
6675                "T *\n"
6676                "f(T &c) {\n" // Break here.
6677                "  return NULL;\n"
6678                "}\n"
6679                "template <class T> T *f(T &c);\n", // No break here.
6680                Style);
6681   verifyFormat("class C {\n"
6682                "  int\n"
6683                "  operator+() {\n"
6684                "    return 1;\n"
6685                "  }\n"
6686                "  int\n"
6687                "  operator()() {\n"
6688                "    return 1;\n"
6689                "  }\n"
6690                "};\n",
6691                Style);
6692   verifyFormat("void\n"
6693                "A::operator()() {}\n"
6694                "void\n"
6695                "A::operator>>() {}\n"
6696                "void\n"
6697                "A::operator+() {}\n"
6698                "void\n"
6699                "A::operator*() {}\n"
6700                "void\n"
6701                "A::operator->() {}\n"
6702                "void\n"
6703                "A::operator void *() {}\n"
6704                "void\n"
6705                "A::operator void &() {}\n"
6706                "void\n"
6707                "A::operator void &&() {}\n"
6708                "void\n"
6709                "A::operator char *() {}\n"
6710                "void\n"
6711                "A::operator[]() {}\n"
6712                "void\n"
6713                "A::operator!() {}\n"
6714                "void\n"
6715                "A::operator**() {}\n"
6716                "void\n"
6717                "A::operator<Foo> *() {}\n"
6718                "void\n"
6719                "A::operator<Foo> **() {}\n"
6720                "void\n"
6721                "A::operator<Foo> &() {}\n"
6722                "void\n"
6723                "A::operator void **() {}\n",
6724                Style);
6725   verifyFormat("constexpr auto\n"
6726                "operator()() const -> reference {}\n"
6727                "constexpr auto\n"
6728                "operator>>() const -> reference {}\n"
6729                "constexpr auto\n"
6730                "operator+() const -> reference {}\n"
6731                "constexpr auto\n"
6732                "operator*() const -> reference {}\n"
6733                "constexpr auto\n"
6734                "operator->() const -> reference {}\n"
6735                "constexpr auto\n"
6736                "operator++() const -> reference {}\n"
6737                "constexpr auto\n"
6738                "operator void *() const -> reference {}\n"
6739                "constexpr auto\n"
6740                "operator void **() const -> reference {}\n"
6741                "constexpr auto\n"
6742                "operator void *() const -> reference {}\n"
6743                "constexpr auto\n"
6744                "operator void &() const -> reference {}\n"
6745                "constexpr auto\n"
6746                "operator void &&() const -> reference {}\n"
6747                "constexpr auto\n"
6748                "operator char *() const -> reference {}\n"
6749                "constexpr auto\n"
6750                "operator!() const -> reference {}\n"
6751                "constexpr auto\n"
6752                "operator[]() const -> reference {}\n",
6753                Style);
6754   verifyFormat("void *operator new(std::size_t s);", // No break here.
6755                Style);
6756   verifyFormat("void *\n"
6757                "operator new(std::size_t s) {}",
6758                Style);
6759   verifyFormat("void *\n"
6760                "operator delete[](void *ptr) {}",
6761                Style);
6762   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6763   verifyFormat("const char *\n"
6764                "f(void)\n" // Break here.
6765                "{\n"
6766                "  return \"\";\n"
6767                "}\n"
6768                "const char *bar(void);\n", // No break here.
6769                Style);
6770   verifyFormat("template <class T>\n"
6771                "T *\n"     // Problem here: no line break
6772                "f(T &c)\n" // Break here.
6773                "{\n"
6774                "  return NULL;\n"
6775                "}\n"
6776                "template <class T> T *f(T &c);\n", // No break here.
6777                Style);
6778   verifyFormat("int\n"
6779                "foo(A<bool> a)\n"
6780                "{\n"
6781                "  return a;\n"
6782                "}\n",
6783                Style);
6784   verifyFormat("int\n"
6785                "foo(A<8> a)\n"
6786                "{\n"
6787                "  return a;\n"
6788                "}\n",
6789                Style);
6790   verifyFormat("int\n"
6791                "foo(A<B<bool>, 8> a)\n"
6792                "{\n"
6793                "  return a;\n"
6794                "}\n",
6795                Style);
6796   verifyFormat("int\n"
6797                "foo(A<B<8>, bool> a)\n"
6798                "{\n"
6799                "  return a;\n"
6800                "}\n",
6801                Style);
6802   verifyFormat("int\n"
6803                "foo(A<B<bool>, bool> a)\n"
6804                "{\n"
6805                "  return a;\n"
6806                "}\n",
6807                Style);
6808   verifyFormat("int\n"
6809                "foo(A<B<8>, 8> a)\n"
6810                "{\n"
6811                "  return a;\n"
6812                "}\n",
6813                Style);
6814 
6815   Style = getGNUStyle();
6816 
6817   // Test for comments at the end of function declarations.
6818   verifyFormat("void\n"
6819                "foo (int a, /*abc*/ int b) // def\n"
6820                "{\n"
6821                "}\n",
6822                Style);
6823 
6824   verifyFormat("void\n"
6825                "foo (int a, /* abc */ int b) /* def */\n"
6826                "{\n"
6827                "}\n",
6828                Style);
6829 
6830   // Definitions that should not break after return type
6831   verifyFormat("void foo (int a, int b); // def\n", Style);
6832   verifyFormat("void foo (int a, int b); /* def */\n", Style);
6833   verifyFormat("void foo (int a, int b);\n", Style);
6834 }
6835 
6836 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
6837   FormatStyle NoBreak = getLLVMStyle();
6838   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
6839   FormatStyle Break = getLLVMStyle();
6840   Break.AlwaysBreakBeforeMultilineStrings = true;
6841   verifyFormat("aaaa = \"bbbb\"\n"
6842                "       \"cccc\";",
6843                NoBreak);
6844   verifyFormat("aaaa =\n"
6845                "    \"bbbb\"\n"
6846                "    \"cccc\";",
6847                Break);
6848   verifyFormat("aaaa(\"bbbb\"\n"
6849                "     \"cccc\");",
6850                NoBreak);
6851   verifyFormat("aaaa(\n"
6852                "    \"bbbb\"\n"
6853                "    \"cccc\");",
6854                Break);
6855   verifyFormat("aaaa(qqq, \"bbbb\"\n"
6856                "          \"cccc\");",
6857                NoBreak);
6858   verifyFormat("aaaa(qqq,\n"
6859                "     \"bbbb\"\n"
6860                "     \"cccc\");",
6861                Break);
6862   verifyFormat("aaaa(qqq,\n"
6863                "     L\"bbbb\"\n"
6864                "     L\"cccc\");",
6865                Break);
6866   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
6867                "                      \"bbbb\"));",
6868                Break);
6869   verifyFormat("string s = someFunction(\n"
6870                "    \"abc\"\n"
6871                "    \"abc\");",
6872                Break);
6873 
6874   // As we break before unary operators, breaking right after them is bad.
6875   verifyFormat("string foo = abc ? \"x\"\n"
6876                "                   \"blah blah blah blah blah blah\"\n"
6877                "                 : \"y\";",
6878                Break);
6879 
6880   // Don't break if there is no column gain.
6881   verifyFormat("f(\"aaaa\"\n"
6882                "  \"bbbb\");",
6883                Break);
6884 
6885   // Treat literals with escaped newlines like multi-line string literals.
6886   EXPECT_EQ("x = \"a\\\n"
6887             "b\\\n"
6888             "c\";",
6889             format("x = \"a\\\n"
6890                    "b\\\n"
6891                    "c\";",
6892                    NoBreak));
6893   EXPECT_EQ("xxxx =\n"
6894             "    \"a\\\n"
6895             "b\\\n"
6896             "c\";",
6897             format("xxxx = \"a\\\n"
6898                    "b\\\n"
6899                    "c\";",
6900                    Break));
6901 
6902   EXPECT_EQ("NSString *const kString =\n"
6903             "    @\"aaaa\"\n"
6904             "    @\"bbbb\";",
6905             format("NSString *const kString = @\"aaaa\"\n"
6906                    "@\"bbbb\";",
6907                    Break));
6908 
6909   Break.ColumnLimit = 0;
6910   verifyFormat("const char *hello = \"hello llvm\";", Break);
6911 }
6912 
6913 TEST_F(FormatTest, AlignsPipes) {
6914   verifyFormat(
6915       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6916       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6917       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6918   verifyFormat(
6919       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
6920       "                     << aaaaaaaaaaaaaaaaaaaa;");
6921   verifyFormat(
6922       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6923       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6924   verifyFormat(
6925       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
6926       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6927   verifyFormat(
6928       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
6929       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
6930       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
6931   verifyFormat(
6932       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6933       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6934       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6935   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6936                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6937                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6938                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
6939   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
6940                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
6941   verifyFormat(
6942       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6943       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6944   verifyFormat(
6945       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
6946       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
6947 
6948   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
6949                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
6950   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6951                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6952                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
6953                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
6954   verifyFormat("LOG_IF(aaa == //\n"
6955                "       bbb)\n"
6956                "    << a << b;");
6957 
6958   // But sometimes, breaking before the first "<<" is desirable.
6959   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6960                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
6961   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
6962                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6963                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6964   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
6965                "    << BEF << IsTemplate << Description << E->getType();");
6966   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6967                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6968                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6969   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6970                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6971                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6972                "    << aaa;");
6973 
6974   verifyFormat(
6975       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6976       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
6977 
6978   // Incomplete string literal.
6979   EXPECT_EQ("llvm::errs() << \"\n"
6980             "             << a;",
6981             format("llvm::errs() << \"\n<<a;"));
6982 
6983   verifyFormat("void f() {\n"
6984                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
6985                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
6986                "}");
6987 
6988   // Handle 'endl'.
6989   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
6990                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
6991   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
6992 
6993   // Handle '\n'.
6994   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
6995                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
6996   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
6997                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
6998   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
6999                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
7000   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7001 }
7002 
7003 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
7004   verifyFormat("return out << \"somepacket = {\\n\"\n"
7005                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
7006                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
7007                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
7008                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
7009                "           << \"}\";");
7010 
7011   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7012                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7013                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7014   verifyFormat(
7015       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7016       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7017       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7018       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7019       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7020   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7021                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7022   verifyFormat(
7023       "void f() {\n"
7024       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7025       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7026       "}");
7027 
7028   // Breaking before the first "<<" is generally not desirable.
7029   verifyFormat(
7030       "llvm::errs()\n"
7031       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7032       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7033       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7034       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7035       getLLVMStyleWithColumns(70));
7036   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7037                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7038                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7039                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7040                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7041                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7042                getLLVMStyleWithColumns(70));
7043 
7044   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7045                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7046                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7047   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7048                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7049                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7050   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7051                "           (aaaa + aaaa);",
7052                getLLVMStyleWithColumns(40));
7053   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7054                "                  (aaaaaaa + aaaaa));",
7055                getLLVMStyleWithColumns(40));
7056   verifyFormat(
7057       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7058       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7059       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
7060 }
7061 
7062 TEST_F(FormatTest, UnderstandsEquals) {
7063   verifyFormat(
7064       "aaaaaaaaaaaaaaaaa =\n"
7065       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7066   verifyFormat(
7067       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7068       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7069   verifyFormat(
7070       "if (a) {\n"
7071       "  f();\n"
7072       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7073       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7074       "}");
7075 
7076   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7077                "        100000000 + 10000000) {\n}");
7078 }
7079 
7080 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7081   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7082                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
7083 
7084   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7085                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
7086 
7087   verifyFormat(
7088       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7089       "                                                          Parameter2);");
7090 
7091   verifyFormat(
7092       "ShortObject->shortFunction(\n"
7093       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7094       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7095 
7096   verifyFormat("loooooooooooooongFunction(\n"
7097                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
7098 
7099   verifyFormat(
7100       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7101       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7102 
7103   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7104                "    .WillRepeatedly(Return(SomeValue));");
7105   verifyFormat("void f() {\n"
7106                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7107                "      .Times(2)\n"
7108                "      .WillRepeatedly(Return(SomeValue));\n"
7109                "}");
7110   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7111                "    ccccccccccccccccccccccc);");
7112   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7113                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7114                "          .aaaaa(aaaaa),\n"
7115                "      aaaaaaaaaaaaaaaaaaaaa);");
7116   verifyFormat("void f() {\n"
7117                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7118                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7119                "}");
7120   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7121                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7122                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7123                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7124                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7125   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7126                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7127                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7128                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7129                "}");
7130 
7131   // Here, it is not necessary to wrap at "." or "->".
7132   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7133                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7134   verifyFormat(
7135       "aaaaaaaaaaa->aaaaaaaaa(\n"
7136       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7137       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7138 
7139   verifyFormat(
7140       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7141       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7142   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7143                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7144   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7145                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7146 
7147   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7148                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7149                "    .a();");
7150 
7151   FormatStyle NoBinPacking = getLLVMStyle();
7152   NoBinPacking.BinPackParameters = false;
7153   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7154                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7155                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7156                "                         aaaaaaaaaaaaaaaaaaa,\n"
7157                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7158                NoBinPacking);
7159 
7160   // If there is a subsequent call, change to hanging indentation.
7161   verifyFormat(
7162       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7163       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7164       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7165   verifyFormat(
7166       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7167       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7168   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7169                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7170                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7171   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7172                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7173                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7174 }
7175 
7176 TEST_F(FormatTest, WrapsTemplateDeclarations) {
7177   verifyFormat("template <typename T>\n"
7178                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7179   verifyFormat("template <typename T>\n"
7180                "// T should be one of {A, B}.\n"
7181                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7182   verifyFormat(
7183       "template <typename T>\n"
7184       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7185   verifyFormat("template <typename T>\n"
7186                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7187                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7188   verifyFormat(
7189       "template <typename T>\n"
7190       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7191       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
7192   verifyFormat(
7193       "template <typename T>\n"
7194       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7195       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7196       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7197   verifyFormat("template <typename T>\n"
7198                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7199                "    int aaaaaaaaaaaaaaaaaaaaaa);");
7200   verifyFormat(
7201       "template <typename T1, typename T2 = char, typename T3 = char,\n"
7202       "          typename T4 = char>\n"
7203       "void f();");
7204   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7205                "          template <typename> class cccccccccccccccccccccc,\n"
7206                "          typename ddddddddddddd>\n"
7207                "class C {};");
7208   verifyFormat(
7209       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7210       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7211 
7212   verifyFormat("void f() {\n"
7213                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7214                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7215                "}");
7216 
7217   verifyFormat("template <typename T> class C {};");
7218   verifyFormat("template <typename T> void f();");
7219   verifyFormat("template <typename T> void f() {}");
7220   verifyFormat(
7221       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7222       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7223       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7224       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7225       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7226       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7227       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
7228       getLLVMStyleWithColumns(72));
7229   EXPECT_EQ("static_cast<A< //\n"
7230             "    B> *>(\n"
7231             "\n"
7232             ");",
7233             format("static_cast<A<//\n"
7234                    "    B>*>(\n"
7235                    "\n"
7236                    "    );"));
7237   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7238                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7239 
7240   FormatStyle AlwaysBreak = getLLVMStyle();
7241   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7242   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7243   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7244   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7245   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7246                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7247                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
7248   verifyFormat("template <template <typename> class Fooooooo,\n"
7249                "          template <typename> class Baaaaaaar>\n"
7250                "struct C {};",
7251                AlwaysBreak);
7252   verifyFormat("template <typename T> // T can be A, B or C.\n"
7253                "struct C {};",
7254                AlwaysBreak);
7255   verifyFormat("template <enum E> class A {\n"
7256                "public:\n"
7257                "  E *f();\n"
7258                "};");
7259 
7260   FormatStyle NeverBreak = getLLVMStyle();
7261   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7262   verifyFormat("template <typename T> class C {};", NeverBreak);
7263   verifyFormat("template <typename T> void f();", NeverBreak);
7264   verifyFormat("template <typename T> void f() {}", NeverBreak);
7265   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7266                "bbbbbbbbbbbbbbbbbbbb) {}",
7267                NeverBreak);
7268   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7269                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7270                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
7271                NeverBreak);
7272   verifyFormat("template <template <typename> class Fooooooo,\n"
7273                "          template <typename> class Baaaaaaar>\n"
7274                "struct C {};",
7275                NeverBreak);
7276   verifyFormat("template <typename T> // T can be A, B or C.\n"
7277                "struct C {};",
7278                NeverBreak);
7279   verifyFormat("template <enum E> class A {\n"
7280                "public:\n"
7281                "  E *f();\n"
7282                "};",
7283                NeverBreak);
7284   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7285   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7286                "bbbbbbbbbbbbbbbbbbbb) {}",
7287                NeverBreak);
7288 }
7289 
7290 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7291   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7292   Style.ColumnLimit = 60;
7293   EXPECT_EQ("// Baseline - no comments.\n"
7294             "template <\n"
7295             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7296             "void f() {}",
7297             format("// Baseline - no comments.\n"
7298                    "template <\n"
7299                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7300                    "void f() {}",
7301                    Style));
7302 
7303   EXPECT_EQ("template <\n"
7304             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7305             "void f() {}",
7306             format("template <\n"
7307                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7308                    "void f() {}",
7309                    Style));
7310 
7311   EXPECT_EQ(
7312       "template <\n"
7313       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7314       "void f() {}",
7315       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
7316              "void f() {}",
7317              Style));
7318 
7319   EXPECT_EQ(
7320       "template <\n"
7321       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7322       "                                               // multiline\n"
7323       "void f() {}",
7324       format("template <\n"
7325              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7326              "                                              // multiline\n"
7327              "void f() {}",
7328              Style));
7329 
7330   EXPECT_EQ(
7331       "template <typename aaaaaaaaaa<\n"
7332       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
7333       "void f() {}",
7334       format(
7335           "template <\n"
7336           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7337           "void f() {}",
7338           Style));
7339 }
7340 
7341 TEST_F(FormatTest, WrapsTemplateParameters) {
7342   FormatStyle Style = getLLVMStyle();
7343   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7344   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7345   verifyFormat(
7346       "template <typename... a> struct q {};\n"
7347       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7348       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7349       "    y;",
7350       Style);
7351   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7352   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7353   verifyFormat(
7354       "template <typename... a> struct r {};\n"
7355       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7356       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7357       "    y;",
7358       Style);
7359   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7360   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7361   verifyFormat("template <typename... a> struct s {};\n"
7362                "extern s<\n"
7363                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7364                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7365                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7366                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7367                "    y;",
7368                Style);
7369   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7370   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7371   verifyFormat("template <typename... a> struct t {};\n"
7372                "extern t<\n"
7373                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7374                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7375                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7376                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7377                "    y;",
7378                Style);
7379 }
7380 
7381 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7382   verifyFormat(
7383       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7384       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7385   verifyFormat(
7386       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7387       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7388       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7389 
7390   // FIXME: Should we have the extra indent after the second break?
7391   verifyFormat(
7392       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7393       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7394       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7395 
7396   verifyFormat(
7397       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7398       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
7399 
7400   // Breaking at nested name specifiers is generally not desirable.
7401   verifyFormat(
7402       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7403       "    aaaaaaaaaaaaaaaaaaaaaaa);");
7404 
7405   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7406                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7407                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7408                "                   aaaaaaaaaaaaaaaaaaaaa);",
7409                getLLVMStyleWithColumns(74));
7410 
7411   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7412                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7413                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7414 }
7415 
7416 TEST_F(FormatTest, UnderstandsTemplateParameters) {
7417   verifyFormat("A<int> a;");
7418   verifyFormat("A<A<A<int>>> a;");
7419   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7420   verifyFormat("bool x = a < 1 || 2 > a;");
7421   verifyFormat("bool x = 5 < f<int>();");
7422   verifyFormat("bool x = f<int>() > 5;");
7423   verifyFormat("bool x = 5 < a<int>::x;");
7424   verifyFormat("bool x = a < 4 ? a > 2 : false;");
7425   verifyFormat("bool x = f() ? a < 2 : a > 2;");
7426 
7427   verifyGoogleFormat("A<A<int>> a;");
7428   verifyGoogleFormat("A<A<A<int>>> a;");
7429   verifyGoogleFormat("A<A<A<A<int>>>> a;");
7430   verifyGoogleFormat("A<A<int> > a;");
7431   verifyGoogleFormat("A<A<A<int> > > a;");
7432   verifyGoogleFormat("A<A<A<A<int> > > > a;");
7433   verifyGoogleFormat("A<::A<int>> a;");
7434   verifyGoogleFormat("A<::A> a;");
7435   verifyGoogleFormat("A< ::A> a;");
7436   verifyGoogleFormat("A< ::A<int> > a;");
7437   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7438   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7439   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7440   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7441   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7442             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7443 
7444   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7445 
7446   // template closer followed by a token that starts with > or =
7447   verifyFormat("bool b = a<1> > 1;");
7448   verifyFormat("bool b = a<1> >= 1;");
7449   verifyFormat("int i = a<1> >> 1;");
7450   FormatStyle Style = getLLVMStyle();
7451   Style.SpaceBeforeAssignmentOperators = false;
7452   verifyFormat("bool b= a<1> == 1;", Style);
7453   verifyFormat("a<int> = 1;", Style);
7454   verifyFormat("a<int> >>= 1;", Style);
7455 
7456   verifyFormat("test >> a >> b;");
7457   verifyFormat("test << a >> b;");
7458 
7459   verifyFormat("f<int>();");
7460   verifyFormat("template <typename T> void f() {}");
7461   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7462   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7463                "sizeof(char)>::type>;");
7464   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7465   verifyFormat("f(a.operator()<A>());");
7466   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7467                "      .template operator()<A>());",
7468                getLLVMStyleWithColumns(35));
7469 
7470   // Not template parameters.
7471   verifyFormat("return a < b && c > d;");
7472   verifyFormat("void f() {\n"
7473                "  while (a < b && c > d) {\n"
7474                "  }\n"
7475                "}");
7476   verifyFormat("template <typename... Types>\n"
7477                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7478 
7479   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7480                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7481                getLLVMStyleWithColumns(60));
7482   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7483   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7484   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7485 }
7486 
7487 TEST_F(FormatTest, BitshiftOperatorWidth) {
7488   EXPECT_EQ("int a = 1 << 2; /* foo\n"
7489             "                   bar */",
7490             format("int    a=1<<2;  /* foo\n"
7491                    "                   bar */"));
7492 
7493   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7494             "                     bar */",
7495             format("int  b  =256>>1 ;  /* foo\n"
7496                    "                      bar */"));
7497 }
7498 
7499 TEST_F(FormatTest, UnderstandsBinaryOperators) {
7500   verifyFormat("COMPARE(a, ==, b);");
7501   verifyFormat("auto s = sizeof...(Ts) - 1;");
7502 }
7503 
7504 TEST_F(FormatTest, UnderstandsPointersToMembers) {
7505   verifyFormat("int A::*x;");
7506   verifyFormat("int (S::*func)(void *);");
7507   verifyFormat("void f() { int (S::*func)(void *); }");
7508   verifyFormat("typedef bool *(Class::*Member)() const;");
7509   verifyFormat("void f() {\n"
7510                "  (a->*f)();\n"
7511                "  a->*x;\n"
7512                "  (a.*f)();\n"
7513                "  ((*a).*f)();\n"
7514                "  a.*x;\n"
7515                "}");
7516   verifyFormat("void f() {\n"
7517                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7518                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7519                "}");
7520   verifyFormat(
7521       "(aaaaaaaaaa->*bbbbbbb)(\n"
7522       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7523   FormatStyle Style = getLLVMStyle();
7524   Style.PointerAlignment = FormatStyle::PAS_Left;
7525   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7526 }
7527 
7528 TEST_F(FormatTest, UnderstandsUnaryOperators) {
7529   verifyFormat("int a = -2;");
7530   verifyFormat("f(-1, -2, -3);");
7531   verifyFormat("a[-1] = 5;");
7532   verifyFormat("int a = 5 + -2;");
7533   verifyFormat("if (i == -1) {\n}");
7534   verifyFormat("if (i != -1) {\n}");
7535   verifyFormat("if (i > -1) {\n}");
7536   verifyFormat("if (i < -1) {\n}");
7537   verifyFormat("++(a->f());");
7538   verifyFormat("--(a->f());");
7539   verifyFormat("(a->f())++;");
7540   verifyFormat("a[42]++;");
7541   verifyFormat("if (!(a->f())) {\n}");
7542   verifyFormat("if (!+i) {\n}");
7543   verifyFormat("~&a;");
7544 
7545   verifyFormat("a-- > b;");
7546   verifyFormat("b ? -a : c;");
7547   verifyFormat("n * sizeof char16;");
7548   verifyFormat("n * alignof char16;", getGoogleStyle());
7549   verifyFormat("sizeof(char);");
7550   verifyFormat("alignof(char);", getGoogleStyle());
7551 
7552   verifyFormat("return -1;");
7553   verifyFormat("throw -1;");
7554   verifyFormat("switch (a) {\n"
7555                "case -1:\n"
7556                "  break;\n"
7557                "}");
7558   verifyFormat("#define X -1");
7559   verifyFormat("#define X -kConstant");
7560 
7561   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7562   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7563 
7564   verifyFormat("int a = /* confusing comment */ -1;");
7565   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7566   verifyFormat("int a = i /* confusing comment */++;");
7567 
7568   verifyFormat("co_yield -1;");
7569   verifyFormat("co_return -1;");
7570 }
7571 
7572 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7573   verifyFormat("if (!aaaaaaaaaa( // break\n"
7574                "        aaaaa)) {\n"
7575                "}");
7576   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7577                "    aaaaa));");
7578   verifyFormat("*aaa = aaaaaaa( // break\n"
7579                "    bbbbbb);");
7580 }
7581 
7582 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7583   verifyFormat("bool operator<();");
7584   verifyFormat("bool operator>();");
7585   verifyFormat("bool operator=();");
7586   verifyFormat("bool operator==();");
7587   verifyFormat("bool operator!=();");
7588   verifyFormat("int operator+();");
7589   verifyFormat("int operator++();");
7590   verifyFormat("int operator++(int) volatile noexcept;");
7591   verifyFormat("bool operator,();");
7592   verifyFormat("bool operator();");
7593   verifyFormat("bool operator()();");
7594   verifyFormat("bool operator[]();");
7595   verifyFormat("operator bool();");
7596   verifyFormat("operator int();");
7597   verifyFormat("operator void *();");
7598   verifyFormat("operator SomeType<int>();");
7599   verifyFormat("operator SomeType<int, int>();");
7600   verifyFormat("operator SomeType<SomeType<int>>();");
7601   verifyFormat("void *operator new(std::size_t size);");
7602   verifyFormat("void *operator new[](std::size_t size);");
7603   verifyFormat("void operator delete(void *ptr);");
7604   verifyFormat("void operator delete[](void *ptr);");
7605   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7606                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7607   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7608                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7609 
7610   verifyFormat(
7611       "ostream &operator<<(ostream &OutputStream,\n"
7612       "                    SomeReallyLongType WithSomeReallyLongValue);");
7613   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7614                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7615                "  return left.group < right.group;\n"
7616                "}");
7617   verifyFormat("SomeType &operator=(const SomeType &S);");
7618   verifyFormat("f.template operator()<int>();");
7619 
7620   verifyGoogleFormat("operator void*();");
7621   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7622   verifyGoogleFormat("operator ::A();");
7623 
7624   verifyFormat("using A::operator+;");
7625   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7626                "int i;");
7627 }
7628 
7629 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7630   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7631   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7632   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7633   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7634   verifyFormat("Deleted &operator=(const Deleted &) &;");
7635   verifyFormat("Deleted &operator=(const Deleted &) &&;");
7636   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7637   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7638   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7639   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7640   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7641   verifyFormat("void Fn(T const &) const &;");
7642   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7643   verifyFormat("template <typename T>\n"
7644                "void F(T) && = delete;",
7645                getGoogleStyle());
7646 
7647   FormatStyle AlignLeft = getLLVMStyle();
7648   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7649   verifyFormat("void A::b() && {}", AlignLeft);
7650   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7651   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7652                AlignLeft);
7653   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7654   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7655   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7656   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7657   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7658   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7659   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7660   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7661 
7662   FormatStyle Spaces = getLLVMStyle();
7663   Spaces.SpacesInCStyleCastParentheses = true;
7664   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7665   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7666   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7667   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7668 
7669   Spaces.SpacesInCStyleCastParentheses = false;
7670   Spaces.SpacesInParentheses = true;
7671   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7672   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7673                Spaces);
7674   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7675   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7676 
7677   FormatStyle BreakTemplate = getLLVMStyle();
7678   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7679 
7680   verifyFormat("struct f {\n"
7681                "  template <class T>\n"
7682                "  int &foo(const std::string &str) &noexcept {}\n"
7683                "};",
7684                BreakTemplate);
7685 
7686   verifyFormat("struct f {\n"
7687                "  template <class T>\n"
7688                "  int &foo(const std::string &str) &&noexcept {}\n"
7689                "};",
7690                BreakTemplate);
7691 
7692   verifyFormat("struct f {\n"
7693                "  template <class T>\n"
7694                "  int &foo(const std::string &str) const &noexcept {}\n"
7695                "};",
7696                BreakTemplate);
7697 
7698   verifyFormat("struct f {\n"
7699                "  template <class T>\n"
7700                "  int &foo(const std::string &str) const &noexcept {}\n"
7701                "};",
7702                BreakTemplate);
7703 
7704   verifyFormat("struct f {\n"
7705                "  template <class T>\n"
7706                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
7707                "};",
7708                BreakTemplate);
7709 
7710   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7711   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7712       FormatStyle::BTDS_Yes;
7713   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7714 
7715   verifyFormat("struct f {\n"
7716                "  template <class T>\n"
7717                "  int& foo(const std::string& str) & noexcept {}\n"
7718                "};",
7719                AlignLeftBreakTemplate);
7720 
7721   verifyFormat("struct f {\n"
7722                "  template <class T>\n"
7723                "  int& foo(const std::string& str) && noexcept {}\n"
7724                "};",
7725                AlignLeftBreakTemplate);
7726 
7727   verifyFormat("struct f {\n"
7728                "  template <class T>\n"
7729                "  int& foo(const std::string& str) const& noexcept {}\n"
7730                "};",
7731                AlignLeftBreakTemplate);
7732 
7733   verifyFormat("struct f {\n"
7734                "  template <class T>\n"
7735                "  int& foo(const std::string& str) const&& noexcept {}\n"
7736                "};",
7737                AlignLeftBreakTemplate);
7738 
7739   verifyFormat("struct f {\n"
7740                "  template <class T>\n"
7741                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7742                "};",
7743                AlignLeftBreakTemplate);
7744 
7745   // The `&` in `Type&` should not be confused with a trailing `&` of
7746   // DEPRECATED(reason) member function.
7747   verifyFormat("struct f {\n"
7748                "  template <class T>\n"
7749                "  DEPRECATED(reason)\n"
7750                "  Type &foo(arguments) {}\n"
7751                "};",
7752                BreakTemplate);
7753 
7754   verifyFormat("struct f {\n"
7755                "  template <class T>\n"
7756                "  DEPRECATED(reason)\n"
7757                "  Type& foo(arguments) {}\n"
7758                "};",
7759                AlignLeftBreakTemplate);
7760 
7761   verifyFormat("void (*foopt)(int) = &func;");
7762 }
7763 
7764 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7765   verifyFormat("void f() {\n"
7766                "  A *a = new A;\n"
7767                "  A *a = new (placement) A;\n"
7768                "  delete a;\n"
7769                "  delete (A *)a;\n"
7770                "}");
7771   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7772                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7773   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7774                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7775                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7776   verifyFormat("delete[] h->p;");
7777 }
7778 
7779 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
7780   verifyFormat("int *f(int *a) {}");
7781   verifyFormat("int main(int argc, char **argv) {}");
7782   verifyFormat("Test::Test(int b) : a(b * b) {}");
7783   verifyIndependentOfContext("f(a, *a);");
7784   verifyFormat("void g() { f(*a); }");
7785   verifyIndependentOfContext("int a = b * 10;");
7786   verifyIndependentOfContext("int a = 10 * b;");
7787   verifyIndependentOfContext("int a = b * c;");
7788   verifyIndependentOfContext("int a += b * c;");
7789   verifyIndependentOfContext("int a -= b * c;");
7790   verifyIndependentOfContext("int a *= b * c;");
7791   verifyIndependentOfContext("int a /= b * c;");
7792   verifyIndependentOfContext("int a = *b;");
7793   verifyIndependentOfContext("int a = *b * c;");
7794   verifyIndependentOfContext("int a = b * *c;");
7795   verifyIndependentOfContext("int a = b * (10);");
7796   verifyIndependentOfContext("S << b * (10);");
7797   verifyIndependentOfContext("return 10 * b;");
7798   verifyIndependentOfContext("return *b * *c;");
7799   verifyIndependentOfContext("return a & ~b;");
7800   verifyIndependentOfContext("f(b ? *c : *d);");
7801   verifyIndependentOfContext("int a = b ? *c : *d;");
7802   verifyIndependentOfContext("*b = a;");
7803   verifyIndependentOfContext("a * ~b;");
7804   verifyIndependentOfContext("a * !b;");
7805   verifyIndependentOfContext("a * +b;");
7806   verifyIndependentOfContext("a * -b;");
7807   verifyIndependentOfContext("a * ++b;");
7808   verifyIndependentOfContext("a * --b;");
7809   verifyIndependentOfContext("a[4] * b;");
7810   verifyIndependentOfContext("a[a * a] = 1;");
7811   verifyIndependentOfContext("f() * b;");
7812   verifyIndependentOfContext("a * [self dostuff];");
7813   verifyIndependentOfContext("int x = a * (a + b);");
7814   verifyIndependentOfContext("(a *)(a + b);");
7815   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
7816   verifyIndependentOfContext("int *pa = (int *)&a;");
7817   verifyIndependentOfContext("return sizeof(int **);");
7818   verifyIndependentOfContext("return sizeof(int ******);");
7819   verifyIndependentOfContext("return (int **&)a;");
7820   verifyIndependentOfContext("f((*PointerToArray)[10]);");
7821   verifyFormat("void f(Type (*parameter)[10]) {}");
7822   verifyFormat("void f(Type (&parameter)[10]) {}");
7823   verifyGoogleFormat("return sizeof(int**);");
7824   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
7825   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
7826   verifyFormat("auto a = [](int **&, int ***) {};");
7827   verifyFormat("auto PointerBinding = [](const char *S) {};");
7828   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
7829   verifyFormat("[](const decltype(*a) &value) {}");
7830   verifyFormat("decltype(a * b) F();");
7831   verifyFormat("#define MACRO() [](A *a) { return 1; }");
7832   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
7833   verifyIndependentOfContext("typedef void (*f)(int *a);");
7834   verifyIndependentOfContext("int i{a * b};");
7835   verifyIndependentOfContext("aaa && aaa->f();");
7836   verifyIndependentOfContext("int x = ~*p;");
7837   verifyFormat("Constructor() : a(a), area(width * height) {}");
7838   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
7839   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
7840   verifyFormat("void f() { f(a, c * d); }");
7841   verifyFormat("void f() { f(new a(), c * d); }");
7842   verifyFormat("void f(const MyOverride &override);");
7843   verifyFormat("void f(const MyFinal &final);");
7844   verifyIndependentOfContext("bool a = f() && override.f();");
7845   verifyIndependentOfContext("bool a = f() && final.f();");
7846 
7847   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
7848 
7849   verifyIndependentOfContext("A<int *> a;");
7850   verifyIndependentOfContext("A<int **> a;");
7851   verifyIndependentOfContext("A<int *, int *> a;");
7852   verifyIndependentOfContext("A<int *[]> a;");
7853   verifyIndependentOfContext(
7854       "const char *const p = reinterpret_cast<const char *const>(q);");
7855   verifyIndependentOfContext("A<int **, int **> a;");
7856   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
7857   verifyFormat("for (char **a = b; *a; ++a) {\n}");
7858   verifyFormat("for (; a && b;) {\n}");
7859   verifyFormat("bool foo = true && [] { return false; }();");
7860 
7861   verifyFormat(
7862       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7863       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7864 
7865   verifyGoogleFormat("int const* a = &b;");
7866   verifyGoogleFormat("**outparam = 1;");
7867   verifyGoogleFormat("*outparam = a * b;");
7868   verifyGoogleFormat("int main(int argc, char** argv) {}");
7869   verifyGoogleFormat("A<int*> a;");
7870   verifyGoogleFormat("A<int**> a;");
7871   verifyGoogleFormat("A<int*, int*> a;");
7872   verifyGoogleFormat("A<int**, int**> a;");
7873   verifyGoogleFormat("f(b ? *c : *d);");
7874   verifyGoogleFormat("int a = b ? *c : *d;");
7875   verifyGoogleFormat("Type* t = **x;");
7876   verifyGoogleFormat("Type* t = *++*x;");
7877   verifyGoogleFormat("*++*x;");
7878   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
7879   verifyGoogleFormat("Type* t = x++ * y;");
7880   verifyGoogleFormat(
7881       "const char* const p = reinterpret_cast<const char* const>(q);");
7882   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
7883   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
7884   verifyGoogleFormat("template <typename T>\n"
7885                      "void f(int i = 0, SomeType** temps = NULL);");
7886 
7887   FormatStyle Left = getLLVMStyle();
7888   Left.PointerAlignment = FormatStyle::PAS_Left;
7889   verifyFormat("x = *a(x) = *a(y);", Left);
7890   verifyFormat("for (;; *a = b) {\n}", Left);
7891   verifyFormat("return *this += 1;", Left);
7892   verifyFormat("throw *x;", Left);
7893   verifyFormat("delete *x;", Left);
7894   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
7895   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
7896   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
7897   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
7898   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
7899   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
7900 
7901   verifyIndependentOfContext("a = *(x + y);");
7902   verifyIndependentOfContext("a = &(x + y);");
7903   verifyIndependentOfContext("*(x + y).call();");
7904   verifyIndependentOfContext("&(x + y)->call();");
7905   verifyFormat("void f() { &(*I).first; }");
7906 
7907   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
7908   verifyFormat(
7909       "int *MyValues = {\n"
7910       "    *A, // Operator detection might be confused by the '{'\n"
7911       "    *BB // Operator detection might be confused by previous comment\n"
7912       "};");
7913 
7914   verifyIndependentOfContext("if (int *a = &b)");
7915   verifyIndependentOfContext("if (int &a = *b)");
7916   verifyIndependentOfContext("if (a & b[i])");
7917   verifyIndependentOfContext("if constexpr (a & b[i])");
7918   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
7919   verifyIndependentOfContext("if (a * (b * c))");
7920   verifyIndependentOfContext("if constexpr (a * (b * c))");
7921   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
7922   verifyIndependentOfContext("if (a::b::c::d & b[i])");
7923   verifyIndependentOfContext("if (*b[i])");
7924   verifyIndependentOfContext("if (int *a = (&b))");
7925   verifyIndependentOfContext("while (int *a = &b)");
7926   verifyIndependentOfContext("while (a * (b * c))");
7927   verifyIndependentOfContext("size = sizeof *a;");
7928   verifyIndependentOfContext("if (a && (b = c))");
7929   verifyFormat("void f() {\n"
7930                "  for (const int &v : Values) {\n"
7931                "  }\n"
7932                "}");
7933   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
7934   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
7935   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
7936 
7937   verifyFormat("#define A (!a * b)");
7938   verifyFormat("#define MACRO     \\\n"
7939                "  int *i = a * b; \\\n"
7940                "  void f(a *b);",
7941                getLLVMStyleWithColumns(19));
7942 
7943   verifyIndependentOfContext("A = new SomeType *[Length];");
7944   verifyIndependentOfContext("A = new SomeType *[Length]();");
7945   verifyIndependentOfContext("T **t = new T *;");
7946   verifyIndependentOfContext("T **t = new T *();");
7947   verifyGoogleFormat("A = new SomeType*[Length]();");
7948   verifyGoogleFormat("A = new SomeType*[Length];");
7949   verifyGoogleFormat("T** t = new T*;");
7950   verifyGoogleFormat("T** t = new T*();");
7951 
7952   verifyFormat("STATIC_ASSERT((a & b) == 0);");
7953   verifyFormat("STATIC_ASSERT(0 == (a & b));");
7954   verifyFormat("template <bool a, bool b> "
7955                "typename t::if<x && y>::type f() {}");
7956   verifyFormat("template <int *y> f() {}");
7957   verifyFormat("vector<int *> v;");
7958   verifyFormat("vector<int *const> v;");
7959   verifyFormat("vector<int *const **const *> v;");
7960   verifyFormat("vector<int *volatile> v;");
7961   verifyFormat("vector<a * b> v;");
7962   verifyFormat("foo<b && false>();");
7963   verifyFormat("foo<b & 1>();");
7964   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
7965   verifyFormat(
7966       "template <class T, class = typename std::enable_if<\n"
7967       "                       std::is_integral<T>::value &&\n"
7968       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
7969       "void F();",
7970       getLLVMStyleWithColumns(70));
7971   verifyFormat("template <class T,\n"
7972                "          class = typename std::enable_if<\n"
7973                "              std::is_integral<T>::value &&\n"
7974                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
7975                "          class U>\n"
7976                "void F();",
7977                getLLVMStyleWithColumns(70));
7978   verifyFormat(
7979       "template <class T,\n"
7980       "          class = typename ::std::enable_if<\n"
7981       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
7982       "void F();",
7983       getGoogleStyleWithColumns(68));
7984 
7985   verifyIndependentOfContext("MACRO(int *i);");
7986   verifyIndependentOfContext("MACRO(auto *a);");
7987   verifyIndependentOfContext("MACRO(const A *a);");
7988   verifyIndependentOfContext("MACRO(A *const a);");
7989   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
7990   verifyFormat("void f() { f(float{1}, a * a); }");
7991   // FIXME: Is there a way to make this work?
7992   // verifyIndependentOfContext("MACRO(A *a);");
7993 
7994   verifyFormat("DatumHandle const *operator->() const { return input_; }");
7995   verifyFormat("return options != nullptr && operator==(*options);");
7996 
7997   EXPECT_EQ("#define OP(x)                                    \\\n"
7998             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
7999             "    return s << a.DebugString();                 \\\n"
8000             "  }",
8001             format("#define OP(x) \\\n"
8002                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
8003                    "    return s << a.DebugString(); \\\n"
8004                    "  }",
8005                    getLLVMStyleWithColumns(50)));
8006 
8007   // FIXME: We cannot handle this case yet; we might be able to figure out that
8008   // foo<x> d > v; doesn't make sense.
8009   verifyFormat("foo<a<b && c> d> v;");
8010 
8011   FormatStyle PointerMiddle = getLLVMStyle();
8012   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8013   verifyFormat("delete *x;", PointerMiddle);
8014   verifyFormat("int * x;", PointerMiddle);
8015   verifyFormat("int *[] x;", PointerMiddle);
8016   verifyFormat("template <int * y> f() {}", PointerMiddle);
8017   verifyFormat("int * f(int * a) {}", PointerMiddle);
8018   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8019   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8020   verifyFormat("A<int *> a;", PointerMiddle);
8021   verifyFormat("A<int **> a;", PointerMiddle);
8022   verifyFormat("A<int *, int *> a;", PointerMiddle);
8023   verifyFormat("A<int *[]> a;", PointerMiddle);
8024   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8025   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8026   verifyFormat("T ** t = new T *;", PointerMiddle);
8027 
8028   // Member function reference qualifiers aren't binary operators.
8029   verifyFormat("string // break\n"
8030                "operator()() & {}");
8031   verifyFormat("string // break\n"
8032                "operator()() && {}");
8033   verifyGoogleFormat("template <typename T>\n"
8034                      "auto x() & -> int {}");
8035 }
8036 
8037 TEST_F(FormatTest, UnderstandsAttributes) {
8038   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8039   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8040                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8041   FormatStyle AfterType = getLLVMStyle();
8042   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
8043   verifyFormat("__attribute__((nodebug)) void\n"
8044                "foo() {}\n",
8045                AfterType);
8046 }
8047 
8048 TEST_F(FormatTest, UnderstandsSquareAttributes) {
8049   verifyFormat("SomeType s [[unused]] (InitValue);");
8050   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8051   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8052   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8053   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8054   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8055                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8056   verifyFormat("[[nodiscard]] bool f() { return false; }");
8057   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
8058   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
8059   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
8060 
8061   // Make sure we do not mistake attributes for array subscripts.
8062   verifyFormat("int a() {}\n"
8063                "[[unused]] int b() {}\n");
8064   verifyFormat("NSArray *arr;\n"
8065                "arr[[Foo() bar]];");
8066 
8067   // On the other hand, we still need to correctly find array subscripts.
8068   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8069 
8070   // Make sure that we do not mistake Objective-C method inside array literals
8071   // as attributes, even if those method names are also keywords.
8072   verifyFormat("@[ [foo bar] ];");
8073   verifyFormat("@[ [NSArray class] ];");
8074   verifyFormat("@[ [foo enum] ];");
8075 
8076   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8077 
8078   // Make sure we do not parse attributes as lambda introducers.
8079   FormatStyle MultiLineFunctions = getLLVMStyle();
8080   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8081   verifyFormat("[[unused]] int b() {\n"
8082                "  return 42;\n"
8083                "}\n",
8084                MultiLineFunctions);
8085 }
8086 
8087 TEST_F(FormatTest, AttributeClass) {
8088   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8089   verifyFormat("class S {\n"
8090                "  S(S&&) = default;\n"
8091                "};",
8092                Style);
8093   verifyFormat("class [[nodiscard]] S {\n"
8094                "  S(S&&) = default;\n"
8095                "};",
8096                Style);
8097   verifyFormat("class __attribute((maybeunused)) S {\n"
8098                "  S(S&&) = default;\n"
8099                "};",
8100                Style);
8101   verifyFormat("struct S {\n"
8102                "  S(S&&) = default;\n"
8103                "};",
8104                Style);
8105   verifyFormat("struct [[nodiscard]] S {\n"
8106                "  S(S&&) = default;\n"
8107                "};",
8108                Style);
8109 }
8110 
8111 TEST_F(FormatTest, AttributesAfterMacro) {
8112   FormatStyle Style = getLLVMStyle();
8113   verifyFormat("MACRO;\n"
8114                "__attribute__((maybe_unused)) int foo() {\n"
8115                "  //...\n"
8116                "}");
8117 
8118   verifyFormat("MACRO;\n"
8119                "[[nodiscard]] int foo() {\n"
8120                "  //...\n"
8121                "}");
8122 
8123   EXPECT_EQ("MACRO\n\n"
8124             "__attribute__((maybe_unused)) int foo() {\n"
8125             "  //...\n"
8126             "}",
8127             format("MACRO\n\n"
8128                    "__attribute__((maybe_unused)) int foo() {\n"
8129                    "  //...\n"
8130                    "}"));
8131 
8132   EXPECT_EQ("MACRO\n\n"
8133             "[[nodiscard]] int foo() {\n"
8134             "  //...\n"
8135             "}",
8136             format("MACRO\n\n"
8137                    "[[nodiscard]] int foo() {\n"
8138                    "  //...\n"
8139                    "}"));
8140 }
8141 
8142 TEST_F(FormatTest, AttributePenaltyBreaking) {
8143   FormatStyle Style = getLLVMStyle();
8144   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8145                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8146                Style);
8147   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8148                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8149                Style);
8150   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8151                "shared_ptr<ALongTypeName> &C d) {\n}",
8152                Style);
8153 }
8154 
8155 TEST_F(FormatTest, UnderstandsEllipsis) {
8156   verifyFormat("int printf(const char *fmt, ...);");
8157   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8158   verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
8159 
8160   FormatStyle PointersLeft = getLLVMStyle();
8161   PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
8162   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
8163 }
8164 
8165 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8166   EXPECT_EQ("int *a;\n"
8167             "int *a;\n"
8168             "int *a;",
8169             format("int *a;\n"
8170                    "int* a;\n"
8171                    "int *a;",
8172                    getGoogleStyle()));
8173   EXPECT_EQ("int* a;\n"
8174             "int* a;\n"
8175             "int* a;",
8176             format("int* a;\n"
8177                    "int* a;\n"
8178                    "int *a;",
8179                    getGoogleStyle()));
8180   EXPECT_EQ("int *a;\n"
8181             "int *a;\n"
8182             "int *a;",
8183             format("int *a;\n"
8184                    "int * a;\n"
8185                    "int *  a;",
8186                    getGoogleStyle()));
8187   EXPECT_EQ("auto x = [] {\n"
8188             "  int *a;\n"
8189             "  int *a;\n"
8190             "  int *a;\n"
8191             "};",
8192             format("auto x=[]{int *a;\n"
8193                    "int * a;\n"
8194                    "int *  a;};",
8195                    getGoogleStyle()));
8196 }
8197 
8198 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8199   verifyFormat("int f(int &&a) {}");
8200   verifyFormat("int f(int a, char &&b) {}");
8201   verifyFormat("void f() { int &&a = b; }");
8202   verifyGoogleFormat("int f(int a, char&& b) {}");
8203   verifyGoogleFormat("void f() { int&& a = b; }");
8204 
8205   verifyIndependentOfContext("A<int &&> a;");
8206   verifyIndependentOfContext("A<int &&, int &&> a;");
8207   verifyGoogleFormat("A<int&&> a;");
8208   verifyGoogleFormat("A<int&&, int&&> a;");
8209 
8210   // Not rvalue references:
8211   verifyFormat("template <bool B, bool C> class A {\n"
8212                "  static_assert(B && C, \"Something is wrong\");\n"
8213                "};");
8214   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8215   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8216   verifyFormat("#define A(a, b) (a && b)");
8217 }
8218 
8219 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8220   verifyFormat("void f() {\n"
8221                "  x[aaaaaaaaa -\n"
8222                "    b] = 23;\n"
8223                "}",
8224                getLLVMStyleWithColumns(15));
8225 }
8226 
8227 TEST_F(FormatTest, FormatsCasts) {
8228   verifyFormat("Type *A = static_cast<Type *>(P);");
8229   verifyFormat("Type *A = (Type *)P;");
8230   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8231   verifyFormat("int a = (int)(2.0f);");
8232   verifyFormat("int a = (int)2.0f;");
8233   verifyFormat("x[(int32)y];");
8234   verifyFormat("x = (int32)y;");
8235   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8236   verifyFormat("int a = (int)*b;");
8237   verifyFormat("int a = (int)2.0f;");
8238   verifyFormat("int a = (int)~0;");
8239   verifyFormat("int a = (int)++a;");
8240   verifyFormat("int a = (int)sizeof(int);");
8241   verifyFormat("int a = (int)+2;");
8242   verifyFormat("my_int a = (my_int)2.0f;");
8243   verifyFormat("my_int a = (my_int)sizeof(int);");
8244   verifyFormat("return (my_int)aaa;");
8245   verifyFormat("#define x ((int)-1)");
8246   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8247   verifyFormat("#define p(q) ((int *)&q)");
8248   verifyFormat("fn(a)(b) + 1;");
8249 
8250   verifyFormat("void f() { my_int a = (my_int)*b; }");
8251   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8252   verifyFormat("my_int a = (my_int)~0;");
8253   verifyFormat("my_int a = (my_int)++a;");
8254   verifyFormat("my_int a = (my_int)-2;");
8255   verifyFormat("my_int a = (my_int)1;");
8256   verifyFormat("my_int a = (my_int *)1;");
8257   verifyFormat("my_int a = (const my_int)-1;");
8258   verifyFormat("my_int a = (const my_int *)-1;");
8259   verifyFormat("my_int a = (my_int)(my_int)-1;");
8260   verifyFormat("my_int a = (ns::my_int)-2;");
8261   verifyFormat("case (my_int)ONE:");
8262   verifyFormat("auto x = (X)this;");
8263   // Casts in Obj-C style calls used to not be recognized as such.
8264   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8265 
8266   // FIXME: single value wrapped with paren will be treated as cast.
8267   verifyFormat("void f(int i = (kValue)*kMask) {}");
8268 
8269   verifyFormat("{ (void)F; }");
8270 
8271   // Don't break after a cast's
8272   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8273                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8274                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8275 
8276   // These are not casts.
8277   verifyFormat("void f(int *) {}");
8278   verifyFormat("f(foo)->b;");
8279   verifyFormat("f(foo).b;");
8280   verifyFormat("f(foo)(b);");
8281   verifyFormat("f(foo)[b];");
8282   verifyFormat("[](foo) { return 4; }(bar);");
8283   verifyFormat("(*funptr)(foo)[4];");
8284   verifyFormat("funptrs[4](foo)[4];");
8285   verifyFormat("void f(int *);");
8286   verifyFormat("void f(int *) = 0;");
8287   verifyFormat("void f(SmallVector<int>) {}");
8288   verifyFormat("void f(SmallVector<int>);");
8289   verifyFormat("void f(SmallVector<int>) = 0;");
8290   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8291   verifyFormat("int a = sizeof(int) * b;");
8292   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8293   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8294   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8295   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8296 
8297   // These are not casts, but at some point were confused with casts.
8298   verifyFormat("virtual void foo(int *) override;");
8299   verifyFormat("virtual void foo(char &) const;");
8300   verifyFormat("virtual void foo(int *a, char *) const;");
8301   verifyFormat("int a = sizeof(int *) + b;");
8302   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8303   verifyFormat("bool b = f(g<int>) && c;");
8304   verifyFormat("typedef void (*f)(int i) func;");
8305   verifyFormat("void operator++(int) noexcept;");
8306   verifyFormat("void operator++(int &) noexcept;");
8307   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8308                "&) noexcept;");
8309   verifyFormat(
8310       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8311   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8312   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8313   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8314   verifyFormat("void operator delete(foo &) noexcept;");
8315   verifyFormat("void operator delete(foo) noexcept;");
8316   verifyFormat("void operator delete(int) noexcept;");
8317   verifyFormat("void operator delete(int &) noexcept;");
8318   verifyFormat("void operator delete(int &) volatile noexcept;");
8319   verifyFormat("void operator delete(int &) const");
8320   verifyFormat("void operator delete(int &) = default");
8321   verifyFormat("void operator delete(int &) = delete");
8322   verifyFormat("void operator delete(int &) [[noreturn]]");
8323   verifyFormat("void operator delete(int &) throw();");
8324   verifyFormat("void operator delete(int &) throw(int);");
8325   verifyFormat("auto operator delete(int &) -> int;");
8326   verifyFormat("auto operator delete(int &) override");
8327   verifyFormat("auto operator delete(int &) final");
8328 
8329   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8330                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8331   // FIXME: The indentation here is not ideal.
8332   verifyFormat(
8333       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8334       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8335       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8336 }
8337 
8338 TEST_F(FormatTest, FormatsFunctionTypes) {
8339   verifyFormat("A<bool()> a;");
8340   verifyFormat("A<SomeType()> a;");
8341   verifyFormat("A<void (*)(int, std::string)> a;");
8342   verifyFormat("A<void *(int)>;");
8343   verifyFormat("void *(*a)(int *, SomeType *);");
8344   verifyFormat("int (*func)(void *);");
8345   verifyFormat("void f() { int (*func)(void *); }");
8346   verifyFormat("template <class CallbackClass>\n"
8347                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8348 
8349   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8350   verifyGoogleFormat("void* (*a)(int);");
8351   verifyGoogleFormat(
8352       "template <class CallbackClass>\n"
8353       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8354 
8355   // Other constructs can look somewhat like function types:
8356   verifyFormat("A<sizeof(*x)> a;");
8357   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8358   verifyFormat("some_var = function(*some_pointer_var)[0];");
8359   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8360   verifyFormat("int x = f(&h)();");
8361   verifyFormat("returnsFunction(&param1, &param2)(param);");
8362   verifyFormat("std::function<\n"
8363                "    LooooooooooongTemplatedType<\n"
8364                "        SomeType>*(\n"
8365                "        LooooooooooooooooongType type)>\n"
8366                "    function;",
8367                getGoogleStyleWithColumns(40));
8368 }
8369 
8370 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8371   verifyFormat("A (*foo_)[6];");
8372   verifyFormat("vector<int> (*foo_)[6];");
8373 }
8374 
8375 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8376   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8377                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8378   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8379                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8380   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8381                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8382 
8383   // Different ways of ()-initializiation.
8384   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8385                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8386   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8387                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8388   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8389                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8390   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8391                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8392 
8393   // Lambdas should not confuse the variable declaration heuristic.
8394   verifyFormat("LooooooooooooooooongType\n"
8395                "    variable(nullptr, [](A *a) {});",
8396                getLLVMStyleWithColumns(40));
8397 }
8398 
8399 TEST_F(FormatTest, BreaksLongDeclarations) {
8400   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8401                "    AnotherNameForTheLongType;");
8402   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8403                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8404   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8405                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8406   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8407                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8408   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8409                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8410   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8411                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8412   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8413                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8414   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8415                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8416   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8417                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8418   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8419                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8420   FormatStyle Indented = getLLVMStyle();
8421   Indented.IndentWrappedFunctionNames = true;
8422   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8423                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8424                Indented);
8425   verifyFormat(
8426       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8427       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8428       Indented);
8429   verifyFormat(
8430       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8431       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8432       Indented);
8433   verifyFormat(
8434       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8435       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8436       Indented);
8437 
8438   // FIXME: Without the comment, this breaks after "(".
8439   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8440                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8441                getGoogleStyle());
8442 
8443   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8444                "                  int LoooooooooooooooooooongParam2) {}");
8445   verifyFormat(
8446       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8447       "                                   SourceLocation L, IdentifierIn *II,\n"
8448       "                                   Type *T) {}");
8449   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8450                "ReallyReaaallyLongFunctionName(\n"
8451                "    const std::string &SomeParameter,\n"
8452                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8453                "        &ReallyReallyLongParameterName,\n"
8454                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8455                "        &AnotherLongParameterName) {}");
8456   verifyFormat("template <typename A>\n"
8457                "SomeLoooooooooooooooooooooongType<\n"
8458                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8459                "Function() {}");
8460 
8461   verifyGoogleFormat(
8462       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8463       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8464   verifyGoogleFormat(
8465       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8466       "                                   SourceLocation L) {}");
8467   verifyGoogleFormat(
8468       "some_namespace::LongReturnType\n"
8469       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8470       "    int first_long_parameter, int second_parameter) {}");
8471 
8472   verifyGoogleFormat("template <typename T>\n"
8473                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8474                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8475   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8476                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8477 
8478   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8479                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8480                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8481   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8482                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8483                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8484   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8485                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8486                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8487                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8488 
8489   verifyFormat("template <typename T> // Templates on own line.\n"
8490                "static int            // Some comment.\n"
8491                "MyFunction(int a);",
8492                getLLVMStyle());
8493 }
8494 
8495 TEST_F(FormatTest, FormatsArrays) {
8496   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8497                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8498   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8499                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8500   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8501                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8502   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8503                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8504   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8505                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8506   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8507                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8508                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8509   verifyFormat(
8510       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8511       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8512       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8513   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8514                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8515 
8516   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8517                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8518   verifyFormat(
8519       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8520       "                                  .aaaaaaa[0]\n"
8521       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8522   verifyFormat("a[::b::c];");
8523 
8524   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8525 
8526   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8527   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8528 }
8529 
8530 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8531   verifyFormat("(a)->b();");
8532   verifyFormat("--a;");
8533 }
8534 
8535 TEST_F(FormatTest, HandlesIncludeDirectives) {
8536   verifyFormat("#include <string>\n"
8537                "#include <a/b/c.h>\n"
8538                "#include \"a/b/string\"\n"
8539                "#include \"string.h\"\n"
8540                "#include \"string.h\"\n"
8541                "#include <a-a>\n"
8542                "#include < path with space >\n"
8543                "#include_next <test.h>"
8544                "#include \"abc.h\" // this is included for ABC\n"
8545                "#include \"some long include\" // with a comment\n"
8546                "#include \"some very long include path\"\n"
8547                "#include <some/very/long/include/path>\n",
8548                getLLVMStyleWithColumns(35));
8549   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8550   EXPECT_EQ("#include <a>", format("#include<a>"));
8551 
8552   verifyFormat("#import <string>");
8553   verifyFormat("#import <a/b/c.h>");
8554   verifyFormat("#import \"a/b/string\"");
8555   verifyFormat("#import \"string.h\"");
8556   verifyFormat("#import \"string.h\"");
8557   verifyFormat("#if __has_include(<strstream>)\n"
8558                "#include <strstream>\n"
8559                "#endif");
8560 
8561   verifyFormat("#define MY_IMPORT <a/b>");
8562 
8563   verifyFormat("#if __has_include(<a/b>)");
8564   verifyFormat("#if __has_include_next(<a/b>)");
8565   verifyFormat("#define F __has_include(<a/b>)");
8566   verifyFormat("#define F __has_include_next(<a/b>)");
8567 
8568   // Protocol buffer definition or missing "#".
8569   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8570                getLLVMStyleWithColumns(30));
8571 
8572   FormatStyle Style = getLLVMStyle();
8573   Style.AlwaysBreakBeforeMultilineStrings = true;
8574   Style.ColumnLimit = 0;
8575   verifyFormat("#import \"abc.h\"", Style);
8576 
8577   // But 'import' might also be a regular C++ namespace.
8578   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8579                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8580 }
8581 
8582 //===----------------------------------------------------------------------===//
8583 // Error recovery tests.
8584 //===----------------------------------------------------------------------===//
8585 
8586 TEST_F(FormatTest, IncompleteParameterLists) {
8587   FormatStyle NoBinPacking = getLLVMStyle();
8588   NoBinPacking.BinPackParameters = false;
8589   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8590                "                        double *min_x,\n"
8591                "                        double *max_x,\n"
8592                "                        double *min_y,\n"
8593                "                        double *max_y,\n"
8594                "                        double *min_z,\n"
8595                "                        double *max_z, ) {}",
8596                NoBinPacking);
8597 }
8598 
8599 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8600   verifyFormat("void f() { return; }\n42");
8601   verifyFormat("void f() {\n"
8602                "  if (0)\n"
8603                "    return;\n"
8604                "}\n"
8605                "42");
8606   verifyFormat("void f() { return }\n42");
8607   verifyFormat("void f() {\n"
8608                "  if (0)\n"
8609                "    return\n"
8610                "}\n"
8611                "42");
8612 }
8613 
8614 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
8615   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
8616   EXPECT_EQ("void f() {\n"
8617             "  if (a)\n"
8618             "    return\n"
8619             "}",
8620             format("void  f  (  )  {  if  ( a )  return  }"));
8621   EXPECT_EQ("namespace N {\n"
8622             "void f()\n"
8623             "}",
8624             format("namespace  N  {  void f()  }"));
8625   EXPECT_EQ("namespace N {\n"
8626             "void f() {}\n"
8627             "void g()\n"
8628             "} // namespace N",
8629             format("namespace N  { void f( ) { } void g( ) }"));
8630 }
8631 
8632 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
8633   verifyFormat("int aaaaaaaa =\n"
8634                "    // Overlylongcomment\n"
8635                "    b;",
8636                getLLVMStyleWithColumns(20));
8637   verifyFormat("function(\n"
8638                "    ShortArgument,\n"
8639                "    LoooooooooooongArgument);\n",
8640                getLLVMStyleWithColumns(20));
8641 }
8642 
8643 TEST_F(FormatTest, IncorrectAccessSpecifier) {
8644   verifyFormat("public:");
8645   verifyFormat("class A {\n"
8646                "public\n"
8647                "  void f() {}\n"
8648                "};");
8649   verifyFormat("public\n"
8650                "int qwerty;");
8651   verifyFormat("public\n"
8652                "B {}");
8653   verifyFormat("public\n"
8654                "{}");
8655   verifyFormat("public\n"
8656                "B { int x; }");
8657 }
8658 
8659 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
8660   verifyFormat("{");
8661   verifyFormat("#})");
8662   verifyNoCrash("(/**/[:!] ?[).");
8663 }
8664 
8665 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
8666   // Found by oss-fuzz:
8667   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
8668   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
8669   Style.ColumnLimit = 60;
8670   verifyNoCrash(
8671       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
8672       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
8673       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
8674       Style);
8675 }
8676 
8677 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
8678   verifyFormat("do {\n}");
8679   verifyFormat("do {\n}\n"
8680                "f();");
8681   verifyFormat("do {\n}\n"
8682                "wheeee(fun);");
8683   verifyFormat("do {\n"
8684                "  f();\n"
8685                "}");
8686 }
8687 
8688 TEST_F(FormatTest, IncorrectCodeMissingParens) {
8689   verifyFormat("if {\n  foo;\n  foo();\n}");
8690   verifyFormat("switch {\n  foo;\n  foo();\n}");
8691   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
8692   verifyFormat("while {\n  foo;\n  foo();\n}");
8693   verifyFormat("do {\n  foo;\n  foo();\n} while;");
8694 }
8695 
8696 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
8697   verifyIncompleteFormat("namespace {\n"
8698                          "class Foo { Foo (\n"
8699                          "};\n"
8700                          "} // namespace");
8701 }
8702 
8703 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
8704   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
8705   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
8706   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
8707   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
8708 
8709   EXPECT_EQ("{\n"
8710             "  {\n"
8711             "    breakme(\n"
8712             "        qwe);\n"
8713             "  }\n",
8714             format("{\n"
8715                    "    {\n"
8716                    " breakme(qwe);\n"
8717                    "}\n",
8718                    getLLVMStyleWithColumns(10)));
8719 }
8720 
8721 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
8722   verifyFormat("int x = {\n"
8723                "    avariable,\n"
8724                "    b(alongervariable)};",
8725                getLLVMStyleWithColumns(25));
8726 }
8727 
8728 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
8729   verifyFormat("return (a)(b){1, 2, 3};");
8730 }
8731 
8732 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
8733   verifyFormat("vector<int> x{1, 2, 3, 4};");
8734   verifyFormat("vector<int> x{\n"
8735                "    1,\n"
8736                "    2,\n"
8737                "    3,\n"
8738                "    4,\n"
8739                "};");
8740   verifyFormat("vector<T> x{{}, {}, {}, {}};");
8741   verifyFormat("f({1, 2});");
8742   verifyFormat("auto v = Foo{-1};");
8743   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
8744   verifyFormat("Class::Class : member{1, 2, 3} {}");
8745   verifyFormat("new vector<int>{1, 2, 3};");
8746   verifyFormat("new int[3]{1, 2, 3};");
8747   verifyFormat("new int{1};");
8748   verifyFormat("return {arg1, arg2};");
8749   verifyFormat("return {arg1, SomeType{parameter}};");
8750   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
8751   verifyFormat("new T{arg1, arg2};");
8752   verifyFormat("f(MyMap[{composite, key}]);");
8753   verifyFormat("class Class {\n"
8754                "  T member = {arg1, arg2};\n"
8755                "};");
8756   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
8757   verifyFormat("const struct A a = {.a = 1, .b = 2};");
8758   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
8759   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
8760   verifyFormat("int a = std::is_integral<int>{} + 0;");
8761 
8762   verifyFormat("int foo(int i) { return fo1{}(i); }");
8763   verifyFormat("int foo(int i) { return fo1{}(i); }");
8764   verifyFormat("auto i = decltype(x){};");
8765   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
8766   verifyFormat("Node n{1, Node{1000}, //\n"
8767                "       2};");
8768   verifyFormat("Aaaa aaaaaaa{\n"
8769                "    {\n"
8770                "        aaaa,\n"
8771                "    },\n"
8772                "};");
8773   verifyFormat("class C : public D {\n"
8774                "  SomeClass SC{2};\n"
8775                "};");
8776   verifyFormat("class C : public A {\n"
8777                "  class D : public B {\n"
8778                "    void f() { int i{2}; }\n"
8779                "  };\n"
8780                "};");
8781   verifyFormat("#define A {a, a},");
8782 
8783   // Avoid breaking between equal sign and opening brace
8784   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
8785   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
8786   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
8787                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
8788                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
8789                "     {\"ccccccccccccccccccccc\", 2}};",
8790                AvoidBreakingFirstArgument);
8791 
8792   // Binpacking only if there is no trailing comma
8793   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
8794                "                      cccccccccc, dddddddddd};",
8795                getLLVMStyleWithColumns(50));
8796   verifyFormat("const Aaaaaa aaaaa = {\n"
8797                "    aaaaaaaaaaa,\n"
8798                "    bbbbbbbbbbb,\n"
8799                "    ccccccccccc,\n"
8800                "    ddddddddddd,\n"
8801                "};",
8802                getLLVMStyleWithColumns(50));
8803 
8804   // Cases where distinguising braced lists and blocks is hard.
8805   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
8806   verifyFormat("void f() {\n"
8807                "  return; // comment\n"
8808                "}\n"
8809                "SomeType t;");
8810   verifyFormat("void f() {\n"
8811                "  if (a) {\n"
8812                "    f();\n"
8813                "  }\n"
8814                "}\n"
8815                "SomeType t;");
8816 
8817   // In combination with BinPackArguments = false.
8818   FormatStyle NoBinPacking = getLLVMStyle();
8819   NoBinPacking.BinPackArguments = false;
8820   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
8821                "                      bbbbb,\n"
8822                "                      ccccc,\n"
8823                "                      ddddd,\n"
8824                "                      eeeee,\n"
8825                "                      ffffff,\n"
8826                "                      ggggg,\n"
8827                "                      hhhhhh,\n"
8828                "                      iiiiii,\n"
8829                "                      jjjjjj,\n"
8830                "                      kkkkkk};",
8831                NoBinPacking);
8832   verifyFormat("const Aaaaaa aaaaa = {\n"
8833                "    aaaaa,\n"
8834                "    bbbbb,\n"
8835                "    ccccc,\n"
8836                "    ddddd,\n"
8837                "    eeeee,\n"
8838                "    ffffff,\n"
8839                "    ggggg,\n"
8840                "    hhhhhh,\n"
8841                "    iiiiii,\n"
8842                "    jjjjjj,\n"
8843                "    kkkkkk,\n"
8844                "};",
8845                NoBinPacking);
8846   verifyFormat(
8847       "const Aaaaaa aaaaa = {\n"
8848       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
8849       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
8850       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
8851       "};",
8852       NoBinPacking);
8853 
8854   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
8855   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
8856             "    CDDDP83848_BMCR_REGISTER,\n"
8857             "    CDDDP83848_BMSR_REGISTER,\n"
8858             "    CDDDP83848_RBR_REGISTER};",
8859             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
8860                    "                                CDDDP83848_BMSR_REGISTER,\n"
8861                    "                                CDDDP83848_RBR_REGISTER};",
8862                    NoBinPacking));
8863 
8864   // FIXME: The alignment of these trailing comments might be bad. Then again,
8865   // this might be utterly useless in real code.
8866   verifyFormat("Constructor::Constructor()\n"
8867                "    : some_value{         //\n"
8868                "                 aaaaaaa, //\n"
8869                "                 bbbbbbb} {}");
8870 
8871   // In braced lists, the first comment is always assumed to belong to the
8872   // first element. Thus, it can be moved to the next or previous line as
8873   // appropriate.
8874   EXPECT_EQ("function({// First element:\n"
8875             "          1,\n"
8876             "          // Second element:\n"
8877             "          2});",
8878             format("function({\n"
8879                    "    // First element:\n"
8880                    "    1,\n"
8881                    "    // Second element:\n"
8882                    "    2});"));
8883   EXPECT_EQ("std::vector<int> MyNumbers{\n"
8884             "    // First element:\n"
8885             "    1,\n"
8886             "    // Second element:\n"
8887             "    2};",
8888             format("std::vector<int> MyNumbers{// First element:\n"
8889                    "                           1,\n"
8890                    "                           // Second element:\n"
8891                    "                           2};",
8892                    getLLVMStyleWithColumns(30)));
8893   // A trailing comma should still lead to an enforced line break and no
8894   // binpacking.
8895   EXPECT_EQ("vector<int> SomeVector = {\n"
8896             "    // aaa\n"
8897             "    1,\n"
8898             "    2,\n"
8899             "};",
8900             format("vector<int> SomeVector = { // aaa\n"
8901                    "    1, 2, };"));
8902 
8903   // C++11 brace initializer list l-braces should not be treated any differently
8904   // when breaking before lambda bodies is enabled
8905   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
8906   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
8907   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
8908   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
8909   verifyFormat(
8910       "std::runtime_error{\n"
8911       "    \"Long string which will force a break onto the next line...\"};",
8912       BreakBeforeLambdaBody);
8913 
8914   FormatStyle ExtraSpaces = getLLVMStyle();
8915   ExtraSpaces.Cpp11BracedListStyle = false;
8916   ExtraSpaces.ColumnLimit = 75;
8917   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
8918   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
8919   verifyFormat("f({ 1, 2 });", ExtraSpaces);
8920   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
8921   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
8922   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
8923   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
8924   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
8925   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
8926   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
8927   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
8928   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
8929   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
8930   verifyFormat("class Class {\n"
8931                "  T member = { arg1, arg2 };\n"
8932                "};",
8933                ExtraSpaces);
8934   verifyFormat(
8935       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8936       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
8937       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
8938       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
8939       ExtraSpaces);
8940   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
8941   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
8942                ExtraSpaces);
8943   verifyFormat(
8944       "someFunction(OtherParam,\n"
8945       "             BracedList{ // comment 1 (Forcing interesting break)\n"
8946       "                         param1, param2,\n"
8947       "                         // comment 2\n"
8948       "                         param3, param4 });",
8949       ExtraSpaces);
8950   verifyFormat(
8951       "std::this_thread::sleep_for(\n"
8952       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
8953       ExtraSpaces);
8954   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
8955                "    aaaaaaa,\n"
8956                "    aaaaaaaaaa,\n"
8957                "    aaaaa,\n"
8958                "    aaaaaaaaaaaaaaa,\n"
8959                "    aaa,\n"
8960                "    aaaaaaaaaa,\n"
8961                "    a,\n"
8962                "    aaaaaaaaaaaaaaaaaaaaa,\n"
8963                "    aaaaaaaaaaaa,\n"
8964                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
8965                "    aaaaaaa,\n"
8966                "    a};");
8967   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
8968   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
8969   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
8970 
8971   // Avoid breaking between initializer/equal sign and opening brace
8972   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
8973   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
8974                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
8975                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
8976                "  { \"ccccccccccccccccccccc\", 2 }\n"
8977                "};",
8978                ExtraSpaces);
8979   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
8980                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
8981                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
8982                "  { \"ccccccccccccccccccccc\", 2 }\n"
8983                "};",
8984                ExtraSpaces);
8985 
8986   FormatStyle SpaceBeforeBrace = getLLVMStyle();
8987   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
8988   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
8989   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
8990 
8991   FormatStyle SpaceBetweenBraces = getLLVMStyle();
8992   SpaceBetweenBraces.SpacesInAngles = true;
8993   SpaceBetweenBraces.SpacesInParentheses = true;
8994   SpaceBetweenBraces.SpacesInSquareBrackets = true;
8995   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
8996   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
8997   verifyFormat("vector< int > x{ // comment 1\n"
8998                "                 1, 2, 3, 4 };",
8999                SpaceBetweenBraces);
9000   SpaceBetweenBraces.ColumnLimit = 20;
9001   EXPECT_EQ("vector< int > x{\n"
9002             "    1, 2, 3, 4 };",
9003             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9004   SpaceBetweenBraces.ColumnLimit = 24;
9005   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9006             "                 3, 4 };",
9007             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9008   EXPECT_EQ("vector< int > x{\n"
9009             "    1,\n"
9010             "    2,\n"
9011             "    3,\n"
9012             "    4,\n"
9013             "};",
9014             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9015   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9016   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9017   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9018 }
9019 
9020 TEST_F(FormatTest, FormatSpacesInAngles) {
9021   FormatStyle SpaceInAngles = getLLVMStyle();
9022   SpaceInAngles.SpacesInAngles = true;
9023   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9024   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9025   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9026 
9027   SpaceInAngles.SpacesInAngles = false;
9028   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9029   verifyFormat("vector<int> x5;", SpaceInAngles);
9030   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9031   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9032 }
9033 
9034 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9035   verifyFormat("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, 7777777,\n"
9038                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9039                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9040                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9041   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9042                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9043                "                 1, 22, 333, 4444, 55555, //\n"
9044                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9045                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9046   verifyFormat(
9047       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9048       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9049       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9050       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9051       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9052       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9053       "                 7777777};");
9054   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9055                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9056                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9057   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9058                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9059                "    // Separating comment.\n"
9060                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9061   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9062                "    // Leading comment\n"
9063                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9064                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9065   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9066                "                 1, 1, 1, 1};",
9067                getLLVMStyleWithColumns(39));
9068   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9069                "                 1, 1, 1, 1};",
9070                getLLVMStyleWithColumns(38));
9071   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9072                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9073                getLLVMStyleWithColumns(43));
9074   verifyFormat(
9075       "static unsigned SomeValues[10][3] = {\n"
9076       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9077       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9078   verifyFormat("static auto fields = new vector<string>{\n"
9079                "    \"aaaaaaaaaaaaa\",\n"
9080                "    \"aaaaaaaaaaaaa\",\n"
9081                "    \"aaaaaaaaaaaa\",\n"
9082                "    \"aaaaaaaaaaaaaa\",\n"
9083                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9084                "    \"aaaaaaaaaaaa\",\n"
9085                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9086                "};");
9087   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9088   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9089                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9090                "                 3, cccccccccccccccccccccc};",
9091                getLLVMStyleWithColumns(60));
9092 
9093   // Trailing commas.
9094   verifyFormat("vector<int> x = {\n"
9095                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9096                "};",
9097                getLLVMStyleWithColumns(39));
9098   verifyFormat("vector<int> x = {\n"
9099                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9100                "};",
9101                getLLVMStyleWithColumns(39));
9102   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9103                "                 1, 1, 1, 1,\n"
9104                "                 /**/ /**/};",
9105                getLLVMStyleWithColumns(39));
9106 
9107   // Trailing comment in the first line.
9108   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9109                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9110                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9111                "    11111111,   22222222,   333333333,   44444444};");
9112   // Trailing comment in the last line.
9113   verifyFormat("int aaaaa[] = {\n"
9114                "    1, 2, 3, // comment\n"
9115                "    4, 5, 6  // comment\n"
9116                "};");
9117 
9118   // With nested lists, we should either format one item per line or all nested
9119   // lists one on line.
9120   // FIXME: For some nested lists, we can do better.
9121   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9122                "        {aaaaaaaaaaaaaaaaaaa},\n"
9123                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9124                "        {aaaaaaaaaaaaaaaaa}};",
9125                getLLVMStyleWithColumns(60));
9126   verifyFormat(
9127       "SomeStruct my_struct_array = {\n"
9128       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9129       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9130       "    {aaa, aaa},\n"
9131       "    {aaa, aaa},\n"
9132       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9133       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9134       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9135 
9136   // No column layout should be used here.
9137   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9138                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9139 
9140   verifyNoCrash("a<,");
9141 
9142   // No braced initializer here.
9143   verifyFormat("void f() {\n"
9144                "  struct Dummy {};\n"
9145                "  f(v);\n"
9146                "}");
9147 
9148   // Long lists should be formatted in columns even if they are nested.
9149   verifyFormat(
9150       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9151       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9152       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9153       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9154       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9155       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9156 
9157   // Allow "single-column" layout even if that violates the column limit. There
9158   // isn't going to be a better way.
9159   verifyFormat("std::vector<int> a = {\n"
9160                "    aaaaaaaa,\n"
9161                "    aaaaaaaa,\n"
9162                "    aaaaaaaa,\n"
9163                "    aaaaaaaa,\n"
9164                "    aaaaaaaaaa,\n"
9165                "    aaaaaaaa,\n"
9166                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9167                getLLVMStyleWithColumns(30));
9168   verifyFormat("vector<int> aaaa = {\n"
9169                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9170                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9171                "    aaaaaa.aaaaaaa,\n"
9172                "    aaaaaa.aaaaaaa,\n"
9173                "    aaaaaa.aaaaaaa,\n"
9174                "    aaaaaa.aaaaaaa,\n"
9175                "};");
9176 
9177   // Don't create hanging lists.
9178   verifyFormat("someFunction(Param, {List1, List2,\n"
9179                "                     List3});",
9180                getLLVMStyleWithColumns(35));
9181   verifyFormat("someFunction(Param, Param,\n"
9182                "             {List1, List2,\n"
9183                "              List3});",
9184                getLLVMStyleWithColumns(35));
9185   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9186                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9187 }
9188 
9189 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9190   FormatStyle DoNotMerge = getLLVMStyle();
9191   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9192 
9193   verifyFormat("void f() { return 42; }");
9194   verifyFormat("void f() {\n"
9195                "  return 42;\n"
9196                "}",
9197                DoNotMerge);
9198   verifyFormat("void f() {\n"
9199                "  // Comment\n"
9200                "}");
9201   verifyFormat("{\n"
9202                "#error {\n"
9203                "  int a;\n"
9204                "}");
9205   verifyFormat("{\n"
9206                "  int a;\n"
9207                "#error {\n"
9208                "}");
9209   verifyFormat("void f() {} // comment");
9210   verifyFormat("void f() { int a; } // comment");
9211   verifyFormat("void f() {\n"
9212                "} // comment",
9213                DoNotMerge);
9214   verifyFormat("void f() {\n"
9215                "  int a;\n"
9216                "} // comment",
9217                DoNotMerge);
9218   verifyFormat("void f() {\n"
9219                "} // comment",
9220                getLLVMStyleWithColumns(15));
9221 
9222   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9223   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9224 
9225   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9226   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9227   verifyFormat("class C {\n"
9228                "  C()\n"
9229                "      : iiiiiiii(nullptr),\n"
9230                "        kkkkkkk(nullptr),\n"
9231                "        mmmmmmm(nullptr),\n"
9232                "        nnnnnnn(nullptr) {}\n"
9233                "};",
9234                getGoogleStyle());
9235 
9236   FormatStyle NoColumnLimit = getLLVMStyle();
9237   NoColumnLimit.ColumnLimit = 0;
9238   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9239   EXPECT_EQ("class C {\n"
9240             "  A() : b(0) {}\n"
9241             "};",
9242             format("class C{A():b(0){}};", NoColumnLimit));
9243   EXPECT_EQ("A()\n"
9244             "    : b(0) {\n"
9245             "}",
9246             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9247 
9248   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9249   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9250       FormatStyle::SFS_None;
9251   EXPECT_EQ("A()\n"
9252             "    : b(0) {\n"
9253             "}",
9254             format("A():b(0){}", DoNotMergeNoColumnLimit));
9255   EXPECT_EQ("A()\n"
9256             "    : b(0) {\n"
9257             "}",
9258             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9259 
9260   verifyFormat("#define A          \\\n"
9261                "  void f() {       \\\n"
9262                "    int i;         \\\n"
9263                "  }",
9264                getLLVMStyleWithColumns(20));
9265   verifyFormat("#define A           \\\n"
9266                "  void f() { int i; }",
9267                getLLVMStyleWithColumns(21));
9268   verifyFormat("#define A            \\\n"
9269                "  void f() {         \\\n"
9270                "    int i;           \\\n"
9271                "  }                  \\\n"
9272                "  int j;",
9273                getLLVMStyleWithColumns(22));
9274   verifyFormat("#define A             \\\n"
9275                "  void f() { int i; } \\\n"
9276                "  int j;",
9277                getLLVMStyleWithColumns(23));
9278 }
9279 
9280 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9281   FormatStyle MergeEmptyOnly = getLLVMStyle();
9282   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9283   verifyFormat("class C {\n"
9284                "  int f() {}\n"
9285                "};",
9286                MergeEmptyOnly);
9287   verifyFormat("class C {\n"
9288                "  int f() {\n"
9289                "    return 42;\n"
9290                "  }\n"
9291                "};",
9292                MergeEmptyOnly);
9293   verifyFormat("int f() {}", MergeEmptyOnly);
9294   verifyFormat("int f() {\n"
9295                "  return 42;\n"
9296                "}",
9297                MergeEmptyOnly);
9298 
9299   // Also verify behavior when BraceWrapping.AfterFunction = true
9300   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9301   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9302   verifyFormat("int f() {}", MergeEmptyOnly);
9303   verifyFormat("class C {\n"
9304                "  int f() {}\n"
9305                "};",
9306                MergeEmptyOnly);
9307 }
9308 
9309 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9310   FormatStyle MergeInlineOnly = getLLVMStyle();
9311   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9312   verifyFormat("class C {\n"
9313                "  int f() { return 42; }\n"
9314                "};",
9315                MergeInlineOnly);
9316   verifyFormat("int f() {\n"
9317                "  return 42;\n"
9318                "}",
9319                MergeInlineOnly);
9320 
9321   // SFS_Inline implies SFS_Empty
9322   verifyFormat("class C {\n"
9323                "  int f() {}\n"
9324                "};",
9325                MergeInlineOnly);
9326   verifyFormat("int f() {}", MergeInlineOnly);
9327 
9328   // Also verify behavior when BraceWrapping.AfterFunction = true
9329   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9330   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9331   verifyFormat("class C {\n"
9332                "  int f() { return 42; }\n"
9333                "};",
9334                MergeInlineOnly);
9335   verifyFormat("int f()\n"
9336                "{\n"
9337                "  return 42;\n"
9338                "}",
9339                MergeInlineOnly);
9340 
9341   // SFS_Inline implies SFS_Empty
9342   verifyFormat("int f() {}", MergeInlineOnly);
9343   verifyFormat("class C {\n"
9344                "  int f() {}\n"
9345                "};",
9346                MergeInlineOnly);
9347 }
9348 
9349 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9350   FormatStyle MergeInlineOnly = getLLVMStyle();
9351   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9352       FormatStyle::SFS_InlineOnly;
9353   verifyFormat("class C {\n"
9354                "  int f() { return 42; }\n"
9355                "};",
9356                MergeInlineOnly);
9357   verifyFormat("int f() {\n"
9358                "  return 42;\n"
9359                "}",
9360                MergeInlineOnly);
9361 
9362   // SFS_InlineOnly does not imply SFS_Empty
9363   verifyFormat("class C {\n"
9364                "  int f() {}\n"
9365                "};",
9366                MergeInlineOnly);
9367   verifyFormat("int f() {\n"
9368                "}",
9369                MergeInlineOnly);
9370 
9371   // Also verify behavior when BraceWrapping.AfterFunction = true
9372   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9373   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9374   verifyFormat("class C {\n"
9375                "  int f() { return 42; }\n"
9376                "};",
9377                MergeInlineOnly);
9378   verifyFormat("int f()\n"
9379                "{\n"
9380                "  return 42;\n"
9381                "}",
9382                MergeInlineOnly);
9383 
9384   // SFS_InlineOnly does not imply SFS_Empty
9385   verifyFormat("int f()\n"
9386                "{\n"
9387                "}",
9388                MergeInlineOnly);
9389   verifyFormat("class C {\n"
9390                "  int f() {}\n"
9391                "};",
9392                MergeInlineOnly);
9393 }
9394 
9395 TEST_F(FormatTest, SplitEmptyFunction) {
9396   FormatStyle Style = getLLVMStyle();
9397   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9398   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9399   Style.BraceWrapping.AfterFunction = true;
9400   Style.BraceWrapping.SplitEmptyFunction = false;
9401   Style.ColumnLimit = 40;
9402 
9403   verifyFormat("int f()\n"
9404                "{}",
9405                Style);
9406   verifyFormat("int f()\n"
9407                "{\n"
9408                "  return 42;\n"
9409                "}",
9410                Style);
9411   verifyFormat("int f()\n"
9412                "{\n"
9413                "  // some comment\n"
9414                "}",
9415                Style);
9416 
9417   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9418   verifyFormat("int f() {}", Style);
9419   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9420                "{}",
9421                Style);
9422   verifyFormat("int f()\n"
9423                "{\n"
9424                "  return 0;\n"
9425                "}",
9426                Style);
9427 
9428   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9429   verifyFormat("class Foo {\n"
9430                "  int f() {}\n"
9431                "};\n",
9432                Style);
9433   verifyFormat("class Foo {\n"
9434                "  int f() { return 0; }\n"
9435                "};\n",
9436                Style);
9437   verifyFormat("class Foo {\n"
9438                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9439                "  {}\n"
9440                "};\n",
9441                Style);
9442   verifyFormat("class Foo {\n"
9443                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9444                "  {\n"
9445                "    return 0;\n"
9446                "  }\n"
9447                "};\n",
9448                Style);
9449 
9450   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9451   verifyFormat("int f() {}", Style);
9452   verifyFormat("int f() { return 0; }", Style);
9453   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9454                "{}",
9455                Style);
9456   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9457                "{\n"
9458                "  return 0;\n"
9459                "}",
9460                Style);
9461 }
9462 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9463   FormatStyle Style = getLLVMStyle();
9464   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9465   verifyFormat("#ifdef A\n"
9466                "int f() {}\n"
9467                "#else\n"
9468                "int g() {}\n"
9469                "#endif",
9470                Style);
9471 }
9472 
9473 TEST_F(FormatTest, SplitEmptyClass) {
9474   FormatStyle Style = getLLVMStyle();
9475   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9476   Style.BraceWrapping.AfterClass = true;
9477   Style.BraceWrapping.SplitEmptyRecord = false;
9478 
9479   verifyFormat("class Foo\n"
9480                "{};",
9481                Style);
9482   verifyFormat("/* something */ class Foo\n"
9483                "{};",
9484                Style);
9485   verifyFormat("template <typename X> class Foo\n"
9486                "{};",
9487                Style);
9488   verifyFormat("class Foo\n"
9489                "{\n"
9490                "  Foo();\n"
9491                "};",
9492                Style);
9493   verifyFormat("typedef class Foo\n"
9494                "{\n"
9495                "} Foo_t;",
9496                Style);
9497 }
9498 
9499 TEST_F(FormatTest, SplitEmptyStruct) {
9500   FormatStyle Style = getLLVMStyle();
9501   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9502   Style.BraceWrapping.AfterStruct = true;
9503   Style.BraceWrapping.SplitEmptyRecord = false;
9504 
9505   verifyFormat("struct Foo\n"
9506                "{};",
9507                Style);
9508   verifyFormat("/* something */ struct Foo\n"
9509                "{};",
9510                Style);
9511   verifyFormat("template <typename X> struct Foo\n"
9512                "{};",
9513                Style);
9514   verifyFormat("struct Foo\n"
9515                "{\n"
9516                "  Foo();\n"
9517                "};",
9518                Style);
9519   verifyFormat("typedef struct Foo\n"
9520                "{\n"
9521                "} Foo_t;",
9522                Style);
9523   // typedef struct Bar {} Bar_t;
9524 }
9525 
9526 TEST_F(FormatTest, SplitEmptyUnion) {
9527   FormatStyle Style = getLLVMStyle();
9528   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9529   Style.BraceWrapping.AfterUnion = true;
9530   Style.BraceWrapping.SplitEmptyRecord = false;
9531 
9532   verifyFormat("union Foo\n"
9533                "{};",
9534                Style);
9535   verifyFormat("/* something */ union Foo\n"
9536                "{};",
9537                Style);
9538   verifyFormat("union Foo\n"
9539                "{\n"
9540                "  A,\n"
9541                "};",
9542                Style);
9543   verifyFormat("typedef union Foo\n"
9544                "{\n"
9545                "} Foo_t;",
9546                Style);
9547 }
9548 
9549 TEST_F(FormatTest, SplitEmptyNamespace) {
9550   FormatStyle Style = getLLVMStyle();
9551   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9552   Style.BraceWrapping.AfterNamespace = true;
9553   Style.BraceWrapping.SplitEmptyNamespace = false;
9554 
9555   verifyFormat("namespace Foo\n"
9556                "{};",
9557                Style);
9558   verifyFormat("/* something */ namespace Foo\n"
9559                "{};",
9560                Style);
9561   verifyFormat("inline namespace Foo\n"
9562                "{};",
9563                Style);
9564   verifyFormat("/* something */ inline namespace Foo\n"
9565                "{};",
9566                Style);
9567   verifyFormat("export namespace Foo\n"
9568                "{};",
9569                Style);
9570   verifyFormat("namespace Foo\n"
9571                "{\n"
9572                "void Bar();\n"
9573                "};",
9574                Style);
9575 }
9576 
9577 TEST_F(FormatTest, NeverMergeShortRecords) {
9578   FormatStyle Style = getLLVMStyle();
9579 
9580   verifyFormat("class Foo {\n"
9581                "  Foo();\n"
9582                "};",
9583                Style);
9584   verifyFormat("typedef class Foo {\n"
9585                "  Foo();\n"
9586                "} Foo_t;",
9587                Style);
9588   verifyFormat("struct Foo {\n"
9589                "  Foo();\n"
9590                "};",
9591                Style);
9592   verifyFormat("typedef struct Foo {\n"
9593                "  Foo();\n"
9594                "} Foo_t;",
9595                Style);
9596   verifyFormat("union Foo {\n"
9597                "  A,\n"
9598                "};",
9599                Style);
9600   verifyFormat("typedef union Foo {\n"
9601                "  A,\n"
9602                "} Foo_t;",
9603                Style);
9604   verifyFormat("namespace Foo {\n"
9605                "void Bar();\n"
9606                "};",
9607                Style);
9608 
9609   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9610   Style.BraceWrapping.AfterClass = true;
9611   Style.BraceWrapping.AfterStruct = true;
9612   Style.BraceWrapping.AfterUnion = true;
9613   Style.BraceWrapping.AfterNamespace = true;
9614   verifyFormat("class Foo\n"
9615                "{\n"
9616                "  Foo();\n"
9617                "};",
9618                Style);
9619   verifyFormat("typedef class Foo\n"
9620                "{\n"
9621                "  Foo();\n"
9622                "} Foo_t;",
9623                Style);
9624   verifyFormat("struct Foo\n"
9625                "{\n"
9626                "  Foo();\n"
9627                "};",
9628                Style);
9629   verifyFormat("typedef struct Foo\n"
9630                "{\n"
9631                "  Foo();\n"
9632                "} Foo_t;",
9633                Style);
9634   verifyFormat("union Foo\n"
9635                "{\n"
9636                "  A,\n"
9637                "};",
9638                Style);
9639   verifyFormat("typedef union Foo\n"
9640                "{\n"
9641                "  A,\n"
9642                "} Foo_t;",
9643                Style);
9644   verifyFormat("namespace Foo\n"
9645                "{\n"
9646                "void Bar();\n"
9647                "};",
9648                Style);
9649 }
9650 
9651 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
9652   // Elaborate type variable declarations.
9653   verifyFormat("struct foo a = {bar};\nint n;");
9654   verifyFormat("class foo a = {bar};\nint n;");
9655   verifyFormat("union foo a = {bar};\nint n;");
9656 
9657   // Elaborate types inside function definitions.
9658   verifyFormat("struct foo f() {}\nint n;");
9659   verifyFormat("class foo f() {}\nint n;");
9660   verifyFormat("union foo f() {}\nint n;");
9661 
9662   // Templates.
9663   verifyFormat("template <class X> void f() {}\nint n;");
9664   verifyFormat("template <struct X> void f() {}\nint n;");
9665   verifyFormat("template <union X> void f() {}\nint n;");
9666 
9667   // Actual definitions...
9668   verifyFormat("struct {\n} n;");
9669   verifyFormat(
9670       "template <template <class T, class Y>, class Z> class X {\n} n;");
9671   verifyFormat("union Z {\n  int n;\n} x;");
9672   verifyFormat("class MACRO Z {\n} n;");
9673   verifyFormat("class MACRO(X) Z {\n} n;");
9674   verifyFormat("class __attribute__(X) Z {\n} n;");
9675   verifyFormat("class __declspec(X) Z {\n} n;");
9676   verifyFormat("class A##B##C {\n} n;");
9677   verifyFormat("class alignas(16) Z {\n} n;");
9678   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
9679   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
9680 
9681   // Redefinition from nested context:
9682   verifyFormat("class A::B::C {\n} n;");
9683 
9684   // Template definitions.
9685   verifyFormat(
9686       "template <typename F>\n"
9687       "Matcher(const Matcher<F> &Other,\n"
9688       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
9689       "                             !is_same<F, T>::value>::type * = 0)\n"
9690       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
9691 
9692   // FIXME: This is still incorrectly handled at the formatter side.
9693   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
9694   verifyFormat("int i = SomeFunction(a<b, a> b);");
9695 
9696   // FIXME:
9697   // This now gets parsed incorrectly as class definition.
9698   // verifyFormat("class A<int> f() {\n}\nint n;");
9699 
9700   // Elaborate types where incorrectly parsing the structural element would
9701   // break the indent.
9702   verifyFormat("if (true)\n"
9703                "  class X x;\n"
9704                "else\n"
9705                "  f();\n");
9706 
9707   // This is simply incomplete. Formatting is not important, but must not crash.
9708   verifyFormat("class A:");
9709 }
9710 
9711 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
9712   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
9713             format("#error Leave     all         white!!!!! space* alone!\n"));
9714   EXPECT_EQ(
9715       "#warning Leave     all         white!!!!! space* alone!\n",
9716       format("#warning Leave     all         white!!!!! space* alone!\n"));
9717   EXPECT_EQ("#error 1", format("  #  error   1"));
9718   EXPECT_EQ("#warning 1", format("  #  warning 1"));
9719 }
9720 
9721 TEST_F(FormatTest, FormatHashIfExpressions) {
9722   verifyFormat("#if AAAA && BBBB");
9723   verifyFormat("#if (AAAA && BBBB)");
9724   verifyFormat("#elif (AAAA && BBBB)");
9725   // FIXME: Come up with a better indentation for #elif.
9726   verifyFormat(
9727       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
9728       "    defined(BBBBBBBB)\n"
9729       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
9730       "    defined(BBBBBBBB)\n"
9731       "#endif",
9732       getLLVMStyleWithColumns(65));
9733 }
9734 
9735 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
9736   FormatStyle AllowsMergedIf = getGoogleStyle();
9737   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
9738       FormatStyle::SIS_WithoutElse;
9739   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
9740   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
9741   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
9742   EXPECT_EQ("if (true) return 42;",
9743             format("if (true)\nreturn 42;", AllowsMergedIf));
9744   FormatStyle ShortMergedIf = AllowsMergedIf;
9745   ShortMergedIf.ColumnLimit = 25;
9746   verifyFormat("#define A \\\n"
9747                "  if (true) return 42;",
9748                ShortMergedIf);
9749   verifyFormat("#define A \\\n"
9750                "  f();    \\\n"
9751                "  if (true)\n"
9752                "#define B",
9753                ShortMergedIf);
9754   verifyFormat("#define A \\\n"
9755                "  f();    \\\n"
9756                "  if (true)\n"
9757                "g();",
9758                ShortMergedIf);
9759   verifyFormat("{\n"
9760                "#ifdef A\n"
9761                "  // Comment\n"
9762                "  if (true) continue;\n"
9763                "#endif\n"
9764                "  // Comment\n"
9765                "  if (true) continue;\n"
9766                "}",
9767                ShortMergedIf);
9768   ShortMergedIf.ColumnLimit = 33;
9769   verifyFormat("#define A \\\n"
9770                "  if constexpr (true) return 42;",
9771                ShortMergedIf);
9772   verifyFormat("#define A \\\n"
9773                "  if CONSTEXPR (true) return 42;",
9774                ShortMergedIf);
9775   ShortMergedIf.ColumnLimit = 29;
9776   verifyFormat("#define A                   \\\n"
9777                "  if (aaaaaaaaaa) return 1; \\\n"
9778                "  return 2;",
9779                ShortMergedIf);
9780   ShortMergedIf.ColumnLimit = 28;
9781   verifyFormat("#define A         \\\n"
9782                "  if (aaaaaaaaaa) \\\n"
9783                "    return 1;     \\\n"
9784                "  return 2;",
9785                ShortMergedIf);
9786   verifyFormat("#define A                \\\n"
9787                "  if constexpr (aaaaaaa) \\\n"
9788                "    return 1;            \\\n"
9789                "  return 2;",
9790                ShortMergedIf);
9791   verifyFormat("#define A                \\\n"
9792                "  if CONSTEXPR (aaaaaaa) \\\n"
9793                "    return 1;            \\\n"
9794                "  return 2;",
9795                ShortMergedIf);
9796 }
9797 
9798 TEST_F(FormatTest, FormatStarDependingOnContext) {
9799   verifyFormat("void f(int *a);");
9800   verifyFormat("void f() { f(fint * b); }");
9801   verifyFormat("class A {\n  void f(int *a);\n};");
9802   verifyFormat("class A {\n  int *a;\n};");
9803   verifyFormat("namespace a {\n"
9804                "namespace b {\n"
9805                "class A {\n"
9806                "  void f() {}\n"
9807                "  int *a;\n"
9808                "};\n"
9809                "} // namespace b\n"
9810                "} // namespace a");
9811 }
9812 
9813 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
9814   verifyFormat("while");
9815   verifyFormat("operator");
9816 }
9817 
9818 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
9819   // This code would be painfully slow to format if we didn't skip it.
9820   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
9821                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9822                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9823                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9824                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9825                    "A(1, 1)\n"
9826                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
9827                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9828                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9829                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9830                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9831                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9832                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9833                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9834                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9835                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
9836   // Deeply nested part is untouched, rest is formatted.
9837   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
9838             format(std::string("int    i;\n") + Code + "int    j;\n",
9839                    getLLVMStyle(), SC_ExpectIncomplete));
9840 }
9841 
9842 //===----------------------------------------------------------------------===//
9843 // Objective-C tests.
9844 //===----------------------------------------------------------------------===//
9845 
9846 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
9847   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
9848   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
9849             format("-(NSUInteger)indexOfObject:(id)anObject;"));
9850   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
9851   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
9852   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
9853             format("-(NSInteger)Method3:(id)anObject;"));
9854   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
9855             format("-(NSInteger)Method4:(id)anObject;"));
9856   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
9857             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
9858   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
9859             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
9860   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9861             "forAllCells:(BOOL)flag;",
9862             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9863                    "forAllCells:(BOOL)flag;"));
9864 
9865   // Very long objectiveC method declaration.
9866   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
9867                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
9868   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
9869                "                    inRange:(NSRange)range\n"
9870                "                   outRange:(NSRange)out_range\n"
9871                "                  outRange1:(NSRange)out_range1\n"
9872                "                  outRange2:(NSRange)out_range2\n"
9873                "                  outRange3:(NSRange)out_range3\n"
9874                "                  outRange4:(NSRange)out_range4\n"
9875                "                  outRange5:(NSRange)out_range5\n"
9876                "                  outRange6:(NSRange)out_range6\n"
9877                "                  outRange7:(NSRange)out_range7\n"
9878                "                  outRange8:(NSRange)out_range8\n"
9879                "                  outRange9:(NSRange)out_range9;");
9880 
9881   // When the function name has to be wrapped.
9882   FormatStyle Style = getLLVMStyle();
9883   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
9884   // and always indents instead.
9885   Style.IndentWrappedFunctionNames = false;
9886   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9887                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
9888                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
9889                "}",
9890                Style);
9891   Style.IndentWrappedFunctionNames = true;
9892   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9893                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
9894                "               anotherName:(NSString)dddddddddddddd {\n"
9895                "}",
9896                Style);
9897 
9898   verifyFormat("- (int)sum:(vector<int>)numbers;");
9899   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
9900   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
9901   // protocol lists (but not for template classes):
9902   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
9903 
9904   verifyFormat("- (int (*)())foo:(int (*)())f;");
9905   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
9906 
9907   // If there's no return type (very rare in practice!), LLVM and Google style
9908   // agree.
9909   verifyFormat("- foo;");
9910   verifyFormat("- foo:(int)f;");
9911   verifyGoogleFormat("- foo:(int)foo;");
9912 }
9913 
9914 TEST_F(FormatTest, BreaksStringLiterals) {
9915   EXPECT_EQ("\"some text \"\n"
9916             "\"other\";",
9917             format("\"some text other\";", getLLVMStyleWithColumns(12)));
9918   EXPECT_EQ("\"some text \"\n"
9919             "\"other\";",
9920             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
9921   EXPECT_EQ(
9922       "#define A  \\\n"
9923       "  \"some \"  \\\n"
9924       "  \"text \"  \\\n"
9925       "  \"other\";",
9926       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
9927   EXPECT_EQ(
9928       "#define A  \\\n"
9929       "  \"so \"    \\\n"
9930       "  \"text \"  \\\n"
9931       "  \"other\";",
9932       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
9933 
9934   EXPECT_EQ("\"some text\"",
9935             format("\"some text\"", getLLVMStyleWithColumns(1)));
9936   EXPECT_EQ("\"some text\"",
9937             format("\"some text\"", getLLVMStyleWithColumns(11)));
9938   EXPECT_EQ("\"some \"\n"
9939             "\"text\"",
9940             format("\"some text\"", getLLVMStyleWithColumns(10)));
9941   EXPECT_EQ("\"some \"\n"
9942             "\"text\"",
9943             format("\"some text\"", getLLVMStyleWithColumns(7)));
9944   EXPECT_EQ("\"some\"\n"
9945             "\" tex\"\n"
9946             "\"t\"",
9947             format("\"some text\"", getLLVMStyleWithColumns(6)));
9948   EXPECT_EQ("\"some\"\n"
9949             "\" tex\"\n"
9950             "\" and\"",
9951             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
9952   EXPECT_EQ("\"some\"\n"
9953             "\"/tex\"\n"
9954             "\"/and\"",
9955             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
9956 
9957   EXPECT_EQ("variable =\n"
9958             "    \"long string \"\n"
9959             "    \"literal\";",
9960             format("variable = \"long string literal\";",
9961                    getLLVMStyleWithColumns(20)));
9962 
9963   EXPECT_EQ("variable = f(\n"
9964             "    \"long string \"\n"
9965             "    \"literal\",\n"
9966             "    short,\n"
9967             "    loooooooooooooooooooong);",
9968             format("variable = f(\"long string literal\", short, "
9969                    "loooooooooooooooooooong);",
9970                    getLLVMStyleWithColumns(20)));
9971 
9972   EXPECT_EQ(
9973       "f(g(\"long string \"\n"
9974       "    \"literal\"),\n"
9975       "  b);",
9976       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
9977   EXPECT_EQ("f(g(\"long string \"\n"
9978             "    \"literal\",\n"
9979             "    a),\n"
9980             "  b);",
9981             format("f(g(\"long string literal\", a), b);",
9982                    getLLVMStyleWithColumns(20)));
9983   EXPECT_EQ(
9984       "f(\"one two\".split(\n"
9985       "    variable));",
9986       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
9987   EXPECT_EQ("f(\"one two three four five six \"\n"
9988             "  \"seven\".split(\n"
9989             "      really_looooong_variable));",
9990             format("f(\"one two three four five six seven\"."
9991                    "split(really_looooong_variable));",
9992                    getLLVMStyleWithColumns(33)));
9993 
9994   EXPECT_EQ("f(\"some \"\n"
9995             "  \"text\",\n"
9996             "  other);",
9997             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
9998 
9999   // Only break as a last resort.
10000   verifyFormat(
10001       "aaaaaaaaaaaaaaaaaaaa(\n"
10002       "    aaaaaaaaaaaaaaaaaaaa,\n"
10003       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10004 
10005   EXPECT_EQ("\"splitmea\"\n"
10006             "\"trandomp\"\n"
10007             "\"oint\"",
10008             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10009 
10010   EXPECT_EQ("\"split/\"\n"
10011             "\"pathat/\"\n"
10012             "\"slashes\"",
10013             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10014 
10015   EXPECT_EQ("\"split/\"\n"
10016             "\"pathat/\"\n"
10017             "\"slashes\"",
10018             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10019   EXPECT_EQ("\"split at \"\n"
10020             "\"spaces/at/\"\n"
10021             "\"slashes.at.any$\"\n"
10022             "\"non-alphanumeric%\"\n"
10023             "\"1111111111characte\"\n"
10024             "\"rs\"",
10025             format("\"split at "
10026                    "spaces/at/"
10027                    "slashes.at."
10028                    "any$non-"
10029                    "alphanumeric%"
10030                    "1111111111characte"
10031                    "rs\"",
10032                    getLLVMStyleWithColumns(20)));
10033 
10034   // Verify that splitting the strings understands
10035   // Style::AlwaysBreakBeforeMultilineStrings.
10036   EXPECT_EQ("aaaaaaaaaaaa(\n"
10037             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10038             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10039             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10040                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10041                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10042                    getGoogleStyle()));
10043   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10044             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10045             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10046                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10047                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10048                    getGoogleStyle()));
10049   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10050             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10051             format("llvm::outs() << "
10052                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10053                    "aaaaaaaaaaaaaaaaaaa\";"));
10054   EXPECT_EQ("ffff(\n"
10055             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10056             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10057             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10058                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10059                    getGoogleStyle()));
10060 
10061   FormatStyle Style = getLLVMStyleWithColumns(12);
10062   Style.BreakStringLiterals = false;
10063   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10064 
10065   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10066   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10067   EXPECT_EQ("#define A \\\n"
10068             "  \"some \" \\\n"
10069             "  \"text \" \\\n"
10070             "  \"other\";",
10071             format("#define A \"some text other\";", AlignLeft));
10072 }
10073 
10074 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10075   EXPECT_EQ("C a = \"some more \"\n"
10076             "      \"text\";",
10077             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10078 }
10079 
10080 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10081   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10082   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10083   EXPECT_EQ("int i = a(b());",
10084             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10085 }
10086 
10087 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10088   EXPECT_EQ(
10089       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10090       "(\n"
10091       "    \"x\t\");",
10092       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10093              "aaaaaaa("
10094              "\"x\t\");"));
10095 }
10096 
10097 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10098   EXPECT_EQ(
10099       "u8\"utf8 string \"\n"
10100       "u8\"literal\";",
10101       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10102   EXPECT_EQ(
10103       "u\"utf16 string \"\n"
10104       "u\"literal\";",
10105       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10106   EXPECT_EQ(
10107       "U\"utf32 string \"\n"
10108       "U\"literal\";",
10109       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10110   EXPECT_EQ("L\"wide string \"\n"
10111             "L\"literal\";",
10112             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10113   EXPECT_EQ("@\"NSString \"\n"
10114             "@\"literal\";",
10115             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10116   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10117 
10118   // This input makes clang-format try to split the incomplete unicode escape
10119   // sequence, which used to lead to a crasher.
10120   verifyNoCrash(
10121       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10122       getLLVMStyleWithColumns(60));
10123 }
10124 
10125 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10126   FormatStyle Style = getGoogleStyleWithColumns(15);
10127   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10128   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10129   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10130   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10131   EXPECT_EQ("u8R\"x(raw literal)x\";",
10132             format("u8R\"x(raw literal)x\";", Style));
10133 }
10134 
10135 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10136   FormatStyle Style = getLLVMStyleWithColumns(20);
10137   EXPECT_EQ(
10138       "_T(\"aaaaaaaaaaaaaa\")\n"
10139       "_T(\"aaaaaaaaaaaaaa\")\n"
10140       "_T(\"aaaaaaaaaaaa\")",
10141       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10142   EXPECT_EQ("f(x,\n"
10143             "  _T(\"aaaaaaaaaaaa\")\n"
10144             "  _T(\"aaa\"),\n"
10145             "  z);",
10146             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10147 
10148   // FIXME: Handle embedded spaces in one iteration.
10149   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10150   //            "_T(\"aaaaaaaaaaaaa\")\n"
10151   //            "_T(\"aaaaaaaaaaaaa\")\n"
10152   //            "_T(\"a\")",
10153   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10154   //                   getLLVMStyleWithColumns(20)));
10155   EXPECT_EQ(
10156       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10157       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10158   EXPECT_EQ("f(\n"
10159             "#if !TEST\n"
10160             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10161             "#endif\n"
10162             ");",
10163             format("f(\n"
10164                    "#if !TEST\n"
10165                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10166                    "#endif\n"
10167                    ");"));
10168   EXPECT_EQ("f(\n"
10169             "\n"
10170             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10171             format("f(\n"
10172                    "\n"
10173                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10174 }
10175 
10176 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10177   // In a function call with two operands, the second can be broken with no line
10178   // break before it.
10179   EXPECT_EQ(
10180       "func(a, \"long long \"\n"
10181       "        \"long long\");",
10182       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10183   // In a function call with three operands, the second must be broken with a
10184   // line break before it.
10185   EXPECT_EQ("func(a,\n"
10186             "     \"long long long \"\n"
10187             "     \"long\",\n"
10188             "     c);",
10189             format("func(a, \"long long long long\", c);",
10190                    getLLVMStyleWithColumns(24)));
10191   // In a function call with three operands, the third must be broken with a
10192   // line break before it.
10193   EXPECT_EQ("func(a, b,\n"
10194             "     \"long long long \"\n"
10195             "     \"long\");",
10196             format("func(a, b, \"long long long long\");",
10197                    getLLVMStyleWithColumns(24)));
10198   // In a function call with three operands, both the second and the third must
10199   // be broken with a line break before them.
10200   EXPECT_EQ("func(a,\n"
10201             "     \"long long long \"\n"
10202             "     \"long\",\n"
10203             "     \"long long long \"\n"
10204             "     \"long\");",
10205             format("func(a, \"long long long long\", \"long long long long\");",
10206                    getLLVMStyleWithColumns(24)));
10207   // In a chain of << with two operands, the second can be broken with no line
10208   // break before it.
10209   EXPECT_EQ("a << \"line line \"\n"
10210             "     \"line\";",
10211             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10212   // In a chain of << with three operands, the second can be broken with no line
10213   // break before it.
10214   EXPECT_EQ(
10215       "abcde << \"line \"\n"
10216       "         \"line line\"\n"
10217       "      << c;",
10218       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10219   // In a chain of << with three operands, the third must be broken with a line
10220   // break before it.
10221   EXPECT_EQ(
10222       "a << b\n"
10223       "  << \"line line \"\n"
10224       "     \"line\";",
10225       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10226   // In a chain of << with three operands, the second can be broken with no line
10227   // break before it and the third must be broken with a line break before it.
10228   EXPECT_EQ("abcd << \"line line \"\n"
10229             "        \"line\"\n"
10230             "     << \"line line \"\n"
10231             "        \"line\";",
10232             format("abcd << \"line line line\" << \"line line line\";",
10233                    getLLVMStyleWithColumns(20)));
10234   // In a chain of binary operators with two operands, the second can be broken
10235   // with no line break before it.
10236   EXPECT_EQ(
10237       "abcd + \"line line \"\n"
10238       "       \"line line\";",
10239       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10240   // In a chain of binary operators with three operands, the second must be
10241   // broken with a line break before it.
10242   EXPECT_EQ("abcd +\n"
10243             "    \"line line \"\n"
10244             "    \"line line\" +\n"
10245             "    e;",
10246             format("abcd + \"line line line line\" + e;",
10247                    getLLVMStyleWithColumns(20)));
10248   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10249   // the first must be broken with a line break before it.
10250   FormatStyle Style = getLLVMStyleWithColumns(25);
10251   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10252   EXPECT_EQ("someFunction(\n"
10253             "    \"long long long \"\n"
10254             "    \"long\",\n"
10255             "    a);",
10256             format("someFunction(\"long long long long\", a);", Style));
10257 }
10258 
10259 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10260   EXPECT_EQ(
10261       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10262       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10263       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10264       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10265              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10266              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10267 }
10268 
10269 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10270   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10271             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10272   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10273             "multiline raw string literal xxxxxxxxxxxxxx\n"
10274             ")x\",\n"
10275             "              a),\n"
10276             "            b);",
10277             format("fffffffffff(g(R\"x(\n"
10278                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10279                    ")x\", a), b);",
10280                    getGoogleStyleWithColumns(20)));
10281   EXPECT_EQ("fffffffffff(\n"
10282             "    g(R\"x(qqq\n"
10283             "multiline raw string literal xxxxxxxxxxxxxx\n"
10284             ")x\",\n"
10285             "      a),\n"
10286             "    b);",
10287             format("fffffffffff(g(R\"x(qqq\n"
10288                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10289                    ")x\", a), b);",
10290                    getGoogleStyleWithColumns(20)));
10291 
10292   EXPECT_EQ("fffffffffff(R\"x(\n"
10293             "multiline raw string literal xxxxxxxxxxxxxx\n"
10294             ")x\");",
10295             format("fffffffffff(R\"x(\n"
10296                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10297                    ")x\");",
10298                    getGoogleStyleWithColumns(20)));
10299   EXPECT_EQ("fffffffffff(R\"x(\n"
10300             "multiline raw string literal xxxxxxxxxxxxxx\n"
10301             ")x\" + bbbbbb);",
10302             format("fffffffffff(R\"x(\n"
10303                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10304                    ")x\" +   bbbbbb);",
10305                    getGoogleStyleWithColumns(20)));
10306   EXPECT_EQ("fffffffffff(\n"
10307             "    R\"x(\n"
10308             "multiline raw string literal xxxxxxxxxxxxxx\n"
10309             ")x\" +\n"
10310             "    bbbbbb);",
10311             format("fffffffffff(\n"
10312                    " R\"x(\n"
10313                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10314                    ")x\" + bbbbbb);",
10315                    getGoogleStyleWithColumns(20)));
10316   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10317             format("fffffffffff(\n"
10318                    " R\"(single line raw string)\" + bbbbbb);"));
10319 }
10320 
10321 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10322   verifyFormat("string a = \"unterminated;");
10323   EXPECT_EQ("function(\"unterminated,\n"
10324             "         OtherParameter);",
10325             format("function(  \"unterminated,\n"
10326                    "    OtherParameter);"));
10327 }
10328 
10329 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10330   FormatStyle Style = getLLVMStyle();
10331   Style.Standard = FormatStyle::LS_Cpp03;
10332   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10333             format("#define x(_a) printf(\"foo\"_a);", Style));
10334 }
10335 
10336 TEST_F(FormatTest, CppLexVersion) {
10337   FormatStyle Style = getLLVMStyle();
10338   // Formatting of x * y differs if x is a type.
10339   verifyFormat("void foo() { MACRO(a * b); }", Style);
10340   verifyFormat("void foo() { MACRO(int *b); }", Style);
10341 
10342   // LLVM style uses latest lexer.
10343   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10344   Style.Standard = FormatStyle::LS_Cpp17;
10345   // But in c++17, char8_t isn't a keyword.
10346   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10347 }
10348 
10349 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10350 
10351 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10352   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10353             "             \"ddeeefff\");",
10354             format("someFunction(\"aaabbbcccdddeeefff\");",
10355                    getLLVMStyleWithColumns(25)));
10356   EXPECT_EQ("someFunction1234567890(\n"
10357             "    \"aaabbbcccdddeeefff\");",
10358             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10359                    getLLVMStyleWithColumns(26)));
10360   EXPECT_EQ("someFunction1234567890(\n"
10361             "    \"aaabbbcccdddeeeff\"\n"
10362             "    \"f\");",
10363             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10364                    getLLVMStyleWithColumns(25)));
10365   EXPECT_EQ("someFunction1234567890(\n"
10366             "    \"aaabbbcccdddeeeff\"\n"
10367             "    \"f\");",
10368             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10369                    getLLVMStyleWithColumns(24)));
10370   EXPECT_EQ("someFunction(\n"
10371             "    \"aaabbbcc ddde \"\n"
10372             "    \"efff\");",
10373             format("someFunction(\"aaabbbcc ddde efff\");",
10374                    getLLVMStyleWithColumns(25)));
10375   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10376             "             \"ddeeefff\");",
10377             format("someFunction(\"aaabbbccc ddeeefff\");",
10378                    getLLVMStyleWithColumns(25)));
10379   EXPECT_EQ("someFunction1234567890(\n"
10380             "    \"aaabb \"\n"
10381             "    \"cccdddeeefff\");",
10382             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10383                    getLLVMStyleWithColumns(25)));
10384   EXPECT_EQ("#define A          \\\n"
10385             "  string s =       \\\n"
10386             "      \"123456789\"  \\\n"
10387             "      \"0\";         \\\n"
10388             "  int i;",
10389             format("#define A string s = \"1234567890\"; int i;",
10390                    getLLVMStyleWithColumns(20)));
10391   EXPECT_EQ("someFunction(\n"
10392             "    \"aaabbbcc \"\n"
10393             "    \"dddeeefff\");",
10394             format("someFunction(\"aaabbbcc dddeeefff\");",
10395                    getLLVMStyleWithColumns(25)));
10396 }
10397 
10398 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10399   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10400   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10401   EXPECT_EQ("\"test\"\n"
10402             "\"\\n\"",
10403             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10404   EXPECT_EQ("\"tes\\\\\"\n"
10405             "\"n\"",
10406             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10407   EXPECT_EQ("\"\\\\\\\\\"\n"
10408             "\"\\n\"",
10409             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10410   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10411   EXPECT_EQ("\"\\uff01\"\n"
10412             "\"test\"",
10413             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10414   EXPECT_EQ("\"\\Uff01ff02\"",
10415             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10416   EXPECT_EQ("\"\\x000000000001\"\n"
10417             "\"next\"",
10418             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10419   EXPECT_EQ("\"\\x000000000001next\"",
10420             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10421   EXPECT_EQ("\"\\x000000000001\"",
10422             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10423   EXPECT_EQ("\"test\"\n"
10424             "\"\\000000\"\n"
10425             "\"000001\"",
10426             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10427   EXPECT_EQ("\"test\\000\"\n"
10428             "\"00000000\"\n"
10429             "\"1\"",
10430             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10431 }
10432 
10433 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10434   verifyFormat("void f() {\n"
10435                "  return g() {}\n"
10436                "  void h() {}");
10437   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10438                "g();\n"
10439                "}");
10440 }
10441 
10442 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10443   verifyFormat(
10444       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10445 }
10446 
10447 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10448   verifyFormat("class X {\n"
10449                "  void f() {\n"
10450                "  }\n"
10451                "};",
10452                getLLVMStyleWithColumns(12));
10453 }
10454 
10455 TEST_F(FormatTest, ConfigurableIndentWidth) {
10456   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10457   EightIndent.IndentWidth = 8;
10458   EightIndent.ContinuationIndentWidth = 8;
10459   verifyFormat("void f() {\n"
10460                "        someFunction();\n"
10461                "        if (true) {\n"
10462                "                f();\n"
10463                "        }\n"
10464                "}",
10465                EightIndent);
10466   verifyFormat("class X {\n"
10467                "        void f() {\n"
10468                "        }\n"
10469                "};",
10470                EightIndent);
10471   verifyFormat("int x[] = {\n"
10472                "        call(),\n"
10473                "        call()};",
10474                EightIndent);
10475 }
10476 
10477 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10478   verifyFormat("double\n"
10479                "f();",
10480                getLLVMStyleWithColumns(8));
10481 }
10482 
10483 TEST_F(FormatTest, ConfigurableUseOfTab) {
10484   FormatStyle Tab = getLLVMStyleWithColumns(42);
10485   Tab.IndentWidth = 8;
10486   Tab.UseTab = FormatStyle::UT_Always;
10487   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10488 
10489   EXPECT_EQ("if (aaaaaaaa && // q\n"
10490             "    bb)\t\t// w\n"
10491             "\t;",
10492             format("if (aaaaaaaa &&// q\n"
10493                    "bb)// w\n"
10494                    ";",
10495                    Tab));
10496   EXPECT_EQ("if (aaa && bbb) // w\n"
10497             "\t;",
10498             format("if(aaa&&bbb)// w\n"
10499                    ";",
10500                    Tab));
10501 
10502   verifyFormat("class X {\n"
10503                "\tvoid f() {\n"
10504                "\t\tsomeFunction(parameter1,\n"
10505                "\t\t\t     parameter2);\n"
10506                "\t}\n"
10507                "};",
10508                Tab);
10509   verifyFormat("#define A                        \\\n"
10510                "\tvoid f() {               \\\n"
10511                "\t\tsomeFunction(    \\\n"
10512                "\t\t    parameter1,  \\\n"
10513                "\t\t    parameter2); \\\n"
10514                "\t}",
10515                Tab);
10516   verifyFormat("int a;\t      // x\n"
10517                "int bbbbbbbb; // x\n",
10518                Tab);
10519 
10520   Tab.TabWidth = 4;
10521   Tab.IndentWidth = 8;
10522   verifyFormat("class TabWidth4Indent8 {\n"
10523                "\t\tvoid f() {\n"
10524                "\t\t\t\tsomeFunction(parameter1,\n"
10525                "\t\t\t\t\t\t\t parameter2);\n"
10526                "\t\t}\n"
10527                "};",
10528                Tab);
10529 
10530   Tab.TabWidth = 4;
10531   Tab.IndentWidth = 4;
10532   verifyFormat("class TabWidth4Indent4 {\n"
10533                "\tvoid f() {\n"
10534                "\t\tsomeFunction(parameter1,\n"
10535                "\t\t\t\t\t parameter2);\n"
10536                "\t}\n"
10537                "};",
10538                Tab);
10539 
10540   Tab.TabWidth = 8;
10541   Tab.IndentWidth = 4;
10542   verifyFormat("class TabWidth8Indent4 {\n"
10543                "    void f() {\n"
10544                "\tsomeFunction(parameter1,\n"
10545                "\t\t     parameter2);\n"
10546                "    }\n"
10547                "};",
10548                Tab);
10549 
10550   Tab.TabWidth = 8;
10551   Tab.IndentWidth = 8;
10552   EXPECT_EQ("/*\n"
10553             "\t      a\t\tcomment\n"
10554             "\t      in multiple lines\n"
10555             "       */",
10556             format("   /*\t \t \n"
10557                    " \t \t a\t\tcomment\t \t\n"
10558                    " \t \t in multiple lines\t\n"
10559                    " \t  */",
10560                    Tab));
10561 
10562   Tab.UseTab = FormatStyle::UT_ForIndentation;
10563   verifyFormat("{\n"
10564                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10565                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10566                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10567                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10568                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10569                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10570                "};",
10571                Tab);
10572   verifyFormat("enum AA {\n"
10573                "\ta1, // Force multiple lines\n"
10574                "\ta2,\n"
10575                "\ta3\n"
10576                "};",
10577                Tab);
10578   EXPECT_EQ("if (aaaaaaaa && // q\n"
10579             "    bb)         // w\n"
10580             "\t;",
10581             format("if (aaaaaaaa &&// q\n"
10582                    "bb)// w\n"
10583                    ";",
10584                    Tab));
10585   verifyFormat("class X {\n"
10586                "\tvoid f() {\n"
10587                "\t\tsomeFunction(parameter1,\n"
10588                "\t\t             parameter2);\n"
10589                "\t}\n"
10590                "};",
10591                Tab);
10592   verifyFormat("{\n"
10593                "\tQ(\n"
10594                "\t    {\n"
10595                "\t\t    int a;\n"
10596                "\t\t    someFunction(aaaaaaaa,\n"
10597                "\t\t                 bbbbbbb);\n"
10598                "\t    },\n"
10599                "\t    p);\n"
10600                "}",
10601                Tab);
10602   EXPECT_EQ("{\n"
10603             "\t/* aaaa\n"
10604             "\t   bbbb */\n"
10605             "}",
10606             format("{\n"
10607                    "/* aaaa\n"
10608                    "   bbbb */\n"
10609                    "}",
10610                    Tab));
10611   EXPECT_EQ("{\n"
10612             "\t/*\n"
10613             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10614             "\t  bbbbbbbbbbbbb\n"
10615             "\t*/\n"
10616             "}",
10617             format("{\n"
10618                    "/*\n"
10619                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10620                    "*/\n"
10621                    "}",
10622                    Tab));
10623   EXPECT_EQ("{\n"
10624             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10625             "\t// bbbbbbbbbbbbb\n"
10626             "}",
10627             format("{\n"
10628                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10629                    "}",
10630                    Tab));
10631   EXPECT_EQ("{\n"
10632             "\t/*\n"
10633             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10634             "\t  bbbbbbbbbbbbb\n"
10635             "\t*/\n"
10636             "}",
10637             format("{\n"
10638                    "\t/*\n"
10639                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10640                    "\t*/\n"
10641                    "}",
10642                    Tab));
10643   EXPECT_EQ("{\n"
10644             "\t/*\n"
10645             "\n"
10646             "\t*/\n"
10647             "}",
10648             format("{\n"
10649                    "\t/*\n"
10650                    "\n"
10651                    "\t*/\n"
10652                    "}",
10653                    Tab));
10654   EXPECT_EQ("{\n"
10655             "\t/*\n"
10656             " asdf\n"
10657             "\t*/\n"
10658             "}",
10659             format("{\n"
10660                    "\t/*\n"
10661                    " asdf\n"
10662                    "\t*/\n"
10663                    "}",
10664                    Tab));
10665 
10666   Tab.UseTab = FormatStyle::UT_Never;
10667   EXPECT_EQ("/*\n"
10668             "              a\t\tcomment\n"
10669             "              in multiple lines\n"
10670             "       */",
10671             format("   /*\t \t \n"
10672                    " \t \t a\t\tcomment\t \t\n"
10673                    " \t \t in multiple lines\t\n"
10674                    " \t  */",
10675                    Tab));
10676   EXPECT_EQ("/* some\n"
10677             "   comment */",
10678             format(" \t \t /* some\n"
10679                    " \t \t    comment */",
10680                    Tab));
10681   EXPECT_EQ("int a; /* some\n"
10682             "   comment */",
10683             format(" \t \t int a; /* some\n"
10684                    " \t \t    comment */",
10685                    Tab));
10686 
10687   EXPECT_EQ("int a; /* some\n"
10688             "comment */",
10689             format(" \t \t int\ta; /* some\n"
10690                    " \t \t    comment */",
10691                    Tab));
10692   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10693             "    comment */",
10694             format(" \t \t f(\"\t\t\"); /* some\n"
10695                    " \t \t    comment */",
10696                    Tab));
10697   EXPECT_EQ("{\n"
10698             "        /*\n"
10699             "         * Comment\n"
10700             "         */\n"
10701             "        int i;\n"
10702             "}",
10703             format("{\n"
10704                    "\t/*\n"
10705                    "\t * Comment\n"
10706                    "\t */\n"
10707                    "\t int i;\n"
10708                    "}",
10709                    Tab));
10710 
10711   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
10712   Tab.TabWidth = 8;
10713   Tab.IndentWidth = 8;
10714   EXPECT_EQ("if (aaaaaaaa && // q\n"
10715             "    bb)         // w\n"
10716             "\t;",
10717             format("if (aaaaaaaa &&// q\n"
10718                    "bb)// w\n"
10719                    ";",
10720                    Tab));
10721   EXPECT_EQ("if (aaa && bbb) // w\n"
10722             "\t;",
10723             format("if(aaa&&bbb)// w\n"
10724                    ";",
10725                    Tab));
10726   verifyFormat("class X {\n"
10727                "\tvoid f() {\n"
10728                "\t\tsomeFunction(parameter1,\n"
10729                "\t\t\t     parameter2);\n"
10730                "\t}\n"
10731                "};",
10732                Tab);
10733   verifyFormat("#define A                        \\\n"
10734                "\tvoid f() {               \\\n"
10735                "\t\tsomeFunction(    \\\n"
10736                "\t\t    parameter1,  \\\n"
10737                "\t\t    parameter2); \\\n"
10738                "\t}",
10739                Tab);
10740   Tab.TabWidth = 4;
10741   Tab.IndentWidth = 8;
10742   verifyFormat("class TabWidth4Indent8 {\n"
10743                "\t\tvoid f() {\n"
10744                "\t\t\t\tsomeFunction(parameter1,\n"
10745                "\t\t\t\t\t\t\t parameter2);\n"
10746                "\t\t}\n"
10747                "};",
10748                Tab);
10749   Tab.TabWidth = 4;
10750   Tab.IndentWidth = 4;
10751   verifyFormat("class TabWidth4Indent4 {\n"
10752                "\tvoid f() {\n"
10753                "\t\tsomeFunction(parameter1,\n"
10754                "\t\t\t\t\t parameter2);\n"
10755                "\t}\n"
10756                "};",
10757                Tab);
10758   Tab.TabWidth = 8;
10759   Tab.IndentWidth = 4;
10760   verifyFormat("class TabWidth8Indent4 {\n"
10761                "    void f() {\n"
10762                "\tsomeFunction(parameter1,\n"
10763                "\t\t     parameter2);\n"
10764                "    }\n"
10765                "};",
10766                Tab);
10767   Tab.TabWidth = 8;
10768   Tab.IndentWidth = 8;
10769   EXPECT_EQ("/*\n"
10770             "\t      a\t\tcomment\n"
10771             "\t      in multiple lines\n"
10772             "       */",
10773             format("   /*\t \t \n"
10774                    " \t \t a\t\tcomment\t \t\n"
10775                    " \t \t in multiple lines\t\n"
10776                    " \t  */",
10777                    Tab));
10778   verifyFormat("{\n"
10779                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10780                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10781                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10782                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10783                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10784                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10785                "};",
10786                Tab);
10787   verifyFormat("enum AA {\n"
10788                "\ta1, // Force multiple lines\n"
10789                "\ta2,\n"
10790                "\ta3\n"
10791                "};",
10792                Tab);
10793   EXPECT_EQ("if (aaaaaaaa && // q\n"
10794             "    bb)         // w\n"
10795             "\t;",
10796             format("if (aaaaaaaa &&// q\n"
10797                    "bb)// w\n"
10798                    ";",
10799                    Tab));
10800   verifyFormat("class X {\n"
10801                "\tvoid f() {\n"
10802                "\t\tsomeFunction(parameter1,\n"
10803                "\t\t\t     parameter2);\n"
10804                "\t}\n"
10805                "};",
10806                Tab);
10807   verifyFormat("{\n"
10808                "\tQ(\n"
10809                "\t    {\n"
10810                "\t\t    int a;\n"
10811                "\t\t    someFunction(aaaaaaaa,\n"
10812                "\t\t\t\t bbbbbbb);\n"
10813                "\t    },\n"
10814                "\t    p);\n"
10815                "}",
10816                Tab);
10817   EXPECT_EQ("{\n"
10818             "\t/* aaaa\n"
10819             "\t   bbbb */\n"
10820             "}",
10821             format("{\n"
10822                    "/* aaaa\n"
10823                    "   bbbb */\n"
10824                    "}",
10825                    Tab));
10826   EXPECT_EQ("{\n"
10827             "\t/*\n"
10828             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10829             "\t  bbbbbbbbbbbbb\n"
10830             "\t*/\n"
10831             "}",
10832             format("{\n"
10833                    "/*\n"
10834                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10835                    "*/\n"
10836                    "}",
10837                    Tab));
10838   EXPECT_EQ("{\n"
10839             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10840             "\t// bbbbbbbbbbbbb\n"
10841             "}",
10842             format("{\n"
10843                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10844                    "}",
10845                    Tab));
10846   EXPECT_EQ("{\n"
10847             "\t/*\n"
10848             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10849             "\t  bbbbbbbbbbbbb\n"
10850             "\t*/\n"
10851             "}",
10852             format("{\n"
10853                    "\t/*\n"
10854                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10855                    "\t*/\n"
10856                    "}",
10857                    Tab));
10858   EXPECT_EQ("{\n"
10859             "\t/*\n"
10860             "\n"
10861             "\t*/\n"
10862             "}",
10863             format("{\n"
10864                    "\t/*\n"
10865                    "\n"
10866                    "\t*/\n"
10867                    "}",
10868                    Tab));
10869   EXPECT_EQ("{\n"
10870             "\t/*\n"
10871             " asdf\n"
10872             "\t*/\n"
10873             "}",
10874             format("{\n"
10875                    "\t/*\n"
10876                    " asdf\n"
10877                    "\t*/\n"
10878                    "}",
10879                    Tab));
10880   EXPECT_EQ("/* some\n"
10881             "   comment */",
10882             format(" \t \t /* some\n"
10883                    " \t \t    comment */",
10884                    Tab));
10885   EXPECT_EQ("int a; /* some\n"
10886             "   comment */",
10887             format(" \t \t int a; /* some\n"
10888                    " \t \t    comment */",
10889                    Tab));
10890   EXPECT_EQ("int a; /* some\n"
10891             "comment */",
10892             format(" \t \t int\ta; /* some\n"
10893                    " \t \t    comment */",
10894                    Tab));
10895   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10896             "    comment */",
10897             format(" \t \t f(\"\t\t\"); /* some\n"
10898                    " \t \t    comment */",
10899                    Tab));
10900   EXPECT_EQ("{\n"
10901             "\t/*\n"
10902             "\t * Comment\n"
10903             "\t */\n"
10904             "\tint i;\n"
10905             "}",
10906             format("{\n"
10907                    "\t/*\n"
10908                    "\t * Comment\n"
10909                    "\t */\n"
10910                    "\t int i;\n"
10911                    "}",
10912                    Tab));
10913   Tab.TabWidth = 2;
10914   Tab.IndentWidth = 2;
10915   EXPECT_EQ("{\n"
10916             "\t/* aaaa\n"
10917             "\t\t bbbb */\n"
10918             "}",
10919             format("{\n"
10920                    "/* aaaa\n"
10921                    "\t bbbb */\n"
10922                    "}",
10923                    Tab));
10924   EXPECT_EQ("{\n"
10925             "\t/*\n"
10926             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10927             "\t\tbbbbbbbbbbbbb\n"
10928             "\t*/\n"
10929             "}",
10930             format("{\n"
10931                    "/*\n"
10932                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10933                    "*/\n"
10934                    "}",
10935                    Tab));
10936   Tab.AlignConsecutiveAssignments = true;
10937   Tab.AlignConsecutiveDeclarations = true;
10938   Tab.TabWidth = 4;
10939   Tab.IndentWidth = 4;
10940   verifyFormat("class Assign {\n"
10941                "\tvoid f() {\n"
10942                "\t\tint         x      = 123;\n"
10943                "\t\tint         random = 4;\n"
10944                "\t\tstd::string alphabet =\n"
10945                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
10946                "\t}\n"
10947                "};",
10948                Tab);
10949 
10950   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
10951   Tab.TabWidth = 8;
10952   Tab.IndentWidth = 8;
10953   EXPECT_EQ("if (aaaaaaaa && // q\n"
10954             "    bb)         // w\n"
10955             "\t;",
10956             format("if (aaaaaaaa &&// q\n"
10957                    "bb)// w\n"
10958                    ";",
10959                    Tab));
10960   EXPECT_EQ("if (aaa && bbb) // w\n"
10961             "\t;",
10962             format("if(aaa&&bbb)// w\n"
10963                    ";",
10964                    Tab));
10965   verifyFormat("class X {\n"
10966                "\tvoid f() {\n"
10967                "\t\tsomeFunction(parameter1,\n"
10968                "\t\t             parameter2);\n"
10969                "\t}\n"
10970                "};",
10971                Tab);
10972   verifyFormat("#define A                        \\\n"
10973                "\tvoid f() {               \\\n"
10974                "\t\tsomeFunction(    \\\n"
10975                "\t\t    parameter1,  \\\n"
10976                "\t\t    parameter2); \\\n"
10977                "\t}",
10978                Tab);
10979   Tab.TabWidth = 4;
10980   Tab.IndentWidth = 8;
10981   verifyFormat("class TabWidth4Indent8 {\n"
10982                "\t\tvoid f() {\n"
10983                "\t\t\t\tsomeFunction(parameter1,\n"
10984                "\t\t\t\t             parameter2);\n"
10985                "\t\t}\n"
10986                "};",
10987                Tab);
10988   Tab.TabWidth = 4;
10989   Tab.IndentWidth = 4;
10990   verifyFormat("class TabWidth4Indent4 {\n"
10991                "\tvoid f() {\n"
10992                "\t\tsomeFunction(parameter1,\n"
10993                "\t\t             parameter2);\n"
10994                "\t}\n"
10995                "};",
10996                Tab);
10997   Tab.TabWidth = 8;
10998   Tab.IndentWidth = 4;
10999   verifyFormat("class TabWidth8Indent4 {\n"
11000                "    void f() {\n"
11001                "\tsomeFunction(parameter1,\n"
11002                "\t             parameter2);\n"
11003                "    }\n"
11004                "};",
11005                Tab);
11006   Tab.TabWidth = 8;
11007   Tab.IndentWidth = 8;
11008   EXPECT_EQ("/*\n"
11009             "              a\t\tcomment\n"
11010             "              in multiple lines\n"
11011             "       */",
11012             format("   /*\t \t \n"
11013                    " \t \t a\t\tcomment\t \t\n"
11014                    " \t \t in multiple lines\t\n"
11015                    " \t  */",
11016                    Tab));
11017   verifyFormat("{\n"
11018                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11019                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11020                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11021                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11022                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11023                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11024                "};",
11025                Tab);
11026   verifyFormat("enum AA {\n"
11027                "\ta1, // Force multiple lines\n"
11028                "\ta2,\n"
11029                "\ta3\n"
11030                "};",
11031                Tab);
11032   EXPECT_EQ("if (aaaaaaaa && // q\n"
11033             "    bb)         // w\n"
11034             "\t;",
11035             format("if (aaaaaaaa &&// q\n"
11036                    "bb)// w\n"
11037                    ";",
11038                    Tab));
11039   verifyFormat("class X {\n"
11040                "\tvoid f() {\n"
11041                "\t\tsomeFunction(parameter1,\n"
11042                "\t\t             parameter2);\n"
11043                "\t}\n"
11044                "};",
11045                Tab);
11046   verifyFormat("{\n"
11047                "\tQ(\n"
11048                "\t    {\n"
11049                "\t\t    int a;\n"
11050                "\t\t    someFunction(aaaaaaaa,\n"
11051                "\t\t                 bbbbbbb);\n"
11052                "\t    },\n"
11053                "\t    p);\n"
11054                "}",
11055                Tab);
11056   EXPECT_EQ("{\n"
11057             "\t/* aaaa\n"
11058             "\t   bbbb */\n"
11059             "}",
11060             format("{\n"
11061                    "/* aaaa\n"
11062                    "   bbbb */\n"
11063                    "}",
11064                    Tab));
11065   EXPECT_EQ("{\n"
11066             "\t/*\n"
11067             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11068             "\t  bbbbbbbbbbbbb\n"
11069             "\t*/\n"
11070             "}",
11071             format("{\n"
11072                    "/*\n"
11073                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11074                    "*/\n"
11075                    "}",
11076                    Tab));
11077   EXPECT_EQ("{\n"
11078             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11079             "\t// bbbbbbbbbbbbb\n"
11080             "}",
11081             format("{\n"
11082                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11083                    "}",
11084                    Tab));
11085   EXPECT_EQ("{\n"
11086             "\t/*\n"
11087             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11088             "\t  bbbbbbbbbbbbb\n"
11089             "\t*/\n"
11090             "}",
11091             format("{\n"
11092                    "\t/*\n"
11093                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11094                    "\t*/\n"
11095                    "}",
11096                    Tab));
11097   EXPECT_EQ("{\n"
11098             "\t/*\n"
11099             "\n"
11100             "\t*/\n"
11101             "}",
11102             format("{\n"
11103                    "\t/*\n"
11104                    "\n"
11105                    "\t*/\n"
11106                    "}",
11107                    Tab));
11108   EXPECT_EQ("{\n"
11109             "\t/*\n"
11110             " asdf\n"
11111             "\t*/\n"
11112             "}",
11113             format("{\n"
11114                    "\t/*\n"
11115                    " asdf\n"
11116                    "\t*/\n"
11117                    "}",
11118                    Tab));
11119   EXPECT_EQ("/* some\n"
11120             "   comment */",
11121             format(" \t \t /* some\n"
11122                    " \t \t    comment */",
11123                    Tab));
11124   EXPECT_EQ("int a; /* some\n"
11125             "   comment */",
11126             format(" \t \t int a; /* some\n"
11127                    " \t \t    comment */",
11128                    Tab));
11129   EXPECT_EQ("int a; /* some\n"
11130             "comment */",
11131             format(" \t \t int\ta; /* some\n"
11132                    " \t \t    comment */",
11133                    Tab));
11134   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11135             "    comment */",
11136             format(" \t \t f(\"\t\t\"); /* some\n"
11137                    " \t \t    comment */",
11138                    Tab));
11139   EXPECT_EQ("{\n"
11140             "\t/*\n"
11141             "\t * Comment\n"
11142             "\t */\n"
11143             "\tint i;\n"
11144             "}",
11145             format("{\n"
11146                    "\t/*\n"
11147                    "\t * Comment\n"
11148                    "\t */\n"
11149                    "\t int i;\n"
11150                    "}",
11151                    Tab));
11152   Tab.TabWidth = 2;
11153   Tab.IndentWidth = 2;
11154   EXPECT_EQ("{\n"
11155             "\t/* aaaa\n"
11156             "\t   bbbb */\n"
11157             "}",
11158             format("{\n"
11159                    "/* aaaa\n"
11160                    "   bbbb */\n"
11161                    "}",
11162                    Tab));
11163   EXPECT_EQ("{\n"
11164             "\t/*\n"
11165             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11166             "\t  bbbbbbbbbbbbb\n"
11167             "\t*/\n"
11168             "}",
11169             format("{\n"
11170                    "/*\n"
11171                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11172                    "*/\n"
11173                    "}",
11174                    Tab));
11175   Tab.AlignConsecutiveAssignments = true;
11176   Tab.AlignConsecutiveDeclarations = true;
11177   Tab.TabWidth = 4;
11178   Tab.IndentWidth = 4;
11179   verifyFormat("class Assign {\n"
11180                "\tvoid f() {\n"
11181                "\t\tint         x      = 123;\n"
11182                "\t\tint         random = 4;\n"
11183                "\t\tstd::string alphabet =\n"
11184                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11185                "\t}\n"
11186                "};",
11187                Tab);
11188 }
11189 
11190 TEST_F(FormatTest, ZeroTabWidth) {
11191   FormatStyle Tab = getLLVMStyleWithColumns(42);
11192   Tab.IndentWidth = 8;
11193   Tab.UseTab = FormatStyle::UT_Never;
11194   Tab.TabWidth = 0;
11195   EXPECT_EQ("void a(){\n"
11196             "    // line starts with '\t'\n"
11197             "};",
11198             format("void a(){\n"
11199                    "\t// line starts with '\t'\n"
11200                    "};",
11201                    Tab));
11202 
11203   EXPECT_EQ("void a(){\n"
11204             "    // line starts with '\t'\n"
11205             "};",
11206             format("void a(){\n"
11207                    "\t\t// line starts with '\t'\n"
11208                    "};",
11209                    Tab));
11210 
11211   Tab.UseTab = FormatStyle::UT_ForIndentation;
11212   EXPECT_EQ("void a(){\n"
11213             "    // line starts with '\t'\n"
11214             "};",
11215             format("void a(){\n"
11216                    "\t// line starts with '\t'\n"
11217                    "};",
11218                    Tab));
11219 
11220   EXPECT_EQ("void a(){\n"
11221             "    // line starts with '\t'\n"
11222             "};",
11223             format("void a(){\n"
11224                    "\t\t// line starts with '\t'\n"
11225                    "};",
11226                    Tab));
11227 
11228   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11229   EXPECT_EQ("void a(){\n"
11230             "    // line starts with '\t'\n"
11231             "};",
11232             format("void a(){\n"
11233                    "\t// line starts with '\t'\n"
11234                    "};",
11235                    Tab));
11236 
11237   EXPECT_EQ("void a(){\n"
11238             "    // line starts with '\t'\n"
11239             "};",
11240             format("void a(){\n"
11241                    "\t\t// line starts with '\t'\n"
11242                    "};",
11243                    Tab));
11244 
11245   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11246   EXPECT_EQ("void a(){\n"
11247             "    // line starts with '\t'\n"
11248             "};",
11249             format("void a(){\n"
11250                    "\t// line starts with '\t'\n"
11251                    "};",
11252                    Tab));
11253 
11254   EXPECT_EQ("void a(){\n"
11255             "    // line starts with '\t'\n"
11256             "};",
11257             format("void a(){\n"
11258                    "\t\t// line starts with '\t'\n"
11259                    "};",
11260                    Tab));
11261 
11262   Tab.UseTab = FormatStyle::UT_Always;
11263   EXPECT_EQ("void a(){\n"
11264             "// line starts with '\t'\n"
11265             "};",
11266             format("void a(){\n"
11267                    "\t// line starts with '\t'\n"
11268                    "};",
11269                    Tab));
11270 
11271   EXPECT_EQ("void a(){\n"
11272             "// line starts with '\t'\n"
11273             "};",
11274             format("void a(){\n"
11275                    "\t\t// line starts with '\t'\n"
11276                    "};",
11277                    Tab));
11278 }
11279 
11280 TEST_F(FormatTest, CalculatesOriginalColumn) {
11281   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11282             "q\"; /* some\n"
11283             "       comment */",
11284             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11285                    "q\"; /* some\n"
11286                    "       comment */",
11287                    getLLVMStyle()));
11288   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11289             "/* some\n"
11290             "   comment */",
11291             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11292                    " /* some\n"
11293                    "    comment */",
11294                    getLLVMStyle()));
11295   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11296             "qqq\n"
11297             "/* some\n"
11298             "   comment */",
11299             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11300                    "qqq\n"
11301                    " /* some\n"
11302                    "    comment */",
11303                    getLLVMStyle()));
11304   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11305             "wwww; /* some\n"
11306             "         comment */",
11307             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11308                    "wwww; /* some\n"
11309                    "         comment */",
11310                    getLLVMStyle()));
11311 }
11312 
11313 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11314   FormatStyle NoSpace = getLLVMStyle();
11315   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11316 
11317   verifyFormat("while(true)\n"
11318                "  continue;",
11319                NoSpace);
11320   verifyFormat("for(;;)\n"
11321                "  continue;",
11322                NoSpace);
11323   verifyFormat("if(true)\n"
11324                "  f();\n"
11325                "else if(true)\n"
11326                "  f();",
11327                NoSpace);
11328   verifyFormat("do {\n"
11329                "  do_something();\n"
11330                "} while(something());",
11331                NoSpace);
11332   verifyFormat("switch(x) {\n"
11333                "default:\n"
11334                "  break;\n"
11335                "}",
11336                NoSpace);
11337   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11338   verifyFormat("size_t x = sizeof(x);", NoSpace);
11339   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11340   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11341   verifyFormat("alignas(128) char a[128];", NoSpace);
11342   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11343   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11344   verifyFormat("int f() throw(Deprecated);", NoSpace);
11345   verifyFormat("typedef void (*cb)(int);", NoSpace);
11346   verifyFormat("T A::operator()();", NoSpace);
11347   verifyFormat("X A::operator++(T);", NoSpace);
11348   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11349 
11350   FormatStyle Space = getLLVMStyle();
11351   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11352 
11353   verifyFormat("int f ();", Space);
11354   verifyFormat("void f (int a, T b) {\n"
11355                "  while (true)\n"
11356                "    continue;\n"
11357                "}",
11358                Space);
11359   verifyFormat("if (true)\n"
11360                "  f ();\n"
11361                "else if (true)\n"
11362                "  f ();",
11363                Space);
11364   verifyFormat("do {\n"
11365                "  do_something ();\n"
11366                "} while (something ());",
11367                Space);
11368   verifyFormat("switch (x) {\n"
11369                "default:\n"
11370                "  break;\n"
11371                "}",
11372                Space);
11373   verifyFormat("A::A () : a (1) {}", Space);
11374   verifyFormat("void f () __attribute__ ((asdf));", Space);
11375   verifyFormat("*(&a + 1);\n"
11376                "&((&a)[1]);\n"
11377                "a[(b + c) * d];\n"
11378                "(((a + 1) * 2) + 3) * 4;",
11379                Space);
11380   verifyFormat("#define A(x) x", Space);
11381   verifyFormat("#define A (x) x", Space);
11382   verifyFormat("#if defined(x)\n"
11383                "#endif",
11384                Space);
11385   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11386   verifyFormat("size_t x = sizeof (x);", Space);
11387   verifyFormat("auto f (int x) -> decltype (x);", Space);
11388   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11389   verifyFormat("alignas (128) char a[128];", Space);
11390   verifyFormat("size_t x = alignof (MyType);", Space);
11391   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11392   verifyFormat("int f () throw (Deprecated);", Space);
11393   verifyFormat("typedef void (*cb) (int);", Space);
11394   verifyFormat("T A::operator() ();", Space);
11395   verifyFormat("X A::operator++ (T);", Space);
11396   verifyFormat("auto lambda = [] () { return 0; };", Space);
11397   verifyFormat("int x = int (y);", Space);
11398 
11399   FormatStyle SomeSpace = getLLVMStyle();
11400   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11401 
11402   verifyFormat("[]() -> float {}", SomeSpace);
11403   verifyFormat("[] (auto foo) {}", SomeSpace);
11404   verifyFormat("[foo]() -> int {}", SomeSpace);
11405   verifyFormat("int f();", SomeSpace);
11406   verifyFormat("void f (int a, T b) {\n"
11407                "  while (true)\n"
11408                "    continue;\n"
11409                "}",
11410                SomeSpace);
11411   verifyFormat("if (true)\n"
11412                "  f();\n"
11413                "else if (true)\n"
11414                "  f();",
11415                SomeSpace);
11416   verifyFormat("do {\n"
11417                "  do_something();\n"
11418                "} while (something());",
11419                SomeSpace);
11420   verifyFormat("switch (x) {\n"
11421                "default:\n"
11422                "  break;\n"
11423                "}",
11424                SomeSpace);
11425   verifyFormat("A::A() : a (1) {}", SomeSpace);
11426   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11427   verifyFormat("*(&a + 1);\n"
11428                "&((&a)[1]);\n"
11429                "a[(b + c) * d];\n"
11430                "(((a + 1) * 2) + 3) * 4;",
11431                SomeSpace);
11432   verifyFormat("#define A(x) x", SomeSpace);
11433   verifyFormat("#define A (x) x", SomeSpace);
11434   verifyFormat("#if defined(x)\n"
11435                "#endif",
11436                SomeSpace);
11437   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11438   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11439   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11440   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11441   verifyFormat("alignas (128) char a[128];", SomeSpace);
11442   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11443   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11444                SomeSpace);
11445   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11446   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11447   verifyFormat("T A::operator()();", SomeSpace);
11448   verifyFormat("X A::operator++ (T);", SomeSpace);
11449   verifyFormat("int x = int (y);", SomeSpace);
11450   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11451 }
11452 
11453 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11454   FormatStyle Spaces = getLLVMStyle();
11455   Spaces.SpaceAfterLogicalNot = true;
11456 
11457   verifyFormat("bool x = ! y", Spaces);
11458   verifyFormat("if (! isFailure())", Spaces);
11459   verifyFormat("if (! (a && b))", Spaces);
11460   verifyFormat("\"Error!\"", Spaces);
11461   verifyFormat("! ! x", Spaces);
11462 }
11463 
11464 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11465   FormatStyle Spaces = getLLVMStyle();
11466 
11467   Spaces.SpacesInParentheses = true;
11468   verifyFormat("do_something( ::globalVar );", Spaces);
11469   verifyFormat("call( x, y, z );", Spaces);
11470   verifyFormat("call();", Spaces);
11471   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11472   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11473                Spaces);
11474   verifyFormat("while ( (bool)1 )\n"
11475                "  continue;",
11476                Spaces);
11477   verifyFormat("for ( ;; )\n"
11478                "  continue;",
11479                Spaces);
11480   verifyFormat("if ( true )\n"
11481                "  f();\n"
11482                "else if ( true )\n"
11483                "  f();",
11484                Spaces);
11485   verifyFormat("do {\n"
11486                "  do_something( (int)i );\n"
11487                "} while ( something() );",
11488                Spaces);
11489   verifyFormat("switch ( x ) {\n"
11490                "default:\n"
11491                "  break;\n"
11492                "}",
11493                Spaces);
11494 
11495   Spaces.SpacesInParentheses = false;
11496   Spaces.SpacesInCStyleCastParentheses = true;
11497   verifyFormat("Type *A = ( Type * )P;", Spaces);
11498   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11499   verifyFormat("x = ( int32 )y;", Spaces);
11500   verifyFormat("int a = ( int )(2.0f);", Spaces);
11501   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11502   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11503   verifyFormat("#define x (( int )-1)", Spaces);
11504 
11505   // Run the first set of tests again with:
11506   Spaces.SpacesInParentheses = false;
11507   Spaces.SpaceInEmptyParentheses = true;
11508   Spaces.SpacesInCStyleCastParentheses = true;
11509   verifyFormat("call(x, y, z);", Spaces);
11510   verifyFormat("call( );", Spaces);
11511   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11512   verifyFormat("while (( bool )1)\n"
11513                "  continue;",
11514                Spaces);
11515   verifyFormat("for (;;)\n"
11516                "  continue;",
11517                Spaces);
11518   verifyFormat("if (true)\n"
11519                "  f( );\n"
11520                "else if (true)\n"
11521                "  f( );",
11522                Spaces);
11523   verifyFormat("do {\n"
11524                "  do_something(( int )i);\n"
11525                "} while (something( ));",
11526                Spaces);
11527   verifyFormat("switch (x) {\n"
11528                "default:\n"
11529                "  break;\n"
11530                "}",
11531                Spaces);
11532 
11533   // Run the first set of tests again with:
11534   Spaces.SpaceAfterCStyleCast = true;
11535   verifyFormat("call(x, y, z);", Spaces);
11536   verifyFormat("call( );", Spaces);
11537   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11538   verifyFormat("while (( bool ) 1)\n"
11539                "  continue;",
11540                Spaces);
11541   verifyFormat("for (;;)\n"
11542                "  continue;",
11543                Spaces);
11544   verifyFormat("if (true)\n"
11545                "  f( );\n"
11546                "else if (true)\n"
11547                "  f( );",
11548                Spaces);
11549   verifyFormat("do {\n"
11550                "  do_something(( int ) i);\n"
11551                "} while (something( ));",
11552                Spaces);
11553   verifyFormat("switch (x) {\n"
11554                "default:\n"
11555                "  break;\n"
11556                "}",
11557                Spaces);
11558 
11559   // Run subset of tests again with:
11560   Spaces.SpacesInCStyleCastParentheses = false;
11561   Spaces.SpaceAfterCStyleCast = true;
11562   verifyFormat("while ((bool) 1)\n"
11563                "  continue;",
11564                Spaces);
11565   verifyFormat("do {\n"
11566                "  do_something((int) i);\n"
11567                "} while (something( ));",
11568                Spaces);
11569 }
11570 
11571 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
11572   verifyFormat("int a[5];");
11573   verifyFormat("a[3] += 42;");
11574 
11575   FormatStyle Spaces = getLLVMStyle();
11576   Spaces.SpacesInSquareBrackets = true;
11577   // Not lambdas.
11578   verifyFormat("int a[ 5 ];", Spaces);
11579   verifyFormat("a[ 3 ] += 42;", Spaces);
11580   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
11581   verifyFormat("double &operator[](int i) { return 0; }\n"
11582                "int i;",
11583                Spaces);
11584   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
11585   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
11586   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
11587   // Lambdas.
11588   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
11589   verifyFormat("return [ i, args... ] {};", Spaces);
11590   verifyFormat("int foo = [ &bar ]() {};", Spaces);
11591   verifyFormat("int foo = [ = ]() {};", Spaces);
11592   verifyFormat("int foo = [ & ]() {};", Spaces);
11593   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
11594   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
11595 }
11596 
11597 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
11598   FormatStyle NoSpaceStyle = getLLVMStyle();
11599   verifyFormat("int a[5];", NoSpaceStyle);
11600   verifyFormat("a[3] += 42;", NoSpaceStyle);
11601 
11602   verifyFormat("int a[1];", NoSpaceStyle);
11603   verifyFormat("int 1 [a];", NoSpaceStyle);
11604   verifyFormat("int a[1][2];", NoSpaceStyle);
11605   verifyFormat("a[7] = 5;", NoSpaceStyle);
11606   verifyFormat("int a = (f())[23];", NoSpaceStyle);
11607   verifyFormat("f([] {})", NoSpaceStyle);
11608 
11609   FormatStyle Space = getLLVMStyle();
11610   Space.SpaceBeforeSquareBrackets = true;
11611   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
11612   verifyFormat("return [i, args...] {};", Space);
11613 
11614   verifyFormat("int a [5];", Space);
11615   verifyFormat("a [3] += 42;", Space);
11616   verifyFormat("constexpr char hello []{\"hello\"};", Space);
11617   verifyFormat("double &operator[](int i) { return 0; }\n"
11618                "int i;",
11619                Space);
11620   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
11621   verifyFormat("int i = a [a][a]->f();", Space);
11622   verifyFormat("int i = (*b) [a]->f();", Space);
11623 
11624   verifyFormat("int a [1];", Space);
11625   verifyFormat("int 1 [a];", Space);
11626   verifyFormat("int a [1][2];", Space);
11627   verifyFormat("a [7] = 5;", Space);
11628   verifyFormat("int a = (f()) [23];", Space);
11629   verifyFormat("f([] {})", Space);
11630 }
11631 
11632 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
11633   verifyFormat("int a = 5;");
11634   verifyFormat("a += 42;");
11635   verifyFormat("a or_eq 8;");
11636 
11637   FormatStyle Spaces = getLLVMStyle();
11638   Spaces.SpaceBeforeAssignmentOperators = false;
11639   verifyFormat("int a= 5;", Spaces);
11640   verifyFormat("a+= 42;", Spaces);
11641   verifyFormat("a or_eq 8;", Spaces);
11642 }
11643 
11644 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
11645   verifyFormat("class Foo : public Bar {};");
11646   verifyFormat("Foo::Foo() : foo(1) {}");
11647   verifyFormat("for (auto a : b) {\n}");
11648   verifyFormat("int x = a ? b : c;");
11649   verifyFormat("{\n"
11650                "label0:\n"
11651                "  int x = 0;\n"
11652                "}");
11653   verifyFormat("switch (x) {\n"
11654                "case 1:\n"
11655                "default:\n"
11656                "}");
11657 
11658   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
11659   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
11660   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
11661   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
11662   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
11663   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
11664   verifyFormat("{\n"
11665                "label1:\n"
11666                "  int x = 0;\n"
11667                "}",
11668                CtorInitializerStyle);
11669   verifyFormat("switch (x) {\n"
11670                "case 1:\n"
11671                "default:\n"
11672                "}",
11673                CtorInitializerStyle);
11674   CtorInitializerStyle.BreakConstructorInitializers =
11675       FormatStyle::BCIS_AfterColon;
11676   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
11677                "    aaaaaaaaaaaaaaaa(1),\n"
11678                "    bbbbbbbbbbbbbbbb(2) {}",
11679                CtorInitializerStyle);
11680   CtorInitializerStyle.BreakConstructorInitializers =
11681       FormatStyle::BCIS_BeforeComma;
11682   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11683                "    : aaaaaaaaaaaaaaaa(1)\n"
11684                "    , bbbbbbbbbbbbbbbb(2) {}",
11685                CtorInitializerStyle);
11686   CtorInitializerStyle.BreakConstructorInitializers =
11687       FormatStyle::BCIS_BeforeColon;
11688   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11689                "    : aaaaaaaaaaaaaaaa(1),\n"
11690                "      bbbbbbbbbbbbbbbb(2) {}",
11691                CtorInitializerStyle);
11692   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
11693   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11694                ": aaaaaaaaaaaaaaaa(1),\n"
11695                "  bbbbbbbbbbbbbbbb(2) {}",
11696                CtorInitializerStyle);
11697 
11698   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
11699   InheritanceStyle.SpaceBeforeInheritanceColon = false;
11700   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
11701   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
11702   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
11703   verifyFormat("int x = a ? b : c;", InheritanceStyle);
11704   verifyFormat("{\n"
11705                "label2:\n"
11706                "  int x = 0;\n"
11707                "}",
11708                InheritanceStyle);
11709   verifyFormat("switch (x) {\n"
11710                "case 1:\n"
11711                "default:\n"
11712                "}",
11713                InheritanceStyle);
11714   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
11715   verifyFormat("class Foooooooooooooooooooooo:\n"
11716                "    public aaaaaaaaaaaaaaaaaa,\n"
11717                "    public bbbbbbbbbbbbbbbbbb {\n"
11718                "}",
11719                InheritanceStyle);
11720   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
11721   verifyFormat("class Foooooooooooooooooooooo\n"
11722                "    : public aaaaaaaaaaaaaaaaaa\n"
11723                "    , public bbbbbbbbbbbbbbbbbb {\n"
11724                "}",
11725                InheritanceStyle);
11726   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
11727   verifyFormat("class Foooooooooooooooooooooo\n"
11728                "    : public aaaaaaaaaaaaaaaaaa,\n"
11729                "      public bbbbbbbbbbbbbbbbbb {\n"
11730                "}",
11731                InheritanceStyle);
11732   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
11733   verifyFormat("class Foooooooooooooooooooooo\n"
11734                ": public aaaaaaaaaaaaaaaaaa,\n"
11735                "  public bbbbbbbbbbbbbbbbbb {}",
11736                InheritanceStyle);
11737 
11738   FormatStyle ForLoopStyle = getLLVMStyle();
11739   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
11740   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
11741   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
11742   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
11743   verifyFormat("int x = a ? b : c;", ForLoopStyle);
11744   verifyFormat("{\n"
11745                "label2:\n"
11746                "  int x = 0;\n"
11747                "}",
11748                ForLoopStyle);
11749   verifyFormat("switch (x) {\n"
11750                "case 1:\n"
11751                "default:\n"
11752                "}",
11753                ForLoopStyle);
11754 
11755   FormatStyle NoSpaceStyle = getLLVMStyle();
11756   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
11757   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
11758   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
11759   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
11760   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
11761   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
11762   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
11763   verifyFormat("{\n"
11764                "label3:\n"
11765                "  int x = 0;\n"
11766                "}",
11767                NoSpaceStyle);
11768   verifyFormat("switch (x) {\n"
11769                "case 1:\n"
11770                "default:\n"
11771                "}",
11772                NoSpaceStyle);
11773 }
11774 
11775 TEST_F(FormatTest, AlignConsecutiveMacros) {
11776   FormatStyle Style = getLLVMStyle();
11777   Style.AlignConsecutiveAssignments = true;
11778   Style.AlignConsecutiveDeclarations = true;
11779   Style.AlignConsecutiveMacros = false;
11780 
11781   verifyFormat("#define a 3\n"
11782                "#define bbbb 4\n"
11783                "#define ccc (5)",
11784                Style);
11785 
11786   verifyFormat("#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   verifyFormat("#define foo(x, y) (x + y)\n"
11792                "#define bar (5, 6)(2 + 2)",
11793                Style);
11794 
11795   verifyFormat("#define a 3\n"
11796                "#define bbbb 4\n"
11797                "#define ccc (5)\n"
11798                "#define f(x) (x * x)\n"
11799                "#define fff(x, y, z) (x * y + z)\n"
11800                "#define ffff(x, y) (x - y)",
11801                Style);
11802 
11803   Style.AlignConsecutiveMacros = true;
11804   verifyFormat("#define a    3\n"
11805                "#define bbbb 4\n"
11806                "#define ccc  (5)",
11807                Style);
11808 
11809   verifyFormat("#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 foo(x, y) (x + y)\n"
11815                "#define bar       (5, 6)(2 + 2)",
11816                Style);
11817 
11818   verifyFormat("#define a            3\n"
11819                "#define bbbb         4\n"
11820                "#define ccc          (5)\n"
11821                "#define f(x)         (x * x)\n"
11822                "#define fff(x, y, z) (x * y + z)\n"
11823                "#define ffff(x, y)   (x - y)",
11824                Style);
11825 
11826   verifyFormat("#define a         5\n"
11827                "#define foo(x, y) (x + y)\n"
11828                "#define CCC       (6)\n"
11829                "auto lambda = []() {\n"
11830                "  auto  ii = 0;\n"
11831                "  float j  = 0;\n"
11832                "  return 0;\n"
11833                "};\n"
11834                "int   i  = 0;\n"
11835                "float i2 = 0;\n"
11836                "auto  v  = type{\n"
11837                "    i = 1,   //\n"
11838                "    (i = 2), //\n"
11839                "    i = 3    //\n"
11840                "};",
11841                Style);
11842 
11843   Style.AlignConsecutiveMacros = false;
11844   Style.ColumnLimit = 20;
11845 
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   Style.AlignConsecutiveMacros = true;
11858   verifyFormat("#define a          \\\n"
11859                "  \"aabbbbbbbbbbbb\"\n"
11860                "#define D          \\\n"
11861                "  \"aabbbbbbbbbbbb\" \\\n"
11862                "  \"ccddeeeeeeeee\"\n"
11863                "#define B          \\\n"
11864                "  \"QQQQQQQQQQQQQ\"  \\\n"
11865                "  \"FFFFFFFFFFFFF\"  \\\n"
11866                "  \"LLLLLLLL\"\n",
11867                Style);
11868 }
11869 
11870 TEST_F(FormatTest, AlignConsecutiveAssignments) {
11871   FormatStyle Alignment = getLLVMStyle();
11872   Alignment.AlignConsecutiveMacros = true;
11873   Alignment.AlignConsecutiveAssignments = false;
11874   verifyFormat("int a = 5;\n"
11875                "int oneTwoThree = 123;",
11876                Alignment);
11877   verifyFormat("int a = 5;\n"
11878                "int oneTwoThree = 123;",
11879                Alignment);
11880 
11881   Alignment.AlignConsecutiveAssignments = true;
11882   verifyFormat("int a           = 5;\n"
11883                "int oneTwoThree = 123;",
11884                Alignment);
11885   verifyFormat("int a           = method();\n"
11886                "int oneTwoThree = 133;",
11887                Alignment);
11888   verifyFormat("a &= 5;\n"
11889                "bcd *= 5;\n"
11890                "ghtyf += 5;\n"
11891                "dvfvdb -= 5;\n"
11892                "a /= 5;\n"
11893                "vdsvsv %= 5;\n"
11894                "sfdbddfbdfbb ^= 5;\n"
11895                "dvsdsv |= 5;\n"
11896                "int dsvvdvsdvvv = 123;",
11897                Alignment);
11898   verifyFormat("int i = 1, j = 10;\n"
11899                "something = 2000;",
11900                Alignment);
11901   verifyFormat("something = 2000;\n"
11902                "int i = 1, j = 10;\n",
11903                Alignment);
11904   verifyFormat("something = 2000;\n"
11905                "another   = 911;\n"
11906                "int i = 1, j = 10;\n"
11907                "oneMore = 1;\n"
11908                "i       = 2;",
11909                Alignment);
11910   verifyFormat("int a   = 5;\n"
11911                "int one = 1;\n"
11912                "method();\n"
11913                "int oneTwoThree = 123;\n"
11914                "int oneTwo      = 12;",
11915                Alignment);
11916   verifyFormat("int oneTwoThree = 123;\n"
11917                "int oneTwo      = 12;\n"
11918                "method();\n",
11919                Alignment);
11920   verifyFormat("int oneTwoThree = 123; // comment\n"
11921                "int oneTwo      = 12;  // comment",
11922                Alignment);
11923 
11924   // Bug 25167
11925   verifyFormat("#if A\n"
11926                "#else\n"
11927                "int aaaaaaaa = 12;\n"
11928                "#endif\n"
11929                "#if B\n"
11930                "#else\n"
11931                "int a = 12;\n"
11932                "#endif\n",
11933                Alignment);
11934   verifyFormat("enum foo {\n"
11935                "#if A\n"
11936                "#else\n"
11937                "  aaaaaaaa = 12;\n"
11938                "#endif\n"
11939                "#if B\n"
11940                "#else\n"
11941                "  a = 12;\n"
11942                "#endif\n"
11943                "};\n",
11944                Alignment);
11945 
11946   EXPECT_EQ("int a = 5;\n"
11947             "\n"
11948             "int oneTwoThree = 123;",
11949             format("int a       = 5;\n"
11950                    "\n"
11951                    "int oneTwoThree= 123;",
11952                    Alignment));
11953   EXPECT_EQ("int a   = 5;\n"
11954             "int one = 1;\n"
11955             "\n"
11956             "int oneTwoThree = 123;",
11957             format("int a = 5;\n"
11958                    "int one = 1;\n"
11959                    "\n"
11960                    "int oneTwoThree = 123;",
11961                    Alignment));
11962   EXPECT_EQ("int a   = 5;\n"
11963             "int one = 1;\n"
11964             "\n"
11965             "int oneTwoThree = 123;\n"
11966             "int oneTwo      = 12;",
11967             format("int a = 5;\n"
11968                    "int one = 1;\n"
11969                    "\n"
11970                    "int oneTwoThree = 123;\n"
11971                    "int oneTwo = 12;",
11972                    Alignment));
11973   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
11974   verifyFormat("#define A \\\n"
11975                "  int aaaa       = 12; \\\n"
11976                "  int b          = 23; \\\n"
11977                "  int ccc        = 234; \\\n"
11978                "  int dddddddddd = 2345;",
11979                Alignment);
11980   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
11981   verifyFormat("#define A               \\\n"
11982                "  int aaaa       = 12;  \\\n"
11983                "  int b          = 23;  \\\n"
11984                "  int ccc        = 234; \\\n"
11985                "  int dddddddddd = 2345;",
11986                Alignment);
11987   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
11988   verifyFormat("#define A                                                      "
11989                "                \\\n"
11990                "  int aaaa       = 12;                                         "
11991                "                \\\n"
11992                "  int b          = 23;                                         "
11993                "                \\\n"
11994                "  int ccc        = 234;                                        "
11995                "                \\\n"
11996                "  int dddddddddd = 2345;",
11997                Alignment);
11998   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
11999                "k = 4, int l = 5,\n"
12000                "                  int m = 6) {\n"
12001                "  int j      = 10;\n"
12002                "  otherThing = 1;\n"
12003                "}",
12004                Alignment);
12005   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12006                "  int i   = 1;\n"
12007                "  int j   = 2;\n"
12008                "  int big = 10000;\n"
12009                "}",
12010                Alignment);
12011   verifyFormat("class C {\n"
12012                "public:\n"
12013                "  int i            = 1;\n"
12014                "  virtual void f() = 0;\n"
12015                "};",
12016                Alignment);
12017   verifyFormat("int i = 1;\n"
12018                "if (SomeType t = getSomething()) {\n"
12019                "}\n"
12020                "int j   = 2;\n"
12021                "int big = 10000;",
12022                Alignment);
12023   verifyFormat("int j = 7;\n"
12024                "for (int k = 0; k < N; ++k) {\n"
12025                "}\n"
12026                "int j   = 2;\n"
12027                "int big = 10000;\n"
12028                "}",
12029                Alignment);
12030   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12031   verifyFormat("int i = 1;\n"
12032                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12033                "    = someLooooooooooooooooongFunction();\n"
12034                "int j = 2;",
12035                Alignment);
12036   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12037   verifyFormat("int i = 1;\n"
12038                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12039                "    someLooooooooooooooooongFunction();\n"
12040                "int j = 2;",
12041                Alignment);
12042 
12043   verifyFormat("auto lambda = []() {\n"
12044                "  auto i = 0;\n"
12045                "  return 0;\n"
12046                "};\n"
12047                "int i  = 0;\n"
12048                "auto v = type{\n"
12049                "    i = 1,   //\n"
12050                "    (i = 2), //\n"
12051                "    i = 3    //\n"
12052                "};",
12053                Alignment);
12054 
12055   verifyFormat(
12056       "int i      = 1;\n"
12057       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12058       "                          loooooooooooooooooooooongParameterB);\n"
12059       "int j      = 2;",
12060       Alignment);
12061 
12062   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12063                "          typename B   = very_long_type_name_1,\n"
12064                "          typename T_2 = very_long_type_name_2>\n"
12065                "auto foo() {}\n",
12066                Alignment);
12067   verifyFormat("int a, b = 1;\n"
12068                "int c  = 2;\n"
12069                "int dd = 3;\n",
12070                Alignment);
12071   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12072                "float b[1][] = {{3.f}};\n",
12073                Alignment);
12074   verifyFormat("for (int i = 0; i < 1; i++)\n"
12075                "  int x = 1;\n",
12076                Alignment);
12077   verifyFormat("for (i = 0; i < 1; i++)\n"
12078                "  x = 1;\n"
12079                "y = 1;\n",
12080                Alignment);
12081 
12082   Alignment.ReflowComments = true;
12083   Alignment.ColumnLimit = 50;
12084   EXPECT_EQ("int x   = 0;\n"
12085             "int yy  = 1; /// specificlennospace\n"
12086             "int zzz = 2;\n",
12087             format("int x   = 0;\n"
12088                    "int yy  = 1; ///specificlennospace\n"
12089                    "int zzz = 2;\n",
12090                    Alignment));
12091 }
12092 
12093 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12094   FormatStyle Alignment = getLLVMStyle();
12095   Alignment.AlignConsecutiveBitFields = true;
12096   verifyFormat("int const a     : 5;\n"
12097                "int oneTwoThree : 23;",
12098                Alignment);
12099 
12100   // Initializers are allowed starting with c++2a
12101   verifyFormat("int const a     : 5 = 1;\n"
12102                "int oneTwoThree : 23 = 0;",
12103                Alignment);
12104 
12105   Alignment.AlignConsecutiveDeclarations = true;
12106   verifyFormat("int const a           : 5;\n"
12107                "int       oneTwoThree : 23;",
12108                Alignment);
12109 
12110   verifyFormat("int const a           : 5;  // comment\n"
12111                "int       oneTwoThree : 23; // comment",
12112                Alignment);
12113 
12114   verifyFormat("int const a           : 5 = 1;\n"
12115                "int       oneTwoThree : 23 = 0;",
12116                Alignment);
12117 
12118   Alignment.AlignConsecutiveAssignments = true;
12119   verifyFormat("int const a           : 5  = 1;\n"
12120                "int       oneTwoThree : 23 = 0;",
12121                Alignment);
12122   verifyFormat("int const a           : 5  = {1};\n"
12123                "int       oneTwoThree : 23 = 0;",
12124                Alignment);
12125 
12126   // Known limitations: ':' is only recognized as a bitfield colon when
12127   // followed by a number.
12128   /*
12129   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12130                "int a           : 5;",
12131                Alignment);
12132   */
12133 }
12134 
12135 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12136   FormatStyle Alignment = getLLVMStyle();
12137   Alignment.AlignConsecutiveMacros = true;
12138   Alignment.AlignConsecutiveDeclarations = false;
12139   verifyFormat("float const a = 5;\n"
12140                "int oneTwoThree = 123;",
12141                Alignment);
12142   verifyFormat("int a = 5;\n"
12143                "float const oneTwoThree = 123;",
12144                Alignment);
12145 
12146   Alignment.AlignConsecutiveDeclarations = true;
12147   verifyFormat("float const a = 5;\n"
12148                "int         oneTwoThree = 123;",
12149                Alignment);
12150   verifyFormat("int         a = method();\n"
12151                "float const oneTwoThree = 133;",
12152                Alignment);
12153   verifyFormat("int i = 1, j = 10;\n"
12154                "something = 2000;",
12155                Alignment);
12156   verifyFormat("something = 2000;\n"
12157                "int i = 1, j = 10;\n",
12158                Alignment);
12159   verifyFormat("float      something = 2000;\n"
12160                "double     another = 911;\n"
12161                "int        i = 1, j = 10;\n"
12162                "const int *oneMore = 1;\n"
12163                "unsigned   i = 2;",
12164                Alignment);
12165   verifyFormat("float a = 5;\n"
12166                "int   one = 1;\n"
12167                "method();\n"
12168                "const double       oneTwoThree = 123;\n"
12169                "const unsigned int oneTwo = 12;",
12170                Alignment);
12171   verifyFormat("int      oneTwoThree{0}; // comment\n"
12172                "unsigned oneTwo;         // comment",
12173                Alignment);
12174   EXPECT_EQ("float const a = 5;\n"
12175             "\n"
12176             "int oneTwoThree = 123;",
12177             format("float const   a = 5;\n"
12178                    "\n"
12179                    "int           oneTwoThree= 123;",
12180                    Alignment));
12181   EXPECT_EQ("float a = 5;\n"
12182             "int   one = 1;\n"
12183             "\n"
12184             "unsigned oneTwoThree = 123;",
12185             format("float    a = 5;\n"
12186                    "int      one = 1;\n"
12187                    "\n"
12188                    "unsigned oneTwoThree = 123;",
12189                    Alignment));
12190   EXPECT_EQ("float a = 5;\n"
12191             "int   one = 1;\n"
12192             "\n"
12193             "unsigned oneTwoThree = 123;\n"
12194             "int      oneTwo = 12;",
12195             format("float    a = 5;\n"
12196                    "int one = 1;\n"
12197                    "\n"
12198                    "unsigned oneTwoThree = 123;\n"
12199                    "int oneTwo = 12;",
12200                    Alignment));
12201   // Function prototype alignment
12202   verifyFormat("int    a();\n"
12203                "double b();",
12204                Alignment);
12205   verifyFormat("int    a(int x);\n"
12206                "double b();",
12207                Alignment);
12208   unsigned OldColumnLimit = Alignment.ColumnLimit;
12209   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12210   // otherwise the function parameters will be re-flowed onto a single line.
12211   Alignment.ColumnLimit = 0;
12212   EXPECT_EQ("int    a(int   x,\n"
12213             "         float y);\n"
12214             "double b(int    x,\n"
12215             "         double y);",
12216             format("int a(int x,\n"
12217                    " float y);\n"
12218                    "double b(int x,\n"
12219                    " double y);",
12220                    Alignment));
12221   // This ensures that function parameters of function declarations are
12222   // correctly indented when their owning functions are indented.
12223   // The failure case here is for 'double y' to not be indented enough.
12224   EXPECT_EQ("double a(int x);\n"
12225             "int    b(int    y,\n"
12226             "         double z);",
12227             format("double a(int x);\n"
12228                    "int b(int y,\n"
12229                    " double z);",
12230                    Alignment));
12231   // Set ColumnLimit low so that we induce wrapping immediately after
12232   // the function name and opening paren.
12233   Alignment.ColumnLimit = 13;
12234   verifyFormat("int function(\n"
12235                "    int  x,\n"
12236                "    bool y);",
12237                Alignment);
12238   Alignment.ColumnLimit = OldColumnLimit;
12239   // Ensure function pointers don't screw up recursive alignment
12240   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12241                "double b();",
12242                Alignment);
12243   Alignment.AlignConsecutiveAssignments = true;
12244   // Ensure recursive alignment is broken by function braces, so that the
12245   // "a = 1" does not align with subsequent assignments inside the function
12246   // body.
12247   verifyFormat("int func(int a = 1) {\n"
12248                "  int b  = 2;\n"
12249                "  int cc = 3;\n"
12250                "}",
12251                Alignment);
12252   verifyFormat("float      something = 2000;\n"
12253                "double     another   = 911;\n"
12254                "int        i = 1, j = 10;\n"
12255                "const int *oneMore = 1;\n"
12256                "unsigned   i       = 2;",
12257                Alignment);
12258   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12259                "unsigned oneTwo      = 0;   // comment",
12260                Alignment);
12261   // Make sure that scope is correctly tracked, in the absence of braces
12262   verifyFormat("for (int i = 0; i < n; i++)\n"
12263                "  j = i;\n"
12264                "double x = 1;\n",
12265                Alignment);
12266   verifyFormat("if (int i = 0)\n"
12267                "  j = i;\n"
12268                "double x = 1;\n",
12269                Alignment);
12270   // Ensure operator[] and operator() are comprehended
12271   verifyFormat("struct test {\n"
12272                "  long long int foo();\n"
12273                "  int           operator[](int a);\n"
12274                "  double        bar();\n"
12275                "};\n",
12276                Alignment);
12277   verifyFormat("struct test {\n"
12278                "  long long int foo();\n"
12279                "  int           operator()(int a);\n"
12280                "  double        bar();\n"
12281                "};\n",
12282                Alignment);
12283   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12284             "  int const i   = 1;\n"
12285             "  int *     j   = 2;\n"
12286             "  int       big = 10000;\n"
12287             "\n"
12288             "  unsigned oneTwoThree = 123;\n"
12289             "  int      oneTwo      = 12;\n"
12290             "  method();\n"
12291             "  float k  = 2;\n"
12292             "  int   ll = 10000;\n"
12293             "}",
12294             format("void SomeFunction(int parameter= 0) {\n"
12295                    " int const  i= 1;\n"
12296                    "  int *j=2;\n"
12297                    " int big  =  10000;\n"
12298                    "\n"
12299                    "unsigned oneTwoThree  =123;\n"
12300                    "int oneTwo = 12;\n"
12301                    "  method();\n"
12302                    "float k= 2;\n"
12303                    "int ll=10000;\n"
12304                    "}",
12305                    Alignment));
12306   Alignment.AlignConsecutiveAssignments = false;
12307   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12308   verifyFormat("#define A \\\n"
12309                "  int       aaaa = 12; \\\n"
12310                "  float     b = 23; \\\n"
12311                "  const int ccc = 234; \\\n"
12312                "  unsigned  dddddddddd = 2345;",
12313                Alignment);
12314   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12315   verifyFormat("#define A              \\\n"
12316                "  int       aaaa = 12; \\\n"
12317                "  float     b = 23;    \\\n"
12318                "  const int ccc = 234; \\\n"
12319                "  unsigned  dddddddddd = 2345;",
12320                Alignment);
12321   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12322   Alignment.ColumnLimit = 30;
12323   verifyFormat("#define A                    \\\n"
12324                "  int       aaaa = 12;       \\\n"
12325                "  float     b = 23;          \\\n"
12326                "  const int ccc = 234;       \\\n"
12327                "  int       dddddddddd = 2345;",
12328                Alignment);
12329   Alignment.ColumnLimit = 80;
12330   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12331                "k = 4, int l = 5,\n"
12332                "                  int m = 6) {\n"
12333                "  const int j = 10;\n"
12334                "  otherThing = 1;\n"
12335                "}",
12336                Alignment);
12337   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12338                "  int const i = 1;\n"
12339                "  int *     j = 2;\n"
12340                "  int       big = 10000;\n"
12341                "}",
12342                Alignment);
12343   verifyFormat("class C {\n"
12344                "public:\n"
12345                "  int          i = 1;\n"
12346                "  virtual void f() = 0;\n"
12347                "};",
12348                Alignment);
12349   verifyFormat("float i = 1;\n"
12350                "if (SomeType t = getSomething()) {\n"
12351                "}\n"
12352                "const unsigned j = 2;\n"
12353                "int            big = 10000;",
12354                Alignment);
12355   verifyFormat("float j = 7;\n"
12356                "for (int k = 0; k < N; ++k) {\n"
12357                "}\n"
12358                "unsigned j = 2;\n"
12359                "int      big = 10000;\n"
12360                "}",
12361                Alignment);
12362   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12363   verifyFormat("float              i = 1;\n"
12364                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12365                "    = someLooooooooooooooooongFunction();\n"
12366                "int j = 2;",
12367                Alignment);
12368   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12369   verifyFormat("int                i = 1;\n"
12370                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12371                "    someLooooooooooooooooongFunction();\n"
12372                "int j = 2;",
12373                Alignment);
12374 
12375   Alignment.AlignConsecutiveAssignments = true;
12376   verifyFormat("auto lambda = []() {\n"
12377                "  auto  ii = 0;\n"
12378                "  float j  = 0;\n"
12379                "  return 0;\n"
12380                "};\n"
12381                "int   i  = 0;\n"
12382                "float i2 = 0;\n"
12383                "auto  v  = type{\n"
12384                "    i = 1,   //\n"
12385                "    (i = 2), //\n"
12386                "    i = 3    //\n"
12387                "};",
12388                Alignment);
12389   Alignment.AlignConsecutiveAssignments = false;
12390 
12391   verifyFormat(
12392       "int      i = 1;\n"
12393       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12394       "                          loooooooooooooooooooooongParameterB);\n"
12395       "int      j = 2;",
12396       Alignment);
12397 
12398   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12399   // We expect declarations and assignments to align, as long as it doesn't
12400   // exceed the column limit, starting a new alignment sequence whenever it
12401   // happens.
12402   Alignment.AlignConsecutiveAssignments = true;
12403   Alignment.ColumnLimit = 30;
12404   verifyFormat("float    ii              = 1;\n"
12405                "unsigned j               = 2;\n"
12406                "int someVerylongVariable = 1;\n"
12407                "AnotherLongType  ll = 123456;\n"
12408                "VeryVeryLongType k  = 2;\n"
12409                "int              myvar = 1;",
12410                Alignment);
12411   Alignment.ColumnLimit = 80;
12412   Alignment.AlignConsecutiveAssignments = false;
12413 
12414   verifyFormat(
12415       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12416       "          typename LongType, typename B>\n"
12417       "auto foo() {}\n",
12418       Alignment);
12419   verifyFormat("float a, b = 1;\n"
12420                "int   c = 2;\n"
12421                "int   dd = 3;\n",
12422                Alignment);
12423   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12424                "float b[1][] = {{3.f}};\n",
12425                Alignment);
12426   Alignment.AlignConsecutiveAssignments = true;
12427   verifyFormat("float a, b = 1;\n"
12428                "int   c  = 2;\n"
12429                "int   dd = 3;\n",
12430                Alignment);
12431   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12432                "float b[1][] = {{3.f}};\n",
12433                Alignment);
12434   Alignment.AlignConsecutiveAssignments = false;
12435 
12436   Alignment.ColumnLimit = 30;
12437   Alignment.BinPackParameters = false;
12438   verifyFormat("void foo(float     a,\n"
12439                "         float     b,\n"
12440                "         int       c,\n"
12441                "         uint32_t *d) {\n"
12442                "  int *  e = 0;\n"
12443                "  float  f = 0;\n"
12444                "  double g = 0;\n"
12445                "}\n"
12446                "void bar(ino_t     a,\n"
12447                "         int       b,\n"
12448                "         uint32_t *c,\n"
12449                "         bool      d) {}\n",
12450                Alignment);
12451   Alignment.BinPackParameters = true;
12452   Alignment.ColumnLimit = 80;
12453 
12454   // Bug 33507
12455   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12456   verifyFormat(
12457       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12458       "  static const Version verVs2017;\n"
12459       "  return true;\n"
12460       "});\n",
12461       Alignment);
12462   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12463 
12464   // See llvm.org/PR35641
12465   Alignment.AlignConsecutiveDeclarations = true;
12466   verifyFormat("int func() { //\n"
12467                "  int      b;\n"
12468                "  unsigned c;\n"
12469                "}",
12470                Alignment);
12471 
12472   // See PR37175
12473   FormatStyle Style = getMozillaStyle();
12474   Style.AlignConsecutiveDeclarations = true;
12475   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12476             "foo(int a);",
12477             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12478 }
12479 
12480 TEST_F(FormatTest, LinuxBraceBreaking) {
12481   FormatStyle LinuxBraceStyle = getLLVMStyle();
12482   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12483   verifyFormat("namespace a\n"
12484                "{\n"
12485                "class A\n"
12486                "{\n"
12487                "  void f()\n"
12488                "  {\n"
12489                "    if (true) {\n"
12490                "      a();\n"
12491                "      b();\n"
12492                "    } else {\n"
12493                "      a();\n"
12494                "    }\n"
12495                "  }\n"
12496                "  void g() { return; }\n"
12497                "};\n"
12498                "struct B {\n"
12499                "  int x;\n"
12500                "};\n"
12501                "} // namespace a\n",
12502                LinuxBraceStyle);
12503   verifyFormat("enum X {\n"
12504                "  Y = 0,\n"
12505                "}\n",
12506                LinuxBraceStyle);
12507   verifyFormat("struct S {\n"
12508                "  int Type;\n"
12509                "  union {\n"
12510                "    int x;\n"
12511                "    double y;\n"
12512                "  } Value;\n"
12513                "  class C\n"
12514                "  {\n"
12515                "    MyFavoriteType Value;\n"
12516                "  } Class;\n"
12517                "}\n",
12518                LinuxBraceStyle);
12519 }
12520 
12521 TEST_F(FormatTest, MozillaBraceBreaking) {
12522   FormatStyle MozillaBraceStyle = getLLVMStyle();
12523   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
12524   MozillaBraceStyle.FixNamespaceComments = false;
12525   verifyFormat("namespace a {\n"
12526                "class A\n"
12527                "{\n"
12528                "  void f()\n"
12529                "  {\n"
12530                "    if (true) {\n"
12531                "      a();\n"
12532                "      b();\n"
12533                "    }\n"
12534                "  }\n"
12535                "  void g() { return; }\n"
12536                "};\n"
12537                "enum E\n"
12538                "{\n"
12539                "  A,\n"
12540                "  // foo\n"
12541                "  B,\n"
12542                "  C\n"
12543                "};\n"
12544                "struct B\n"
12545                "{\n"
12546                "  int x;\n"
12547                "};\n"
12548                "}\n",
12549                MozillaBraceStyle);
12550   verifyFormat("struct S\n"
12551                "{\n"
12552                "  int Type;\n"
12553                "  union\n"
12554                "  {\n"
12555                "    int x;\n"
12556                "    double y;\n"
12557                "  } Value;\n"
12558                "  class C\n"
12559                "  {\n"
12560                "    MyFavoriteType Value;\n"
12561                "  } Class;\n"
12562                "}\n",
12563                MozillaBraceStyle);
12564 }
12565 
12566 TEST_F(FormatTest, StroustrupBraceBreaking) {
12567   FormatStyle StroustrupBraceStyle = getLLVMStyle();
12568   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12569   verifyFormat("namespace a {\n"
12570                "class A {\n"
12571                "  void f()\n"
12572                "  {\n"
12573                "    if (true) {\n"
12574                "      a();\n"
12575                "      b();\n"
12576                "    }\n"
12577                "  }\n"
12578                "  void g() { return; }\n"
12579                "};\n"
12580                "struct B {\n"
12581                "  int x;\n"
12582                "};\n"
12583                "} // namespace a\n",
12584                StroustrupBraceStyle);
12585 
12586   verifyFormat("void foo()\n"
12587                "{\n"
12588                "  if (a) {\n"
12589                "    a();\n"
12590                "  }\n"
12591                "  else {\n"
12592                "    b();\n"
12593                "  }\n"
12594                "}\n",
12595                StroustrupBraceStyle);
12596 
12597   verifyFormat("#ifdef _DEBUG\n"
12598                "int foo(int i = 0)\n"
12599                "#else\n"
12600                "int foo(int i = 5)\n"
12601                "#endif\n"
12602                "{\n"
12603                "  return i;\n"
12604                "}",
12605                StroustrupBraceStyle);
12606 
12607   verifyFormat("void foo() {}\n"
12608                "void bar()\n"
12609                "#ifdef _DEBUG\n"
12610                "{\n"
12611                "  foo();\n"
12612                "}\n"
12613                "#else\n"
12614                "{\n"
12615                "}\n"
12616                "#endif",
12617                StroustrupBraceStyle);
12618 
12619   verifyFormat("void foobar() { int i = 5; }\n"
12620                "#ifdef _DEBUG\n"
12621                "void bar() {}\n"
12622                "#else\n"
12623                "void bar() { foobar(); }\n"
12624                "#endif",
12625                StroustrupBraceStyle);
12626 }
12627 
12628 TEST_F(FormatTest, AllmanBraceBreaking) {
12629   FormatStyle AllmanBraceStyle = getLLVMStyle();
12630   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
12631 
12632   EXPECT_EQ("namespace a\n"
12633             "{\n"
12634             "void f();\n"
12635             "void g();\n"
12636             "} // namespace a\n",
12637             format("namespace a\n"
12638                    "{\n"
12639                    "void f();\n"
12640                    "void g();\n"
12641                    "}\n",
12642                    AllmanBraceStyle));
12643 
12644   verifyFormat("namespace a\n"
12645                "{\n"
12646                "class A\n"
12647                "{\n"
12648                "  void f()\n"
12649                "  {\n"
12650                "    if (true)\n"
12651                "    {\n"
12652                "      a();\n"
12653                "      b();\n"
12654                "    }\n"
12655                "  }\n"
12656                "  void g() { return; }\n"
12657                "};\n"
12658                "struct B\n"
12659                "{\n"
12660                "  int x;\n"
12661                "};\n"
12662                "union C\n"
12663                "{\n"
12664                "};\n"
12665                "} // namespace a",
12666                AllmanBraceStyle);
12667 
12668   verifyFormat("void f()\n"
12669                "{\n"
12670                "  if (true)\n"
12671                "  {\n"
12672                "    a();\n"
12673                "  }\n"
12674                "  else if (false)\n"
12675                "  {\n"
12676                "    b();\n"
12677                "  }\n"
12678                "  else\n"
12679                "  {\n"
12680                "    c();\n"
12681                "  }\n"
12682                "}\n",
12683                AllmanBraceStyle);
12684 
12685   verifyFormat("void f()\n"
12686                "{\n"
12687                "  for (int i = 0; i < 10; ++i)\n"
12688                "  {\n"
12689                "    a();\n"
12690                "  }\n"
12691                "  while (false)\n"
12692                "  {\n"
12693                "    b();\n"
12694                "  }\n"
12695                "  do\n"
12696                "  {\n"
12697                "    c();\n"
12698                "  } while (false)\n"
12699                "}\n",
12700                AllmanBraceStyle);
12701 
12702   verifyFormat("void f(int a)\n"
12703                "{\n"
12704                "  switch (a)\n"
12705                "  {\n"
12706                "  case 0:\n"
12707                "    break;\n"
12708                "  case 1:\n"
12709                "  {\n"
12710                "    break;\n"
12711                "  }\n"
12712                "  case 2:\n"
12713                "  {\n"
12714                "  }\n"
12715                "  break;\n"
12716                "  default:\n"
12717                "    break;\n"
12718                "  }\n"
12719                "}\n",
12720                AllmanBraceStyle);
12721 
12722   verifyFormat("enum X\n"
12723                "{\n"
12724                "  Y = 0,\n"
12725                "}\n",
12726                AllmanBraceStyle);
12727   verifyFormat("enum X\n"
12728                "{\n"
12729                "  Y = 0\n"
12730                "}\n",
12731                AllmanBraceStyle);
12732 
12733   verifyFormat("@interface BSApplicationController ()\n"
12734                "{\n"
12735                "@private\n"
12736                "  id _extraIvar;\n"
12737                "}\n"
12738                "@end\n",
12739                AllmanBraceStyle);
12740 
12741   verifyFormat("#ifdef _DEBUG\n"
12742                "int foo(int i = 0)\n"
12743                "#else\n"
12744                "int foo(int i = 5)\n"
12745                "#endif\n"
12746                "{\n"
12747                "  return i;\n"
12748                "}",
12749                AllmanBraceStyle);
12750 
12751   verifyFormat("void foo() {}\n"
12752                "void bar()\n"
12753                "#ifdef _DEBUG\n"
12754                "{\n"
12755                "  foo();\n"
12756                "}\n"
12757                "#else\n"
12758                "{\n"
12759                "}\n"
12760                "#endif",
12761                AllmanBraceStyle);
12762 
12763   verifyFormat("void foobar() { int i = 5; }\n"
12764                "#ifdef _DEBUG\n"
12765                "void bar() {}\n"
12766                "#else\n"
12767                "void bar() { foobar(); }\n"
12768                "#endif",
12769                AllmanBraceStyle);
12770 
12771   // This shouldn't affect ObjC blocks..
12772   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
12773                "  // ...\n"
12774                "  int i;\n"
12775                "}];",
12776                AllmanBraceStyle);
12777   verifyFormat("void (^block)(void) = ^{\n"
12778                "  // ...\n"
12779                "  int i;\n"
12780                "};",
12781                AllmanBraceStyle);
12782   // .. or dict literals.
12783   verifyFormat("void f()\n"
12784                "{\n"
12785                "  // ...\n"
12786                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
12787                "}",
12788                AllmanBraceStyle);
12789   verifyFormat("void f()\n"
12790                "{\n"
12791                "  // ...\n"
12792                "  [object someMethod:@{a : @\"b\"}];\n"
12793                "}",
12794                AllmanBraceStyle);
12795   verifyFormat("int f()\n"
12796                "{ // comment\n"
12797                "  return 42;\n"
12798                "}",
12799                AllmanBraceStyle);
12800 
12801   AllmanBraceStyle.ColumnLimit = 19;
12802   verifyFormat("void f() { int i; }", AllmanBraceStyle);
12803   AllmanBraceStyle.ColumnLimit = 18;
12804   verifyFormat("void f()\n"
12805                "{\n"
12806                "  int i;\n"
12807                "}",
12808                AllmanBraceStyle);
12809   AllmanBraceStyle.ColumnLimit = 80;
12810 
12811   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
12812   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
12813       FormatStyle::SIS_WithoutElse;
12814   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
12815   verifyFormat("void f(bool b)\n"
12816                "{\n"
12817                "  if (b)\n"
12818                "  {\n"
12819                "    return;\n"
12820                "  }\n"
12821                "}\n",
12822                BreakBeforeBraceShortIfs);
12823   verifyFormat("void f(bool b)\n"
12824                "{\n"
12825                "  if constexpr (b)\n"
12826                "  {\n"
12827                "    return;\n"
12828                "  }\n"
12829                "}\n",
12830                BreakBeforeBraceShortIfs);
12831   verifyFormat("void f(bool b)\n"
12832                "{\n"
12833                "  if CONSTEXPR (b)\n"
12834                "  {\n"
12835                "    return;\n"
12836                "  }\n"
12837                "}\n",
12838                BreakBeforeBraceShortIfs);
12839   verifyFormat("void f(bool b)\n"
12840                "{\n"
12841                "  if (b) return;\n"
12842                "}\n",
12843                BreakBeforeBraceShortIfs);
12844   verifyFormat("void f(bool b)\n"
12845                "{\n"
12846                "  if constexpr (b) return;\n"
12847                "}\n",
12848                BreakBeforeBraceShortIfs);
12849   verifyFormat("void f(bool b)\n"
12850                "{\n"
12851                "  if CONSTEXPR (b) return;\n"
12852                "}\n",
12853                BreakBeforeBraceShortIfs);
12854   verifyFormat("void f(bool b)\n"
12855                "{\n"
12856                "  while (b)\n"
12857                "  {\n"
12858                "    return;\n"
12859                "  }\n"
12860                "}\n",
12861                BreakBeforeBraceShortIfs);
12862 }
12863 
12864 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
12865   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
12866   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
12867 
12868   // Make a few changes to the style for testing purposes
12869   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
12870       FormatStyle::SFS_Empty;
12871   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
12872   WhitesmithsBraceStyle.ColumnLimit = 0;
12873 
12874   // FIXME: this test case can't decide whether there should be a blank line
12875   // after the ~D() line or not. It adds one if one doesn't exist in the test
12876   // and it removes the line if one exists.
12877   /*
12878   verifyFormat("class A;\n"
12879                "namespace B\n"
12880                "  {\n"
12881                "class C;\n"
12882                "// Comment\n"
12883                "class D\n"
12884                "  {\n"
12885                "public:\n"
12886                "  D();\n"
12887                "  ~D() {}\n"
12888                "private:\n"
12889                "  enum E\n"
12890                "    {\n"
12891                "    F\n"
12892                "    }\n"
12893                "  };\n"
12894                "  } // namespace B\n",
12895                WhitesmithsBraceStyle);
12896   */
12897 
12898   verifyFormat("namespace a\n"
12899                "  {\n"
12900                "class A\n"
12901                "  {\n"
12902                "  void f()\n"
12903                "    {\n"
12904                "    if (true)\n"
12905                "      {\n"
12906                "      a();\n"
12907                "      b();\n"
12908                "      }\n"
12909                "    }\n"
12910                "  void g()\n"
12911                "    {\n"
12912                "    return;\n"
12913                "    }\n"
12914                "  };\n"
12915                "struct B\n"
12916                "  {\n"
12917                "  int x;\n"
12918                "  };\n"
12919                "  } // namespace a",
12920                WhitesmithsBraceStyle);
12921 
12922   verifyFormat("void f()\n"
12923                "  {\n"
12924                "  if (true)\n"
12925                "    {\n"
12926                "    a();\n"
12927                "    }\n"
12928                "  else if (false)\n"
12929                "    {\n"
12930                "    b();\n"
12931                "    }\n"
12932                "  else\n"
12933                "    {\n"
12934                "    c();\n"
12935                "    }\n"
12936                "  }\n",
12937                WhitesmithsBraceStyle);
12938 
12939   verifyFormat("void f()\n"
12940                "  {\n"
12941                "  for (int i = 0; i < 10; ++i)\n"
12942                "    {\n"
12943                "    a();\n"
12944                "    }\n"
12945                "  while (false)\n"
12946                "    {\n"
12947                "    b();\n"
12948                "    }\n"
12949                "  do\n"
12950                "    {\n"
12951                "    c();\n"
12952                "    } while (false)\n"
12953                "  }\n",
12954                WhitesmithsBraceStyle);
12955 
12956   // FIXME: the block and the break under case 2 in this test don't get indented
12957   // correctly
12958   /*
12959   verifyFormat("void switchTest1(int a)\n"
12960                "  {\n"
12961                "  switch (a)\n"
12962                "    {\n"
12963                "    case 2:\n"
12964                "      {\n"
12965                "      }\n"
12966                "      break;\n"
12967                "    }\n"
12968                "  }\n",
12969                WhitesmithsBraceStyle);
12970   */
12971 
12972   // FIXME: the block and the break under case 2 in this test don't get indented
12973   // correctly
12974   /*
12975   verifyFormat("void switchTest2(int a)\n"
12976                "  {\n"
12977                "  switch (a)\n"
12978                "    {\n"
12979                "  case 0:\n"
12980                "    break;\n"
12981                "  case 1:\n"
12982                "    {\n"
12983                "    break;\n"
12984                "    }\n"
12985                "  case 2:\n"
12986                "    {\n"
12987                "    }\n"
12988                "    break;\n"
12989                "  default:\n"
12990                "    break;\n"
12991                "    }\n"
12992                "  }\n",
12993                WhitesmithsBraceStyle);
12994   */
12995 
12996   verifyFormat("enum X\n"
12997                "  {\n"
12998                "  Y = 0, // testing\n"
12999                "  }\n",
13000                WhitesmithsBraceStyle);
13001 
13002   verifyFormat("enum X\n"
13003                "  {\n"
13004                "  Y = 0\n"
13005                "  }\n",
13006                WhitesmithsBraceStyle);
13007   verifyFormat("enum X\n"
13008                "  {\n"
13009                "  Y = 0,\n"
13010                "  Z = 1\n"
13011                "  };\n",
13012                WhitesmithsBraceStyle);
13013 
13014   verifyFormat("@interface BSApplicationController ()\n"
13015                "  {\n"
13016                "@private\n"
13017                "  id _extraIvar;\n"
13018                "  }\n"
13019                "@end\n",
13020                WhitesmithsBraceStyle);
13021 
13022   verifyFormat("#ifdef _DEBUG\n"
13023                "int foo(int i = 0)\n"
13024                "#else\n"
13025                "int foo(int i = 5)\n"
13026                "#endif\n"
13027                "  {\n"
13028                "  return i;\n"
13029                "  }",
13030                WhitesmithsBraceStyle);
13031 
13032   verifyFormat("void foo() {}\n"
13033                "void bar()\n"
13034                "#ifdef _DEBUG\n"
13035                "  {\n"
13036                "  foo();\n"
13037                "  }\n"
13038                "#else\n"
13039                "  {\n"
13040                "  }\n"
13041                "#endif",
13042                WhitesmithsBraceStyle);
13043 
13044   verifyFormat("void foobar()\n"
13045                "  {\n"
13046                "  int i = 5;\n"
13047                "  }\n"
13048                "#ifdef _DEBUG\n"
13049                "void bar()\n"
13050                "  {\n"
13051                "  }\n"
13052                "#else\n"
13053                "void bar()\n"
13054                "  {\n"
13055                "  foobar();\n"
13056                "  }\n"
13057                "#endif",
13058                WhitesmithsBraceStyle);
13059 
13060   // This shouldn't affect ObjC blocks..
13061   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13062                "  // ...\n"
13063                "  int i;\n"
13064                "}];",
13065                WhitesmithsBraceStyle);
13066   verifyFormat("void (^block)(void) = ^{\n"
13067                "  // ...\n"
13068                "  int i;\n"
13069                "};",
13070                WhitesmithsBraceStyle);
13071   // .. or dict literals.
13072   verifyFormat("void f()\n"
13073                "  {\n"
13074                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13075                "  }",
13076                WhitesmithsBraceStyle);
13077 
13078   verifyFormat("int f()\n"
13079                "  { // comment\n"
13080                "  return 42;\n"
13081                "  }",
13082                WhitesmithsBraceStyle);
13083 
13084   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13085   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13086       FormatStyle::SIS_Always;
13087   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13088   verifyFormat("void f(bool b)\n"
13089                "  {\n"
13090                "  if (b)\n"
13091                "    {\n"
13092                "    return;\n"
13093                "    }\n"
13094                "  }\n",
13095                BreakBeforeBraceShortIfs);
13096   verifyFormat("void f(bool b)\n"
13097                "  {\n"
13098                "  if (b) return;\n"
13099                "  }\n",
13100                BreakBeforeBraceShortIfs);
13101   verifyFormat("void f(bool b)\n"
13102                "  {\n"
13103                "  while (b)\n"
13104                "    {\n"
13105                "    return;\n"
13106                "    }\n"
13107                "  }\n",
13108                BreakBeforeBraceShortIfs);
13109 }
13110 
13111 TEST_F(FormatTest, GNUBraceBreaking) {
13112   FormatStyle GNUBraceStyle = getLLVMStyle();
13113   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13114   verifyFormat("namespace a\n"
13115                "{\n"
13116                "class A\n"
13117                "{\n"
13118                "  void f()\n"
13119                "  {\n"
13120                "    int a;\n"
13121                "    {\n"
13122                "      int b;\n"
13123                "    }\n"
13124                "    if (true)\n"
13125                "      {\n"
13126                "        a();\n"
13127                "        b();\n"
13128                "      }\n"
13129                "  }\n"
13130                "  void g() { return; }\n"
13131                "}\n"
13132                "} // namespace a",
13133                GNUBraceStyle);
13134 
13135   verifyFormat("void f()\n"
13136                "{\n"
13137                "  if (true)\n"
13138                "    {\n"
13139                "      a();\n"
13140                "    }\n"
13141                "  else if (false)\n"
13142                "    {\n"
13143                "      b();\n"
13144                "    }\n"
13145                "  else\n"
13146                "    {\n"
13147                "      c();\n"
13148                "    }\n"
13149                "}\n",
13150                GNUBraceStyle);
13151 
13152   verifyFormat("void f()\n"
13153                "{\n"
13154                "  for (int i = 0; i < 10; ++i)\n"
13155                "    {\n"
13156                "      a();\n"
13157                "    }\n"
13158                "  while (false)\n"
13159                "    {\n"
13160                "      b();\n"
13161                "    }\n"
13162                "  do\n"
13163                "    {\n"
13164                "      c();\n"
13165                "    }\n"
13166                "  while (false);\n"
13167                "}\n",
13168                GNUBraceStyle);
13169 
13170   verifyFormat("void f(int a)\n"
13171                "{\n"
13172                "  switch (a)\n"
13173                "    {\n"
13174                "    case 0:\n"
13175                "      break;\n"
13176                "    case 1:\n"
13177                "      {\n"
13178                "        break;\n"
13179                "      }\n"
13180                "    case 2:\n"
13181                "      {\n"
13182                "      }\n"
13183                "      break;\n"
13184                "    default:\n"
13185                "      break;\n"
13186                "    }\n"
13187                "}\n",
13188                GNUBraceStyle);
13189 
13190   verifyFormat("enum X\n"
13191                "{\n"
13192                "  Y = 0,\n"
13193                "}\n",
13194                GNUBraceStyle);
13195 
13196   verifyFormat("@interface BSApplicationController ()\n"
13197                "{\n"
13198                "@private\n"
13199                "  id _extraIvar;\n"
13200                "}\n"
13201                "@end\n",
13202                GNUBraceStyle);
13203 
13204   verifyFormat("#ifdef _DEBUG\n"
13205                "int foo(int i = 0)\n"
13206                "#else\n"
13207                "int foo(int i = 5)\n"
13208                "#endif\n"
13209                "{\n"
13210                "  return i;\n"
13211                "}",
13212                GNUBraceStyle);
13213 
13214   verifyFormat("void foo() {}\n"
13215                "void bar()\n"
13216                "#ifdef _DEBUG\n"
13217                "{\n"
13218                "  foo();\n"
13219                "}\n"
13220                "#else\n"
13221                "{\n"
13222                "}\n"
13223                "#endif",
13224                GNUBraceStyle);
13225 
13226   verifyFormat("void foobar() { int i = 5; }\n"
13227                "#ifdef _DEBUG\n"
13228                "void bar() {}\n"
13229                "#else\n"
13230                "void bar() { foobar(); }\n"
13231                "#endif",
13232                GNUBraceStyle);
13233 }
13234 
13235 TEST_F(FormatTest, WebKitBraceBreaking) {
13236   FormatStyle WebKitBraceStyle = getLLVMStyle();
13237   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13238   WebKitBraceStyle.FixNamespaceComments = false;
13239   verifyFormat("namespace a {\n"
13240                "class A {\n"
13241                "  void f()\n"
13242                "  {\n"
13243                "    if (true) {\n"
13244                "      a();\n"
13245                "      b();\n"
13246                "    }\n"
13247                "  }\n"
13248                "  void g() { return; }\n"
13249                "};\n"
13250                "enum E {\n"
13251                "  A,\n"
13252                "  // foo\n"
13253                "  B,\n"
13254                "  C\n"
13255                "};\n"
13256                "struct B {\n"
13257                "  int x;\n"
13258                "};\n"
13259                "}\n",
13260                WebKitBraceStyle);
13261   verifyFormat("struct S {\n"
13262                "  int Type;\n"
13263                "  union {\n"
13264                "    int x;\n"
13265                "    double y;\n"
13266                "  } Value;\n"
13267                "  class C {\n"
13268                "    MyFavoriteType Value;\n"
13269                "  } Class;\n"
13270                "};\n",
13271                WebKitBraceStyle);
13272 }
13273 
13274 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13275   verifyFormat("void f() {\n"
13276                "  try {\n"
13277                "  } catch (const Exception &e) {\n"
13278                "  }\n"
13279                "}\n",
13280                getLLVMStyle());
13281 }
13282 
13283 TEST_F(FormatTest, UnderstandsPragmas) {
13284   verifyFormat("#pragma omp reduction(| : var)");
13285   verifyFormat("#pragma omp reduction(+ : var)");
13286 
13287   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13288             "(including parentheses).",
13289             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13290                    "(including parentheses)."));
13291 }
13292 
13293 TEST_F(FormatTest, UnderstandPragmaOption) {
13294   verifyFormat("#pragma option -C -A");
13295 
13296   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13297 }
13298 
13299 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13300   FormatStyle Style = getLLVMStyle();
13301   Style.ColumnLimit = 20;
13302 
13303   // See PR41213
13304   EXPECT_EQ("/*\n"
13305             " *\t9012345\n"
13306             " * /8901\n"
13307             " */",
13308             format("/*\n"
13309                    " *\t9012345 /8901\n"
13310                    " */",
13311                    Style));
13312   EXPECT_EQ("/*\n"
13313             " *345678\n"
13314             " *\t/8901\n"
13315             " */",
13316             format("/*\n"
13317                    " *345678\t/8901\n"
13318                    " */",
13319                    Style));
13320 
13321   verifyFormat("int a; // the\n"
13322                "       // comment",
13323                Style);
13324   EXPECT_EQ("int a; /* first line\n"
13325             "        * second\n"
13326             "        * line third\n"
13327             "        * line\n"
13328             "        */",
13329             format("int a; /* first line\n"
13330                    "        * second\n"
13331                    "        * line third\n"
13332                    "        * line\n"
13333                    "        */",
13334                    Style));
13335   EXPECT_EQ("int a; // first line\n"
13336             "       // second\n"
13337             "       // line third\n"
13338             "       // line",
13339             format("int a; // first line\n"
13340                    "       // second line\n"
13341                    "       // third line",
13342                    Style));
13343 
13344   Style.PenaltyExcessCharacter = 90;
13345   verifyFormat("int a; // the comment", Style);
13346   EXPECT_EQ("int a; // the comment\n"
13347             "       // aaa",
13348             format("int a; // the comment aaa", Style));
13349   EXPECT_EQ("int a; /* first line\n"
13350             "        * second line\n"
13351             "        * third line\n"
13352             "        */",
13353             format("int a; /* first line\n"
13354                    "        * second line\n"
13355                    "        * third line\n"
13356                    "        */",
13357                    Style));
13358   EXPECT_EQ("int a; // first line\n"
13359             "       // second line\n"
13360             "       // third line",
13361             format("int a; // first line\n"
13362                    "       // second line\n"
13363                    "       // third line",
13364                    Style));
13365   // FIXME: Investigate why this is not getting the same layout as the test
13366   // above.
13367   EXPECT_EQ("int a; /* first line\n"
13368             "        * second line\n"
13369             "        * third line\n"
13370             "        */",
13371             format("int a; /* first line second line third line"
13372                    "\n*/",
13373                    Style));
13374 
13375   EXPECT_EQ("// foo bar baz bazfoo\n"
13376             "// foo bar foo bar\n",
13377             format("// foo bar baz bazfoo\n"
13378                    "// foo bar foo           bar\n",
13379                    Style));
13380   EXPECT_EQ("// foo bar baz bazfoo\n"
13381             "// foo bar foo bar\n",
13382             format("// foo bar baz      bazfoo\n"
13383                    "// foo            bar foo bar\n",
13384                    Style));
13385 
13386   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13387   // next one.
13388   EXPECT_EQ("// foo bar baz bazfoo\n"
13389             "// bar foo bar\n",
13390             format("// foo bar baz      bazfoo bar\n"
13391                    "// foo            bar\n",
13392                    Style));
13393 
13394   EXPECT_EQ("// foo bar baz bazfoo\n"
13395             "// foo bar baz bazfoo\n"
13396             "// bar foo bar\n",
13397             format("// foo bar baz      bazfoo\n"
13398                    "// foo bar baz      bazfoo bar\n"
13399                    "// foo bar\n",
13400                    Style));
13401 
13402   EXPECT_EQ("// foo bar baz bazfoo\n"
13403             "// foo bar baz bazfoo\n"
13404             "// bar foo bar\n",
13405             format("// foo bar baz      bazfoo\n"
13406                    "// foo bar baz      bazfoo bar\n"
13407                    "// foo           bar\n",
13408                    Style));
13409 
13410   // Make sure we do not keep protruding characters if strict mode reflow is
13411   // cheaper than keeping protruding characters.
13412   Style.ColumnLimit = 21;
13413   EXPECT_EQ(
13414       "// foo foo foo foo\n"
13415       "// foo foo foo foo\n"
13416       "// foo foo foo foo\n",
13417       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13418 
13419   EXPECT_EQ("int a = /* long block\n"
13420             "           comment */\n"
13421             "    42;",
13422             format("int a = /* long block comment */ 42;", Style));
13423 }
13424 
13425 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13426   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13427   EXPECT_EQ(Styles[0], Styles[i])                                              \
13428       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13429 
13430 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13431   SmallVector<FormatStyle, 3> Styles;
13432   Styles.resize(3);
13433 
13434   Styles[0] = getLLVMStyle();
13435   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13436   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13437   EXPECT_ALL_STYLES_EQUAL(Styles);
13438 
13439   Styles[0] = getGoogleStyle();
13440   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13441   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13442   EXPECT_ALL_STYLES_EQUAL(Styles);
13443 
13444   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13445   EXPECT_TRUE(
13446       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13447   EXPECT_TRUE(
13448       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13449   EXPECT_ALL_STYLES_EQUAL(Styles);
13450 
13451   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13452   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13453   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
13454   EXPECT_ALL_STYLES_EQUAL(Styles);
13455 
13456   Styles[0] = getMozillaStyle();
13457   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
13458   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
13459   EXPECT_ALL_STYLES_EQUAL(Styles);
13460 
13461   Styles[0] = getWebKitStyle();
13462   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
13463   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
13464   EXPECT_ALL_STYLES_EQUAL(Styles);
13465 
13466   Styles[0] = getGNUStyle();
13467   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
13468   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
13469   EXPECT_ALL_STYLES_EQUAL(Styles);
13470 
13471   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
13472 }
13473 
13474 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
13475   SmallVector<FormatStyle, 8> Styles;
13476   Styles.resize(2);
13477 
13478   Styles[0] = getGoogleStyle();
13479   Styles[1] = getLLVMStyle();
13480   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13481   EXPECT_ALL_STYLES_EQUAL(Styles);
13482 
13483   Styles.resize(5);
13484   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13485   Styles[1] = getLLVMStyle();
13486   Styles[1].Language = FormatStyle::LK_JavaScript;
13487   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13488 
13489   Styles[2] = getLLVMStyle();
13490   Styles[2].Language = FormatStyle::LK_JavaScript;
13491   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
13492                                   "BasedOnStyle: Google",
13493                                   &Styles[2])
13494                    .value());
13495 
13496   Styles[3] = getLLVMStyle();
13497   Styles[3].Language = FormatStyle::LK_JavaScript;
13498   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
13499                                   "Language: JavaScript",
13500                                   &Styles[3])
13501                    .value());
13502 
13503   Styles[4] = getLLVMStyle();
13504   Styles[4].Language = FormatStyle::LK_JavaScript;
13505   EXPECT_EQ(0, parseConfiguration("---\n"
13506                                   "BasedOnStyle: LLVM\n"
13507                                   "IndentWidth: 123\n"
13508                                   "---\n"
13509                                   "BasedOnStyle: Google\n"
13510                                   "Language: JavaScript",
13511                                   &Styles[4])
13512                    .value());
13513   EXPECT_ALL_STYLES_EQUAL(Styles);
13514 }
13515 
13516 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
13517   Style.FIELD = false;                                                         \
13518   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
13519   EXPECT_TRUE(Style.FIELD);                                                    \
13520   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
13521   EXPECT_FALSE(Style.FIELD);
13522 
13523 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
13524 
13525 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
13526   Style.STRUCT.FIELD = false;                                                  \
13527   EXPECT_EQ(0,                                                                 \
13528             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
13529                 .value());                                                     \
13530   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
13531   EXPECT_EQ(0,                                                                 \
13532             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
13533                 .value());                                                     \
13534   EXPECT_FALSE(Style.STRUCT.FIELD);
13535 
13536 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
13537   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
13538 
13539 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
13540   EXPECT_NE(VALUE, Style.FIELD);                                               \
13541   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
13542   EXPECT_EQ(VALUE, Style.FIELD)
13543 
13544 TEST_F(FormatTest, ParsesConfigurationBools) {
13545   FormatStyle Style = {};
13546   Style.Language = FormatStyle::LK_Cpp;
13547   CHECK_PARSE_BOOL(AlignTrailingComments);
13548   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
13549   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
13550   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
13551   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
13552   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
13553   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
13554   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
13555   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
13556   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
13557   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
13558   CHECK_PARSE_BOOL(BinPackArguments);
13559   CHECK_PARSE_BOOL(BinPackParameters);
13560   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
13561   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
13562   CHECK_PARSE_BOOL(BreakStringLiterals);
13563   CHECK_PARSE_BOOL(CompactNamespaces);
13564   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
13565   CHECK_PARSE_BOOL(DeriveLineEnding);
13566   CHECK_PARSE_BOOL(DerivePointerAlignment);
13567   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
13568   CHECK_PARSE_BOOL(DisableFormat);
13569   CHECK_PARSE_BOOL(IndentCaseLabels);
13570   CHECK_PARSE_BOOL(IndentCaseBlocks);
13571   CHECK_PARSE_BOOL(IndentGotoLabels);
13572   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
13573   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
13574   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
13575   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
13576   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
13577   CHECK_PARSE_BOOL(ReflowComments);
13578   CHECK_PARSE_BOOL(SortIncludes);
13579   CHECK_PARSE_BOOL(SortUsingDeclarations);
13580   CHECK_PARSE_BOOL(SpacesInParentheses);
13581   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
13582   CHECK_PARSE_BOOL(SpacesInAngles);
13583   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
13584   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
13585   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
13586   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
13587   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
13588   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
13589   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
13590   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
13591   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
13592   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
13593   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
13594   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
13595   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
13596   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
13597   CHECK_PARSE_BOOL(UseCRLF);
13598 
13599   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
13600   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
13601   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
13602   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
13603   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
13604   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
13605   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
13606   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
13607   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
13608   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
13609   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
13610   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
13611   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
13612   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
13613   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
13614   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
13615   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
13616 }
13617 
13618 #undef CHECK_PARSE_BOOL
13619 
13620 TEST_F(FormatTest, ParsesConfiguration) {
13621   FormatStyle Style = {};
13622   Style.Language = FormatStyle::LK_Cpp;
13623   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
13624   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
13625               ConstructorInitializerIndentWidth, 1234u);
13626   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
13627   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
13628   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
13629   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
13630   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
13631               PenaltyBreakBeforeFirstCallParameter, 1234u);
13632   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
13633               PenaltyBreakTemplateDeclaration, 1234u);
13634   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
13635   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
13636               PenaltyReturnTypeOnItsOwnLine, 1234u);
13637   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
13638               SpacesBeforeTrailingComments, 1234u);
13639   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
13640   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
13641   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
13642 
13643   Style.PointerAlignment = FormatStyle::PAS_Middle;
13644   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
13645               FormatStyle::PAS_Left);
13646   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
13647               FormatStyle::PAS_Right);
13648   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
13649               FormatStyle::PAS_Middle);
13650   // For backward compatibility:
13651   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
13652               FormatStyle::PAS_Left);
13653   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
13654               FormatStyle::PAS_Right);
13655   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
13656               FormatStyle::PAS_Middle);
13657 
13658   Style.Standard = FormatStyle::LS_Auto;
13659   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
13660   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
13661   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
13662   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
13663   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
13664   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
13665   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
13666   // Legacy aliases:
13667   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
13668   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
13669   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
13670   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
13671 
13672   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13673   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
13674               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
13675   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
13676               FormatStyle::BOS_None);
13677   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
13678               FormatStyle::BOS_All);
13679   // For backward compatibility:
13680   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
13681               FormatStyle::BOS_None);
13682   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
13683               FormatStyle::BOS_All);
13684 
13685   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
13686   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
13687               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13688   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
13689               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
13690   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
13691               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
13692   // For backward compatibility:
13693   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
13694               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13695 
13696   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
13697   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
13698               FormatStyle::BILS_BeforeComma);
13699   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
13700               FormatStyle::BILS_AfterColon);
13701   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
13702               FormatStyle::BILS_BeforeColon);
13703   // For backward compatibility:
13704   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
13705               FormatStyle::BILS_BeforeComma);
13706 
13707   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
13708   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
13709               FormatStyle::BAS_Align);
13710   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
13711               FormatStyle::BAS_DontAlign);
13712   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
13713               FormatStyle::BAS_AlwaysBreak);
13714   // For backward compatibility:
13715   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
13716               FormatStyle::BAS_DontAlign);
13717   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
13718               FormatStyle::BAS_Align);
13719 
13720   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13721   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
13722               FormatStyle::ENAS_DontAlign);
13723   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
13724               FormatStyle::ENAS_Left);
13725   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
13726               FormatStyle::ENAS_Right);
13727   // For backward compatibility:
13728   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
13729               FormatStyle::ENAS_Left);
13730   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
13731               FormatStyle::ENAS_Right);
13732 
13733   Style.AlignOperands = FormatStyle::OAS_Align;
13734   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
13735               FormatStyle::OAS_DontAlign);
13736   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
13737   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
13738               FormatStyle::OAS_AlignAfterOperator);
13739   // For backward compatibility:
13740   CHECK_PARSE("AlignOperands: false", AlignOperands,
13741               FormatStyle::OAS_DontAlign);
13742   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
13743 
13744   Style.UseTab = FormatStyle::UT_ForIndentation;
13745   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
13746   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
13747   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
13748   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
13749               FormatStyle::UT_ForContinuationAndIndentation);
13750   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
13751               FormatStyle::UT_AlignWithSpaces);
13752   // For backward compatibility:
13753   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
13754   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
13755 
13756   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
13757   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
13758               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13759   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
13760               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
13761   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
13762               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13763   // For backward compatibility:
13764   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
13765               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13766   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
13767               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13768 
13769   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
13770   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
13771               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13772   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
13773               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
13774   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
13775               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
13776   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
13777               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13778   // For backward compatibility:
13779   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
13780               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13781   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
13782               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13783 
13784   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
13785   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
13786               FormatStyle::SBPO_Never);
13787   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
13788               FormatStyle::SBPO_Always);
13789   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
13790               FormatStyle::SBPO_ControlStatements);
13791   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
13792               FormatStyle::SBPO_NonEmptyParentheses);
13793   // For backward compatibility:
13794   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
13795               FormatStyle::SBPO_Never);
13796   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
13797               FormatStyle::SBPO_ControlStatements);
13798 
13799   Style.ColumnLimit = 123;
13800   FormatStyle BaseStyle = getLLVMStyle();
13801   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
13802   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
13803 
13804   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
13805   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
13806               FormatStyle::BS_Attach);
13807   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
13808               FormatStyle::BS_Linux);
13809   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
13810               FormatStyle::BS_Mozilla);
13811   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
13812               FormatStyle::BS_Stroustrup);
13813   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
13814               FormatStyle::BS_Allman);
13815   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
13816               FormatStyle::BS_Whitesmiths);
13817   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
13818   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
13819               FormatStyle::BS_WebKit);
13820   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
13821               FormatStyle::BS_Custom);
13822 
13823   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
13824   CHECK_PARSE("BraceWrapping:\n"
13825               "  AfterControlStatement: MultiLine",
13826               BraceWrapping.AfterControlStatement,
13827               FormatStyle::BWACS_MultiLine);
13828   CHECK_PARSE("BraceWrapping:\n"
13829               "  AfterControlStatement: Always",
13830               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13831   CHECK_PARSE("BraceWrapping:\n"
13832               "  AfterControlStatement: Never",
13833               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13834   // For backward compatibility:
13835   CHECK_PARSE("BraceWrapping:\n"
13836               "  AfterControlStatement: true",
13837               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13838   CHECK_PARSE("BraceWrapping:\n"
13839               "  AfterControlStatement: false",
13840               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13841 
13842   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
13843   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
13844               FormatStyle::RTBS_None);
13845   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
13846               FormatStyle::RTBS_All);
13847   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
13848               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
13849   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
13850               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
13851   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
13852               AlwaysBreakAfterReturnType,
13853               FormatStyle::RTBS_TopLevelDefinitions);
13854 
13855   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
13856   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
13857               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
13858   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
13859               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
13860   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
13861               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
13862   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
13863               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
13864   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
13865               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
13866 
13867   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
13868   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
13869               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
13870   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
13871               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
13872   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
13873               AlwaysBreakAfterDefinitionReturnType,
13874               FormatStyle::DRTBS_TopLevel);
13875 
13876   Style.NamespaceIndentation = FormatStyle::NI_All;
13877   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
13878               FormatStyle::NI_None);
13879   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
13880               FormatStyle::NI_Inner);
13881   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
13882               FormatStyle::NI_All);
13883 
13884   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
13885   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
13886               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
13887   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
13888               AllowShortIfStatementsOnASingleLine,
13889               FormatStyle::SIS_WithoutElse);
13890   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
13891               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
13892   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
13893               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
13894   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
13895               AllowShortIfStatementsOnASingleLine,
13896               FormatStyle::SIS_WithoutElse);
13897 
13898   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
13899   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
13900               FormatStyle::IEBS_AfterExternBlock);
13901   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
13902               FormatStyle::IEBS_Indent);
13903   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
13904               FormatStyle::IEBS_NoIndent);
13905   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
13906               FormatStyle::IEBS_Indent);
13907   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
13908               FormatStyle::IEBS_NoIndent);
13909 
13910   // FIXME: This is required because parsing a configuration simply overwrites
13911   // the first N elements of the list instead of resetting it.
13912   Style.ForEachMacros.clear();
13913   std::vector<std::string> BoostForeach;
13914   BoostForeach.push_back("BOOST_FOREACH");
13915   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
13916   std::vector<std::string> BoostAndQForeach;
13917   BoostAndQForeach.push_back("BOOST_FOREACH");
13918   BoostAndQForeach.push_back("Q_FOREACH");
13919   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
13920               BoostAndQForeach);
13921 
13922   Style.StatementMacros.clear();
13923   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
13924               std::vector<std::string>{"QUNUSED"});
13925   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
13926               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
13927 
13928   Style.NamespaceMacros.clear();
13929   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
13930               std::vector<std::string>{"TESTSUITE"});
13931   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
13932               std::vector<std::string>({"TESTSUITE", "SUITE"}));
13933 
13934   Style.IncludeStyle.IncludeCategories.clear();
13935   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
13936       {"abc/.*", 2, 0}, {".*", 1, 0}};
13937   CHECK_PARSE("IncludeCategories:\n"
13938               "  - Regex: abc/.*\n"
13939               "    Priority: 2\n"
13940               "  - Regex: .*\n"
13941               "    Priority: 1",
13942               IncludeStyle.IncludeCategories, ExpectedCategories);
13943   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
13944               "abc$");
13945   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
13946               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
13947 
13948   Style.RawStringFormats.clear();
13949   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
13950       {
13951           FormatStyle::LK_TextProto,
13952           {"pb", "proto"},
13953           {"PARSE_TEXT_PROTO"},
13954           /*CanonicalDelimiter=*/"",
13955           "llvm",
13956       },
13957       {
13958           FormatStyle::LK_Cpp,
13959           {"cc", "cpp"},
13960           {"C_CODEBLOCK", "CPPEVAL"},
13961           /*CanonicalDelimiter=*/"cc",
13962           /*BasedOnStyle=*/"",
13963       },
13964   };
13965 
13966   CHECK_PARSE("RawStringFormats:\n"
13967               "  - Language: TextProto\n"
13968               "    Delimiters:\n"
13969               "      - 'pb'\n"
13970               "      - 'proto'\n"
13971               "    EnclosingFunctions:\n"
13972               "      - 'PARSE_TEXT_PROTO'\n"
13973               "    BasedOnStyle: llvm\n"
13974               "  - Language: Cpp\n"
13975               "    Delimiters:\n"
13976               "      - 'cc'\n"
13977               "      - 'cpp'\n"
13978               "    EnclosingFunctions:\n"
13979               "      - 'C_CODEBLOCK'\n"
13980               "      - 'CPPEVAL'\n"
13981               "    CanonicalDelimiter: 'cc'",
13982               RawStringFormats, ExpectedRawStringFormats);
13983 }
13984 
13985 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
13986   FormatStyle Style = {};
13987   Style.Language = FormatStyle::LK_Cpp;
13988   CHECK_PARSE("Language: Cpp\n"
13989               "IndentWidth: 12",
13990               IndentWidth, 12u);
13991   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
13992                                "IndentWidth: 34",
13993                                &Style),
13994             ParseError::Unsuitable);
13995   FormatStyle BinPackedTCS = {};
13996   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
13997   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
13998                                "InsertTrailingCommas: Wrapped",
13999                                &BinPackedTCS),
14000             ParseError::BinPackTrailingCommaConflict);
14001   EXPECT_EQ(12u, Style.IndentWidth);
14002   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14003   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14004 
14005   Style.Language = FormatStyle::LK_JavaScript;
14006   CHECK_PARSE("Language: JavaScript\n"
14007               "IndentWidth: 12",
14008               IndentWidth, 12u);
14009   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14010   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14011                                "IndentWidth: 34",
14012                                &Style),
14013             ParseError::Unsuitable);
14014   EXPECT_EQ(23u, Style.IndentWidth);
14015   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14016   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14017 
14018   CHECK_PARSE("BasedOnStyle: LLVM\n"
14019               "IndentWidth: 67",
14020               IndentWidth, 67u);
14021 
14022   CHECK_PARSE("---\n"
14023               "Language: JavaScript\n"
14024               "IndentWidth: 12\n"
14025               "---\n"
14026               "Language: Cpp\n"
14027               "IndentWidth: 34\n"
14028               "...\n",
14029               IndentWidth, 12u);
14030 
14031   Style.Language = FormatStyle::LK_Cpp;
14032   CHECK_PARSE("---\n"
14033               "Language: JavaScript\n"
14034               "IndentWidth: 12\n"
14035               "---\n"
14036               "Language: Cpp\n"
14037               "IndentWidth: 34\n"
14038               "...\n",
14039               IndentWidth, 34u);
14040   CHECK_PARSE("---\n"
14041               "IndentWidth: 78\n"
14042               "---\n"
14043               "Language: JavaScript\n"
14044               "IndentWidth: 56\n"
14045               "...\n",
14046               IndentWidth, 78u);
14047 
14048   Style.ColumnLimit = 123;
14049   Style.IndentWidth = 234;
14050   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14051   Style.TabWidth = 345;
14052   EXPECT_FALSE(parseConfiguration("---\n"
14053                                   "IndentWidth: 456\n"
14054                                   "BreakBeforeBraces: Allman\n"
14055                                   "---\n"
14056                                   "Language: JavaScript\n"
14057                                   "IndentWidth: 111\n"
14058                                   "TabWidth: 111\n"
14059                                   "---\n"
14060                                   "Language: Cpp\n"
14061                                   "BreakBeforeBraces: Stroustrup\n"
14062                                   "TabWidth: 789\n"
14063                                   "...\n",
14064                                   &Style));
14065   EXPECT_EQ(123u, Style.ColumnLimit);
14066   EXPECT_EQ(456u, Style.IndentWidth);
14067   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14068   EXPECT_EQ(789u, Style.TabWidth);
14069 
14070   EXPECT_EQ(parseConfiguration("---\n"
14071                                "Language: JavaScript\n"
14072                                "IndentWidth: 56\n"
14073                                "---\n"
14074                                "IndentWidth: 78\n"
14075                                "...\n",
14076                                &Style),
14077             ParseError::Error);
14078   EXPECT_EQ(parseConfiguration("---\n"
14079                                "Language: JavaScript\n"
14080                                "IndentWidth: 56\n"
14081                                "---\n"
14082                                "Language: JavaScript\n"
14083                                "IndentWidth: 78\n"
14084                                "...\n",
14085                                &Style),
14086             ParseError::Error);
14087 
14088   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14089 }
14090 
14091 #undef CHECK_PARSE
14092 
14093 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14094   FormatStyle Style = {};
14095   Style.Language = FormatStyle::LK_JavaScript;
14096   Style.BreakBeforeTernaryOperators = true;
14097   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14098   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14099 
14100   Style.BreakBeforeTernaryOperators = true;
14101   EXPECT_EQ(0, parseConfiguration("---\n"
14102                                   "BasedOnStyle: Google\n"
14103                                   "---\n"
14104                                   "Language: JavaScript\n"
14105                                   "IndentWidth: 76\n"
14106                                   "...\n",
14107                                   &Style)
14108                    .value());
14109   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14110   EXPECT_EQ(76u, Style.IndentWidth);
14111   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14112 }
14113 
14114 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14115   FormatStyle Style = getLLVMStyle();
14116   std::string YAML = configurationAsText(Style);
14117   FormatStyle ParsedStyle = {};
14118   ParsedStyle.Language = FormatStyle::LK_Cpp;
14119   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14120   EXPECT_EQ(Style, ParsedStyle);
14121 }
14122 
14123 TEST_F(FormatTest, WorksFor8bitEncodings) {
14124   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14125             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14126             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14127             "\"\xef\xee\xf0\xf3...\"",
14128             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14129                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14130                    "\xef\xee\xf0\xf3...\"",
14131                    getLLVMStyleWithColumns(12)));
14132 }
14133 
14134 TEST_F(FormatTest, HandlesUTF8BOM) {
14135   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14136   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14137             format("\xef\xbb\xbf#include <iostream>"));
14138   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14139             format("\xef\xbb\xbf\n#include <iostream>"));
14140 }
14141 
14142 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14143 #if !defined(_MSC_VER)
14144 
14145 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14146   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14147                getLLVMStyleWithColumns(35));
14148   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14149                getLLVMStyleWithColumns(31));
14150   verifyFormat("// Однажды в студёную зимнюю пору...",
14151                getLLVMStyleWithColumns(36));
14152   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14153   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14154                getLLVMStyleWithColumns(39));
14155   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14156                getLLVMStyleWithColumns(35));
14157 }
14158 
14159 TEST_F(FormatTest, SplitsUTF8Strings) {
14160   // Non-printable characters' width is currently considered to be the length in
14161   // bytes in UTF8. The characters can be displayed in very different manner
14162   // (zero-width, single width with a substitution glyph, expanded to their code
14163   // (e.g. "<8d>"), so there's no single correct way to handle them.
14164   EXPECT_EQ("\"aaaaÄ\"\n"
14165             "\"\xc2\x8d\";",
14166             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14167   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14168             "\"\xc2\x8d\";",
14169             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14170   EXPECT_EQ("\"Однажды, в \"\n"
14171             "\"студёную \"\n"
14172             "\"зимнюю \"\n"
14173             "\"пору,\"",
14174             format("\"Однажды, в студёную зимнюю пору,\"",
14175                    getLLVMStyleWithColumns(13)));
14176   EXPECT_EQ(
14177       "\"一 二 三 \"\n"
14178       "\"四 五六 \"\n"
14179       "\"七 八 九 \"\n"
14180       "\"十\"",
14181       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14182   EXPECT_EQ("\"一\t\"\n"
14183             "\"二 \t\"\n"
14184             "\"三 四 \"\n"
14185             "\"五\t\"\n"
14186             "\"六 \t\"\n"
14187             "\"七 \"\n"
14188             "\"八九十\tqq\"",
14189             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14190                    getLLVMStyleWithColumns(11)));
14191 
14192   // UTF8 character in an escape sequence.
14193   EXPECT_EQ("\"aaaaaa\"\n"
14194             "\"\\\xC2\x8D\"",
14195             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14196 }
14197 
14198 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14199   EXPECT_EQ("const char *sssss =\n"
14200             "    \"一二三四五六七八\\\n"
14201             " 九 十\";",
14202             format("const char *sssss = \"一二三四五六七八\\\n"
14203                    " 九 十\";",
14204                    getLLVMStyleWithColumns(30)));
14205 }
14206 
14207 TEST_F(FormatTest, SplitsUTF8LineComments) {
14208   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14209             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14210   EXPECT_EQ("// Я из лесу\n"
14211             "// вышел; был\n"
14212             "// сильный\n"
14213             "// мороз.",
14214             format("// Я из лесу вышел; был сильный мороз.",
14215                    getLLVMStyleWithColumns(13)));
14216   EXPECT_EQ("// 一二三\n"
14217             "// 四五六七\n"
14218             "// 八  九\n"
14219             "// 十",
14220             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14221 }
14222 
14223 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14224   EXPECT_EQ("/* Гляжу,\n"
14225             " * поднимается\n"
14226             " * медленно в\n"
14227             " * гору\n"
14228             " * Лошадка,\n"
14229             " * везущая\n"
14230             " * хворосту\n"
14231             " * воз. */",
14232             format("/* Гляжу, поднимается медленно в гору\n"
14233                    " * Лошадка, везущая хворосту воз. */",
14234                    getLLVMStyleWithColumns(13)));
14235   EXPECT_EQ(
14236       "/* 一二三\n"
14237       " * 四五六七\n"
14238       " * 八  九\n"
14239       " * 十  */",
14240       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14241   EXPECT_EQ("/* �������� ��������\n"
14242             " * ��������\n"
14243             " * ������-�� */",
14244             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14245 }
14246 
14247 #endif // _MSC_VER
14248 
14249 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14250   FormatStyle Style = getLLVMStyle();
14251 
14252   Style.ConstructorInitializerIndentWidth = 4;
14253   verifyFormat(
14254       "SomeClass::Constructor()\n"
14255       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14256       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14257       Style);
14258 
14259   Style.ConstructorInitializerIndentWidth = 2;
14260   verifyFormat(
14261       "SomeClass::Constructor()\n"
14262       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14263       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14264       Style);
14265 
14266   Style.ConstructorInitializerIndentWidth = 0;
14267   verifyFormat(
14268       "SomeClass::Constructor()\n"
14269       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14270       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14271       Style);
14272   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14273   verifyFormat(
14274       "SomeLongTemplateVariableName<\n"
14275       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14276       Style);
14277   verifyFormat("bool smaller = 1 < "
14278                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14279                "                       "
14280                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14281                Style);
14282 
14283   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14284   verifyFormat("SomeClass::Constructor() :\n"
14285                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14286                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14287                Style);
14288 }
14289 
14290 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14291   FormatStyle Style = getLLVMStyle();
14292   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14293   Style.ConstructorInitializerIndentWidth = 4;
14294   verifyFormat("SomeClass::Constructor()\n"
14295                "    : a(a)\n"
14296                "    , b(b)\n"
14297                "    , c(c) {}",
14298                Style);
14299   verifyFormat("SomeClass::Constructor()\n"
14300                "    : a(a) {}",
14301                Style);
14302 
14303   Style.ColumnLimit = 0;
14304   verifyFormat("SomeClass::Constructor()\n"
14305                "    : a(a) {}",
14306                Style);
14307   verifyFormat("SomeClass::Constructor() noexcept\n"
14308                "    : a(a) {}",
14309                Style);
14310   verifyFormat("SomeClass::Constructor()\n"
14311                "    : a(a)\n"
14312                "    , b(b)\n"
14313                "    , c(c) {}",
14314                Style);
14315   verifyFormat("SomeClass::Constructor()\n"
14316                "    : a(a) {\n"
14317                "  foo();\n"
14318                "  bar();\n"
14319                "}",
14320                Style);
14321 
14322   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14323   verifyFormat("SomeClass::Constructor()\n"
14324                "    : a(a)\n"
14325                "    , b(b)\n"
14326                "    , c(c) {\n}",
14327                Style);
14328   verifyFormat("SomeClass::Constructor()\n"
14329                "    : a(a) {\n}",
14330                Style);
14331 
14332   Style.ColumnLimit = 80;
14333   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14334   Style.ConstructorInitializerIndentWidth = 2;
14335   verifyFormat("SomeClass::Constructor()\n"
14336                "  : a(a)\n"
14337                "  , b(b)\n"
14338                "  , c(c) {}",
14339                Style);
14340 
14341   Style.ConstructorInitializerIndentWidth = 0;
14342   verifyFormat("SomeClass::Constructor()\n"
14343                ": a(a)\n"
14344                ", b(b)\n"
14345                ", c(c) {}",
14346                Style);
14347 
14348   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14349   Style.ConstructorInitializerIndentWidth = 4;
14350   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14351   verifyFormat(
14352       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14353       Style);
14354   verifyFormat(
14355       "SomeClass::Constructor()\n"
14356       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14357       Style);
14358   Style.ConstructorInitializerIndentWidth = 4;
14359   Style.ColumnLimit = 60;
14360   verifyFormat("SomeClass::Constructor()\n"
14361                "    : aaaaaaaa(aaaaaaaa)\n"
14362                "    , aaaaaaaa(aaaaaaaa)\n"
14363                "    , aaaaaaaa(aaaaaaaa) {}",
14364                Style);
14365 }
14366 
14367 TEST_F(FormatTest, Destructors) {
14368   verifyFormat("void F(int &i) { i.~int(); }");
14369   verifyFormat("void F(int &i) { i->~int(); }");
14370 }
14371 
14372 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14373   FormatStyle Style = getWebKitStyle();
14374 
14375   // Don't indent in outer namespaces.
14376   verifyFormat("namespace outer {\n"
14377                "int i;\n"
14378                "namespace inner {\n"
14379                "    int i;\n"
14380                "} // namespace inner\n"
14381                "} // namespace outer\n"
14382                "namespace other_outer {\n"
14383                "int i;\n"
14384                "}",
14385                Style);
14386 
14387   // Don't indent case labels.
14388   verifyFormat("switch (variable) {\n"
14389                "case 1:\n"
14390                "case 2:\n"
14391                "    doSomething();\n"
14392                "    break;\n"
14393                "default:\n"
14394                "    ++variable;\n"
14395                "}",
14396                Style);
14397 
14398   // Wrap before binary operators.
14399   EXPECT_EQ("void f()\n"
14400             "{\n"
14401             "    if (aaaaaaaaaaaaaaaa\n"
14402             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14403             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14404             "        return;\n"
14405             "}",
14406             format("void f() {\n"
14407                    "if (aaaaaaaaaaaaaaaa\n"
14408                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
14409                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14410                    "return;\n"
14411                    "}",
14412                    Style));
14413 
14414   // Allow functions on a single line.
14415   verifyFormat("void f() { return; }", Style);
14416 
14417   // Allow empty blocks on a single line and insert a space in empty blocks.
14418   EXPECT_EQ("void f() { }", format("void f() {}", Style));
14419   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
14420   // However, don't merge non-empty short loops.
14421   EXPECT_EQ("while (true) {\n"
14422             "    continue;\n"
14423             "}",
14424             format("while (true) { continue; }", Style));
14425 
14426   // Constructor initializers are formatted one per line with the "," on the
14427   // new line.
14428   verifyFormat("Constructor()\n"
14429                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
14430                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
14431                "          aaaaaaaaaaaaaa)\n"
14432                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
14433                "{\n"
14434                "}",
14435                Style);
14436   verifyFormat("SomeClass::Constructor()\n"
14437                "    : a(a)\n"
14438                "{\n"
14439                "}",
14440                Style);
14441   EXPECT_EQ("SomeClass::Constructor()\n"
14442             "    : a(a)\n"
14443             "{\n"
14444             "}",
14445             format("SomeClass::Constructor():a(a){}", Style));
14446   verifyFormat("SomeClass::Constructor()\n"
14447                "    : a(a)\n"
14448                "    , b(b)\n"
14449                "    , c(c)\n"
14450                "{\n"
14451                "}",
14452                Style);
14453   verifyFormat("SomeClass::Constructor()\n"
14454                "    : a(a)\n"
14455                "{\n"
14456                "    foo();\n"
14457                "    bar();\n"
14458                "}",
14459                Style);
14460 
14461   // Access specifiers should be aligned left.
14462   verifyFormat("class C {\n"
14463                "public:\n"
14464                "    int i;\n"
14465                "};",
14466                Style);
14467 
14468   // Do not align comments.
14469   verifyFormat("int a; // Do not\n"
14470                "double b; // align comments.",
14471                Style);
14472 
14473   // Do not align operands.
14474   EXPECT_EQ("ASSERT(aaaa\n"
14475             "    || bbbb);",
14476             format("ASSERT ( aaaa\n||bbbb);", Style));
14477 
14478   // Accept input's line breaks.
14479   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
14480             "    || bbbbbbbbbbbbbbb) {\n"
14481             "    i++;\n"
14482             "}",
14483             format("if (aaaaaaaaaaaaaaa\n"
14484                    "|| bbbbbbbbbbbbbbb) { i++; }",
14485                    Style));
14486   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
14487             "    i++;\n"
14488             "}",
14489             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
14490 
14491   // Don't automatically break all macro definitions (llvm.org/PR17842).
14492   verifyFormat("#define aNumber 10", Style);
14493   // However, generally keep the line breaks that the user authored.
14494   EXPECT_EQ("#define aNumber \\\n"
14495             "    10",
14496             format("#define aNumber \\\n"
14497                    " 10",
14498                    Style));
14499 
14500   // Keep empty and one-element array literals on a single line.
14501   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
14502             "                                  copyItems:YES];",
14503             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
14504                    "copyItems:YES];",
14505                    Style));
14506   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
14507             "                                  copyItems:YES];",
14508             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
14509                    "             copyItems:YES];",
14510                    Style));
14511   // FIXME: This does not seem right, there should be more indentation before
14512   // the array literal's entries. Nested blocks have the same problem.
14513   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14514             "    @\"a\",\n"
14515             "    @\"a\"\n"
14516             "]\n"
14517             "                                  copyItems:YES];",
14518             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14519                    "     @\"a\",\n"
14520                    "     @\"a\"\n"
14521                    "     ]\n"
14522                    "       copyItems:YES];",
14523                    Style));
14524   EXPECT_EQ(
14525       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14526       "                                  copyItems:YES];",
14527       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14528              "   copyItems:YES];",
14529              Style));
14530 
14531   verifyFormat("[self.a b:c c:d];", Style);
14532   EXPECT_EQ("[self.a b:c\n"
14533             "        c:d];",
14534             format("[self.a b:c\n"
14535                    "c:d];",
14536                    Style));
14537 }
14538 
14539 TEST_F(FormatTest, FormatsLambdas) {
14540   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
14541   verifyFormat(
14542       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
14543   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
14544   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
14545   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
14546   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
14547   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
14548   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
14549   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
14550   verifyFormat("int x = f(*+[] {});");
14551   verifyFormat("void f() {\n"
14552                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
14553                "}\n");
14554   verifyFormat("void f() {\n"
14555                "  other(x.begin(), //\n"
14556                "        x.end(),   //\n"
14557                "        [&](int, int) { return 1; });\n"
14558                "}\n");
14559   verifyFormat("void f() {\n"
14560                "  other.other.other.other.other(\n"
14561                "      x.begin(), x.end(),\n"
14562                "      [something, rather](int, int, int, int, int, int, int) { "
14563                "return 1; });\n"
14564                "}\n");
14565   verifyFormat(
14566       "void f() {\n"
14567       "  other.other.other.other.other(\n"
14568       "      x.begin(), x.end(),\n"
14569       "      [something, rather](int, int, int, int, int, int, int) {\n"
14570       "        //\n"
14571       "      });\n"
14572       "}\n");
14573   verifyFormat("SomeFunction([]() { // A cool function...\n"
14574                "  return 43;\n"
14575                "});");
14576   EXPECT_EQ("SomeFunction([]() {\n"
14577             "#define A a\n"
14578             "  return 43;\n"
14579             "});",
14580             format("SomeFunction([](){\n"
14581                    "#define A a\n"
14582                    "return 43;\n"
14583                    "});"));
14584   verifyFormat("void f() {\n"
14585                "  SomeFunction([](decltype(x), A *a) {});\n"
14586                "}");
14587   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14588                "    [](const aaaaaaaaaa &a) { return a; });");
14589   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
14590                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
14591                "});");
14592   verifyFormat("Constructor()\n"
14593                "    : Field([] { // comment\n"
14594                "        int i;\n"
14595                "      }) {}");
14596   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
14597                "  return some_parameter.size();\n"
14598                "};");
14599   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
14600                "    [](const string &s) { return s; };");
14601   verifyFormat("int i = aaaaaa ? 1 //\n"
14602                "               : [] {\n"
14603                "                   return 2; //\n"
14604                "                 }();");
14605   verifyFormat("llvm::errs() << \"number of twos is \"\n"
14606                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
14607                "                  return x == 2; // force break\n"
14608                "                });");
14609   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14610                "    [=](int iiiiiiiiiiii) {\n"
14611                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
14612                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
14613                "    });",
14614                getLLVMStyleWithColumns(60));
14615   verifyFormat("SomeFunction({[&] {\n"
14616                "                // comment\n"
14617                "              },\n"
14618                "              [&] {\n"
14619                "                // comment\n"
14620                "              }});");
14621   verifyFormat("SomeFunction({[&] {\n"
14622                "  // comment\n"
14623                "}});");
14624   verifyFormat(
14625       "virtual aaaaaaaaaaaaaaaa(\n"
14626       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
14627       "    aaaaa aaaaaaaaa);");
14628 
14629   // Lambdas with return types.
14630   verifyFormat("int c = []() -> int { return 2; }();\n");
14631   verifyFormat("int c = []() -> int * { return 2; }();\n");
14632   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
14633   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
14634   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
14635   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
14636   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
14637   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
14638   verifyFormat("[a, a]() -> a<1> {};");
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<5 << 2> { return {}; };");
14645   verifyFormat("[]() -> foo<!5> { return {}; };");
14646   verifyFormat("[]() -> foo<~5> { return {}; };");
14647   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
14648   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
14649   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
14650   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
14651   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
14652   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
14653   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
14654   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
14655   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
14656   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
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 * 2> { return {}; }};\n"
14672                "} // namespace bar");
14673   verifyFormat("namespace bar {\n"
14674                "// broken:\n"
14675                "auto foo{[]() -> foo<5 % 2> { 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> { return {}; }};\n"
14684                "} // namespace bar");
14685   verifyFormat("namespace bar {\n"
14686                "// broken:\n"
14687                "auto foo{[]() -> foo<~5> { 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<5 >= 2> { return {}; }};\n"
14716                "} // namespace bar");
14717   verifyFormat("namespace bar {\n"
14718                "// broken:\n"
14719                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
14720                "} // namespace bar");
14721   verifyFormat("namespace bar {\n"
14722                "// broken:\n"
14723                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
14724                "} // namespace bar");
14725   verifyFormat("namespace bar {\n"
14726                "// broken:\n"
14727                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
14728                "} // namespace bar");
14729   verifyFormat("[]() -> a<1> {};");
14730   verifyFormat("[]() -> a<1> { ; };");
14731   verifyFormat("[]() -> a<1> { ; }();");
14732   verifyFormat("[a, a]() -> a<true> {};");
14733   verifyFormat("[]() -> a<true> {};");
14734   verifyFormat("[]() -> a<true> { ; };");
14735   verifyFormat("[]() -> a<true> { ; }();");
14736   verifyFormat("[a, a]() -> a<false> {};");
14737   verifyFormat("[]() -> a<false> {};");
14738   verifyFormat("[]() -> a<false> { ; };");
14739   verifyFormat("[]() -> a<false> { ; }();");
14740   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
14741   verifyFormat("namespace bar {\n"
14742                "auto foo{[]() -> foo<false> { ; }};\n"
14743                "} // namespace bar");
14744   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
14745                "                   int j) -> int {\n"
14746                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
14747                "};");
14748   verifyFormat(
14749       "aaaaaaaaaaaaaaaaaaaaaa(\n"
14750       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
14751       "      return aaaaaaaaaaaaaaaaa;\n"
14752       "    });",
14753       getLLVMStyleWithColumns(70));
14754   verifyFormat("[]() //\n"
14755                "    -> int {\n"
14756                "  return 1; //\n"
14757                "};");
14758   verifyFormat("[]() -> Void<T...> {};");
14759   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
14760 
14761   // Lambdas with explicit template argument lists.
14762   verifyFormat(
14763       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
14764 
14765   // Multiple lambdas in the same parentheses change indentation rules. These
14766   // lambdas are forced to start on new lines.
14767   verifyFormat("SomeFunction(\n"
14768                "    []() {\n"
14769                "      //\n"
14770                "    },\n"
14771                "    []() {\n"
14772                "      //\n"
14773                "    });");
14774 
14775   // A lambda passed as arg0 is always pushed to the next line.
14776   verifyFormat("SomeFunction(\n"
14777                "    [this] {\n"
14778                "      //\n"
14779                "    },\n"
14780                "    1);\n");
14781 
14782   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
14783   // the arg0 case above.
14784   auto Style = getGoogleStyle();
14785   Style.BinPackArguments = false;
14786   verifyFormat("SomeFunction(\n"
14787                "    a,\n"
14788                "    [this] {\n"
14789                "      //\n"
14790                "    },\n"
14791                "    b);\n",
14792                Style);
14793   verifyFormat("SomeFunction(\n"
14794                "    a,\n"
14795                "    [this] {\n"
14796                "      //\n"
14797                "    },\n"
14798                "    b);\n");
14799 
14800   // A lambda with a very long line forces arg0 to be pushed out irrespective of
14801   // the BinPackArguments value (as long as the code is wide enough).
14802   verifyFormat(
14803       "something->SomeFunction(\n"
14804       "    a,\n"
14805       "    [this] {\n"
14806       "      "
14807       "D0000000000000000000000000000000000000000000000000000000000001();\n"
14808       "    },\n"
14809       "    b);\n");
14810 
14811   // A multi-line lambda is pulled up as long as the introducer fits on the
14812   // previous line and there are no further args.
14813   verifyFormat("function(1, [this, that] {\n"
14814                "  //\n"
14815                "});\n");
14816   verifyFormat("function([this, that] {\n"
14817                "  //\n"
14818                "});\n");
14819   // FIXME: this format is not ideal and we should consider forcing the first
14820   // arg onto its own line.
14821   verifyFormat("function(a, b, c, //\n"
14822                "         d, [this, that] {\n"
14823                "           //\n"
14824                "         });\n");
14825 
14826   // Multiple lambdas are treated correctly even when there is a short arg0.
14827   verifyFormat("SomeFunction(\n"
14828                "    1,\n"
14829                "    [this] {\n"
14830                "      //\n"
14831                "    },\n"
14832                "    [this] {\n"
14833                "      //\n"
14834                "    },\n"
14835                "    1);\n");
14836 
14837   // More complex introducers.
14838   verifyFormat("return [i, args...] {};");
14839 
14840   // Not lambdas.
14841   verifyFormat("constexpr char hello[]{\"hello\"};");
14842   verifyFormat("double &operator[](int i) { return 0; }\n"
14843                "int i;");
14844   verifyFormat("std::unique_ptr<int[]> foo() {}");
14845   verifyFormat("int i = a[a][a]->f();");
14846   verifyFormat("int i = (*b)[a]->f();");
14847 
14848   // Other corner cases.
14849   verifyFormat("void f() {\n"
14850                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
14851                "  );\n"
14852                "}");
14853 
14854   // Lambdas created through weird macros.
14855   verifyFormat("void f() {\n"
14856                "  MACRO((const AA &a) { return 1; });\n"
14857                "  MACRO((AA &a) { return 1; });\n"
14858                "}");
14859 
14860   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
14861                "      doo_dah();\n"
14862                "      doo_dah();\n"
14863                "    })) {\n"
14864                "}");
14865   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
14866                "                doo_dah();\n"
14867                "                doo_dah();\n"
14868                "              })) {\n"
14869                "}");
14870   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
14871                "                doo_dah();\n"
14872                "                doo_dah();\n"
14873                "              })) {\n"
14874                "}");
14875   verifyFormat("auto lambda = []() {\n"
14876                "  int a = 2\n"
14877                "#if A\n"
14878                "          + 2\n"
14879                "#endif\n"
14880                "      ;\n"
14881                "};");
14882 
14883   // Lambdas with complex multiline introducers.
14884   verifyFormat(
14885       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14886       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
14887       "        -> ::std::unordered_set<\n"
14888       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
14889       "      //\n"
14890       "    });");
14891 
14892   FormatStyle DoNotMerge = getLLVMStyle();
14893   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
14894   verifyFormat("auto c = []() {\n"
14895                "  return b;\n"
14896                "};",
14897                "auto c = []() { return b; };", DoNotMerge);
14898   verifyFormat("auto c = []() {\n"
14899                "};",
14900                " auto c = []() {};", DoNotMerge);
14901 
14902   FormatStyle MergeEmptyOnly = getLLVMStyle();
14903   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
14904   verifyFormat("auto c = []() {\n"
14905                "  return b;\n"
14906                "};",
14907                "auto c = []() {\n"
14908                "  return b;\n"
14909                " };",
14910                MergeEmptyOnly);
14911   verifyFormat("auto c = []() {};",
14912                "auto c = []() {\n"
14913                "};",
14914                MergeEmptyOnly);
14915 
14916   FormatStyle MergeInline = getLLVMStyle();
14917   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
14918   verifyFormat("auto c = []() {\n"
14919                "  return b;\n"
14920                "};",
14921                "auto c = []() { return b; };", MergeInline);
14922   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
14923                MergeInline);
14924   verifyFormat("function([]() { return b; }, a)",
14925                "function([]() { return b; }, a)", MergeInline);
14926   verifyFormat("function(a, []() { return b; })",
14927                "function(a, []() { return b; })", MergeInline);
14928 
14929   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
14930   // AllowShortLambdasOnASingleLine
14931   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
14932   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
14933   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
14934   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
14935       FormatStyle::ShortLambdaStyle::SLS_None;
14936   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
14937                "    []()\n"
14938                "    {\n"
14939                "      return 17;\n"
14940                "    });",
14941                LLVMWithBeforeLambdaBody);
14942   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
14943                "    []()\n"
14944                "    {\n"
14945                "    });",
14946                LLVMWithBeforeLambdaBody);
14947   verifyFormat("auto fct_SLS_None = []()\n"
14948                "{\n"
14949                "  return 17;\n"
14950                "};",
14951                LLVMWithBeforeLambdaBody);
14952   verifyFormat("TwoNestedLambdas_SLS_None(\n"
14953                "    []()\n"
14954                "    {\n"
14955                "      return Call(\n"
14956                "          []()\n"
14957                "          {\n"
14958                "            return 17;\n"
14959                "          });\n"
14960                "    });",
14961                LLVMWithBeforeLambdaBody);
14962   verifyFormat("void Fct()\n"
14963                "{\n"
14964                "  return {[]()\n"
14965                "          {\n"
14966                "            return 17;\n"
14967                "          }};\n"
14968                "}",
14969                LLVMWithBeforeLambdaBody);
14970 
14971   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
14972       FormatStyle::ShortLambdaStyle::SLS_Empty;
14973   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
14974                "    []()\n"
14975                "    {\n"
14976                "      return 17;\n"
14977                "    });",
14978                LLVMWithBeforeLambdaBody);
14979   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
14980                LLVMWithBeforeLambdaBody);
14981   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
14982                "ongFunctionName_SLS_Empty(\n"
14983                "    []() {});",
14984                LLVMWithBeforeLambdaBody);
14985   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
14986                "                                []()\n"
14987                "                                {\n"
14988                "                                  return 17;\n"
14989                "                                });",
14990                LLVMWithBeforeLambdaBody);
14991   verifyFormat("auto fct_SLS_Empty = []()\n"
14992                "{\n"
14993                "  return 17;\n"
14994                "};",
14995                LLVMWithBeforeLambdaBody);
14996   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
14997                "    []()\n"
14998                "    {\n"
14999                "      return Call([]() {});\n"
15000                "    });",
15001                LLVMWithBeforeLambdaBody);
15002   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15003                "                           []()\n"
15004                "                           {\n"
15005                "                             return Call([]() {});\n"
15006                "                           });",
15007                LLVMWithBeforeLambdaBody);
15008   verifyFormat(
15009       "FctWithLongLineInLambda_SLS_Empty(\n"
15010       "    []()\n"
15011       "    {\n"
15012       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15013       "                               AndShouldNotBeConsiderAsInline,\n"
15014       "                               LambdaBodyMustBeBreak);\n"
15015       "    });",
15016       LLVMWithBeforeLambdaBody);
15017 
15018   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15019       FormatStyle::ShortLambdaStyle::SLS_Inline;
15020   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15021                LLVMWithBeforeLambdaBody);
15022   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15023                LLVMWithBeforeLambdaBody);
15024   verifyFormat("auto fct_SLS_Inline = []()\n"
15025                "{\n"
15026                "  return 17;\n"
15027                "};",
15028                LLVMWithBeforeLambdaBody);
15029   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15030                "17; }); });",
15031                LLVMWithBeforeLambdaBody);
15032   verifyFormat(
15033       "FctWithLongLineInLambda_SLS_Inline(\n"
15034       "    []()\n"
15035       "    {\n"
15036       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15037       "                               AndShouldNotBeConsiderAsInline,\n"
15038       "                               LambdaBodyMustBeBreak);\n"
15039       "    });",
15040       LLVMWithBeforeLambdaBody);
15041   verifyFormat("FctWithMultipleParams_SLS_Inline("
15042                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15043                "                                 []() { return 17; });",
15044                LLVMWithBeforeLambdaBody);
15045   verifyFormat(
15046       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15047       LLVMWithBeforeLambdaBody);
15048 
15049   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15050       FormatStyle::ShortLambdaStyle::SLS_All;
15051   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15052                LLVMWithBeforeLambdaBody);
15053   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15054                LLVMWithBeforeLambdaBody);
15055   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15056                LLVMWithBeforeLambdaBody);
15057   verifyFormat("FctWithOneParam_SLS_All(\n"
15058                "    []()\n"
15059                "    {\n"
15060                "      // A cool function...\n"
15061                "      return 43;\n"
15062                "    });",
15063                LLVMWithBeforeLambdaBody);
15064   verifyFormat("FctWithMultipleParams_SLS_All("
15065                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15066                "                              []() { return 17; });",
15067                LLVMWithBeforeLambdaBody);
15068   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15069                LLVMWithBeforeLambdaBody);
15070   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15071                LLVMWithBeforeLambdaBody);
15072   verifyFormat(
15073       "FctWithLongLineInLambda_SLS_All(\n"
15074       "    []()\n"
15075       "    {\n"
15076       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15077       "                               AndShouldNotBeConsiderAsInline,\n"
15078       "                               LambdaBodyMustBeBreak);\n"
15079       "    });",
15080       LLVMWithBeforeLambdaBody);
15081   verifyFormat(
15082       "auto fct_SLS_All = []()\n"
15083       "{\n"
15084       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15085       "                           AndShouldNotBeConsiderAsInline,\n"
15086       "                           LambdaBodyMustBeBreak);\n"
15087       "};",
15088       LLVMWithBeforeLambdaBody);
15089   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15090   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15091                LLVMWithBeforeLambdaBody);
15092   verifyFormat(
15093       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15094       "                                FirstParam,\n"
15095       "                                SecondParam,\n"
15096       "                                ThirdParam,\n"
15097       "                                FourthParam);",
15098       LLVMWithBeforeLambdaBody);
15099   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15100                "    []() { return "
15101                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15102                "    FirstParam,\n"
15103                "    SecondParam,\n"
15104                "    ThirdParam,\n"
15105                "    FourthParam);",
15106                LLVMWithBeforeLambdaBody);
15107   verifyFormat(
15108       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15109       "                                SecondParam,\n"
15110       "                                ThirdParam,\n"
15111       "                                FourthParam,\n"
15112       "                                []() { return SomeValueNotSoLong; });",
15113       LLVMWithBeforeLambdaBody);
15114   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15115                "    []()\n"
15116                "    {\n"
15117                "      return "
15118                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15119                "eConsiderAsInline;\n"
15120                "    });",
15121                LLVMWithBeforeLambdaBody);
15122   verifyFormat(
15123       "FctWithLongLineInLambda_SLS_All(\n"
15124       "    []()\n"
15125       "    {\n"
15126       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15127       "                               AndShouldNotBeConsiderAsInline,\n"
15128       "                               LambdaBodyMustBeBreak);\n"
15129       "    });",
15130       LLVMWithBeforeLambdaBody);
15131   verifyFormat("FctWithTwoParams_SLS_All(\n"
15132                "    []()\n"
15133                "    {\n"
15134                "      // A cool function...\n"
15135                "      return 43;\n"
15136                "    },\n"
15137                "    87);",
15138                LLVMWithBeforeLambdaBody);
15139   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15140                LLVMWithBeforeLambdaBody);
15141   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15142                LLVMWithBeforeLambdaBody);
15143   verifyFormat(
15144       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15145       LLVMWithBeforeLambdaBody);
15146   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15147                "}); }, x);",
15148                LLVMWithBeforeLambdaBody);
15149   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15150                "    []()\n"
15151                "    {\n"
15152                "      // A cool function...\n"
15153                "      return Call([]() { return 17; });\n"
15154                "    });",
15155                LLVMWithBeforeLambdaBody);
15156   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15157                "    []()\n"
15158                "    {\n"
15159                "      return Call(\n"
15160                "          []()\n"
15161                "          {\n"
15162                "            // A cool function...\n"
15163                "            return 17;\n"
15164                "          });\n"
15165                "    });",
15166                LLVMWithBeforeLambdaBody);
15167 }
15168 
15169 TEST_F(FormatTest, LambdaWithLineComments) {
15170   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15171   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15172   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15173   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15174       FormatStyle::ShortLambdaStyle::SLS_All;
15175 
15176   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15177   verifyFormat("auto k = []() // comment\n"
15178                "{ return; }",
15179                LLVMWithBeforeLambdaBody);
15180   verifyFormat("auto k = []() /* comment */ { return; }",
15181                LLVMWithBeforeLambdaBody);
15182   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15183                LLVMWithBeforeLambdaBody);
15184   verifyFormat("auto k = []() // X\n"
15185                "{ return; }",
15186                LLVMWithBeforeLambdaBody);
15187   verifyFormat(
15188       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15189       "{ return; }",
15190       LLVMWithBeforeLambdaBody);
15191 }
15192 
15193 TEST_F(FormatTest, EmptyLinesInLambdas) {
15194   verifyFormat("auto lambda = []() {\n"
15195                "  x(); //\n"
15196                "};",
15197                "auto lambda = []() {\n"
15198                "\n"
15199                "  x(); //\n"
15200                "\n"
15201                "};");
15202 }
15203 
15204 TEST_F(FormatTest, FormatsBlocks) {
15205   FormatStyle ShortBlocks = getLLVMStyle();
15206   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15207   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15208   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15209   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15210   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15211   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15212   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15213 
15214   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15215   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15216   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15217 
15218   verifyFormat("[operation setCompletionBlock:^{\n"
15219                "  [self onOperationDone];\n"
15220                "}];");
15221   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15222                "  [self onOperationDone];\n"
15223                "}]};");
15224   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15225                "  f();\n"
15226                "}];");
15227   verifyFormat("int a = [operation block:^int(int *i) {\n"
15228                "  return 1;\n"
15229                "}];");
15230   verifyFormat("[myObject doSomethingWith:arg1\n"
15231                "                      aaa:^int(int *a) {\n"
15232                "                        return 1;\n"
15233                "                      }\n"
15234                "                      bbb:f(a * bbbbbbbb)];");
15235 
15236   verifyFormat("[operation setCompletionBlock:^{\n"
15237                "  [self.delegate newDataAvailable];\n"
15238                "}];",
15239                getLLVMStyleWithColumns(60));
15240   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15241                "  NSString *path = [self sessionFilePath];\n"
15242                "  if (path) {\n"
15243                "    // ...\n"
15244                "  }\n"
15245                "});");
15246   verifyFormat("[[SessionService sharedService]\n"
15247                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15248                "      if (window) {\n"
15249                "        [self windowDidLoad:window];\n"
15250                "      } else {\n"
15251                "        [self errorLoadingWindow];\n"
15252                "      }\n"
15253                "    }];");
15254   verifyFormat("void (^largeBlock)(void) = ^{\n"
15255                "  // ...\n"
15256                "};\n",
15257                getLLVMStyleWithColumns(40));
15258   verifyFormat("[[SessionService sharedService]\n"
15259                "    loadWindowWithCompletionBlock: //\n"
15260                "        ^(SessionWindow *window) {\n"
15261                "          if (window) {\n"
15262                "            [self windowDidLoad:window];\n"
15263                "          } else {\n"
15264                "            [self errorLoadingWindow];\n"
15265                "          }\n"
15266                "        }];",
15267                getLLVMStyleWithColumns(60));
15268   verifyFormat("[myObject doSomethingWith:arg1\n"
15269                "    firstBlock:^(Foo *a) {\n"
15270                "      // ...\n"
15271                "      int i;\n"
15272                "    }\n"
15273                "    secondBlock:^(Bar *b) {\n"
15274                "      // ...\n"
15275                "      int i;\n"
15276                "    }\n"
15277                "    thirdBlock:^Foo(Bar *b) {\n"
15278                "      // ...\n"
15279                "      int i;\n"
15280                "    }];");
15281   verifyFormat("[myObject doSomethingWith:arg1\n"
15282                "               firstBlock:-1\n"
15283                "              secondBlock:^(Bar *b) {\n"
15284                "                // ...\n"
15285                "                int i;\n"
15286                "              }];");
15287 
15288   verifyFormat("f(^{\n"
15289                "  @autoreleasepool {\n"
15290                "    if (a) {\n"
15291                "      g();\n"
15292                "    }\n"
15293                "  }\n"
15294                "});");
15295   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15296   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15297                "};");
15298 
15299   FormatStyle FourIndent = getLLVMStyle();
15300   FourIndent.ObjCBlockIndentWidth = 4;
15301   verifyFormat("[operation setCompletionBlock:^{\n"
15302                "    [self onOperationDone];\n"
15303                "}];",
15304                FourIndent);
15305 }
15306 
15307 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15308   FormatStyle ZeroColumn = getLLVMStyle();
15309   ZeroColumn.ColumnLimit = 0;
15310 
15311   verifyFormat("[[SessionService sharedService] "
15312                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15313                "  if (window) {\n"
15314                "    [self windowDidLoad:window];\n"
15315                "  } else {\n"
15316                "    [self errorLoadingWindow];\n"
15317                "  }\n"
15318                "}];",
15319                ZeroColumn);
15320   EXPECT_EQ("[[SessionService sharedService]\n"
15321             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15322             "      if (window) {\n"
15323             "        [self windowDidLoad:window];\n"
15324             "      } else {\n"
15325             "        [self errorLoadingWindow];\n"
15326             "      }\n"
15327             "    }];",
15328             format("[[SessionService sharedService]\n"
15329                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15330                    "                if (window) {\n"
15331                    "    [self windowDidLoad:window];\n"
15332                    "  } else {\n"
15333                    "    [self errorLoadingWindow];\n"
15334                    "  }\n"
15335                    "}];",
15336                    ZeroColumn));
15337   verifyFormat("[myObject doSomethingWith:arg1\n"
15338                "    firstBlock:^(Foo *a) {\n"
15339                "      // ...\n"
15340                "      int i;\n"
15341                "    }\n"
15342                "    secondBlock:^(Bar *b) {\n"
15343                "      // ...\n"
15344                "      int i;\n"
15345                "    }\n"
15346                "    thirdBlock:^Foo(Bar *b) {\n"
15347                "      // ...\n"
15348                "      int i;\n"
15349                "    }];",
15350                ZeroColumn);
15351   verifyFormat("f(^{\n"
15352                "  @autoreleasepool {\n"
15353                "    if (a) {\n"
15354                "      g();\n"
15355                "    }\n"
15356                "  }\n"
15357                "});",
15358                ZeroColumn);
15359   verifyFormat("void (^largeBlock)(void) = ^{\n"
15360                "  // ...\n"
15361                "};",
15362                ZeroColumn);
15363 
15364   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15365   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15366             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15367   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15368   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15369             "  int i;\n"
15370             "};",
15371             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15372 }
15373 
15374 TEST_F(FormatTest, SupportsCRLF) {
15375   EXPECT_EQ("int a;\r\n"
15376             "int b;\r\n"
15377             "int c;\r\n",
15378             format("int a;\r\n"
15379                    "  int b;\r\n"
15380                    "    int c;\r\n",
15381                    getLLVMStyle()));
15382   EXPECT_EQ("int a;\r\n"
15383             "int b;\r\n"
15384             "int c;\r\n",
15385             format("int a;\r\n"
15386                    "  int b;\n"
15387                    "    int c;\r\n",
15388                    getLLVMStyle()));
15389   EXPECT_EQ("int a;\n"
15390             "int b;\n"
15391             "int c;\n",
15392             format("int a;\r\n"
15393                    "  int b;\n"
15394                    "    int c;\n",
15395                    getLLVMStyle()));
15396   EXPECT_EQ("\"aaaaaaa \"\r\n"
15397             "\"bbbbbbb\";\r\n",
15398             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15399   EXPECT_EQ("#define A \\\r\n"
15400             "  b;      \\\r\n"
15401             "  c;      \\\r\n"
15402             "  d;\r\n",
15403             format("#define A \\\r\n"
15404                    "  b; \\\r\n"
15405                    "  c; d; \r\n",
15406                    getGoogleStyle()));
15407 
15408   EXPECT_EQ("/*\r\n"
15409             "multi line block comments\r\n"
15410             "should not introduce\r\n"
15411             "an extra carriage return\r\n"
15412             "*/\r\n",
15413             format("/*\r\n"
15414                    "multi line block comments\r\n"
15415                    "should not introduce\r\n"
15416                    "an extra carriage return\r\n"
15417                    "*/\r\n"));
15418   EXPECT_EQ("/*\r\n"
15419             "\r\n"
15420             "*/",
15421             format("/*\r\n"
15422                    "    \r\r\r\n"
15423                    "*/"));
15424 
15425   FormatStyle style = getLLVMStyle();
15426 
15427   style.DeriveLineEnding = true;
15428   style.UseCRLF = false;
15429   EXPECT_EQ("union FooBarBazQux {\n"
15430             "  int foo;\n"
15431             "  int bar;\n"
15432             "  int baz;\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   style.UseCRLF = true;
15441   EXPECT_EQ("union FooBarBazQux {\r\n"
15442             "  int foo;\r\n"
15443             "  int bar;\r\n"
15444             "  int baz;\r\n"
15445             "};",
15446             format("union FooBarBazQux {\r\n"
15447                    "  int foo;\n"
15448                    "  int bar;\r\n"
15449                    "  int baz;\n"
15450                    "};",
15451                    style));
15452 
15453   style.DeriveLineEnding = false;
15454   style.UseCRLF = false;
15455   EXPECT_EQ("union FooBarBazQux {\n"
15456             "  int foo;\n"
15457             "  int bar;\n"
15458             "  int baz;\n"
15459             "  int qux;\n"
15460             "};",
15461             format("union FooBarBazQux {\r\n"
15462                    "  int foo;\n"
15463                    "  int bar;\r\n"
15464                    "  int baz;\n"
15465                    "  int qux;\r\n"
15466                    "};",
15467                    style));
15468   style.UseCRLF = true;
15469   EXPECT_EQ("union FooBarBazQux {\r\n"
15470             "  int foo;\r\n"
15471             "  int bar;\r\n"
15472             "  int baz;\r\n"
15473             "  int qux;\r\n"
15474             "};",
15475             format("union FooBarBazQux {\r\n"
15476                    "  int foo;\n"
15477                    "  int bar;\r\n"
15478                    "  int baz;\n"
15479                    "  int qux;\n"
15480                    "};",
15481                    style));
15482 
15483   style.DeriveLineEnding = true;
15484   style.UseCRLF = false;
15485   EXPECT_EQ("union FooBarBazQux {\r\n"
15486             "  int foo;\r\n"
15487             "  int bar;\r\n"
15488             "  int baz;\r\n"
15489             "  int qux;\r\n"
15490             "};",
15491             format("union FooBarBazQux {\r\n"
15492                    "  int foo;\n"
15493                    "  int bar;\r\n"
15494                    "  int baz;\n"
15495                    "  int qux;\r\n"
15496                    "};",
15497                    style));
15498   style.UseCRLF = true;
15499   EXPECT_EQ("union FooBarBazQux {\n"
15500             "  int foo;\n"
15501             "  int bar;\n"
15502             "  int baz;\n"
15503             "  int qux;\n"
15504             "};",
15505             format("union FooBarBazQux {\r\n"
15506                    "  int foo;\n"
15507                    "  int bar;\r\n"
15508                    "  int baz;\n"
15509                    "  int qux;\n"
15510                    "};",
15511                    style));
15512 }
15513 
15514 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
15515   verifyFormat("MY_CLASS(C) {\n"
15516                "  int i;\n"
15517                "  int j;\n"
15518                "};");
15519 }
15520 
15521 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
15522   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
15523   TwoIndent.ContinuationIndentWidth = 2;
15524 
15525   EXPECT_EQ("int i =\n"
15526             "  longFunction(\n"
15527             "    arg);",
15528             format("int i = longFunction(arg);", TwoIndent));
15529 
15530   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
15531   SixIndent.ContinuationIndentWidth = 6;
15532 
15533   EXPECT_EQ("int i =\n"
15534             "      longFunction(\n"
15535             "            arg);",
15536             format("int i = longFunction(arg);", SixIndent));
15537 }
15538 
15539 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
15540   FormatStyle Style = getLLVMStyle();
15541   verifyFormat("int Foo::getter(\n"
15542                "    //\n"
15543                ") const {\n"
15544                "  return foo;\n"
15545                "}",
15546                Style);
15547   verifyFormat("void Foo::setter(\n"
15548                "    //\n"
15549                ") {\n"
15550                "  foo = 1;\n"
15551                "}",
15552                Style);
15553 }
15554 
15555 TEST_F(FormatTest, SpacesInAngles) {
15556   FormatStyle Spaces = getLLVMStyle();
15557   Spaces.SpacesInAngles = true;
15558 
15559   verifyFormat("static_cast< int >(arg);", Spaces);
15560   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
15561   verifyFormat("f< int, float >();", Spaces);
15562   verifyFormat("template <> g() {}", Spaces);
15563   verifyFormat("template < std::vector< int > > f() {}", Spaces);
15564   verifyFormat("std::function< void(int, int) > fct;", Spaces);
15565   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
15566                Spaces);
15567 
15568   Spaces.Standard = FormatStyle::LS_Cpp03;
15569   Spaces.SpacesInAngles = true;
15570   verifyFormat("A< A< int > >();", Spaces);
15571 
15572   Spaces.SpacesInAngles = false;
15573   verifyFormat("A<A<int> >();", Spaces);
15574 
15575   Spaces.Standard = FormatStyle::LS_Cpp11;
15576   Spaces.SpacesInAngles = true;
15577   verifyFormat("A< A< int > >();", Spaces);
15578 
15579   Spaces.SpacesInAngles = false;
15580   verifyFormat("A<A<int>>();", Spaces);
15581 }
15582 
15583 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
15584   FormatStyle Style = getLLVMStyle();
15585   Style.SpaceAfterTemplateKeyword = false;
15586   verifyFormat("template<int> void foo();", Style);
15587 }
15588 
15589 TEST_F(FormatTest, TripleAngleBrackets) {
15590   verifyFormat("f<<<1, 1>>>();");
15591   verifyFormat("f<<<1, 1, 1, s>>>();");
15592   verifyFormat("f<<<a, b, c, d>>>();");
15593   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
15594   verifyFormat("f<param><<<1, 1>>>();");
15595   verifyFormat("f<1><<<1, 1>>>();");
15596   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
15597   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15598                "aaaaaaaaaaa<<<\n    1, 1>>>();");
15599   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
15600                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
15601 }
15602 
15603 TEST_F(FormatTest, MergeLessLessAtEnd) {
15604   verifyFormat("<<");
15605   EXPECT_EQ("< < <", format("\\\n<<<"));
15606   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15607                "aaallvm::outs() <<");
15608   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15609                "aaaallvm::outs()\n    <<");
15610 }
15611 
15612 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
15613   std::string code = "#if A\n"
15614                      "#if B\n"
15615                      "a.\n"
15616                      "#endif\n"
15617                      "    a = 1;\n"
15618                      "#else\n"
15619                      "#endif\n"
15620                      "#if C\n"
15621                      "#else\n"
15622                      "#endif\n";
15623   EXPECT_EQ(code, format(code));
15624 }
15625 
15626 TEST_F(FormatTest, HandleConflictMarkers) {
15627   // Git/SVN conflict markers.
15628   EXPECT_EQ("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, parameter3),\n"
15638             ">>>>>>> text by the vcs\n"
15639             "         otherparameter);\n",
15640             format("int a;\n"
15641                    "void f() {\n"
15642                    "  callme(some(parameter1,\n"
15643                    "<<<<<<< text by the vcs\n"
15644                    "  parameter2),\n"
15645                    "||||||| text by the vcs\n"
15646                    "  parameter2),\n"
15647                    "  parameter3,\n"
15648                    "======= text by the vcs\n"
15649                    "  parameter2,\n"
15650                    "  parameter3),\n"
15651                    ">>>>>>> text by the vcs\n"
15652                    "  otherparameter);\n"));
15653 
15654   // Perforce markers.
15655   EXPECT_EQ("void f() {\n"
15656             "  function(\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             "<<<< text by the vcs\n"
15664             "      parameter);\n",
15665             format("void f() {\n"
15666                    "  function(\n"
15667                    ">>>> text by the vcs\n"
15668                    "  parameter,\n"
15669                    "==== text by the vcs\n"
15670                    "  parameter,\n"
15671                    "==== text by the vcs\n"
15672                    "  parameter,\n"
15673                    "<<<< text by the vcs\n"
15674                    "  parameter);\n"));
15675 
15676   EXPECT_EQ("<<<<<<<\n"
15677             "|||||||\n"
15678             "=======\n"
15679             ">>>>>>>",
15680             format("<<<<<<<\n"
15681                    "|||||||\n"
15682                    "=======\n"
15683                    ">>>>>>>"));
15684 
15685   EXPECT_EQ("<<<<<<<\n"
15686             "|||||||\n"
15687             "int i;\n"
15688             "=======\n"
15689             ">>>>>>>",
15690             format("<<<<<<<\n"
15691                    "|||||||\n"
15692                    "int i;\n"
15693                    "=======\n"
15694                    ">>>>>>>"));
15695 
15696   // FIXME: Handle parsing of macros around conflict markers correctly:
15697   EXPECT_EQ("#define Macro \\\n"
15698             "<<<<<<<\n"
15699             "Something \\\n"
15700             "|||||||\n"
15701             "Else \\\n"
15702             "=======\n"
15703             "Other \\\n"
15704             ">>>>>>>\n"
15705             "    End int i;\n",
15706             format("#define Macro \\\n"
15707                    "<<<<<<<\n"
15708                    "  Something \\\n"
15709                    "|||||||\n"
15710                    "  Else \\\n"
15711                    "=======\n"
15712                    "  Other \\\n"
15713                    ">>>>>>>\n"
15714                    "  End\n"
15715                    "int i;\n"));
15716 }
15717 
15718 TEST_F(FormatTest, DisableRegions) {
15719   EXPECT_EQ("int i;\n"
15720             "// clang-format off\n"
15721             "  int j;\n"
15722             "// clang-format on\n"
15723             "int k;",
15724             format(" int  i;\n"
15725                    "   // clang-format off\n"
15726                    "  int j;\n"
15727                    " // clang-format on\n"
15728                    "   int   k;"));
15729   EXPECT_EQ("int i;\n"
15730             "/* clang-format off */\n"
15731             "  int j;\n"
15732             "/* clang-format on */\n"
15733             "int k;",
15734             format(" int  i;\n"
15735                    "   /* clang-format off */\n"
15736                    "  int j;\n"
15737                    " /* clang-format on */\n"
15738                    "   int   k;"));
15739 
15740   // Don't reflow comments within disabled regions.
15741   EXPECT_EQ("// clang-format off\n"
15742             "// long long long long long long line\n"
15743             "/* clang-format on */\n"
15744             "/* long long long\n"
15745             " * long long long\n"
15746             " * line */\n"
15747             "int i;\n"
15748             "/* clang-format off */\n"
15749             "/* long long long long long long line */\n",
15750             format("// clang-format off\n"
15751                    "// long long long long long long line\n"
15752                    "/* clang-format on */\n"
15753                    "/* long long long long long long line */\n"
15754                    "int i;\n"
15755                    "/* clang-format off */\n"
15756                    "/* long long long long long long line */\n",
15757                    getLLVMStyleWithColumns(20)));
15758 }
15759 
15760 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
15761   format("? ) =");
15762   verifyNoCrash("#define a\\\n /**/}");
15763 }
15764 
15765 TEST_F(FormatTest, FormatsTableGenCode) {
15766   FormatStyle Style = getLLVMStyle();
15767   Style.Language = FormatStyle::LK_TableGen;
15768   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
15769 }
15770 
15771 TEST_F(FormatTest, ArrayOfTemplates) {
15772   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
15773             format("auto a = new unique_ptr<int > [ 10];"));
15774 
15775   FormatStyle Spaces = getLLVMStyle();
15776   Spaces.SpacesInSquareBrackets = true;
15777   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
15778             format("auto a = new unique_ptr<int > [10];", Spaces));
15779 }
15780 
15781 TEST_F(FormatTest, ArrayAsTemplateType) {
15782   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
15783             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
15784 
15785   FormatStyle Spaces = getLLVMStyle();
15786   Spaces.SpacesInSquareBrackets = true;
15787   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
15788             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
15789 }
15790 
15791 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
15792 
15793 TEST(FormatStyle, GetStyleWithEmptyFileName) {
15794   llvm::vfs::InMemoryFileSystem FS;
15795   auto Style1 = getStyle("file", "", "Google", "", &FS);
15796   ASSERT_TRUE((bool)Style1);
15797   ASSERT_EQ(*Style1, getGoogleStyle());
15798 }
15799 
15800 TEST(FormatStyle, GetStyleOfFile) {
15801   llvm::vfs::InMemoryFileSystem FS;
15802   // Test 1: format file in the same directory.
15803   ASSERT_TRUE(
15804       FS.addFile("/a/.clang-format", 0,
15805                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
15806   ASSERT_TRUE(
15807       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15808   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
15809   ASSERT_TRUE((bool)Style1);
15810   ASSERT_EQ(*Style1, getLLVMStyle());
15811 
15812   // Test 2.1: fallback to default.
15813   ASSERT_TRUE(
15814       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15815   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
15816   ASSERT_TRUE((bool)Style2);
15817   ASSERT_EQ(*Style2, getMozillaStyle());
15818 
15819   // Test 2.2: no format on 'none' fallback style.
15820   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
15821   ASSERT_TRUE((bool)Style2);
15822   ASSERT_EQ(*Style2, getNoStyle());
15823 
15824   // Test 2.3: format if config is found with no based style while fallback is
15825   // 'none'.
15826   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
15827                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
15828   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
15829   ASSERT_TRUE((bool)Style2);
15830   ASSERT_EQ(*Style2, getLLVMStyle());
15831 
15832   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
15833   Style2 = getStyle("{}", "a.h", "none", "", &FS);
15834   ASSERT_TRUE((bool)Style2);
15835   ASSERT_EQ(*Style2, getLLVMStyle());
15836 
15837   // Test 3: format file in parent directory.
15838   ASSERT_TRUE(
15839       FS.addFile("/c/.clang-format", 0,
15840                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
15841   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
15842                          llvm::MemoryBuffer::getMemBuffer("int i;")));
15843   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
15844   ASSERT_TRUE((bool)Style3);
15845   ASSERT_EQ(*Style3, getGoogleStyle());
15846 
15847   // Test 4: error on invalid fallback style
15848   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
15849   ASSERT_FALSE((bool)Style4);
15850   llvm::consumeError(Style4.takeError());
15851 
15852   // Test 5: error on invalid yaml on command line
15853   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
15854   ASSERT_FALSE((bool)Style5);
15855   llvm::consumeError(Style5.takeError());
15856 
15857   // Test 6: error on invalid style
15858   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
15859   ASSERT_FALSE((bool)Style6);
15860   llvm::consumeError(Style6.takeError());
15861 
15862   // Test 7: found config file, error on parsing it
15863   ASSERT_TRUE(
15864       FS.addFile("/d/.clang-format", 0,
15865                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
15866                                                   "InvalidKey: InvalidValue")));
15867   ASSERT_TRUE(
15868       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15869   auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
15870   ASSERT_FALSE((bool)Style7);
15871   llvm::consumeError(Style7.takeError());
15872 
15873   // Test 8: inferred per-language defaults apply.
15874   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
15875   ASSERT_TRUE((bool)StyleTd);
15876   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
15877 }
15878 
15879 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
15880   // Column limit is 20.
15881   std::string Code = "Type *a =\n"
15882                      "    new Type();\n"
15883                      "g(iiiii, 0, jjjjj,\n"
15884                      "  0, kkkkk, 0, mm);\n"
15885                      "int  bad     = format   ;";
15886   std::string Expected = "auto a = new Type();\n"
15887                          "g(iiiii, nullptr,\n"
15888                          "  jjjjj, nullptr,\n"
15889                          "  kkkkk, nullptr,\n"
15890                          "  mm);\n"
15891                          "int  bad     = format   ;";
15892   FileID ID = Context.createInMemoryFile("format.cpp", Code);
15893   tooling::Replacements Replaces = toReplacements(
15894       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
15895                             "auto "),
15896        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
15897                             "nullptr"),
15898        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
15899                             "nullptr"),
15900        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
15901                             "nullptr")});
15902 
15903   format::FormatStyle Style = format::getLLVMStyle();
15904   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
15905   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
15906   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
15907       << llvm::toString(FormattedReplaces.takeError()) << "\n";
15908   auto Result = applyAllReplacements(Code, *FormattedReplaces);
15909   EXPECT_TRUE(static_cast<bool>(Result));
15910   EXPECT_EQ(Expected, *Result);
15911 }
15912 
15913 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
15914   std::string Code = "#include \"a.h\"\n"
15915                      "#include \"c.h\"\n"
15916                      "\n"
15917                      "int main() {\n"
15918                      "  return 0;\n"
15919                      "}";
15920   std::string Expected = "#include \"a.h\"\n"
15921                          "#include \"b.h\"\n"
15922                          "#include \"c.h\"\n"
15923                          "\n"
15924                          "int main() {\n"
15925                          "  return 0;\n"
15926                          "}";
15927   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
15928   tooling::Replacements Replaces = toReplacements(
15929       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
15930                             "#include \"b.h\"\n")});
15931 
15932   format::FormatStyle Style = format::getLLVMStyle();
15933   Style.SortIncludes = true;
15934   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
15935   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
15936       << llvm::toString(FormattedReplaces.takeError()) << "\n";
15937   auto Result = applyAllReplacements(Code, *FormattedReplaces);
15938   EXPECT_TRUE(static_cast<bool>(Result));
15939   EXPECT_EQ(Expected, *Result);
15940 }
15941 
15942 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
15943   EXPECT_EQ("using std::cin;\n"
15944             "using std::cout;",
15945             format("using std::cout;\n"
15946                    "using std::cin;",
15947                    getGoogleStyle()));
15948 }
15949 
15950 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
15951   format::FormatStyle Style = format::getLLVMStyle();
15952   Style.Standard = FormatStyle::LS_Cpp03;
15953   // cpp03 recognize this string as identifier u8 and literal character 'a'
15954   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
15955 }
15956 
15957 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
15958   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
15959   // all modes, including C++11, C++14 and C++17
15960   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
15961 }
15962 
15963 TEST_F(FormatTest, DoNotFormatLikelyXml) {
15964   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
15965   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
15966 }
15967 
15968 TEST_F(FormatTest, StructuredBindings) {
15969   // Structured bindings is a C++17 feature.
15970   // all modes, including C++11, C++14 and C++17
15971   verifyFormat("auto [a, b] = f();");
15972   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
15973   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
15974   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
15975   EXPECT_EQ("auto const volatile [a, b] = f();",
15976             format("auto  const   volatile[a, b] = f();"));
15977   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
15978   EXPECT_EQ("auto &[a, b, c] = f();",
15979             format("auto   &[  a  ,  b,c   ] = f();"));
15980   EXPECT_EQ("auto &&[a, b, c] = f();",
15981             format("auto   &&[  a  ,  b,c   ] = f();"));
15982   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
15983   EXPECT_EQ("auto const volatile &&[a, b] = f();",
15984             format("auto  const  volatile  &&[a, b] = f();"));
15985   EXPECT_EQ("auto const &&[a, b] = f();",
15986             format("auto  const   &&  [a, b] = f();"));
15987   EXPECT_EQ("const auto &[a, b] = f();",
15988             format("const  auto  &  [a, b] = f();"));
15989   EXPECT_EQ("const auto volatile &&[a, b] = f();",
15990             format("const  auto   volatile  &&[a, b] = f();"));
15991   EXPECT_EQ("volatile const auto &&[a, b] = f();",
15992             format("volatile  const  auto   &&[a, b] = f();"));
15993   EXPECT_EQ("const auto &&[a, b] = f();",
15994             format("const  auto  &&  [a, b] = f();"));
15995 
15996   // Make sure we don't mistake structured bindings for lambdas.
15997   FormatStyle PointerMiddle = getLLVMStyle();
15998   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
15999   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16000   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16001   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16002   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16003   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16004   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16005   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16006   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16007   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16008   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16009   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16010   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16011 
16012   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16013             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16014   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16015             format("for (const auto   &   [a, b] : some_range) {\n}"));
16016   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16017             format("for (const auto[a, b] : some_range) {\n}"));
16018   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16019   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16020   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16021   EXPECT_EQ("auto const &[x, y](expr);",
16022             format("auto  const  &  [x,y]  (expr);"));
16023   EXPECT_EQ("auto const &&[x, y](expr);",
16024             format("auto  const  &&  [x,y]  (expr);"));
16025   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16026   EXPECT_EQ("auto const &[x, y]{expr};",
16027             format("auto  const  &  [x,y]  {expr};"));
16028   EXPECT_EQ("auto const &&[x, y]{expr};",
16029             format("auto  const  &&  [x,y]  {expr};"));
16030 
16031   format::FormatStyle Spaces = format::getLLVMStyle();
16032   Spaces.SpacesInSquareBrackets = true;
16033   verifyFormat("auto [ a, b ] = f();", Spaces);
16034   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16035   verifyFormat("auto &[ a, b ] = f();", Spaces);
16036   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16037   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16038 }
16039 
16040 TEST_F(FormatTest, FileAndCode) {
16041   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16042   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16043   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16044   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16045   EXPECT_EQ(FormatStyle::LK_ObjC,
16046             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16047   EXPECT_EQ(
16048       FormatStyle::LK_ObjC,
16049       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16050   EXPECT_EQ(FormatStyle::LK_ObjC,
16051             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16052   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16053   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16054   EXPECT_EQ(FormatStyle::LK_ObjC,
16055             guessLanguage("foo", "@interface Foo\n@end\n"));
16056   EXPECT_EQ(FormatStyle::LK_ObjC,
16057             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16058   EXPECT_EQ(
16059       FormatStyle::LK_ObjC,
16060       guessLanguage("foo.h",
16061                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16062   EXPECT_EQ(
16063       FormatStyle::LK_Cpp,
16064       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16065 }
16066 
16067 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16068   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16069   EXPECT_EQ(FormatStyle::LK_ObjC,
16070             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16071   EXPECT_EQ(FormatStyle::LK_Cpp,
16072             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16073   EXPECT_EQ(
16074       FormatStyle::LK_Cpp,
16075       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16076   EXPECT_EQ(FormatStyle::LK_ObjC,
16077             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16078   EXPECT_EQ(FormatStyle::LK_Cpp,
16079             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16080   EXPECT_EQ(FormatStyle::LK_ObjC,
16081             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16082   EXPECT_EQ(FormatStyle::LK_Cpp,
16083             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16084   EXPECT_EQ(FormatStyle::LK_Cpp,
16085             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16086   EXPECT_EQ(FormatStyle::LK_ObjC,
16087             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16088   EXPECT_EQ(FormatStyle::LK_Cpp,
16089             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16090   EXPECT_EQ(
16091       FormatStyle::LK_Cpp,
16092       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16093   EXPECT_EQ(
16094       FormatStyle::LK_Cpp,
16095       guessLanguage("foo.h",
16096                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16097   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16098 }
16099 
16100 TEST_F(FormatTest, GuessLanguageWithCaret) {
16101   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16102   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16103   EXPECT_EQ(FormatStyle::LK_ObjC,
16104             guessLanguage("foo.h", "int(^)(char, float);"));
16105   EXPECT_EQ(FormatStyle::LK_ObjC,
16106             guessLanguage("foo.h", "int(^foo)(char, float);"));
16107   EXPECT_EQ(FormatStyle::LK_ObjC,
16108             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16109   EXPECT_EQ(FormatStyle::LK_ObjC,
16110             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16111   EXPECT_EQ(
16112       FormatStyle::LK_ObjC,
16113       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16114 }
16115 
16116 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16117   // ASM symbolic names are identifiers that must be surrounded by [] without
16118   // space in between:
16119   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16120 
16121   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16122   verifyFormat(R"(//
16123 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16124 )");
16125 
16126   // A list of several ASM symbolic names.
16127   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16128 
16129   // ASM symbolic names in inline ASM with inputs and outputs.
16130   verifyFormat(R"(//
16131 asm("cmoveq %1, %2, %[result]"
16132     : [result] "=r"(result)
16133     : "r"(test), "r"(new), "[result]"(old));
16134 )");
16135 
16136   // ASM symbolic names in inline ASM with no outputs.
16137   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16138 }
16139 
16140 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
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__ (\"mov %[e], %[d]\"\n"
16162                                    "     : [d] \"=rm\" (d)\n"
16163                                    "       [e] \"rm\" (*e));\n"
16164                                    "}"));
16165   EXPECT_EQ(FormatStyle::LK_Cpp,
16166             guessLanguage("foo.h", "void f() {\n"
16167                                    "  asm (\"mov %[e], %[d]\"\n"
16168                                    "     : [d] \"=rm\" (d),\n"
16169                                    "       [e] \"rm\" (*e));\n"
16170                                    "}"));
16171   EXPECT_EQ(FormatStyle::LK_Cpp,
16172             guessLanguage("foo.h", "void f() {\n"
16173                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16174                                    "     : [d] \"=rm\" (d)\n"
16175                                    "       [e] \"rm\" (*e));\n"
16176                                    "}"));
16177 }
16178 
16179 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16180   EXPECT_EQ(FormatStyle::LK_Cpp,
16181             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16182   EXPECT_EQ(FormatStyle::LK_ObjC,
16183             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16184   EXPECT_EQ(
16185       FormatStyle::LK_Cpp,
16186       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16187   EXPECT_EQ(
16188       FormatStyle::LK_ObjC,
16189       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16190 }
16191 
16192 TEST_F(FormatTest, TypenameMacros) {
16193   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16194 
16195   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16196   FormatStyle Google = getGoogleStyleWithColumns(0);
16197   Google.TypenameMacros = TypenameMacros;
16198   verifyFormat("struct foo {\n"
16199                "  int bar;\n"
16200                "  TAILQ_ENTRY(a) bleh;\n"
16201                "};",
16202                Google);
16203 
16204   FormatStyle Macros = getLLVMStyle();
16205   Macros.TypenameMacros = TypenameMacros;
16206 
16207   verifyFormat("STACK_OF(int) a;", Macros);
16208   verifyFormat("STACK_OF(int) *a;", Macros);
16209   verifyFormat("STACK_OF(int const *) *a;", Macros);
16210   verifyFormat("STACK_OF(int *const) *a;", Macros);
16211   verifyFormat("STACK_OF(int, string) a;", Macros);
16212   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16213   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16214   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16215   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16216 
16217   Macros.PointerAlignment = FormatStyle::PAS_Left;
16218   verifyFormat("STACK_OF(int)* a;", Macros);
16219   verifyFormat("STACK_OF(int*)* a;", Macros);
16220 }
16221 
16222 TEST_F(FormatTest, AmbersandInLamda) {
16223   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16224   FormatStyle AlignStyle = getLLVMStyle();
16225   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16226   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16227   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16228   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16229 }
16230 
16231 TEST_F(FormatTest, SpacesInConditionalStatement) {
16232   FormatStyle Spaces = getLLVMStyle();
16233   Spaces.SpacesInConditionalStatement = true;
16234   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16235   verifyFormat("if ( !a )\n  return;", Spaces);
16236   verifyFormat("if ( a )\n  return;", Spaces);
16237   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16238   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16239   verifyFormat("while ( a )\n  return;", Spaces);
16240   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16241   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16242   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16243   // Check that space on the left of "::" is inserted as expected at beginning
16244   // of condition.
16245   verifyFormat("while ( ::func() )\n  return;", Spaces);
16246 }
16247 
16248 TEST_F(FormatTest, AlternativeOperators) {
16249   // Test case for ensuring alternate operators are not
16250   // combined with their right most neighbour.
16251   verifyFormat("int a and b;");
16252   verifyFormat("int a and_eq b;");
16253   verifyFormat("int a bitand b;");
16254   verifyFormat("int a bitor b;");
16255   verifyFormat("int a compl b;");
16256   verifyFormat("int a not b;");
16257   verifyFormat("int a not_eq b;");
16258   verifyFormat("int a or b;");
16259   verifyFormat("int a xor b;");
16260   verifyFormat("int a xor_eq b;");
16261   verifyFormat("return this not_eq bitand other;");
16262   verifyFormat("bool operator not_eq(const X bitand other)");
16263 
16264   verifyFormat("int a and 5;");
16265   verifyFormat("int a and_eq 5;");
16266   verifyFormat("int a bitand 5;");
16267   verifyFormat("int a bitor 5;");
16268   verifyFormat("int a compl 5;");
16269   verifyFormat("int a not 5;");
16270   verifyFormat("int a not_eq 5;");
16271   verifyFormat("int a or 5;");
16272   verifyFormat("int a xor 5;");
16273   verifyFormat("int a xor_eq 5;");
16274 
16275   verifyFormat("int a compl(5);");
16276   verifyFormat("int a not(5);");
16277 
16278   /* FIXME handle alternate tokens
16279    * https://en.cppreference.com/w/cpp/language/operator_alternative
16280   // alternative tokens
16281   verifyFormat("compl foo();");     //  ~foo();
16282   verifyFormat("foo() <%%>;");      // foo();
16283   verifyFormat("void foo() <%%>;"); // void foo(){}
16284   verifyFormat("int a <:1:>;");     // int a[1];[
16285   verifyFormat("%:define ABC abc"); // #define ABC abc
16286   verifyFormat("%:%:");             // ##
16287   */
16288 }
16289 
16290 TEST_F(FormatTest, STLWhileNotDefineChed) {
16291   verifyFormat("#if defined(while)\n"
16292                "#define while EMIT WARNING C4005\n"
16293                "#endif // while");
16294 }
16295 
16296 TEST_F(FormatTest, OperatorSpacing) {
16297   FormatStyle Style = getLLVMStyle();
16298   Style.PointerAlignment = FormatStyle::PAS_Right;
16299   verifyFormat("Foo::operator*();", Style);
16300   verifyFormat("Foo::operator void *();", Style);
16301   verifyFormat("Foo::operator void **();", Style);
16302   verifyFormat("Foo::operator void *&();", Style);
16303   verifyFormat("Foo::operator void *&&();", Style);
16304   verifyFormat("Foo::operator()(void *);", Style);
16305   verifyFormat("Foo::operator*(void *);", Style);
16306   verifyFormat("Foo::operator*();", Style);
16307   verifyFormat("Foo::operator**();", Style);
16308   verifyFormat("Foo::operator&();", Style);
16309   verifyFormat("Foo::operator<int> *();", Style);
16310   verifyFormat("Foo::operator<Foo> *();", Style);
16311   verifyFormat("Foo::operator<int> **();", Style);
16312   verifyFormat("Foo::operator<Foo> **();", Style);
16313   verifyFormat("Foo::operator<int> &();", Style);
16314   verifyFormat("Foo::operator<Foo> &();", Style);
16315   verifyFormat("Foo::operator<int> &&();", Style);
16316   verifyFormat("Foo::operator<Foo> &&();", Style);
16317   verifyFormat("Foo::operator<int> *&();", Style);
16318   verifyFormat("Foo::operator<Foo> *&();", Style);
16319   verifyFormat("Foo::operator<int> *&&();", Style);
16320   verifyFormat("Foo::operator<Foo> *&&();", Style);
16321   verifyFormat("operator*(int (*)(), class Foo);", Style);
16322 
16323   verifyFormat("Foo::operator&();", Style);
16324   verifyFormat("Foo::operator void &();", Style);
16325   verifyFormat("Foo::operator()(void &);", Style);
16326   verifyFormat("Foo::operator&(void &);", Style);
16327   verifyFormat("Foo::operator&();", Style);
16328   verifyFormat("operator&(int (&)(), class Foo);", Style);
16329 
16330   verifyFormat("Foo::operator&&();", Style);
16331   verifyFormat("Foo::operator**();", Style);
16332   verifyFormat("Foo::operator void &&();", Style);
16333   verifyFormat("Foo::operator()(void &&);", Style);
16334   verifyFormat("Foo::operator&&(void &&);", Style);
16335   verifyFormat("Foo::operator&&();", Style);
16336   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16337   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16338   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16339                Style);
16340   verifyFormat("operator void **()", Style);
16341   verifyFormat("operator const FooRight<Object> &()", Style);
16342   verifyFormat("operator const FooRight<Object> *()", Style);
16343   verifyFormat("operator const FooRight<Object> **()", Style);
16344   verifyFormat("operator const FooRight<Object> *&()", Style);
16345   verifyFormat("operator const FooRight<Object> *&&()", Style);
16346 
16347   Style.PointerAlignment = FormatStyle::PAS_Left;
16348   verifyFormat("Foo::operator*();", Style);
16349   verifyFormat("Foo::operator**();", Style);
16350   verifyFormat("Foo::operator void*();", Style);
16351   verifyFormat("Foo::operator void**();", Style);
16352   verifyFormat("Foo::operator void*&();", Style);
16353   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16354   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16355   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16356   verifyFormat("Foo::operator()(void*);", Style);
16357   verifyFormat("Foo::operator*(void*);", Style);
16358   verifyFormat("Foo::operator*();", Style);
16359   verifyFormat("Foo::operator<int>*();", Style);
16360   verifyFormat("Foo::operator<Foo>*();", Style);
16361   verifyFormat("Foo::operator<int>**();", Style);
16362   verifyFormat("Foo::operator<Foo>**();", Style);
16363   verifyFormat("Foo::operator<Foo>*&();", Style);
16364   verifyFormat("Foo::operator<int>&();", Style);
16365   verifyFormat("Foo::operator<Foo>&();", Style);
16366   verifyFormat("Foo::operator<int>&&();", Style);
16367   verifyFormat("Foo::operator<Foo>&&();", Style);
16368   verifyFormat("Foo::operator<int>*&();", Style);
16369   verifyFormat("Foo::operator<Foo>*&();", Style);
16370   verifyFormat("operator*(int (*)(), class Foo);", Style);
16371 
16372   verifyFormat("Foo::operator&();", Style);
16373   verifyFormat("Foo::operator void&();", Style);
16374   verifyFormat("Foo::operator/*comment*/ void&();", Style);
16375   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
16376   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
16377   verifyFormat("Foo::operator()(void&);", Style);
16378   verifyFormat("Foo::operator&(void&);", Style);
16379   verifyFormat("Foo::operator&();", Style);
16380   verifyFormat("operator&(int (&)(), class Foo);", Style);
16381 
16382   verifyFormat("Foo::operator&&();", Style);
16383   verifyFormat("Foo::operator void&&();", Style);
16384   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
16385   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
16386   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
16387   verifyFormat("Foo::operator()(void&&);", Style);
16388   verifyFormat("Foo::operator&&(void&&);", Style);
16389   verifyFormat("Foo::operator&&();", Style);
16390   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16391   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
16392   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
16393                Style);
16394   verifyFormat("operator void**()", Style);
16395   verifyFormat("operator const FooLeft<Object>&()", Style);
16396   verifyFormat("operator const FooLeft<Object>*()", Style);
16397   verifyFormat("operator const FooLeft<Object>**()", Style);
16398   verifyFormat("operator const FooLeft<Object>*&()", Style);
16399   verifyFormat("operator const FooLeft<Object>*&&()", Style);
16400 
16401   // PR45107
16402   verifyFormat("operator Vector<String>&();", Style);
16403   verifyFormat("operator const Vector<String>&();", Style);
16404   verifyFormat("operator foo::Bar*();", Style);
16405   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
16406   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
16407                Style);
16408 
16409   Style.PointerAlignment = FormatStyle::PAS_Middle;
16410   verifyFormat("Foo::operator*();", Style);
16411   verifyFormat("Foo::operator void *();", Style);
16412   verifyFormat("Foo::operator()(void *);", Style);
16413   verifyFormat("Foo::operator*(void *);", Style);
16414   verifyFormat("Foo::operator*();", Style);
16415   verifyFormat("operator*(int (*)(), class Foo);", Style);
16416 
16417   verifyFormat("Foo::operator&();", Style);
16418   verifyFormat("Foo::operator void &();", Style);
16419   verifyFormat("Foo::operator()(void &);", Style);
16420   verifyFormat("Foo::operator&(void &);", Style);
16421   verifyFormat("Foo::operator&();", Style);
16422   verifyFormat("operator&(int (&)(), class Foo);", Style);
16423 
16424   verifyFormat("Foo::operator&&();", Style);
16425   verifyFormat("Foo::operator void &&();", Style);
16426   verifyFormat("Foo::operator()(void &&);", Style);
16427   verifyFormat("Foo::operator&&(void &&);", Style);
16428   verifyFormat("Foo::operator&&();", Style);
16429   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16430 }
16431 
16432 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
16433   FormatStyle Style = getLLVMStyle();
16434   // PR46157
16435   verifyFormat("foo(operator+, -42);", Style);
16436   verifyFormat("foo(operator++, -42);", Style);
16437   verifyFormat("foo(operator--, -42);", Style);
16438   verifyFormat("foo(-42, operator--);", Style);
16439   verifyFormat("foo(-42, operator, );", Style);
16440   verifyFormat("foo(operator, , -42);", Style);
16441 }
16442 
16443 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
16444   // These tests are not in NamespaceFixer because that doesn't
16445   // test its interaction with line wrapping
16446   FormatStyle Style = getLLVMStyle();
16447   Style.ColumnLimit = 80;
16448   verifyFormat("namespace {\n"
16449                "int i;\n"
16450                "int j;\n"
16451                "} // namespace",
16452                Style);
16453 
16454   verifyFormat("namespace AAA {\n"
16455                "int i;\n"
16456                "int j;\n"
16457                "} // namespace AAA",
16458                Style);
16459 
16460   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
16461             "int i;\n"
16462             "int j;\n"
16463             "} // namespace Averyveryveryverylongnamespace",
16464             format("namespace Averyveryveryverylongnamespace {\n"
16465                    "int i;\n"
16466                    "int j;\n"
16467                    "}",
16468                    Style));
16469 
16470   EXPECT_EQ(
16471       "namespace "
16472       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16473       "    went::mad::now {\n"
16474       "int i;\n"
16475       "int j;\n"
16476       "} // namespace\n"
16477       "  // "
16478       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16479       "went::mad::now",
16480       format("namespace "
16481              "would::it::save::you::a::lot::of::time::if_::i::"
16482              "just::gave::up::and_::went::mad::now {\n"
16483              "int i;\n"
16484              "int j;\n"
16485              "}",
16486              Style));
16487 
16488   // This used to duplicate the comment again and again on subsequent runs
16489   EXPECT_EQ(
16490       "namespace "
16491       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16492       "    went::mad::now {\n"
16493       "int i;\n"
16494       "int j;\n"
16495       "} // namespace\n"
16496       "  // "
16497       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16498       "went::mad::now",
16499       format("namespace "
16500              "would::it::save::you::a::lot::of::time::if_::i::"
16501              "just::gave::up::and_::went::mad::now {\n"
16502              "int i;\n"
16503              "int j;\n"
16504              "} // namespace\n"
16505              "  // "
16506              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
16507              "and_::went::mad::now",
16508              Style));
16509 }
16510 
16511 TEST_F(FormatTest, LikelyUnlikely) {
16512   FormatStyle Style = getLLVMStyle();
16513 
16514   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16515                "  return 29;\n"
16516                "}",
16517                Style);
16518 
16519   verifyFormat("if (argc > 5) [[likely]] {\n"
16520                "  return 29;\n"
16521                "}",
16522                Style);
16523 
16524   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16525                "  return 29;\n"
16526                "} else [[likely]] {\n"
16527                "  return 42;\n"
16528                "}\n",
16529                Style);
16530 
16531   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16532                "  return 29;\n"
16533                "} else if (argc > 10) [[likely]] {\n"
16534                "  return 99;\n"
16535                "} else {\n"
16536                "  return 42;\n"
16537                "}\n",
16538                Style);
16539 
16540   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
16541                "  return 29;\n"
16542                "}",
16543                Style);
16544 }
16545 
16546 TEST_F(FormatTest, LLVMDefaultStyle) {
16547   FormatStyle Style = getLLVMStyle();
16548   verifyFormat("extern \"C\" {\n"
16549                "int foo();\n"
16550                "}",
16551                Style);
16552 }
16553 TEST_F(FormatTest, GNUDefaultStyle) {
16554   FormatStyle Style = getGNUStyle();
16555   verifyFormat("extern \"C\"\n"
16556                "{\n"
16557                "  int foo ();\n"
16558                "}",
16559                Style);
16560 }
16561 TEST_F(FormatTest, MozillaDefaultStyle) {
16562   FormatStyle Style = getMozillaStyle();
16563   verifyFormat("extern \"C\"\n"
16564                "{\n"
16565                "  int foo();\n"
16566                "}",
16567                Style);
16568 }
16569 TEST_F(FormatTest, GoogleDefaultStyle) {
16570   FormatStyle Style = getGoogleStyle();
16571   verifyFormat("extern \"C\" {\n"
16572                "int foo();\n"
16573                "}",
16574                Style);
16575 }
16576 TEST_F(FormatTest, ChromiumDefaultStyle) {
16577   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
16578   verifyFormat("extern \"C\" {\n"
16579                "int foo();\n"
16580                "}",
16581                Style);
16582 }
16583 TEST_F(FormatTest, MicrosoftDefaultStyle) {
16584   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
16585   verifyFormat("extern \"C\"\n"
16586                "{\n"
16587                "    int foo();\n"
16588                "}",
16589                Style);
16590 }
16591 TEST_F(FormatTest, WebKitDefaultStyle) {
16592   FormatStyle Style = getWebKitStyle();
16593   verifyFormat("extern \"C\" {\n"
16594                "int foo();\n"
16595                "}",
16596                Style);
16597 }
16598 } // namespace
16599 } // namespace format
16600 } // namespace clang
16601