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) { fffffffffffffffffffffff(); }",
610                AllowSimpleBracedStatements);
611   verifyFormat("if (true) {\n"
612                "  ffffffffffffffffffffffff();\n"
613                "}",
614                AllowSimpleBracedStatements);
615   verifyFormat("if (true) {\n"
616                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
617                "}",
618                AllowSimpleBracedStatements);
619   verifyFormat("if (true) { //\n"
620                "  f();\n"
621                "}",
622                AllowSimpleBracedStatements);
623   verifyFormat("if (true) {\n"
624                "  f();\n"
625                "  f();\n"
626                "}",
627                AllowSimpleBracedStatements);
628   verifyFormat("if (true) {\n"
629                "  f();\n"
630                "} else {\n"
631                "  f();\n"
632                "}",
633                AllowSimpleBracedStatements);
634 
635   verifyFormat("struct A2 {\n"
636                "  int X;\n"
637                "};",
638                AllowSimpleBracedStatements);
639   verifyFormat("typedef struct A2 {\n"
640                "  int X;\n"
641                "} A2_t;",
642                AllowSimpleBracedStatements);
643   verifyFormat("template <int> struct A2 {\n"
644                "  struct B {};\n"
645                "};",
646                AllowSimpleBracedStatements);
647 
648   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
649       FormatStyle::SIS_Never;
650   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
651   verifyFormat("if (true) {\n"
652                "  f();\n"
653                "}",
654                AllowSimpleBracedStatements);
655   verifyFormat("if (true) {\n"
656                "  f();\n"
657                "} else {\n"
658                "  f();\n"
659                "}",
660                AllowSimpleBracedStatements);
661 
662   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
663   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
664   verifyFormat("while (true) {\n"
665                "  f();\n"
666                "}",
667                AllowSimpleBracedStatements);
668   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
669   verifyFormat("for (;;) {\n"
670                "  f();\n"
671                "}",
672                AllowSimpleBracedStatements);
673 
674   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
675       FormatStyle::SIS_WithoutElse;
676   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
677   AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement =
678       FormatStyle::BWACS_Always;
679 
680   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
681   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
682   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
683   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
684   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
685   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
686   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
687   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
688   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
689   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
690   verifyFormat("if (true) { fffffffffffffffffffffff(); }",
691                AllowSimpleBracedStatements);
692   verifyFormat("if (true)\n"
693                "{\n"
694                "  ffffffffffffffffffffffff();\n"
695                "}",
696                AllowSimpleBracedStatements);
697   verifyFormat("if (true)\n"
698                "{\n"
699                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
700                "}",
701                AllowSimpleBracedStatements);
702   verifyFormat("if (true)\n"
703                "{ //\n"
704                "  f();\n"
705                "}",
706                AllowSimpleBracedStatements);
707   verifyFormat("if (true)\n"
708                "{\n"
709                "  f();\n"
710                "  f();\n"
711                "}",
712                AllowSimpleBracedStatements);
713   verifyFormat("if (true)\n"
714                "{\n"
715                "  f();\n"
716                "} else\n"
717                "{\n"
718                "  f();\n"
719                "}",
720                AllowSimpleBracedStatements);
721 
722   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
723       FormatStyle::SIS_Never;
724   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
725   verifyFormat("if (true)\n"
726                "{\n"
727                "  f();\n"
728                "}",
729                AllowSimpleBracedStatements);
730   verifyFormat("if (true)\n"
731                "{\n"
732                "  f();\n"
733                "} else\n"
734                "{\n"
735                "  f();\n"
736                "}",
737                AllowSimpleBracedStatements);
738 
739   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
740   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
741   verifyFormat("while (true)\n"
742                "{\n"
743                "  f();\n"
744                "}",
745                AllowSimpleBracedStatements);
746   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
747   verifyFormat("for (;;)\n"
748                "{\n"
749                "  f();\n"
750                "}",
751                AllowSimpleBracedStatements);
752 }
753 
754 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) {
755   FormatStyle Style = getLLVMStyleWithColumns(60);
756   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
757   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
758   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
759   EXPECT_EQ("#define A                                                  \\\n"
760             "  if (HANDLEwernufrnuLwrmviferuvnierv)                     \\\n"
761             "  {                                                        \\\n"
762             "    RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier;               \\\n"
763             "  }\n"
764             "X;",
765             format("#define A \\\n"
766                    "   if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"
767                    "      RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
768                    "   }\n"
769                    "X;",
770                    Style));
771 }
772 
773 TEST_F(FormatTest, ParseIfElse) {
774   verifyFormat("if (true)\n"
775                "  if (true)\n"
776                "    if (true)\n"
777                "      f();\n"
778                "    else\n"
779                "      g();\n"
780                "  else\n"
781                "    h();\n"
782                "else\n"
783                "  i();");
784   verifyFormat("if (true)\n"
785                "  if (true)\n"
786                "    if (true) {\n"
787                "      if (true)\n"
788                "        f();\n"
789                "    } else {\n"
790                "      g();\n"
791                "    }\n"
792                "  else\n"
793                "    h();\n"
794                "else {\n"
795                "  i();\n"
796                "}");
797   verifyFormat("if (true)\n"
798                "  if constexpr (true)\n"
799                "    if (true) {\n"
800                "      if constexpr (true)\n"
801                "        f();\n"
802                "    } else {\n"
803                "      g();\n"
804                "    }\n"
805                "  else\n"
806                "    h();\n"
807                "else {\n"
808                "  i();\n"
809                "}");
810   verifyFormat("if (true)\n"
811                "  if CONSTEXPR (true)\n"
812                "    if (true) {\n"
813                "      if CONSTEXPR (true)\n"
814                "        f();\n"
815                "    } else {\n"
816                "      g();\n"
817                "    }\n"
818                "  else\n"
819                "    h();\n"
820                "else {\n"
821                "  i();\n"
822                "}");
823   verifyFormat("void f() {\n"
824                "  if (a) {\n"
825                "  } else {\n"
826                "  }\n"
827                "}");
828 }
829 
830 TEST_F(FormatTest, ElseIf) {
831   verifyFormat("if (a) {\n} else if (b) {\n}");
832   verifyFormat("if (a)\n"
833                "  f();\n"
834                "else if (b)\n"
835                "  g();\n"
836                "else\n"
837                "  h();");
838   verifyFormat("if constexpr (a)\n"
839                "  f();\n"
840                "else if constexpr (b)\n"
841                "  g();\n"
842                "else\n"
843                "  h();");
844   verifyFormat("if CONSTEXPR (a)\n"
845                "  f();\n"
846                "else if CONSTEXPR (b)\n"
847                "  g();\n"
848                "else\n"
849                "  h();");
850   verifyFormat("if (a) {\n"
851                "  f();\n"
852                "}\n"
853                "// or else ..\n"
854                "else {\n"
855                "  g()\n"
856                "}");
857 
858   verifyFormat("if (a) {\n"
859                "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
860                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
861                "}");
862   verifyFormat("if (a) {\n"
863                "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
864                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
865                "}");
866   verifyFormat("if (a) {\n"
867                "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
868                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
869                "}");
870   verifyFormat("if (a) {\n"
871                "} else if (\n"
872                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
873                "}",
874                getLLVMStyleWithColumns(62));
875   verifyFormat("if (a) {\n"
876                "} else if constexpr (\n"
877                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
878                "}",
879                getLLVMStyleWithColumns(62));
880   verifyFormat("if (a) {\n"
881                "} else if CONSTEXPR (\n"
882                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
883                "}",
884                getLLVMStyleWithColumns(62));
885 }
886 
887 TEST_F(FormatTest, FormatsForLoop) {
888   verifyFormat(
889       "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
890       "     ++VeryVeryLongLoopVariable)\n"
891       "  ;");
892   verifyFormat("for (;;)\n"
893                "  f();");
894   verifyFormat("for (;;) {\n}");
895   verifyFormat("for (;;) {\n"
896                "  f();\n"
897                "}");
898   verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
899 
900   verifyFormat(
901       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
902       "                                          E = UnwrappedLines.end();\n"
903       "     I != E; ++I) {\n}");
904 
905   verifyFormat(
906       "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
907       "     ++IIIII) {\n}");
908   verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
909                "         aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
910                "     aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
911   verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
912                "         I = FD->getDeclsInPrototypeScope().begin(),\n"
913                "         E = FD->getDeclsInPrototypeScope().end();\n"
914                "     I != E; ++I) {\n}");
915   verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
916                "         I = Container.begin(),\n"
917                "         E = Container.end();\n"
918                "     I != E; ++I) {\n}",
919                getLLVMStyleWithColumns(76));
920 
921   verifyFormat(
922       "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
923       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
924       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
925       "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
926       "     ++aaaaaaaaaaa) {\n}");
927   verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
928                "                bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
929                "     ++i) {\n}");
930   verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
931                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
932                "}");
933   verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
934                "         aaaaaaaaaa);\n"
935                "     iter; ++iter) {\n"
936                "}");
937   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
938                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
939                "     aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
940                "     ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
941 
942   // These should not be formatted as Objective-C for-in loops.
943   verifyFormat("for (Foo *x = 0; x != in; x++) {\n}");
944   verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}");
945   verifyFormat("Foo *x;\nfor (x in y) {\n}");
946   verifyFormat(
947       "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}");
948 
949   FormatStyle NoBinPacking = getLLVMStyle();
950   NoBinPacking.BinPackParameters = false;
951   verifyFormat("for (int aaaaaaaaaaa = 1;\n"
952                "     aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
953                "                                           aaaaaaaaaaaaaaaa,\n"
954                "                                           aaaaaaaaaaaaaaaa,\n"
955                "                                           aaaaaaaaaaaaaaaa);\n"
956                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
957                "}",
958                NoBinPacking);
959   verifyFormat(
960       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
961       "                                          E = UnwrappedLines.end();\n"
962       "     I != E;\n"
963       "     ++I) {\n}",
964       NoBinPacking);
965 
966   FormatStyle AlignLeft = getLLVMStyle();
967   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
968   verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
969 }
970 
971 TEST_F(FormatTest, RangeBasedForLoops) {
972   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
973                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
974   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
975                "     aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
976   verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
977                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
978   verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
979                "     aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
980 }
981 
982 TEST_F(FormatTest, ForEachLoops) {
983   verifyFormat("void f() {\n"
984                "  foreach (Item *item, itemlist) {}\n"
985                "  Q_FOREACH (Item *item, itemlist) {}\n"
986                "  BOOST_FOREACH (Item *item, itemlist) {}\n"
987                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
988                "}");
989 
990   FormatStyle Style = getLLVMStyle();
991   Style.SpaceBeforeParens =
992       FormatStyle::SBPO_ControlStatementsExceptForEachMacros;
993   verifyFormat("void f() {\n"
994                "  foreach(Item *item, itemlist) {}\n"
995                "  Q_FOREACH(Item *item, itemlist) {}\n"
996                "  BOOST_FOREACH(Item *item, itemlist) {}\n"
997                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
998                "}",
999                Style);
1000 
1001   // As function-like macros.
1002   verifyFormat("#define foreach(x, y)\n"
1003                "#define Q_FOREACH(x, y)\n"
1004                "#define BOOST_FOREACH(x, y)\n"
1005                "#define UNKNOWN_FOREACH(x, y)\n");
1006 
1007   // Not as function-like macros.
1008   verifyFormat("#define foreach (x, y)\n"
1009                "#define Q_FOREACH (x, y)\n"
1010                "#define BOOST_FOREACH (x, y)\n"
1011                "#define UNKNOWN_FOREACH (x, y)\n");
1012 
1013   // handle microsoft non standard extension
1014   verifyFormat("for each (char c in x->MyStringProperty)");
1015 }
1016 
1017 TEST_F(FormatTest, FormatsWhileLoop) {
1018   verifyFormat("while (true) {\n}");
1019   verifyFormat("while (true)\n"
1020                "  f();");
1021   verifyFormat("while () {\n}");
1022   verifyFormat("while () {\n"
1023                "  f();\n"
1024                "}");
1025 }
1026 
1027 TEST_F(FormatTest, FormatsDoWhile) {
1028   verifyFormat("do {\n"
1029                "  do_something();\n"
1030                "} while (something());");
1031   verifyFormat("do\n"
1032                "  do_something();\n"
1033                "while (something());");
1034 }
1035 
1036 TEST_F(FormatTest, FormatsSwitchStatement) {
1037   verifyFormat("switch (x) {\n"
1038                "case 1:\n"
1039                "  f();\n"
1040                "  break;\n"
1041                "case kFoo:\n"
1042                "case ns::kBar:\n"
1043                "case kBaz:\n"
1044                "  break;\n"
1045                "default:\n"
1046                "  g();\n"
1047                "  break;\n"
1048                "}");
1049   verifyFormat("switch (x) {\n"
1050                "case 1: {\n"
1051                "  f();\n"
1052                "  break;\n"
1053                "}\n"
1054                "case 2: {\n"
1055                "  break;\n"
1056                "}\n"
1057                "}");
1058   verifyFormat("switch (x) {\n"
1059                "case 1: {\n"
1060                "  f();\n"
1061                "  {\n"
1062                "    g();\n"
1063                "    h();\n"
1064                "  }\n"
1065                "  break;\n"
1066                "}\n"
1067                "}");
1068   verifyFormat("switch (x) {\n"
1069                "case 1: {\n"
1070                "  f();\n"
1071                "  if (foo) {\n"
1072                "    g();\n"
1073                "    h();\n"
1074                "  }\n"
1075                "  break;\n"
1076                "}\n"
1077                "}");
1078   verifyFormat("switch (x) {\n"
1079                "case 1: {\n"
1080                "  f();\n"
1081                "  g();\n"
1082                "} break;\n"
1083                "}");
1084   verifyFormat("switch (test)\n"
1085                "  ;");
1086   verifyFormat("switch (x) {\n"
1087                "default: {\n"
1088                "  // Do nothing.\n"
1089                "}\n"
1090                "}");
1091   verifyFormat("switch (x) {\n"
1092                "// comment\n"
1093                "// if 1, do f()\n"
1094                "case 1:\n"
1095                "  f();\n"
1096                "}");
1097   verifyFormat("switch (x) {\n"
1098                "case 1:\n"
1099                "  // Do amazing stuff\n"
1100                "  {\n"
1101                "    f();\n"
1102                "    g();\n"
1103                "  }\n"
1104                "  break;\n"
1105                "}");
1106   verifyFormat("#define A          \\\n"
1107                "  switch (x) {     \\\n"
1108                "  case a:          \\\n"
1109                "    foo = b;       \\\n"
1110                "  }",
1111                getLLVMStyleWithColumns(20));
1112   verifyFormat("#define OPERATION_CASE(name)           \\\n"
1113                "  case OP_name:                        \\\n"
1114                "    return operations::Operation##name\n",
1115                getLLVMStyleWithColumns(40));
1116   verifyFormat("switch (x) {\n"
1117                "case 1:;\n"
1118                "default:;\n"
1119                "  int i;\n"
1120                "}");
1121 
1122   verifyGoogleFormat("switch (x) {\n"
1123                      "  case 1:\n"
1124                      "    f();\n"
1125                      "    break;\n"
1126                      "  case kFoo:\n"
1127                      "  case ns::kBar:\n"
1128                      "  case kBaz:\n"
1129                      "    break;\n"
1130                      "  default:\n"
1131                      "    g();\n"
1132                      "    break;\n"
1133                      "}");
1134   verifyGoogleFormat("switch (x) {\n"
1135                      "  case 1: {\n"
1136                      "    f();\n"
1137                      "    break;\n"
1138                      "  }\n"
1139                      "}");
1140   verifyGoogleFormat("switch (test)\n"
1141                      "  ;");
1142 
1143   verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
1144                      "  case OP_name:              \\\n"
1145                      "    return operations::Operation##name\n");
1146   verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
1147                      "  // Get the correction operation class.\n"
1148                      "  switch (OpCode) {\n"
1149                      "    CASE(Add);\n"
1150                      "    CASE(Subtract);\n"
1151                      "    default:\n"
1152                      "      return operations::Unknown;\n"
1153                      "  }\n"
1154                      "#undef OPERATION_CASE\n"
1155                      "}");
1156   verifyFormat("DEBUG({\n"
1157                "  switch (x) {\n"
1158                "  case A:\n"
1159                "    f();\n"
1160                "    break;\n"
1161                "    // fallthrough\n"
1162                "  case B:\n"
1163                "    g();\n"
1164                "    break;\n"
1165                "  }\n"
1166                "});");
1167   EXPECT_EQ("DEBUG({\n"
1168             "  switch (x) {\n"
1169             "  case A:\n"
1170             "    f();\n"
1171             "    break;\n"
1172             "  // On B:\n"
1173             "  case B:\n"
1174             "    g();\n"
1175             "    break;\n"
1176             "  }\n"
1177             "});",
1178             format("DEBUG({\n"
1179                    "  switch (x) {\n"
1180                    "  case A:\n"
1181                    "    f();\n"
1182                    "    break;\n"
1183                    "  // On B:\n"
1184                    "  case B:\n"
1185                    "    g();\n"
1186                    "    break;\n"
1187                    "  }\n"
1188                    "});",
1189                    getLLVMStyle()));
1190   EXPECT_EQ("switch (n) {\n"
1191             "case 0: {\n"
1192             "  return false;\n"
1193             "}\n"
1194             "default: {\n"
1195             "  return true;\n"
1196             "}\n"
1197             "}",
1198             format("switch (n)\n"
1199                    "{\n"
1200                    "case 0: {\n"
1201                    "  return false;\n"
1202                    "}\n"
1203                    "default: {\n"
1204                    "  return true;\n"
1205                    "}\n"
1206                    "}",
1207                    getLLVMStyle()));
1208   verifyFormat("switch (a) {\n"
1209                "case (b):\n"
1210                "  return;\n"
1211                "}");
1212 
1213   verifyFormat("switch (a) {\n"
1214                "case some_namespace::\n"
1215                "    some_constant:\n"
1216                "  return;\n"
1217                "}",
1218                getLLVMStyleWithColumns(34));
1219 
1220   FormatStyle Style = getLLVMStyle();
1221   Style.IndentCaseLabels = true;
1222   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
1223   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1224   Style.BraceWrapping.AfterCaseLabel = true;
1225   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1226   EXPECT_EQ("switch (n)\n"
1227             "{\n"
1228             "  case 0:\n"
1229             "  {\n"
1230             "    return false;\n"
1231             "  }\n"
1232             "  default:\n"
1233             "  {\n"
1234             "    return true;\n"
1235             "  }\n"
1236             "}",
1237             format("switch (n) {\n"
1238                    "  case 0: {\n"
1239                    "    return false;\n"
1240                    "  }\n"
1241                    "  default: {\n"
1242                    "    return true;\n"
1243                    "  }\n"
1244                    "}",
1245                    Style));
1246   Style.BraceWrapping.AfterCaseLabel = false;
1247   EXPECT_EQ("switch (n)\n"
1248             "{\n"
1249             "  case 0: {\n"
1250             "    return false;\n"
1251             "  }\n"
1252             "  default: {\n"
1253             "    return true;\n"
1254             "  }\n"
1255             "}",
1256             format("switch (n) {\n"
1257                    "  case 0:\n"
1258                    "  {\n"
1259                    "    return false;\n"
1260                    "  }\n"
1261                    "  default:\n"
1262                    "  {\n"
1263                    "    return true;\n"
1264                    "  }\n"
1265                    "}",
1266                    Style));
1267   Style.IndentCaseLabels = false;
1268   Style.IndentCaseBlocks = true;
1269   EXPECT_EQ("switch (n)\n"
1270             "{\n"
1271             "case 0:\n"
1272             "  {\n"
1273             "    return false;\n"
1274             "  }\n"
1275             "case 1:\n"
1276             "  break;\n"
1277             "default:\n"
1278             "  {\n"
1279             "    return true;\n"
1280             "  }\n"
1281             "}",
1282             format("switch (n) {\n"
1283                    "case 0: {\n"
1284                    "  return false;\n"
1285                    "}\n"
1286                    "case 1:\n"
1287                    "  break;\n"
1288                    "default: {\n"
1289                    "  return true;\n"
1290                    "}\n"
1291                    "}",
1292                    Style));
1293   Style.IndentCaseLabels = true;
1294   Style.IndentCaseBlocks = true;
1295   EXPECT_EQ("switch (n)\n"
1296             "{\n"
1297             "  case 0:\n"
1298             "    {\n"
1299             "      return false;\n"
1300             "    }\n"
1301             "  case 1:\n"
1302             "    break;\n"
1303             "  default:\n"
1304             "    {\n"
1305             "      return true;\n"
1306             "    }\n"
1307             "}",
1308             format("switch (n) {\n"
1309                    "case 0: {\n"
1310                    "  return false;\n"
1311                    "}\n"
1312                    "case 1:\n"
1313                    "  break;\n"
1314                    "default: {\n"
1315                    "  return true;\n"
1316                    "}\n"
1317                    "}",
1318                    Style));
1319 }
1320 
1321 TEST_F(FormatTest, CaseRanges) {
1322   verifyFormat("switch (x) {\n"
1323                "case 'A' ... 'Z':\n"
1324                "case 1 ... 5:\n"
1325                "case a ... b:\n"
1326                "  break;\n"
1327                "}");
1328 }
1329 
1330 TEST_F(FormatTest, ShortEnums) {
1331   FormatStyle Style = getLLVMStyle();
1332   Style.AllowShortEnumsOnASingleLine = true;
1333   verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style);
1334   Style.AllowShortEnumsOnASingleLine = false;
1335   verifyFormat("enum\n"
1336                "{\n"
1337                "  A,\n"
1338                "  B,\n"
1339                "  C\n"
1340                "} ShortEnum1, ShortEnum2;",
1341                Style);
1342 }
1343 
1344 TEST_F(FormatTest, ShortCaseLabels) {
1345   FormatStyle Style = getLLVMStyle();
1346   Style.AllowShortCaseLabelsOnASingleLine = true;
1347   verifyFormat("switch (a) {\n"
1348                "case 1: x = 1; break;\n"
1349                "case 2: return;\n"
1350                "case 3:\n"
1351                "case 4:\n"
1352                "case 5: return;\n"
1353                "case 6: // comment\n"
1354                "  return;\n"
1355                "case 7:\n"
1356                "  // comment\n"
1357                "  return;\n"
1358                "case 8:\n"
1359                "  x = 8; // comment\n"
1360                "  break;\n"
1361                "default: y = 1; break;\n"
1362                "}",
1363                Style);
1364   verifyFormat("switch (a) {\n"
1365                "case 0: return; // comment\n"
1366                "case 1: break;  // comment\n"
1367                "case 2: return;\n"
1368                "// comment\n"
1369                "case 3: return;\n"
1370                "// comment 1\n"
1371                "// comment 2\n"
1372                "// comment 3\n"
1373                "case 4: break; /* comment */\n"
1374                "case 5:\n"
1375                "  // comment\n"
1376                "  break;\n"
1377                "case 6: /* comment */ x = 1; break;\n"
1378                "case 7: x = /* comment */ 1; break;\n"
1379                "case 8:\n"
1380                "  x = 1; /* comment */\n"
1381                "  break;\n"
1382                "case 9:\n"
1383                "  break; // comment line 1\n"
1384                "         // comment line 2\n"
1385                "}",
1386                Style);
1387   EXPECT_EQ("switch (a) {\n"
1388             "case 1:\n"
1389             "  x = 8;\n"
1390             "  // fall through\n"
1391             "case 2: x = 8;\n"
1392             "// comment\n"
1393             "case 3:\n"
1394             "  return; /* comment line 1\n"
1395             "           * comment line 2 */\n"
1396             "case 4: i = 8;\n"
1397             "// something else\n"
1398             "#if FOO\n"
1399             "case 5: break;\n"
1400             "#endif\n"
1401             "}",
1402             format("switch (a) {\n"
1403                    "case 1: x = 8;\n"
1404                    "  // fall through\n"
1405                    "case 2:\n"
1406                    "  x = 8;\n"
1407                    "// comment\n"
1408                    "case 3:\n"
1409                    "  return; /* comment line 1\n"
1410                    "           * comment line 2 */\n"
1411                    "case 4:\n"
1412                    "  i = 8;\n"
1413                    "// something else\n"
1414                    "#if FOO\n"
1415                    "case 5: break;\n"
1416                    "#endif\n"
1417                    "}",
1418                    Style));
1419   EXPECT_EQ("switch (a) {\n"
1420             "case 0:\n"
1421             "  return; // long long long long long long long long long long "
1422             "long long comment\n"
1423             "          // line\n"
1424             "}",
1425             format("switch (a) {\n"
1426                    "case 0: return; // long long long long long long long long "
1427                    "long long long long comment line\n"
1428                    "}",
1429                    Style));
1430   EXPECT_EQ("switch (a) {\n"
1431             "case 0:\n"
1432             "  return; /* long long long long long long long long long long "
1433             "long long comment\n"
1434             "             line */\n"
1435             "}",
1436             format("switch (a) {\n"
1437                    "case 0: return; /* long long long long long long long long "
1438                    "long long long long comment line */\n"
1439                    "}",
1440                    Style));
1441   verifyFormat("switch (a) {\n"
1442                "#if FOO\n"
1443                "case 0: return 0;\n"
1444                "#endif\n"
1445                "}",
1446                Style);
1447   verifyFormat("switch (a) {\n"
1448                "case 1: {\n"
1449                "}\n"
1450                "case 2: {\n"
1451                "  return;\n"
1452                "}\n"
1453                "case 3: {\n"
1454                "  x = 1;\n"
1455                "  return;\n"
1456                "}\n"
1457                "case 4:\n"
1458                "  if (x)\n"
1459                "    return;\n"
1460                "}",
1461                Style);
1462   Style.ColumnLimit = 21;
1463   verifyFormat("switch (a) {\n"
1464                "case 1: x = 1; break;\n"
1465                "case 2: return;\n"
1466                "case 3:\n"
1467                "case 4:\n"
1468                "case 5: return;\n"
1469                "default:\n"
1470                "  y = 1;\n"
1471                "  break;\n"
1472                "}",
1473                Style);
1474   Style.ColumnLimit = 80;
1475   Style.AllowShortCaseLabelsOnASingleLine = false;
1476   Style.IndentCaseLabels = true;
1477   EXPECT_EQ("switch (n) {\n"
1478             "  default /*comments*/:\n"
1479             "    return true;\n"
1480             "  case 0:\n"
1481             "    return false;\n"
1482             "}",
1483             format("switch (n) {\n"
1484                    "default/*comments*/:\n"
1485                    "  return true;\n"
1486                    "case 0:\n"
1487                    "  return false;\n"
1488                    "}",
1489                    Style));
1490   Style.AllowShortCaseLabelsOnASingleLine = true;
1491   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1492   Style.BraceWrapping.AfterCaseLabel = true;
1493   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1494   EXPECT_EQ("switch (n)\n"
1495             "{\n"
1496             "  case 0:\n"
1497             "  {\n"
1498             "    return false;\n"
1499             "  }\n"
1500             "  default:\n"
1501             "  {\n"
1502             "    return true;\n"
1503             "  }\n"
1504             "}",
1505             format("switch (n) {\n"
1506                    "  case 0: {\n"
1507                    "    return false;\n"
1508                    "  }\n"
1509                    "  default:\n"
1510                    "  {\n"
1511                    "    return true;\n"
1512                    "  }\n"
1513                    "}",
1514                    Style));
1515 }
1516 
1517 TEST_F(FormatTest, FormatsLabels) {
1518   verifyFormat("void f() {\n"
1519                "  some_code();\n"
1520                "test_label:\n"
1521                "  some_other_code();\n"
1522                "  {\n"
1523                "    some_more_code();\n"
1524                "  another_label:\n"
1525                "    some_more_code();\n"
1526                "  }\n"
1527                "}");
1528   verifyFormat("{\n"
1529                "  some_code();\n"
1530                "test_label:\n"
1531                "  some_other_code();\n"
1532                "}");
1533   verifyFormat("{\n"
1534                "  some_code();\n"
1535                "test_label:;\n"
1536                "  int i = 0;\n"
1537                "}");
1538   FormatStyle Style = getLLVMStyle();
1539   Style.IndentGotoLabels = false;
1540   verifyFormat("void f() {\n"
1541                "  some_code();\n"
1542                "test_label:\n"
1543                "  some_other_code();\n"
1544                "  {\n"
1545                "    some_more_code();\n"
1546                "another_label:\n"
1547                "    some_more_code();\n"
1548                "  }\n"
1549                "}",
1550                Style);
1551   verifyFormat("{\n"
1552                "  some_code();\n"
1553                "test_label:\n"
1554                "  some_other_code();\n"
1555                "}",
1556                Style);
1557   verifyFormat("{\n"
1558                "  some_code();\n"
1559                "test_label:;\n"
1560                "  int i = 0;\n"
1561                "}");
1562 }
1563 
1564 TEST_F(FormatTest, MultiLineControlStatements) {
1565   FormatStyle Style = getLLVMStyle();
1566   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1567   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine;
1568   Style.ColumnLimit = 20;
1569   // Short lines should keep opening brace on same line.
1570   EXPECT_EQ("if (foo) {\n"
1571             "  bar();\n"
1572             "}",
1573             format("if(foo){bar();}", Style));
1574   EXPECT_EQ("if (foo) {\n"
1575             "  bar();\n"
1576             "} else {\n"
1577             "  baz();\n"
1578             "}",
1579             format("if(foo){bar();}else{baz();}", Style));
1580   EXPECT_EQ("if (foo && bar) {\n"
1581             "  baz();\n"
1582             "}",
1583             format("if(foo&&bar){baz();}", Style));
1584   EXPECT_EQ("if (foo) {\n"
1585             "  bar();\n"
1586             "} else if (baz) {\n"
1587             "  quux();\n"
1588             "}",
1589             format("if(foo){bar();}else if(baz){quux();}", Style));
1590   EXPECT_EQ(
1591       "if (foo) {\n"
1592       "  bar();\n"
1593       "} else if (baz) {\n"
1594       "  quux();\n"
1595       "} else {\n"
1596       "  foobar();\n"
1597       "}",
1598       format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style));
1599   EXPECT_EQ("for (;;) {\n"
1600             "  foo();\n"
1601             "}",
1602             format("for(;;){foo();}"));
1603   EXPECT_EQ("while (1) {\n"
1604             "  foo();\n"
1605             "}",
1606             format("while(1){foo();}", Style));
1607   EXPECT_EQ("switch (foo) {\n"
1608             "case bar:\n"
1609             "  return;\n"
1610             "}",
1611             format("switch(foo){case bar:return;}", Style));
1612   EXPECT_EQ("try {\n"
1613             "  foo();\n"
1614             "} catch (...) {\n"
1615             "  bar();\n"
1616             "}",
1617             format("try{foo();}catch(...){bar();}", Style));
1618   EXPECT_EQ("do {\n"
1619             "  foo();\n"
1620             "} while (bar &&\n"
1621             "         baz);",
1622             format("do{foo();}while(bar&&baz);", Style));
1623   // Long lines should put opening brace on new line.
1624   EXPECT_EQ("if (foo && bar &&\n"
1625             "    baz)\n"
1626             "{\n"
1627             "  quux();\n"
1628             "}",
1629             format("if(foo&&bar&&baz){quux();}", Style));
1630   EXPECT_EQ("if (foo && bar &&\n"
1631             "    baz)\n"
1632             "{\n"
1633             "  quux();\n"
1634             "}",
1635             format("if (foo && bar &&\n"
1636                    "    baz) {\n"
1637                    "  quux();\n"
1638                    "}",
1639                    Style));
1640   EXPECT_EQ("if (foo) {\n"
1641             "  bar();\n"
1642             "} else if (baz ||\n"
1643             "           quux)\n"
1644             "{\n"
1645             "  foobar();\n"
1646             "}",
1647             format("if(foo){bar();}else if(baz||quux){foobar();}", Style));
1648   EXPECT_EQ(
1649       "if (foo) {\n"
1650       "  bar();\n"
1651       "} else if (baz ||\n"
1652       "           quux)\n"
1653       "{\n"
1654       "  foobar();\n"
1655       "} else {\n"
1656       "  barbaz();\n"
1657       "}",
1658       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1659              Style));
1660   EXPECT_EQ("for (int i = 0;\n"
1661             "     i < 10; ++i)\n"
1662             "{\n"
1663             "  foo();\n"
1664             "}",
1665             format("for(int i=0;i<10;++i){foo();}", Style));
1666   EXPECT_EQ("while (foo || bar ||\n"
1667             "       baz)\n"
1668             "{\n"
1669             "  quux();\n"
1670             "}",
1671             format("while(foo||bar||baz){quux();}", Style));
1672   EXPECT_EQ("switch (\n"
1673             "    foo = barbaz)\n"
1674             "{\n"
1675             "case quux:\n"
1676             "  return;\n"
1677             "}",
1678             format("switch(foo=barbaz){case quux:return;}", Style));
1679   EXPECT_EQ("try {\n"
1680             "  foo();\n"
1681             "} catch (\n"
1682             "    Exception &bar)\n"
1683             "{\n"
1684             "  baz();\n"
1685             "}",
1686             format("try{foo();}catch(Exception&bar){baz();}", Style));
1687   Style.ColumnLimit =
1688       40; // to concentrate at brace wrapping, not line wrap due to column limit
1689   EXPECT_EQ("try {\n"
1690             "  foo();\n"
1691             "} catch (Exception &bar) {\n"
1692             "  baz();\n"
1693             "}",
1694             format("try{foo();}catch(Exception&bar){baz();}", Style));
1695   Style.ColumnLimit =
1696       20; // to concentrate at brace wrapping, not line wrap due to column limit
1697 
1698   Style.BraceWrapping.BeforeElse = true;
1699   EXPECT_EQ(
1700       "if (foo) {\n"
1701       "  bar();\n"
1702       "}\n"
1703       "else if (baz ||\n"
1704       "         quux)\n"
1705       "{\n"
1706       "  foobar();\n"
1707       "}\n"
1708       "else {\n"
1709       "  barbaz();\n"
1710       "}",
1711       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1712              Style));
1713 
1714   Style.BraceWrapping.BeforeCatch = true;
1715   EXPECT_EQ("try {\n"
1716             "  foo();\n"
1717             "}\n"
1718             "catch (...) {\n"
1719             "  baz();\n"
1720             "}",
1721             format("try{foo();}catch(...){baz();}", Style));
1722 }
1723 
1724 TEST_F(FormatTest, BeforeWhile) {
1725   FormatStyle Style = getLLVMStyle();
1726   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1727 
1728   verifyFormat("do {\n"
1729                "  foo();\n"
1730                "} while (1);",
1731                Style);
1732   Style.BraceWrapping.BeforeWhile = true;
1733   verifyFormat("do {\n"
1734                "  foo();\n"
1735                "}\n"
1736                "while (1);",
1737                Style);
1738 }
1739 
1740 //===----------------------------------------------------------------------===//
1741 // Tests for classes, namespaces, etc.
1742 //===----------------------------------------------------------------------===//
1743 
1744 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
1745   verifyFormat("class A {};");
1746 }
1747 
1748 TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1749   verifyFormat("class A {\n"
1750                "public:\n"
1751                "public: // comment\n"
1752                "protected:\n"
1753                "private:\n"
1754                "  void f() {}\n"
1755                "};");
1756   verifyFormat("export class A {\n"
1757                "public:\n"
1758                "public: // comment\n"
1759                "protected:\n"
1760                "private:\n"
1761                "  void f() {}\n"
1762                "};");
1763   verifyGoogleFormat("class A {\n"
1764                      " public:\n"
1765                      " protected:\n"
1766                      " private:\n"
1767                      "  void f() {}\n"
1768                      "};");
1769   verifyGoogleFormat("export class A {\n"
1770                      " public:\n"
1771                      " protected:\n"
1772                      " private:\n"
1773                      "  void f() {}\n"
1774                      "};");
1775   verifyFormat("class A {\n"
1776                "public slots:\n"
1777                "  void f1() {}\n"
1778                "public Q_SLOTS:\n"
1779                "  void f2() {}\n"
1780                "protected slots:\n"
1781                "  void f3() {}\n"
1782                "protected Q_SLOTS:\n"
1783                "  void f4() {}\n"
1784                "private slots:\n"
1785                "  void f5() {}\n"
1786                "private Q_SLOTS:\n"
1787                "  void f6() {}\n"
1788                "signals:\n"
1789                "  void g1();\n"
1790                "Q_SIGNALS:\n"
1791                "  void g2();\n"
1792                "};");
1793 
1794   // Don't interpret 'signals' the wrong way.
1795   verifyFormat("signals.set();");
1796   verifyFormat("for (Signals signals : f()) {\n}");
1797   verifyFormat("{\n"
1798                "  signals.set(); // This needs indentation.\n"
1799                "}");
1800   verifyFormat("void f() {\n"
1801                "label:\n"
1802                "  signals.baz();\n"
1803                "}");
1804 }
1805 
1806 TEST_F(FormatTest, SeparatesLogicalBlocks) {
1807   EXPECT_EQ("class A {\n"
1808             "public:\n"
1809             "  void f();\n"
1810             "\n"
1811             "private:\n"
1812             "  void g() {}\n"
1813             "  // test\n"
1814             "protected:\n"
1815             "  int h;\n"
1816             "};",
1817             format("class A {\n"
1818                    "public:\n"
1819                    "void f();\n"
1820                    "private:\n"
1821                    "void g() {}\n"
1822                    "// test\n"
1823                    "protected:\n"
1824                    "int h;\n"
1825                    "};"));
1826   EXPECT_EQ("class A {\n"
1827             "protected:\n"
1828             "public:\n"
1829             "  void f();\n"
1830             "};",
1831             format("class A {\n"
1832                    "protected:\n"
1833                    "\n"
1834                    "public:\n"
1835                    "\n"
1836                    "  void f();\n"
1837                    "};"));
1838 
1839   // Even ensure proper spacing inside macros.
1840   EXPECT_EQ("#define B     \\\n"
1841             "  class A {   \\\n"
1842             "   protected: \\\n"
1843             "   public:    \\\n"
1844             "    void f(); \\\n"
1845             "  };",
1846             format("#define B     \\\n"
1847                    "  class A {   \\\n"
1848                    "   protected: \\\n"
1849                    "              \\\n"
1850                    "   public:    \\\n"
1851                    "              \\\n"
1852                    "    void f(); \\\n"
1853                    "  };",
1854                    getGoogleStyle()));
1855   // But don't remove empty lines after macros ending in access specifiers.
1856   EXPECT_EQ("#define A private:\n"
1857             "\n"
1858             "int i;",
1859             format("#define A         private:\n"
1860                    "\n"
1861                    "int              i;"));
1862 }
1863 
1864 TEST_F(FormatTest, FormatsClasses) {
1865   verifyFormat("class A : public B {};");
1866   verifyFormat("class A : public ::B {};");
1867 
1868   verifyFormat(
1869       "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1870       "                             public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1871   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1872                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1873                "      public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1874   verifyFormat(
1875       "class A : public B, public C, public D, public E, public F {};");
1876   verifyFormat("class AAAAAAAAAAAA : public B,\n"
1877                "                     public C,\n"
1878                "                     public D,\n"
1879                "                     public E,\n"
1880                "                     public F,\n"
1881                "                     public G {};");
1882 
1883   verifyFormat("class\n"
1884                "    ReallyReallyLongClassName {\n"
1885                "  int i;\n"
1886                "};",
1887                getLLVMStyleWithColumns(32));
1888   verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1889                "                           aaaaaaaaaaaaaaaa> {};");
1890   verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1891                "    : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1892                "                                 aaaaaaaaaaaaaaaaaaaaaa> {};");
1893   verifyFormat("template <class R, class C>\n"
1894                "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1895                "    : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
1896   verifyFormat("class ::A::B {};");
1897 }
1898 
1899 TEST_F(FormatTest, BreakInheritanceStyle) {
1900   FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle();
1901   StyleWithInheritanceBreakBeforeComma.BreakInheritanceList =
1902       FormatStyle::BILS_BeforeComma;
1903   verifyFormat("class MyClass : public X {};",
1904                StyleWithInheritanceBreakBeforeComma);
1905   verifyFormat("class MyClass\n"
1906                "    : public X\n"
1907                "    , public Y {};",
1908                StyleWithInheritanceBreakBeforeComma);
1909   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
1910                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"
1911                "    , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1912                StyleWithInheritanceBreakBeforeComma);
1913   verifyFormat("struct aaaaaaaaaaaaa\n"
1914                "    : public aaaaaaaaaaaaaaaaaaa< // break\n"
1915                "          aaaaaaaaaaaaaaaa> {};",
1916                StyleWithInheritanceBreakBeforeComma);
1917 
1918   FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle();
1919   StyleWithInheritanceBreakAfterColon.BreakInheritanceList =
1920       FormatStyle::BILS_AfterColon;
1921   verifyFormat("class MyClass : public X {};",
1922                StyleWithInheritanceBreakAfterColon);
1923   verifyFormat("class MyClass : public X, public Y {};",
1924                StyleWithInheritanceBreakAfterColon);
1925   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
1926                "    public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1927                "    public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1928                StyleWithInheritanceBreakAfterColon);
1929   verifyFormat("struct aaaaaaaaaaaaa :\n"
1930                "    public aaaaaaaaaaaaaaaaaaa< // break\n"
1931                "        aaaaaaaaaaaaaaaa> {};",
1932                StyleWithInheritanceBreakAfterColon);
1933 }
1934 
1935 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
1936   verifyFormat("class A {\n} a, b;");
1937   verifyFormat("struct A {\n} a, b;");
1938   verifyFormat("union A {\n} a;");
1939 }
1940 
1941 TEST_F(FormatTest, FormatsEnum) {
1942   verifyFormat("enum {\n"
1943                "  Zero,\n"
1944                "  One = 1,\n"
1945                "  Two = One + 1,\n"
1946                "  Three = (One + Two),\n"
1947                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1948                "  Five = (One, Two, Three, Four, 5)\n"
1949                "};");
1950   verifyGoogleFormat("enum {\n"
1951                      "  Zero,\n"
1952                      "  One = 1,\n"
1953                      "  Two = One + 1,\n"
1954                      "  Three = (One + Two),\n"
1955                      "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1956                      "  Five = (One, Two, Three, Four, 5)\n"
1957                      "};");
1958   verifyFormat("enum Enum {};");
1959   verifyFormat("enum {};");
1960   verifyFormat("enum X E {} d;");
1961   verifyFormat("enum __attribute__((...)) E {} d;");
1962   verifyFormat("enum __declspec__((...)) E {} d;");
1963   verifyFormat("enum {\n"
1964                "  Bar = Foo<int, int>::value\n"
1965                "};",
1966                getLLVMStyleWithColumns(30));
1967 
1968   verifyFormat("enum ShortEnum { A, B, C };");
1969   verifyGoogleFormat("enum ShortEnum { A, B, C };");
1970 
1971   EXPECT_EQ("enum KeepEmptyLines {\n"
1972             "  ONE,\n"
1973             "\n"
1974             "  TWO,\n"
1975             "\n"
1976             "  THREE\n"
1977             "}",
1978             format("enum KeepEmptyLines {\n"
1979                    "  ONE,\n"
1980                    "\n"
1981                    "  TWO,\n"
1982                    "\n"
1983                    "\n"
1984                    "  THREE\n"
1985                    "}"));
1986   verifyFormat("enum E { // comment\n"
1987                "  ONE,\n"
1988                "  TWO\n"
1989                "};\n"
1990                "int i;");
1991 
1992   FormatStyle EightIndent = getLLVMStyle();
1993   EightIndent.IndentWidth = 8;
1994   verifyFormat("enum {\n"
1995                "        VOID,\n"
1996                "        CHAR,\n"
1997                "        SHORT,\n"
1998                "        INT,\n"
1999                "        LONG,\n"
2000                "        SIGNED,\n"
2001                "        UNSIGNED,\n"
2002                "        BOOL,\n"
2003                "        FLOAT,\n"
2004                "        DOUBLE,\n"
2005                "        COMPLEX\n"
2006                "};",
2007                EightIndent);
2008 
2009   // Not enums.
2010   verifyFormat("enum X f() {\n"
2011                "  a();\n"
2012                "  return 42;\n"
2013                "}");
2014   verifyFormat("enum X Type::f() {\n"
2015                "  a();\n"
2016                "  return 42;\n"
2017                "}");
2018   verifyFormat("enum ::X f() {\n"
2019                "  a();\n"
2020                "  return 42;\n"
2021                "}");
2022   verifyFormat("enum ns::X f() {\n"
2023                "  a();\n"
2024                "  return 42;\n"
2025                "}");
2026 }
2027 
2028 TEST_F(FormatTest, FormatsEnumsWithErrors) {
2029   verifyFormat("enum Type {\n"
2030                "  One = 0; // These semicolons should be commas.\n"
2031                "  Two = 1;\n"
2032                "};");
2033   verifyFormat("namespace n {\n"
2034                "enum Type {\n"
2035                "  One,\n"
2036                "  Two, // missing };\n"
2037                "  int i;\n"
2038                "}\n"
2039                "void g() {}");
2040 }
2041 
2042 TEST_F(FormatTest, FormatsEnumStruct) {
2043   verifyFormat("enum struct {\n"
2044                "  Zero,\n"
2045                "  One = 1,\n"
2046                "  Two = One + 1,\n"
2047                "  Three = (One + Two),\n"
2048                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2049                "  Five = (One, Two, Three, Four, 5)\n"
2050                "};");
2051   verifyFormat("enum struct Enum {};");
2052   verifyFormat("enum struct {};");
2053   verifyFormat("enum struct X E {} d;");
2054   verifyFormat("enum struct __attribute__((...)) E {} d;");
2055   verifyFormat("enum struct __declspec__((...)) E {} d;");
2056   verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
2057 }
2058 
2059 TEST_F(FormatTest, FormatsEnumClass) {
2060   verifyFormat("enum class {\n"
2061                "  Zero,\n"
2062                "  One = 1,\n"
2063                "  Two = One + 1,\n"
2064                "  Three = (One + Two),\n"
2065                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2066                "  Five = (One, Two, Three, Four, 5)\n"
2067                "};");
2068   verifyFormat("enum class Enum {};");
2069   verifyFormat("enum class {};");
2070   verifyFormat("enum class X E {} d;");
2071   verifyFormat("enum class __attribute__((...)) E {} d;");
2072   verifyFormat("enum class __declspec__((...)) E {} d;");
2073   verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
2074 }
2075 
2076 TEST_F(FormatTest, FormatsEnumTypes) {
2077   verifyFormat("enum X : int {\n"
2078                "  A, // Force multiple lines.\n"
2079                "  B\n"
2080                "};");
2081   verifyFormat("enum X : int { A, B };");
2082   verifyFormat("enum X : std::uint32_t { A, B };");
2083 }
2084 
2085 TEST_F(FormatTest, FormatsTypedefEnum) {
2086   FormatStyle Style = getLLVMStyle();
2087   Style.ColumnLimit = 40;
2088   verifyFormat("typedef enum {} EmptyEnum;");
2089   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2090   verifyFormat("typedef enum {\n"
2091                "  ZERO = 0,\n"
2092                "  ONE = 1,\n"
2093                "  TWO = 2,\n"
2094                "  THREE = 3\n"
2095                "} LongEnum;",
2096                Style);
2097   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2098   Style.BraceWrapping.AfterEnum = true;
2099   verifyFormat("typedef enum {} EmptyEnum;");
2100   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2101   verifyFormat("typedef enum\n"
2102                "{\n"
2103                "  ZERO = 0,\n"
2104                "  ONE = 1,\n"
2105                "  TWO = 2,\n"
2106                "  THREE = 3\n"
2107                "} LongEnum;",
2108                Style);
2109 }
2110 
2111 TEST_F(FormatTest, FormatsNSEnums) {
2112   verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
2113   verifyGoogleFormat(
2114       "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }");
2115   verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
2116                      "  // Information about someDecentlyLongValue.\n"
2117                      "  someDecentlyLongValue,\n"
2118                      "  // Information about anotherDecentlyLongValue.\n"
2119                      "  anotherDecentlyLongValue,\n"
2120                      "  // Information about aThirdDecentlyLongValue.\n"
2121                      "  aThirdDecentlyLongValue\n"
2122                      "};");
2123   verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n"
2124                      "  // Information about someDecentlyLongValue.\n"
2125                      "  someDecentlyLongValue,\n"
2126                      "  // Information about anotherDecentlyLongValue.\n"
2127                      "  anotherDecentlyLongValue,\n"
2128                      "  // Information about aThirdDecentlyLongValue.\n"
2129                      "  aThirdDecentlyLongValue\n"
2130                      "};");
2131   verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
2132                      "  a = 1,\n"
2133                      "  b = 2,\n"
2134                      "  c = 3,\n"
2135                      "};");
2136   verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
2137                      "  a = 1,\n"
2138                      "  b = 2,\n"
2139                      "  c = 3,\n"
2140                      "};");
2141   verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n"
2142                      "  a = 1,\n"
2143                      "  b = 2,\n"
2144                      "  c = 3,\n"
2145                      "};");
2146   verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
2147                      "  a = 1,\n"
2148                      "  b = 2,\n"
2149                      "  c = 3,\n"
2150                      "};");
2151 }
2152 
2153 TEST_F(FormatTest, FormatsBitfields) {
2154   verifyFormat("struct Bitfields {\n"
2155                "  unsigned sClass : 8;\n"
2156                "  unsigned ValueKind : 2;\n"
2157                "};");
2158   verifyFormat("struct A {\n"
2159                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
2160                "      bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
2161                "};");
2162   verifyFormat("struct MyStruct {\n"
2163                "  uchar data;\n"
2164                "  uchar : 8;\n"
2165                "  uchar : 8;\n"
2166                "  uchar other;\n"
2167                "};");
2168 }
2169 
2170 TEST_F(FormatTest, FormatsNamespaces) {
2171   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
2172   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
2173 
2174   verifyFormat("namespace some_namespace {\n"
2175                "class A {};\n"
2176                "void f() { f(); }\n"
2177                "}",
2178                LLVMWithNoNamespaceFix);
2179   verifyFormat("namespace N::inline D {\n"
2180                "class A {};\n"
2181                "void f() { f(); }\n"
2182                "}",
2183                LLVMWithNoNamespaceFix);
2184   verifyFormat("namespace N::inline D::E {\n"
2185                "class A {};\n"
2186                "void f() { f(); }\n"
2187                "}",
2188                LLVMWithNoNamespaceFix);
2189   verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
2190                "class A {};\n"
2191                "void f() { f(); }\n"
2192                "}",
2193                LLVMWithNoNamespaceFix);
2194   verifyFormat("/* something */ namespace some_namespace {\n"
2195                "class A {};\n"
2196                "void f() { f(); }\n"
2197                "}",
2198                LLVMWithNoNamespaceFix);
2199   verifyFormat("namespace {\n"
2200                "class A {};\n"
2201                "void f() { f(); }\n"
2202                "}",
2203                LLVMWithNoNamespaceFix);
2204   verifyFormat("/* something */ namespace {\n"
2205                "class A {};\n"
2206                "void f() { f(); }\n"
2207                "}",
2208                LLVMWithNoNamespaceFix);
2209   verifyFormat("inline namespace X {\n"
2210                "class A {};\n"
2211                "void f() { f(); }\n"
2212                "}",
2213                LLVMWithNoNamespaceFix);
2214   verifyFormat("/* something */ inline namespace X {\n"
2215                "class A {};\n"
2216                "void f() { f(); }\n"
2217                "}",
2218                LLVMWithNoNamespaceFix);
2219   verifyFormat("export namespace X {\n"
2220                "class A {};\n"
2221                "void f() { f(); }\n"
2222                "}",
2223                LLVMWithNoNamespaceFix);
2224   verifyFormat("using namespace some_namespace;\n"
2225                "class A {};\n"
2226                "void f() { f(); }",
2227                LLVMWithNoNamespaceFix);
2228 
2229   // This code is more common than we thought; if we
2230   // layout this correctly the semicolon will go into
2231   // its own line, which is undesirable.
2232   verifyFormat("namespace {};", LLVMWithNoNamespaceFix);
2233   verifyFormat("namespace {\n"
2234                "class A {};\n"
2235                "};",
2236                LLVMWithNoNamespaceFix);
2237 
2238   verifyFormat("namespace {\n"
2239                "int SomeVariable = 0; // comment\n"
2240                "} // namespace",
2241                LLVMWithNoNamespaceFix);
2242   EXPECT_EQ("#ifndef HEADER_GUARD\n"
2243             "#define HEADER_GUARD\n"
2244             "namespace my_namespace {\n"
2245             "int i;\n"
2246             "} // my_namespace\n"
2247             "#endif // HEADER_GUARD",
2248             format("#ifndef HEADER_GUARD\n"
2249                    " #define HEADER_GUARD\n"
2250                    "   namespace my_namespace {\n"
2251                    "int i;\n"
2252                    "}    // my_namespace\n"
2253                    "#endif    // HEADER_GUARD",
2254                    LLVMWithNoNamespaceFix));
2255 
2256   EXPECT_EQ("namespace A::B {\n"
2257             "class C {};\n"
2258             "}",
2259             format("namespace A::B {\n"
2260                    "class C {};\n"
2261                    "}",
2262                    LLVMWithNoNamespaceFix));
2263 
2264   FormatStyle Style = getLLVMStyle();
2265   Style.NamespaceIndentation = FormatStyle::NI_All;
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   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2281   EXPECT_EQ("namespace out {\n"
2282             "int i;\n"
2283             "namespace in {\n"
2284             "  int i;\n"
2285             "} // namespace in\n"
2286             "} // namespace out",
2287             format("namespace out {\n"
2288                    "int i;\n"
2289                    "namespace in {\n"
2290                    "int i;\n"
2291                    "} // namespace in\n"
2292                    "} // namespace out",
2293                    Style));
2294 }
2295 
2296 TEST_F(FormatTest, NamespaceMacros) {
2297   FormatStyle Style = getLLVMStyle();
2298   Style.NamespaceMacros.push_back("TESTSUITE");
2299 
2300   verifyFormat("TESTSUITE(A) {\n"
2301                "int foo();\n"
2302                "} // TESTSUITE(A)",
2303                Style);
2304 
2305   verifyFormat("TESTSUITE(A, B) {\n"
2306                "int foo();\n"
2307                "} // TESTSUITE(A)",
2308                Style);
2309 
2310   // Properly indent according to NamespaceIndentation style
2311   Style.NamespaceIndentation = FormatStyle::NI_All;
2312   verifyFormat("TESTSUITE(A) {\n"
2313                "  int foo();\n"
2314                "} // TESTSUITE(A)",
2315                Style);
2316   verifyFormat("TESTSUITE(A) {\n"
2317                "  namespace B {\n"
2318                "    int foo();\n"
2319                "  } // namespace B\n"
2320                "} // TESTSUITE(A)",
2321                Style);
2322   verifyFormat("namespace A {\n"
2323                "  TESTSUITE(B) {\n"
2324                "    int foo();\n"
2325                "  } // TESTSUITE(B)\n"
2326                "} // namespace A",
2327                Style);
2328 
2329   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2330   verifyFormat("TESTSUITE(A) {\n"
2331                "TESTSUITE(B) {\n"
2332                "  int foo();\n"
2333                "} // TESTSUITE(B)\n"
2334                "} // TESTSUITE(A)",
2335                Style);
2336   verifyFormat("TESTSUITE(A) {\n"
2337                "namespace B {\n"
2338                "  int foo();\n"
2339                "} // namespace B\n"
2340                "} // TESTSUITE(A)",
2341                Style);
2342   verifyFormat("namespace A {\n"
2343                "TESTSUITE(B) {\n"
2344                "  int foo();\n"
2345                "} // TESTSUITE(B)\n"
2346                "} // namespace A",
2347                Style);
2348 
2349   // Properly merge namespace-macros blocks in CompactNamespaces mode
2350   Style.NamespaceIndentation = FormatStyle::NI_None;
2351   Style.CompactNamespaces = true;
2352   verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
2353                "}} // TESTSUITE(A::B)",
2354                Style);
2355 
2356   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2357             "}} // TESTSUITE(out::in)",
2358             format("TESTSUITE(out) {\n"
2359                    "TESTSUITE(in) {\n"
2360                    "} // TESTSUITE(in)\n"
2361                    "} // TESTSUITE(out)",
2362                    Style));
2363 
2364   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2365             "}} // TESTSUITE(out::in)",
2366             format("TESTSUITE(out) {\n"
2367                    "TESTSUITE(in) {\n"
2368                    "} // TESTSUITE(in)\n"
2369                    "} // TESTSUITE(out)",
2370                    Style));
2371 
2372   // Do not merge different namespaces/macros
2373   EXPECT_EQ("namespace out {\n"
2374             "TESTSUITE(in) {\n"
2375             "} // TESTSUITE(in)\n"
2376             "} // namespace out",
2377             format("namespace out {\n"
2378                    "TESTSUITE(in) {\n"
2379                    "} // TESTSUITE(in)\n"
2380                    "} // namespace out",
2381                    Style));
2382   EXPECT_EQ("TESTSUITE(out) {\n"
2383             "namespace in {\n"
2384             "} // namespace in\n"
2385             "} // TESTSUITE(out)",
2386             format("TESTSUITE(out) {\n"
2387                    "namespace in {\n"
2388                    "} // namespace in\n"
2389                    "} // TESTSUITE(out)",
2390                    Style));
2391   Style.NamespaceMacros.push_back("FOOBAR");
2392   EXPECT_EQ("TESTSUITE(out) {\n"
2393             "FOOBAR(in) {\n"
2394             "} // FOOBAR(in)\n"
2395             "} // TESTSUITE(out)",
2396             format("TESTSUITE(out) {\n"
2397                    "FOOBAR(in) {\n"
2398                    "} // FOOBAR(in)\n"
2399                    "} // TESTSUITE(out)",
2400                    Style));
2401 }
2402 
2403 TEST_F(FormatTest, FormatsCompactNamespaces) {
2404   FormatStyle Style = getLLVMStyle();
2405   Style.CompactNamespaces = true;
2406   Style.NamespaceMacros.push_back("TESTSUITE");
2407 
2408   verifyFormat("namespace A { namespace B {\n"
2409                "}} // namespace A::B",
2410                Style);
2411 
2412   EXPECT_EQ("namespace out { namespace in {\n"
2413             "}} // namespace out::in",
2414             format("namespace out {\n"
2415                    "namespace in {\n"
2416                    "} // namespace in\n"
2417                    "} // namespace out",
2418                    Style));
2419 
2420   // Only namespaces which have both consecutive opening and end get compacted
2421   EXPECT_EQ("namespace out {\n"
2422             "namespace in1 {\n"
2423             "} // namespace in1\n"
2424             "namespace in2 {\n"
2425             "} // namespace in2\n"
2426             "} // namespace out",
2427             format("namespace out {\n"
2428                    "namespace in1 {\n"
2429                    "} // namespace in1\n"
2430                    "namespace in2 {\n"
2431                    "} // namespace in2\n"
2432                    "} // namespace out",
2433                    Style));
2434 
2435   EXPECT_EQ("namespace out {\n"
2436             "int i;\n"
2437             "namespace in {\n"
2438             "int j;\n"
2439             "} // namespace in\n"
2440             "int k;\n"
2441             "} // namespace out",
2442             format("namespace out { int i;\n"
2443                    "namespace in { int j; } // namespace in\n"
2444                    "int k; } // namespace out",
2445                    Style));
2446 
2447   EXPECT_EQ("namespace A { namespace B { namespace C {\n"
2448             "}}} // namespace A::B::C\n",
2449             format("namespace A { namespace B {\n"
2450                    "namespace C {\n"
2451                    "}} // namespace B::C\n"
2452                    "} // namespace A\n",
2453                    Style));
2454 
2455   Style.ColumnLimit = 40;
2456   EXPECT_EQ("namespace aaaaaaaaaa {\n"
2457             "namespace bbbbbbbbbb {\n"
2458             "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
2459             format("namespace aaaaaaaaaa {\n"
2460                    "namespace bbbbbbbbbb {\n"
2461                    "} // namespace bbbbbbbbbb\n"
2462                    "} // namespace aaaaaaaaaa",
2463                    Style));
2464 
2465   EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
2466             "namespace cccccc {\n"
2467             "}}} // namespace aaaaaa::bbbbbb::cccccc",
2468             format("namespace aaaaaa {\n"
2469                    "namespace bbbbbb {\n"
2470                    "namespace cccccc {\n"
2471                    "} // namespace cccccc\n"
2472                    "} // namespace bbbbbb\n"
2473                    "} // namespace aaaaaa",
2474                    Style));
2475   Style.ColumnLimit = 80;
2476 
2477   // Extra semicolon after 'inner' closing brace prevents merging
2478   EXPECT_EQ("namespace out { namespace in {\n"
2479             "}; } // namespace out::in",
2480             format("namespace out {\n"
2481                    "namespace in {\n"
2482                    "}; // namespace in\n"
2483                    "} // namespace out",
2484                    Style));
2485 
2486   // Extra semicolon after 'outer' closing brace is conserved
2487   EXPECT_EQ("namespace out { namespace in {\n"
2488             "}}; // namespace out::in",
2489             format("namespace out {\n"
2490                    "namespace in {\n"
2491                    "} // namespace in\n"
2492                    "}; // namespace out",
2493                    Style));
2494 
2495   Style.NamespaceIndentation = FormatStyle::NI_All;
2496   EXPECT_EQ("namespace out { namespace in {\n"
2497             "  int i;\n"
2498             "}} // namespace out::in",
2499             format("namespace out {\n"
2500                    "namespace in {\n"
2501                    "int i;\n"
2502                    "} // namespace in\n"
2503                    "} // namespace out",
2504                    Style));
2505   EXPECT_EQ("namespace out { namespace mid {\n"
2506             "  namespace in {\n"
2507             "    int j;\n"
2508             "  } // namespace in\n"
2509             "  int k;\n"
2510             "}} // namespace out::mid",
2511             format("namespace out { namespace mid {\n"
2512                    "namespace in { int j; } // namespace in\n"
2513                    "int k; }} // namespace out::mid",
2514                    Style));
2515 
2516   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2517   EXPECT_EQ("namespace out { namespace in {\n"
2518             "  int i;\n"
2519             "}} // namespace out::in",
2520             format("namespace out {\n"
2521                    "namespace in {\n"
2522                    "int i;\n"
2523                    "} // namespace in\n"
2524                    "} // namespace out",
2525                    Style));
2526   EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
2527             "  int i;\n"
2528             "}}} // namespace out::mid::in",
2529             format("namespace out {\n"
2530                    "namespace mid {\n"
2531                    "namespace in {\n"
2532                    "int i;\n"
2533                    "} // namespace in\n"
2534                    "} // namespace mid\n"
2535                    "} // namespace out",
2536                    Style));
2537 }
2538 
2539 TEST_F(FormatTest, FormatsExternC) {
2540   verifyFormat("extern \"C\" {\nint a;");
2541   verifyFormat("extern \"C\" {}");
2542   verifyFormat("extern \"C\" {\n"
2543                "int foo();\n"
2544                "}");
2545   verifyFormat("extern \"C\" int foo() {}");
2546   verifyFormat("extern \"C\" int foo();");
2547   verifyFormat("extern \"C\" int foo() {\n"
2548                "  int i = 42;\n"
2549                "  return i;\n"
2550                "}");
2551 
2552   FormatStyle Style = getLLVMStyle();
2553   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2554   Style.BraceWrapping.AfterFunction = true;
2555   verifyFormat("extern \"C\" int foo() {}", Style);
2556   verifyFormat("extern \"C\" int foo();", Style);
2557   verifyFormat("extern \"C\" int foo()\n"
2558                "{\n"
2559                "  int i = 42;\n"
2560                "  return i;\n"
2561                "}",
2562                Style);
2563 
2564   Style.BraceWrapping.AfterExternBlock = true;
2565   Style.BraceWrapping.SplitEmptyRecord = false;
2566   verifyFormat("extern \"C\"\n"
2567                "{}",
2568                Style);
2569   verifyFormat("extern \"C\"\n"
2570                "{\n"
2571                "  int foo();\n"
2572                "}",
2573                Style);
2574 }
2575 
2576 TEST_F(FormatTest, IndentExternBlockStyle) {
2577   FormatStyle Style = getLLVMStyle();
2578   Style.IndentWidth = 2;
2579 
2580   Style.IndentExternBlock = FormatStyle::IEBS_Indent;
2581   verifyFormat("extern \"C\" { /*9*/\n}", Style);
2582   verifyFormat("extern \"C\" {\n"
2583                "  int foo10();\n"
2584                "}",
2585                Style);
2586 
2587   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
2588   verifyFormat("extern \"C\" { /*11*/\n}", Style);
2589   verifyFormat("extern \"C\" {\n"
2590                "int foo12();\n"
2591                "}",
2592                Style);
2593 
2594   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2595   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2596   Style.BraceWrapping.AfterExternBlock = true;
2597   verifyFormat("extern \"C\"\n{ /*13*/\n}", Style);
2598   verifyFormat("extern \"C\"\n{\n"
2599                "  int foo14();\n"
2600                "}",
2601                Style);
2602 
2603   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2604   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2605   Style.BraceWrapping.AfterExternBlock = false;
2606   verifyFormat("extern \"C\" { /*15*/\n}", Style);
2607   verifyFormat("extern \"C\" {\n"
2608                "int foo16();\n"
2609                "}",
2610                Style);
2611 }
2612 
2613 TEST_F(FormatTest, FormatsInlineASM) {
2614   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
2615   verifyFormat("asm(\"nop\" ::: \"memory\");");
2616   verifyFormat(
2617       "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
2618       "    \"cpuid\\n\\t\"\n"
2619       "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
2620       "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
2621       "    : \"a\"(value));");
2622   EXPECT_EQ(
2623       "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
2624       "  __asm {\n"
2625       "        mov     edx,[that] // vtable in edx\n"
2626       "        mov     eax,methodIndex\n"
2627       "        call    [edx][eax*4] // stdcall\n"
2628       "  }\n"
2629       "}",
2630       format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
2631              "    __asm {\n"
2632              "        mov     edx,[that] // vtable in edx\n"
2633              "        mov     eax,methodIndex\n"
2634              "        call    [edx][eax*4] // stdcall\n"
2635              "    }\n"
2636              "}"));
2637   EXPECT_EQ("_asm {\n"
2638             "  xor eax, eax;\n"
2639             "  cpuid;\n"
2640             "}",
2641             format("_asm {\n"
2642                    "  xor eax, eax;\n"
2643                    "  cpuid;\n"
2644                    "}"));
2645   verifyFormat("void function() {\n"
2646                "  // comment\n"
2647                "  asm(\"\");\n"
2648                "}");
2649   EXPECT_EQ("__asm {\n"
2650             "}\n"
2651             "int i;",
2652             format("__asm   {\n"
2653                    "}\n"
2654                    "int   i;"));
2655 }
2656 
2657 TEST_F(FormatTest, FormatTryCatch) {
2658   verifyFormat("try {\n"
2659                "  throw a * b;\n"
2660                "} catch (int a) {\n"
2661                "  // Do nothing.\n"
2662                "} catch (...) {\n"
2663                "  exit(42);\n"
2664                "}");
2665 
2666   // Function-level try statements.
2667   verifyFormat("int f() try { return 4; } catch (...) {\n"
2668                "  return 5;\n"
2669                "}");
2670   verifyFormat("class A {\n"
2671                "  int a;\n"
2672                "  A() try : a(0) {\n"
2673                "  } catch (...) {\n"
2674                "    throw;\n"
2675                "  }\n"
2676                "};\n");
2677 
2678   // Incomplete try-catch blocks.
2679   verifyIncompleteFormat("try {} catch (");
2680 }
2681 
2682 TEST_F(FormatTest, FormatTryAsAVariable) {
2683   verifyFormat("int try;");
2684   verifyFormat("int try, size;");
2685   verifyFormat("try = foo();");
2686   verifyFormat("if (try < size) {\n  return true;\n}");
2687 
2688   verifyFormat("int catch;");
2689   verifyFormat("int catch, size;");
2690   verifyFormat("catch = foo();");
2691   verifyFormat("if (catch < size) {\n  return true;\n}");
2692 }
2693 
2694 TEST_F(FormatTest, FormatSEHTryCatch) {
2695   verifyFormat("__try {\n"
2696                "  int a = b * c;\n"
2697                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2698                "  // Do nothing.\n"
2699                "}");
2700 
2701   verifyFormat("__try {\n"
2702                "  int a = b * c;\n"
2703                "} __finally {\n"
2704                "  // Do nothing.\n"
2705                "}");
2706 
2707   verifyFormat("DEBUG({\n"
2708                "  __try {\n"
2709                "  } __finally {\n"
2710                "  }\n"
2711                "});\n");
2712 }
2713 
2714 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2715   verifyFormat("try {\n"
2716                "  f();\n"
2717                "} catch {\n"
2718                "  g();\n"
2719                "}");
2720   verifyFormat("try {\n"
2721                "  f();\n"
2722                "} catch (A a) MACRO(x) {\n"
2723                "  g();\n"
2724                "} catch (B b) MACRO(x) {\n"
2725                "  g();\n"
2726                "}");
2727 }
2728 
2729 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2730   FormatStyle Style = getLLVMStyle();
2731   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2732                           FormatStyle::BS_WebKit}) {
2733     Style.BreakBeforeBraces = BraceStyle;
2734     verifyFormat("try {\n"
2735                  "  // something\n"
2736                  "} catch (...) {\n"
2737                  "  // something\n"
2738                  "}",
2739                  Style);
2740   }
2741   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2742   verifyFormat("try {\n"
2743                "  // something\n"
2744                "}\n"
2745                "catch (...) {\n"
2746                "  // something\n"
2747                "}",
2748                Style);
2749   verifyFormat("__try {\n"
2750                "  // something\n"
2751                "}\n"
2752                "__finally {\n"
2753                "  // something\n"
2754                "}",
2755                Style);
2756   verifyFormat("@try {\n"
2757                "  // something\n"
2758                "}\n"
2759                "@finally {\n"
2760                "  // something\n"
2761                "}",
2762                Style);
2763   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2764   verifyFormat("try\n"
2765                "{\n"
2766                "  // something\n"
2767                "}\n"
2768                "catch (...)\n"
2769                "{\n"
2770                "  // something\n"
2771                "}",
2772                Style);
2773   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2774   verifyFormat("try\n"
2775                "  {\n"
2776                "  // something white\n"
2777                "  }\n"
2778                "catch (...)\n"
2779                "  {\n"
2780                "  // something white\n"
2781                "  }",
2782                Style);
2783   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2784   verifyFormat("try\n"
2785                "  {\n"
2786                "    // something\n"
2787                "  }\n"
2788                "catch (...)\n"
2789                "  {\n"
2790                "    // something\n"
2791                "  }",
2792                Style);
2793   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2794   Style.BraceWrapping.BeforeCatch = true;
2795   verifyFormat("try {\n"
2796                "  // something\n"
2797                "}\n"
2798                "catch (...) {\n"
2799                "  // something\n"
2800                "}",
2801                Style);
2802 }
2803 
2804 TEST_F(FormatTest, StaticInitializers) {
2805   verifyFormat("static SomeClass SC = {1, 'a'};");
2806 
2807   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2808                "    100000000, "
2809                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2810 
2811   // Here, everything other than the "}" would fit on a line.
2812   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2813                "    10000000000000000000000000};");
2814   EXPECT_EQ("S s = {a,\n"
2815             "\n"
2816             "       b};",
2817             format("S s = {\n"
2818                    "  a,\n"
2819                    "\n"
2820                    "  b\n"
2821                    "};"));
2822 
2823   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2824   // line. However, the formatting looks a bit off and this probably doesn't
2825   // happen often in practice.
2826   verifyFormat("static int Variable[1] = {\n"
2827                "    {1000000000000000000000000000000000000}};",
2828                getLLVMStyleWithColumns(40));
2829 }
2830 
2831 TEST_F(FormatTest, DesignatedInitializers) {
2832   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2833   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2834                "                    .bbbbbbbbbb = 2,\n"
2835                "                    .cccccccccc = 3,\n"
2836                "                    .dddddddddd = 4,\n"
2837                "                    .eeeeeeeeee = 5};");
2838   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2839                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2840                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2841                "    .ccccccccccccccccccccccccccc = 3,\n"
2842                "    .ddddddddddddddddddddddddddd = 4,\n"
2843                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2844 
2845   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2846 
2847   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2848   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2849                "                    [2] = bbbbbbbbbb,\n"
2850                "                    [3] = cccccccccc,\n"
2851                "                    [4] = dddddddddd,\n"
2852                "                    [5] = eeeeeeeeee};");
2853   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2854                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2855                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2856                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2857                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2858                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2859 }
2860 
2861 TEST_F(FormatTest, NestedStaticInitializers) {
2862   verifyFormat("static A x = {{{}}};\n");
2863   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2864                "               {init1, init2, init3, init4}}};",
2865                getLLVMStyleWithColumns(50));
2866 
2867   verifyFormat("somes Status::global_reps[3] = {\n"
2868                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2869                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2870                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2871                getLLVMStyleWithColumns(60));
2872   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2873                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2874                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2875                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2876   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2877                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
2878                "rect.fTop}};");
2879 
2880   verifyFormat(
2881       "SomeArrayOfSomeType a = {\n"
2882       "    {{1, 2, 3},\n"
2883       "     {1, 2, 3},\n"
2884       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
2885       "      333333333333333333333333333333},\n"
2886       "     {1, 2, 3},\n"
2887       "     {1, 2, 3}}};");
2888   verifyFormat(
2889       "SomeArrayOfSomeType a = {\n"
2890       "    {{1, 2, 3}},\n"
2891       "    {{1, 2, 3}},\n"
2892       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2893       "      333333333333333333333333333333}},\n"
2894       "    {{1, 2, 3}},\n"
2895       "    {{1, 2, 3}}};");
2896 
2897   verifyFormat("struct {\n"
2898                "  unsigned bit;\n"
2899                "  const char *const name;\n"
2900                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2901                "                 {kOsWin, \"Windows\"},\n"
2902                "                 {kOsLinux, \"Linux\"},\n"
2903                "                 {kOsCrOS, \"Chrome OS\"}};");
2904   verifyFormat("struct {\n"
2905                "  unsigned bit;\n"
2906                "  const char *const name;\n"
2907                "} kBitsToOs[] = {\n"
2908                "    {kOsMac, \"Mac\"},\n"
2909                "    {kOsWin, \"Windows\"},\n"
2910                "    {kOsLinux, \"Linux\"},\n"
2911                "    {kOsCrOS, \"Chrome OS\"},\n"
2912                "};");
2913 }
2914 
2915 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2916   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2917                "                      \\\n"
2918                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2919 }
2920 
2921 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
2922   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2923                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
2924 
2925   // Do break defaulted and deleted functions.
2926   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2927                "    default;",
2928                getLLVMStyleWithColumns(40));
2929   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2930                "    delete;",
2931                getLLVMStyleWithColumns(40));
2932 }
2933 
2934 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2935   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2936                getLLVMStyleWithColumns(40));
2937   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2938                getLLVMStyleWithColumns(40));
2939   EXPECT_EQ("#define Q                              \\\n"
2940             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
2941             "  \"aaaaaaaa.cpp\"",
2942             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2943                    getLLVMStyleWithColumns(40)));
2944 }
2945 
2946 TEST_F(FormatTest, UnderstandsLinePPDirective) {
2947   EXPECT_EQ("# 123 \"A string literal\"",
2948             format("   #     123    \"A string literal\""));
2949 }
2950 
2951 TEST_F(FormatTest, LayoutUnknownPPDirective) {
2952   EXPECT_EQ("#;", format("#;"));
2953   verifyFormat("#\n;\n;\n;");
2954 }
2955 
2956 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
2957   EXPECT_EQ("#line 42 \"test\"\n",
2958             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
2959   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
2960                                     getLLVMStyleWithColumns(12)));
2961 }
2962 
2963 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
2964   EXPECT_EQ("#line 42 \"test\"",
2965             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
2966   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
2967 }
2968 
2969 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
2970   verifyFormat("#define A \\x20");
2971   verifyFormat("#define A \\ x20");
2972   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
2973   verifyFormat("#define A ''");
2974   verifyFormat("#define A ''qqq");
2975   verifyFormat("#define A `qqq");
2976   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
2977   EXPECT_EQ("const char *c = STRINGIFY(\n"
2978             "\\na : b);",
2979             format("const char * c = STRINGIFY(\n"
2980                    "\\na : b);"));
2981 
2982   verifyFormat("a\r\\");
2983   verifyFormat("a\v\\");
2984   verifyFormat("a\f\\");
2985 }
2986 
2987 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
2988   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
2989   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
2990   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
2991   // FIXME: We never break before the macro name.
2992   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
2993 
2994   verifyFormat("#define A A\n#define A A");
2995   verifyFormat("#define A(X) A\n#define A A");
2996 
2997   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
2998   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
2999 }
3000 
3001 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
3002   EXPECT_EQ("// somecomment\n"
3003             "#include \"a.h\"\n"
3004             "#define A(  \\\n"
3005             "    A, B)\n"
3006             "#include \"b.h\"\n"
3007             "// somecomment\n",
3008             format("  // somecomment\n"
3009                    "  #include \"a.h\"\n"
3010                    "#define A(A,\\\n"
3011                    "    B)\n"
3012                    "    #include \"b.h\"\n"
3013                    " // somecomment\n",
3014                    getLLVMStyleWithColumns(13)));
3015 }
3016 
3017 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
3018 
3019 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
3020   EXPECT_EQ("#define A    \\\n"
3021             "  c;         \\\n"
3022             "  e;\n"
3023             "f;",
3024             format("#define A c; e;\n"
3025                    "f;",
3026                    getLLVMStyleWithColumns(14)));
3027 }
3028 
3029 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
3030 
3031 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
3032   EXPECT_EQ("int x,\n"
3033             "#define A\n"
3034             "    y;",
3035             format("int x,\n#define A\ny;"));
3036 }
3037 
3038 TEST_F(FormatTest, HashInMacroDefinition) {
3039   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
3040   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
3041   verifyFormat("#define A  \\\n"
3042                "  {        \\\n"
3043                "    f(#c); \\\n"
3044                "  }",
3045                getLLVMStyleWithColumns(11));
3046 
3047   verifyFormat("#define A(X)         \\\n"
3048                "  void function##X()",
3049                getLLVMStyleWithColumns(22));
3050 
3051   verifyFormat("#define A(a, b, c)   \\\n"
3052                "  void a##b##c()",
3053                getLLVMStyleWithColumns(22));
3054 
3055   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
3056 }
3057 
3058 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
3059   EXPECT_EQ("#define A (x)", format("#define A (x)"));
3060   EXPECT_EQ("#define A(x)", format("#define A(x)"));
3061 
3062   FormatStyle Style = getLLVMStyle();
3063   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
3064   verifyFormat("#define true ((foo)1)", Style);
3065   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
3066   verifyFormat("#define false((foo)0)", Style);
3067 }
3068 
3069 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
3070   EXPECT_EQ("#define A b;", format("#define A \\\n"
3071                                    "          \\\n"
3072                                    "  b;",
3073                                    getLLVMStyleWithColumns(25)));
3074   EXPECT_EQ("#define A \\\n"
3075             "          \\\n"
3076             "  a;      \\\n"
3077             "  b;",
3078             format("#define A \\\n"
3079                    "          \\\n"
3080                    "  a;      \\\n"
3081                    "  b;",
3082                    getLLVMStyleWithColumns(11)));
3083   EXPECT_EQ("#define A \\\n"
3084             "  a;      \\\n"
3085             "          \\\n"
3086             "  b;",
3087             format("#define A \\\n"
3088                    "  a;      \\\n"
3089                    "          \\\n"
3090                    "  b;",
3091                    getLLVMStyleWithColumns(11)));
3092 }
3093 
3094 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
3095   verifyIncompleteFormat("#define A :");
3096   verifyFormat("#define SOMECASES  \\\n"
3097                "  case 1:          \\\n"
3098                "  case 2\n",
3099                getLLVMStyleWithColumns(20));
3100   verifyFormat("#define MACRO(a) \\\n"
3101                "  if (a)         \\\n"
3102                "    f();         \\\n"
3103                "  else           \\\n"
3104                "    g()",
3105                getLLVMStyleWithColumns(18));
3106   verifyFormat("#define A template <typename T>");
3107   verifyIncompleteFormat("#define STR(x) #x\n"
3108                          "f(STR(this_is_a_string_literal{));");
3109   verifyFormat("#pragma omp threadprivate( \\\n"
3110                "    y)), // expected-warning",
3111                getLLVMStyleWithColumns(28));
3112   verifyFormat("#d, = };");
3113   verifyFormat("#if \"a");
3114   verifyIncompleteFormat("({\n"
3115                          "#define b     \\\n"
3116                          "  }           \\\n"
3117                          "  a\n"
3118                          "a",
3119                          getLLVMStyleWithColumns(15));
3120   verifyFormat("#define A     \\\n"
3121                "  {           \\\n"
3122                "    {\n"
3123                "#define B     \\\n"
3124                "  }           \\\n"
3125                "  }",
3126                getLLVMStyleWithColumns(15));
3127   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
3128   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
3129   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
3130   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
3131 }
3132 
3133 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
3134   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
3135   EXPECT_EQ("class A : public QObject {\n"
3136             "  Q_OBJECT\n"
3137             "\n"
3138             "  A() {}\n"
3139             "};",
3140             format("class A  :  public QObject {\n"
3141                    "     Q_OBJECT\n"
3142                    "\n"
3143                    "  A() {\n}\n"
3144                    "}  ;"));
3145   EXPECT_EQ("MACRO\n"
3146             "/*static*/ int i;",
3147             format("MACRO\n"
3148                    " /*static*/ int   i;"));
3149   EXPECT_EQ("SOME_MACRO\n"
3150             "namespace {\n"
3151             "void f();\n"
3152             "} // namespace",
3153             format("SOME_MACRO\n"
3154                    "  namespace    {\n"
3155                    "void   f(  );\n"
3156                    "} // namespace"));
3157   // Only if the identifier contains at least 5 characters.
3158   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
3159   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
3160   // Only if everything is upper case.
3161   EXPECT_EQ("class A : public QObject {\n"
3162             "  Q_Object A() {}\n"
3163             "};",
3164             format("class A  :  public QObject {\n"
3165                    "     Q_Object\n"
3166                    "  A() {\n}\n"
3167                    "}  ;"));
3168 
3169   // Only if the next line can actually start an unwrapped line.
3170   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
3171             format("SOME_WEIRD_LOG_MACRO\n"
3172                    "<< SomeThing;"));
3173 
3174   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3175                "(n, buffers))\n",
3176                getChromiumStyle(FormatStyle::LK_Cpp));
3177 
3178   // See PR41483
3179   EXPECT_EQ("/**/ FOO(a)\n"
3180             "FOO(b)",
3181             format("/**/ FOO(a)\n"
3182                    "FOO(b)"));
3183 }
3184 
3185 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
3186   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3187             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3188             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3189             "class X {};\n"
3190             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3191             "int *createScopDetectionPass() { return 0; }",
3192             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3193                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3194                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3195                    "  class X {};\n"
3196                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3197                    "  int *createScopDetectionPass() { return 0; }"));
3198   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
3199   // braces, so that inner block is indented one level more.
3200   EXPECT_EQ("int q() {\n"
3201             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3202             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3203             "  IPC_END_MESSAGE_MAP()\n"
3204             "}",
3205             format("int q() {\n"
3206                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3207                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3208                    "  IPC_END_MESSAGE_MAP()\n"
3209                    "}"));
3210 
3211   // Same inside macros.
3212   EXPECT_EQ("#define LIST(L) \\\n"
3213             "  L(A)          \\\n"
3214             "  L(B)          \\\n"
3215             "  L(C)",
3216             format("#define LIST(L) \\\n"
3217                    "  L(A) \\\n"
3218                    "  L(B) \\\n"
3219                    "  L(C)",
3220                    getGoogleStyle()));
3221 
3222   // These must not be recognized as macros.
3223   EXPECT_EQ("int q() {\n"
3224             "  f(x);\n"
3225             "  f(x) {}\n"
3226             "  f(x)->g();\n"
3227             "  f(x)->*g();\n"
3228             "  f(x).g();\n"
3229             "  f(x) = x;\n"
3230             "  f(x) += x;\n"
3231             "  f(x) -= x;\n"
3232             "  f(x) *= x;\n"
3233             "  f(x) /= x;\n"
3234             "  f(x) %= x;\n"
3235             "  f(x) &= x;\n"
3236             "  f(x) |= x;\n"
3237             "  f(x) ^= x;\n"
3238             "  f(x) >>= x;\n"
3239             "  f(x) <<= x;\n"
3240             "  f(x)[y].z();\n"
3241             "  LOG(INFO) << x;\n"
3242             "  ifstream(x) >> x;\n"
3243             "}\n",
3244             format("int q() {\n"
3245                    "  f(x)\n;\n"
3246                    "  f(x)\n {}\n"
3247                    "  f(x)\n->g();\n"
3248                    "  f(x)\n->*g();\n"
3249                    "  f(x)\n.g();\n"
3250                    "  f(x)\n = x;\n"
3251                    "  f(x)\n += x;\n"
3252                    "  f(x)\n -= x;\n"
3253                    "  f(x)\n *= x;\n"
3254                    "  f(x)\n /= x;\n"
3255                    "  f(x)\n %= x;\n"
3256                    "  f(x)\n &= x;\n"
3257                    "  f(x)\n |= x;\n"
3258                    "  f(x)\n ^= x;\n"
3259                    "  f(x)\n >>= x;\n"
3260                    "  f(x)\n <<= x;\n"
3261                    "  f(x)\n[y].z();\n"
3262                    "  LOG(INFO)\n << x;\n"
3263                    "  ifstream(x)\n >> x;\n"
3264                    "}\n"));
3265   EXPECT_EQ("int q() {\n"
3266             "  F(x)\n"
3267             "  if (1) {\n"
3268             "  }\n"
3269             "  F(x)\n"
3270             "  while (1) {\n"
3271             "  }\n"
3272             "  F(x)\n"
3273             "  G(x);\n"
3274             "  F(x)\n"
3275             "  try {\n"
3276             "    Q();\n"
3277             "  } catch (...) {\n"
3278             "  }\n"
3279             "}\n",
3280             format("int q() {\n"
3281                    "F(x)\n"
3282                    "if (1) {}\n"
3283                    "F(x)\n"
3284                    "while (1) {}\n"
3285                    "F(x)\n"
3286                    "G(x);\n"
3287                    "F(x)\n"
3288                    "try { Q(); } catch (...) {}\n"
3289                    "}\n"));
3290   EXPECT_EQ("class A {\n"
3291             "  A() : t(0) {}\n"
3292             "  A(int i) noexcept() : {}\n"
3293             "  A(X x)\n" // FIXME: function-level try blocks are broken.
3294             "  try : t(0) {\n"
3295             "  } catch (...) {\n"
3296             "  }\n"
3297             "};",
3298             format("class A {\n"
3299                    "  A()\n : t(0) {}\n"
3300                    "  A(int i)\n noexcept() : {}\n"
3301                    "  A(X x)\n"
3302                    "  try : t(0) {} catch (...) {}\n"
3303                    "};"));
3304   FormatStyle Style = getLLVMStyle();
3305   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3306   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3307   Style.BraceWrapping.AfterFunction = true;
3308   EXPECT_EQ("void f()\n"
3309             "try\n"
3310             "{\n"
3311             "}",
3312             format("void f() try {\n"
3313                    "}",
3314                    Style));
3315   EXPECT_EQ("class SomeClass {\n"
3316             "public:\n"
3317             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3318             "};",
3319             format("class SomeClass {\n"
3320                    "public:\n"
3321                    "  SomeClass()\n"
3322                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3323                    "};"));
3324   EXPECT_EQ("class SomeClass {\n"
3325             "public:\n"
3326             "  SomeClass()\n"
3327             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3328             "};",
3329             format("class SomeClass {\n"
3330                    "public:\n"
3331                    "  SomeClass()\n"
3332                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3333                    "};",
3334                    getLLVMStyleWithColumns(40)));
3335 
3336   verifyFormat("MACRO(>)");
3337 
3338   // Some macros contain an implicit semicolon.
3339   Style = getLLVMStyle();
3340   Style.StatementMacros.push_back("FOO");
3341   verifyFormat("FOO(a) int b = 0;");
3342   verifyFormat("FOO(a)\n"
3343                "int b = 0;",
3344                Style);
3345   verifyFormat("FOO(a);\n"
3346                "int b = 0;",
3347                Style);
3348   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3349                "int b = 0;",
3350                Style);
3351   verifyFormat("FOO()\n"
3352                "int b = 0;",
3353                Style);
3354   verifyFormat("FOO\n"
3355                "int b = 0;",
3356                Style);
3357   verifyFormat("void f() {\n"
3358                "  FOO(a)\n"
3359                "  return a;\n"
3360                "}",
3361                Style);
3362   verifyFormat("FOO(a)\n"
3363                "FOO(b)",
3364                Style);
3365   verifyFormat("int a = 0;\n"
3366                "FOO(b)\n"
3367                "int c = 0;",
3368                Style);
3369   verifyFormat("int a = 0;\n"
3370                "int x = FOO(a)\n"
3371                "int b = 0;",
3372                Style);
3373   verifyFormat("void foo(int a) { FOO(a) }\n"
3374                "uint32_t bar() {}",
3375                Style);
3376 }
3377 
3378 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3379   verifyFormat("#define A \\\n"
3380                "  f({     \\\n"
3381                "    g();  \\\n"
3382                "  });",
3383                getLLVMStyleWithColumns(11));
3384 }
3385 
3386 TEST_F(FormatTest, IndentPreprocessorDirectives) {
3387   FormatStyle Style = getLLVMStyle();
3388   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3389   Style.ColumnLimit = 40;
3390   verifyFormat("#ifdef _WIN32\n"
3391                "#define A 0\n"
3392                "#ifdef VAR2\n"
3393                "#define B 1\n"
3394                "#include <someheader.h>\n"
3395                "#define MACRO                          \\\n"
3396                "  some_very_long_func_aaaaaaaaaa();\n"
3397                "#endif\n"
3398                "#else\n"
3399                "#define A 1\n"
3400                "#endif",
3401                Style);
3402   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3403   verifyFormat("#ifdef _WIN32\n"
3404                "#  define A 0\n"
3405                "#  ifdef VAR2\n"
3406                "#    define B 1\n"
3407                "#    include <someheader.h>\n"
3408                "#    define MACRO                      \\\n"
3409                "      some_very_long_func_aaaaaaaaaa();\n"
3410                "#  endif\n"
3411                "#else\n"
3412                "#  define A 1\n"
3413                "#endif",
3414                Style);
3415   verifyFormat("#if A\n"
3416                "#  define MACRO                        \\\n"
3417                "    void a(int x) {                    \\\n"
3418                "      b();                             \\\n"
3419                "      c();                             \\\n"
3420                "      d();                             \\\n"
3421                "      e();                             \\\n"
3422                "      f();                             \\\n"
3423                "    }\n"
3424                "#endif",
3425                Style);
3426   // Comments before include guard.
3427   verifyFormat("// file comment\n"
3428                "// file comment\n"
3429                "#ifndef HEADER_H\n"
3430                "#define HEADER_H\n"
3431                "code();\n"
3432                "#endif",
3433                Style);
3434   // Test with include guards.
3435   verifyFormat("#ifndef HEADER_H\n"
3436                "#define HEADER_H\n"
3437                "code();\n"
3438                "#endif",
3439                Style);
3440   // Include guards must have a #define with the same variable immediately
3441   // after #ifndef.
3442   verifyFormat("#ifndef NOT_GUARD\n"
3443                "#  define FOO\n"
3444                "code();\n"
3445                "#endif",
3446                Style);
3447 
3448   // Include guards must cover the entire file.
3449   verifyFormat("code();\n"
3450                "code();\n"
3451                "#ifndef NOT_GUARD\n"
3452                "#  define NOT_GUARD\n"
3453                "code();\n"
3454                "#endif",
3455                Style);
3456   verifyFormat("#ifndef NOT_GUARD\n"
3457                "#  define NOT_GUARD\n"
3458                "code();\n"
3459                "#endif\n"
3460                "code();",
3461                Style);
3462   // Test with trailing blank lines.
3463   verifyFormat("#ifndef HEADER_H\n"
3464                "#define HEADER_H\n"
3465                "code();\n"
3466                "#endif\n",
3467                Style);
3468   // Include guards don't have #else.
3469   verifyFormat("#ifndef NOT_GUARD\n"
3470                "#  define NOT_GUARD\n"
3471                "code();\n"
3472                "#else\n"
3473                "#endif",
3474                Style);
3475   verifyFormat("#ifndef NOT_GUARD\n"
3476                "#  define NOT_GUARD\n"
3477                "code();\n"
3478                "#elif FOO\n"
3479                "#endif",
3480                Style);
3481   // Non-identifier #define after potential include guard.
3482   verifyFormat("#ifndef FOO\n"
3483                "#  define 1\n"
3484                "#endif\n",
3485                Style);
3486   // #if closes past last non-preprocessor line.
3487   verifyFormat("#ifndef FOO\n"
3488                "#define FOO\n"
3489                "#if 1\n"
3490                "int i;\n"
3491                "#  define A 0\n"
3492                "#endif\n"
3493                "#endif\n",
3494                Style);
3495   // Don't crash if there is an #elif directive without a condition.
3496   verifyFormat("#if 1\n"
3497                "int x;\n"
3498                "#elif\n"
3499                "int y;\n"
3500                "#else\n"
3501                "int z;\n"
3502                "#endif",
3503                Style);
3504   // FIXME: This doesn't handle the case where there's code between the
3505   // #ifndef and #define but all other conditions hold. This is because when
3506   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3507   // previous code line yet, so we can't detect it.
3508   EXPECT_EQ("#ifndef NOT_GUARD\n"
3509             "code();\n"
3510             "#define NOT_GUARD\n"
3511             "code();\n"
3512             "#endif",
3513             format("#ifndef NOT_GUARD\n"
3514                    "code();\n"
3515                    "#  define NOT_GUARD\n"
3516                    "code();\n"
3517                    "#endif",
3518                    Style));
3519   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3520   // be outside an include guard. Examples are #pragma once and
3521   // #pragma GCC diagnostic, or anything else that does not change the meaning
3522   // of the file if it's included multiple times.
3523   EXPECT_EQ("#ifdef WIN32\n"
3524             "#  pragma once\n"
3525             "#endif\n"
3526             "#ifndef HEADER_H\n"
3527             "#  define HEADER_H\n"
3528             "code();\n"
3529             "#endif",
3530             format("#ifdef WIN32\n"
3531                    "#  pragma once\n"
3532                    "#endif\n"
3533                    "#ifndef HEADER_H\n"
3534                    "#define HEADER_H\n"
3535                    "code();\n"
3536                    "#endif",
3537                    Style));
3538   // FIXME: This does not detect when there is a single non-preprocessor line
3539   // in front of an include-guard-like structure where other conditions hold
3540   // because ScopedLineState hides the line.
3541   EXPECT_EQ("code();\n"
3542             "#ifndef HEADER_H\n"
3543             "#define HEADER_H\n"
3544             "code();\n"
3545             "#endif",
3546             format("code();\n"
3547                    "#ifndef HEADER_H\n"
3548                    "#  define HEADER_H\n"
3549                    "code();\n"
3550                    "#endif",
3551                    Style));
3552   // Keep comments aligned with #, otherwise indent comments normally. These
3553   // tests cannot use verifyFormat because messUp manipulates leading
3554   // whitespace.
3555   {
3556     const char *Expected = ""
3557                            "void f() {\n"
3558                            "#if 1\n"
3559                            "// Preprocessor aligned.\n"
3560                            "#  define A 0\n"
3561                            "  // Code. Separated by blank line.\n"
3562                            "\n"
3563                            "#  define B 0\n"
3564                            "  // Code. Not aligned with #\n"
3565                            "#  define C 0\n"
3566                            "#endif";
3567     const char *ToFormat = ""
3568                            "void f() {\n"
3569                            "#if 1\n"
3570                            "// Preprocessor aligned.\n"
3571                            "#  define A 0\n"
3572                            "// Code. Separated by blank line.\n"
3573                            "\n"
3574                            "#  define B 0\n"
3575                            "   // Code. Not aligned with #\n"
3576                            "#  define C 0\n"
3577                            "#endif";
3578     EXPECT_EQ(Expected, format(ToFormat, Style));
3579     EXPECT_EQ(Expected, format(Expected, Style));
3580   }
3581   // Keep block quotes aligned.
3582   {
3583     const char *Expected = ""
3584                            "void f() {\n"
3585                            "#if 1\n"
3586                            "/* Preprocessor aligned. */\n"
3587                            "#  define A 0\n"
3588                            "  /* Code. Separated by blank line. */\n"
3589                            "\n"
3590                            "#  define B 0\n"
3591                            "  /* Code. Not aligned with # */\n"
3592                            "#  define C 0\n"
3593                            "#endif";
3594     const char *ToFormat = ""
3595                            "void f() {\n"
3596                            "#if 1\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                            "#endif";
3605     EXPECT_EQ(Expected, format(ToFormat, Style));
3606     EXPECT_EQ(Expected, format(Expected, Style));
3607   }
3608   // Keep comments aligned with un-indented directives.
3609   {
3610     const char *Expected = ""
3611                            "void f() {\n"
3612                            "// Preprocessor aligned.\n"
3613                            "#define A 0\n"
3614                            "  // Code. Separated by blank line.\n"
3615                            "\n"
3616                            "#define B 0\n"
3617                            "  // Code. Not aligned with #\n"
3618                            "#define C 0\n";
3619     const char *ToFormat = ""
3620                            "void f() {\n"
3621                            "// Preprocessor aligned.\n"
3622                            "#define A 0\n"
3623                            "// Code. Separated by blank line.\n"
3624                            "\n"
3625                            "#define B 0\n"
3626                            "   // Code. Not aligned with #\n"
3627                            "#define C 0\n";
3628     EXPECT_EQ(Expected, format(ToFormat, Style));
3629     EXPECT_EQ(Expected, format(Expected, Style));
3630   }
3631   // Test AfterHash with tabs.
3632   {
3633     FormatStyle Tabbed = Style;
3634     Tabbed.UseTab = FormatStyle::UT_Always;
3635     Tabbed.IndentWidth = 8;
3636     Tabbed.TabWidth = 8;
3637     verifyFormat("#ifdef _WIN32\n"
3638                  "#\tdefine A 0\n"
3639                  "#\tifdef VAR2\n"
3640                  "#\t\tdefine B 1\n"
3641                  "#\t\tinclude <someheader.h>\n"
3642                  "#\t\tdefine MACRO          \\\n"
3643                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3644                  "#\tendif\n"
3645                  "#else\n"
3646                  "#\tdefine A 1\n"
3647                  "#endif",
3648                  Tabbed);
3649   }
3650 
3651   // Regression test: Multiline-macro inside include guards.
3652   verifyFormat("#ifndef HEADER_H\n"
3653                "#define HEADER_H\n"
3654                "#define A()        \\\n"
3655                "  int i;           \\\n"
3656                "  int j;\n"
3657                "#endif // HEADER_H",
3658                getLLVMStyleWithColumns(20));
3659 
3660   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3661   // Basic before hash indent tests
3662   verifyFormat("#ifdef _WIN32\n"
3663                "  #define A 0\n"
3664                "  #ifdef VAR2\n"
3665                "    #define B 1\n"
3666                "    #include <someheader.h>\n"
3667                "    #define MACRO                      \\\n"
3668                "      some_very_long_func_aaaaaaaaaa();\n"
3669                "  #endif\n"
3670                "#else\n"
3671                "  #define A 1\n"
3672                "#endif",
3673                Style);
3674   verifyFormat("#if A\n"
3675                "  #define MACRO                        \\\n"
3676                "    void a(int x) {                    \\\n"
3677                "      b();                             \\\n"
3678                "      c();                             \\\n"
3679                "      d();                             \\\n"
3680                "      e();                             \\\n"
3681                "      f();                             \\\n"
3682                "    }\n"
3683                "#endif",
3684                Style);
3685   // Keep comments aligned with indented directives. These
3686   // tests cannot use verifyFormat because messUp manipulates leading
3687   // whitespace.
3688   {
3689     const char *Expected = "void f() {\n"
3690                            "// Aligned to preprocessor.\n"
3691                            "#if 1\n"
3692                            "  // Aligned to code.\n"
3693                            "  int a;\n"
3694                            "  #if 1\n"
3695                            "    // Aligned to preprocessor.\n"
3696                            "    #define A 0\n"
3697                            "  // Aligned to code.\n"
3698                            "  int b;\n"
3699                            "  #endif\n"
3700                            "#endif\n"
3701                            "}";
3702     const char *ToFormat = "void f() {\n"
3703                            "// Aligned to preprocessor.\n"
3704                            "#if 1\n"
3705                            "// Aligned to code.\n"
3706                            "int a;\n"
3707                            "#if 1\n"
3708                            "// Aligned to preprocessor.\n"
3709                            "#define A 0\n"
3710                            "// Aligned to code.\n"
3711                            "int b;\n"
3712                            "#endif\n"
3713                            "#endif\n"
3714                            "}";
3715     EXPECT_EQ(Expected, format(ToFormat, Style));
3716     EXPECT_EQ(Expected, format(Expected, Style));
3717   }
3718   {
3719     const char *Expected = "void f() {\n"
3720                            "/* Aligned to preprocessor. */\n"
3721                            "#if 1\n"
3722                            "  /* Aligned to code. */\n"
3723                            "  int a;\n"
3724                            "  #if 1\n"
3725                            "    /* Aligned to preprocessor. */\n"
3726                            "    #define A 0\n"
3727                            "  /* Aligned to code. */\n"
3728                            "  int b;\n"
3729                            "  #endif\n"
3730                            "#endif\n"
3731                            "}";
3732     const char *ToFormat = "void f() {\n"
3733                            "/* Aligned to preprocessor. */\n"
3734                            "#if 1\n"
3735                            "/* Aligned to code. */\n"
3736                            "int a;\n"
3737                            "#if 1\n"
3738                            "/* Aligned to preprocessor. */\n"
3739                            "#define A 0\n"
3740                            "/* Aligned to code. */\n"
3741                            "int b;\n"
3742                            "#endif\n"
3743                            "#endif\n"
3744                            "}";
3745     EXPECT_EQ(Expected, format(ToFormat, Style));
3746     EXPECT_EQ(Expected, format(Expected, Style));
3747   }
3748 
3749   // Test single comment before preprocessor
3750   verifyFormat("// Comment\n"
3751                "\n"
3752                "#if 1\n"
3753                "#endif",
3754                Style);
3755 }
3756 
3757 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3758   verifyFormat("{\n  { a #c; }\n}");
3759 }
3760 
3761 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3762   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
3763             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3764   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
3765             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3766 }
3767 
3768 TEST_F(FormatTest, EscapedNewlines) {
3769   FormatStyle Narrow = getLLVMStyleWithColumns(11);
3770   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
3771             format("#define A \\\nint i;\\\n  int j;", Narrow));
3772   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3773   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3774   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
3775   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3776 
3777   FormatStyle AlignLeft = getLLVMStyle();
3778   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3779   EXPECT_EQ("#define MACRO(x) \\\n"
3780             "private:         \\\n"
3781             "  int x(int a);\n",
3782             format("#define MACRO(x) \\\n"
3783                    "private:         \\\n"
3784                    "  int x(int a);\n",
3785                    AlignLeft));
3786 
3787   // CRLF line endings
3788   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
3789             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
3790   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3791   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3792   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
3793   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3794   EXPECT_EQ("#define MACRO(x) \\\r\n"
3795             "private:         \\\r\n"
3796             "  int x(int a);\r\n",
3797             format("#define MACRO(x) \\\r\n"
3798                    "private:         \\\r\n"
3799                    "  int x(int a);\r\n",
3800                    AlignLeft));
3801 
3802   FormatStyle DontAlign = getLLVMStyle();
3803   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3804   DontAlign.MaxEmptyLinesToKeep = 3;
3805   // FIXME: can't use verifyFormat here because the newline before
3806   // "public:" is not inserted the first time it's reformatted
3807   EXPECT_EQ("#define A \\\n"
3808             "  class Foo { \\\n"
3809             "    void bar(); \\\n"
3810             "\\\n"
3811             "\\\n"
3812             "\\\n"
3813             "  public: \\\n"
3814             "    void baz(); \\\n"
3815             "  };",
3816             format("#define A \\\n"
3817                    "  class Foo { \\\n"
3818                    "    void bar(); \\\n"
3819                    "\\\n"
3820                    "\\\n"
3821                    "\\\n"
3822                    "  public: \\\n"
3823                    "    void baz(); \\\n"
3824                    "  };",
3825                    DontAlign));
3826 }
3827 
3828 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3829   verifyFormat("#define A \\\n"
3830                "  int v(  \\\n"
3831                "      a); \\\n"
3832                "  int i;",
3833                getLLVMStyleWithColumns(11));
3834 }
3835 
3836 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3837   EXPECT_EQ(
3838       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3839       "                      \\\n"
3840       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3841       "\n"
3842       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3843       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3844       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
3845              "\\\n"
3846              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3847              "  \n"
3848              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3849              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3850 }
3851 
3852 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3853   EXPECT_EQ("int\n"
3854             "#define A\n"
3855             "    a;",
3856             format("int\n#define A\na;"));
3857   verifyFormat("functionCallTo(\n"
3858                "    someOtherFunction(\n"
3859                "        withSomeParameters, whichInSequence,\n"
3860                "        areLongerThanALine(andAnotherCall,\n"
3861                "#define A B\n"
3862                "                           withMoreParamters,\n"
3863                "                           whichStronglyInfluenceTheLayout),\n"
3864                "        andMoreParameters),\n"
3865                "    trailing);",
3866                getLLVMStyleWithColumns(69));
3867   verifyFormat("Foo::Foo()\n"
3868                "#ifdef BAR\n"
3869                "    : baz(0)\n"
3870                "#endif\n"
3871                "{\n"
3872                "}");
3873   verifyFormat("void f() {\n"
3874                "  if (true)\n"
3875                "#ifdef A\n"
3876                "    f(42);\n"
3877                "  x();\n"
3878                "#else\n"
3879                "    g();\n"
3880                "  x();\n"
3881                "#endif\n"
3882                "}");
3883   verifyFormat("void f(param1, param2,\n"
3884                "       param3,\n"
3885                "#ifdef A\n"
3886                "       param4(param5,\n"
3887                "#ifdef A1\n"
3888                "              param6,\n"
3889                "#ifdef A2\n"
3890                "              param7),\n"
3891                "#else\n"
3892                "              param8),\n"
3893                "       param9,\n"
3894                "#endif\n"
3895                "       param10,\n"
3896                "#endif\n"
3897                "       param11)\n"
3898                "#else\n"
3899                "       param12)\n"
3900                "#endif\n"
3901                "{\n"
3902                "  x();\n"
3903                "}",
3904                getLLVMStyleWithColumns(28));
3905   verifyFormat("#if 1\n"
3906                "int i;");
3907   verifyFormat("#if 1\n"
3908                "#endif\n"
3909                "#if 1\n"
3910                "#else\n"
3911                "#endif\n");
3912   verifyFormat("DEBUG({\n"
3913                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3914                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
3915                "});\n"
3916                "#if a\n"
3917                "#else\n"
3918                "#endif");
3919 
3920   verifyIncompleteFormat("void f(\n"
3921                          "#if A\n"
3922                          ");\n"
3923                          "#else\n"
3924                          "#endif");
3925 }
3926 
3927 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
3928   verifyFormat("#endif\n"
3929                "#if B");
3930 }
3931 
3932 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
3933   FormatStyle SingleLine = getLLVMStyle();
3934   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
3935   verifyFormat("#if 0\n"
3936                "#elif 1\n"
3937                "#endif\n"
3938                "void foo() {\n"
3939                "  if (test) foo2();\n"
3940                "}",
3941                SingleLine);
3942 }
3943 
3944 TEST_F(FormatTest, LayoutBlockInsideParens) {
3945   verifyFormat("functionCall({ int i; });");
3946   verifyFormat("functionCall({\n"
3947                "  int i;\n"
3948                "  int j;\n"
3949                "});");
3950   verifyFormat("functionCall(\n"
3951                "    {\n"
3952                "      int i;\n"
3953                "      int j;\n"
3954                "    },\n"
3955                "    aaaa, bbbb, cccc);");
3956   verifyFormat("functionA(functionB({\n"
3957                "            int i;\n"
3958                "            int j;\n"
3959                "          }),\n"
3960                "          aaaa, bbbb, cccc);");
3961   verifyFormat("functionCall(\n"
3962                "    {\n"
3963                "      int i;\n"
3964                "      int j;\n"
3965                "    },\n"
3966                "    aaaa, bbbb, // comment\n"
3967                "    cccc);");
3968   verifyFormat("functionA(functionB({\n"
3969                "            int i;\n"
3970                "            int j;\n"
3971                "          }),\n"
3972                "          aaaa, bbbb, // comment\n"
3973                "          cccc);");
3974   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
3975   verifyFormat("functionCall(aaaa, bbbb, {\n"
3976                "  int i;\n"
3977                "  int j;\n"
3978                "});");
3979   verifyFormat(
3980       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
3981       "    {\n"
3982       "      int i; // break\n"
3983       "    },\n"
3984       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
3985       "                                     ccccccccccccccccc));");
3986   verifyFormat("DEBUG({\n"
3987                "  if (a)\n"
3988                "    f();\n"
3989                "});");
3990 }
3991 
3992 TEST_F(FormatTest, LayoutBlockInsideStatement) {
3993   EXPECT_EQ("SOME_MACRO { int i; }\n"
3994             "int i;",
3995             format("  SOME_MACRO  {int i;}  int i;"));
3996 }
3997 
3998 TEST_F(FormatTest, LayoutNestedBlocks) {
3999   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
4000                "  struct s {\n"
4001                "    int i;\n"
4002                "  };\n"
4003                "  s kBitsToOs[] = {{10}};\n"
4004                "  for (int i = 0; i < 10; ++i)\n"
4005                "    return;\n"
4006                "}");
4007   verifyFormat("call(parameter, {\n"
4008                "  something();\n"
4009                "  // Comment using all columns.\n"
4010                "  somethingelse();\n"
4011                "});",
4012                getLLVMStyleWithColumns(40));
4013   verifyFormat("DEBUG( //\n"
4014                "    { f(); }, a);");
4015   verifyFormat("DEBUG( //\n"
4016                "    {\n"
4017                "      f(); //\n"
4018                "    },\n"
4019                "    a);");
4020 
4021   EXPECT_EQ("call(parameter, {\n"
4022             "  something();\n"
4023             "  // Comment too\n"
4024             "  // looooooooooong.\n"
4025             "  somethingElse();\n"
4026             "});",
4027             format("call(parameter, {\n"
4028                    "  something();\n"
4029                    "  // Comment too looooooooooong.\n"
4030                    "  somethingElse();\n"
4031                    "});",
4032                    getLLVMStyleWithColumns(29)));
4033   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
4034   EXPECT_EQ("DEBUG({ // comment\n"
4035             "  int i;\n"
4036             "});",
4037             format("DEBUG({ // comment\n"
4038                    "int  i;\n"
4039                    "});"));
4040   EXPECT_EQ("DEBUG({\n"
4041             "  int i;\n"
4042             "\n"
4043             "  // comment\n"
4044             "  int j;\n"
4045             "});",
4046             format("DEBUG({\n"
4047                    "  int  i;\n"
4048                    "\n"
4049                    "  // comment\n"
4050                    "  int  j;\n"
4051                    "});"));
4052 
4053   verifyFormat("DEBUG({\n"
4054                "  if (a)\n"
4055                "    return;\n"
4056                "});");
4057   verifyGoogleFormat("DEBUG({\n"
4058                      "  if (a) return;\n"
4059                      "});");
4060   FormatStyle Style = getGoogleStyle();
4061   Style.ColumnLimit = 45;
4062   verifyFormat("Debug(\n"
4063                "    aaaaa,\n"
4064                "    {\n"
4065                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
4066                "    },\n"
4067                "    a);",
4068                Style);
4069 
4070   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
4071 
4072   verifyNoCrash("^{v^{a}}");
4073 }
4074 
4075 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
4076   EXPECT_EQ("#define MACRO()                     \\\n"
4077             "  Debug(aaa, /* force line break */ \\\n"
4078             "        {                           \\\n"
4079             "          int i;                    \\\n"
4080             "          int j;                    \\\n"
4081             "        })",
4082             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
4083                    "          {  int   i;  int  j;   })",
4084                    getGoogleStyle()));
4085 
4086   EXPECT_EQ("#define A                                       \\\n"
4087             "  [] {                                          \\\n"
4088             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
4089             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
4090             "  }",
4091             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4092                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
4093                    getGoogleStyle()));
4094 }
4095 
4096 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
4097   EXPECT_EQ("{}", format("{}"));
4098   verifyFormat("enum E {};");
4099   verifyFormat("enum E {}");
4100   FormatStyle Style = getLLVMStyle();
4101   Style.SpaceInEmptyBlock = true;
4102   EXPECT_EQ("void f() { }", format("void f() {}", Style));
4103   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
4104   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4105 }
4106 
4107 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
4108   FormatStyle Style = getLLVMStyle();
4109   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
4110   Style.MacroBlockEnd = "^[A-Z_]+_END$";
4111   verifyFormat("FOO_BEGIN\n"
4112                "  FOO_ENTRY\n"
4113                "FOO_END",
4114                Style);
4115   verifyFormat("FOO_BEGIN\n"
4116                "  NESTED_FOO_BEGIN\n"
4117                "    NESTED_FOO_ENTRY\n"
4118                "  NESTED_FOO_END\n"
4119                "FOO_END",
4120                Style);
4121   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
4122                "  int x;\n"
4123                "  x = 1;\n"
4124                "FOO_END(Baz)",
4125                Style);
4126 }
4127 
4128 //===----------------------------------------------------------------------===//
4129 // Line break tests.
4130 //===----------------------------------------------------------------------===//
4131 
4132 TEST_F(FormatTest, PreventConfusingIndents) {
4133   verifyFormat(
4134       "void f() {\n"
4135       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
4136       "                         parameter, parameter, parameter)),\n"
4137       "                     SecondLongCall(parameter));\n"
4138       "}");
4139   verifyFormat(
4140       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4141       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4142       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4143       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
4144   verifyFormat(
4145       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4146       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
4147       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4148       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
4149   verifyFormat(
4150       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
4151       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
4152       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
4153       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
4154   verifyFormat("int a = bbbb && ccc &&\n"
4155                "        fffff(\n"
4156                "#define A Just forcing a new line\n"
4157                "            ddd);");
4158 }
4159 
4160 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
4161   verifyFormat(
4162       "bool aaaaaaa =\n"
4163       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
4164       "    bbbbbbbb();");
4165   verifyFormat(
4166       "bool aaaaaaa =\n"
4167       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
4168       "    bbbbbbbb();");
4169 
4170   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4171                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
4172                "    ccccccccc == ddddddddddd;");
4173   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4174                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
4175                "    ccccccccc == ddddddddddd;");
4176   verifyFormat(
4177       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
4178       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
4179       "    ccccccccc == ddddddddddd;");
4180 
4181   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4182                "                 aaaaaa) &&\n"
4183                "         bbbbbb && cccccc;");
4184   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4185                "                 aaaaaa) >>\n"
4186                "         bbbbbb;");
4187   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
4188                "    SourceMgr.getSpellingColumnNumber(\n"
4189                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
4190                "    1);");
4191 
4192   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4193                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
4194                "    cccccc) {\n}");
4195   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4196                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4197                "              cccccc) {\n}");
4198   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4199                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4200                "              cccccc) {\n}");
4201   verifyFormat("b = a &&\n"
4202                "    // Comment\n"
4203                "    b.c && d;");
4204 
4205   // If the LHS of a comparison is not a binary expression itself, the
4206   // additional linebreak confuses many people.
4207   verifyFormat(
4208       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4209       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
4210       "}");
4211   verifyFormat(
4212       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4213       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4214       "}");
4215   verifyFormat(
4216       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
4217       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4218       "}");
4219   verifyFormat(
4220       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4221       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
4222       "}");
4223   // Even explicit parentheses stress the precedence enough to make the
4224   // additional break unnecessary.
4225   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4226                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4227                "}");
4228   // This cases is borderline, but with the indentation it is still readable.
4229   verifyFormat(
4230       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4231       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4232       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4233       "}",
4234       getLLVMStyleWithColumns(75));
4235 
4236   // If the LHS is a binary expression, we should still use the additional break
4237   // as otherwise the formatting hides the operator precedence.
4238   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4239                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4240                "    5) {\n"
4241                "}");
4242   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4243                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4244                "    5) {\n"
4245                "}");
4246 
4247   FormatStyle OnePerLine = getLLVMStyle();
4248   OnePerLine.BinPackParameters = false;
4249   verifyFormat(
4250       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4251       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4252       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4253       OnePerLine);
4254 
4255   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4256                "                .aaa(aaaaaaaaaaaaa) *\n"
4257                "            aaaaaaa +\n"
4258                "        aaaaaaa;",
4259                getLLVMStyleWithColumns(40));
4260 }
4261 
4262 TEST_F(FormatTest, ExpressionIndentation) {
4263   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4264                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4265                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4266                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4267                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4268                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4269                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4270                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4271                "                 ccccccccccccccccccccccccccccccccccccccccc;");
4272   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4273                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4274                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4275                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4276   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4277                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4278                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4279                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4280   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4281                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4282                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4283                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4284   verifyFormat("if () {\n"
4285                "} else if (aaaaa && bbbbb > // break\n"
4286                "                        ccccc) {\n"
4287                "}");
4288   verifyFormat("if () {\n"
4289                "} else if constexpr (aaaaa && bbbbb > // break\n"
4290                "                                  ccccc) {\n"
4291                "}");
4292   verifyFormat("if () {\n"
4293                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4294                "                                  ccccc) {\n"
4295                "}");
4296   verifyFormat("if () {\n"
4297                "} else if (aaaaa &&\n"
4298                "           bbbbb > // break\n"
4299                "               ccccc &&\n"
4300                "           ddddd) {\n"
4301                "}");
4302 
4303   // Presence of a trailing comment used to change indentation of b.
4304   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4305                "       b;\n"
4306                "return aaaaaaaaaaaaaaaaaaa +\n"
4307                "       b; //",
4308                getLLVMStyleWithColumns(30));
4309 }
4310 
4311 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4312   // Not sure what the best system is here. Like this, the LHS can be found
4313   // immediately above an operator (everything with the same or a higher
4314   // indent). The RHS is aligned right of the operator and so compasses
4315   // everything until something with the same indent as the operator is found.
4316   // FIXME: Is this a good system?
4317   FormatStyle Style = getLLVMStyle();
4318   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4319   verifyFormat(
4320       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4321       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4322       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4323       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4324       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4325       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4326       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4327       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4328       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
4329       Style);
4330   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4331                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4332                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4333                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4334                Style);
4335   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4336                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4337                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4338                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4339                Style);
4340   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4341                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4342                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4343                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4344                Style);
4345   verifyFormat("if () {\n"
4346                "} else if (aaaaa\n"
4347                "           && bbbbb // break\n"
4348                "                  > ccccc) {\n"
4349                "}",
4350                Style);
4351   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4352                "       && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4353                Style);
4354   verifyFormat("return (a)\n"
4355                "       // comment\n"
4356                "       + b;",
4357                Style);
4358   verifyFormat(
4359       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4360       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4361       "             + cc;",
4362       Style);
4363 
4364   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4365                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4366                Style);
4367 
4368   // Forced by comments.
4369   verifyFormat(
4370       "unsigned ContentSize =\n"
4371       "    sizeof(int16_t)   // DWARF ARange version number\n"
4372       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4373       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4374       "    + sizeof(int8_t); // Segment Size (in bytes)");
4375 
4376   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4377                "       == boost::fusion::at_c<1>(iiii).second;",
4378                Style);
4379 
4380   Style.ColumnLimit = 60;
4381   verifyFormat("zzzzzzzzzz\n"
4382                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4383                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4384                Style);
4385 
4386   Style.ColumnLimit = 80;
4387   Style.IndentWidth = 4;
4388   Style.TabWidth = 4;
4389   Style.UseTab = FormatStyle::UT_Always;
4390   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4391   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4392   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4393             "\t&& (someOtherLongishConditionPart1\n"
4394             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4395             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4396                    "(someOtherLongishConditionPart1 || "
4397                    "someOtherEvenLongerNestedConditionPart2);",
4398                    Style));
4399 }
4400 
4401 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
4402   FormatStyle Style = getLLVMStyle();
4403   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4404   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
4405 
4406   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4407                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4408                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4409                "              == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4410                "                         * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4411                "                     + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4412                "          && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4413                "                     * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4414                "                 > ccccccccccccccccccccccccccccccccccccccccc;",
4415                Style);
4416   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4417                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4418                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4419                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4420                Style);
4421   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4422                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4423                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4424                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4425                Style);
4426   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4427                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4428                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4429                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4430                Style);
4431   verifyFormat("if () {\n"
4432                "} else if (aaaaa\n"
4433                "           && bbbbb // break\n"
4434                "                  > ccccc) {\n"
4435                "}",
4436                Style);
4437   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4438                "    && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4439                Style);
4440   verifyFormat("return (a)\n"
4441                "     // comment\n"
4442                "     + b;",
4443                Style);
4444   verifyFormat(
4445       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4446       "               * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4447       "           + cc;",
4448       Style);
4449   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
4450                "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4451                "                        : 3333333333333333;",
4452                Style);
4453   verifyFormat(
4454       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
4455       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
4456       "                                             : eeeeeeeeeeeeeeeeee)\n"
4457       "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4458       "                        : 3333333333333333;",
4459       Style);
4460   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4461                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4462                Style);
4463 
4464   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4465                "    == boost::fusion::at_c<1>(iiii).second;",
4466                Style);
4467 
4468   Style.ColumnLimit = 60;
4469   verifyFormat("zzzzzzzzzzzzz\n"
4470                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4471                "   >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4472                Style);
4473 
4474   // Forced by comments.
4475   Style.ColumnLimit = 80;
4476   verifyFormat(
4477       "unsigned ContentSize\n"
4478       "    = sizeof(int16_t) // DWARF ARange version number\n"
4479       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4480       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4481       "    + sizeof(int8_t); // Segment Size (in bytes)",
4482       Style);
4483 
4484   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4485   verifyFormat(
4486       "unsigned ContentSize =\n"
4487       "    sizeof(int16_t)   // DWARF ARange version number\n"
4488       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4489       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4490       "    + sizeof(int8_t); // Segment Size (in bytes)",
4491       Style);
4492 
4493   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4494   verifyFormat(
4495       "unsigned ContentSize =\n"
4496       "    sizeof(int16_t)   // DWARF ARange version number\n"
4497       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4498       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4499       "    + sizeof(int8_t); // Segment Size (in bytes)",
4500       Style);
4501 }
4502 
4503 TEST_F(FormatTest, EnforcedOperatorWraps) {
4504   // Here we'd like to wrap after the || operators, but a comment is forcing an
4505   // earlier wrap.
4506   verifyFormat("bool x = aaaaa //\n"
4507                "         || bbbbb\n"
4508                "         //\n"
4509                "         || cccc;");
4510 }
4511 
4512 TEST_F(FormatTest, NoOperandAlignment) {
4513   FormatStyle Style = getLLVMStyle();
4514   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4515   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4516                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4517                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4518                Style);
4519   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4520   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4521                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4522                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4523                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4524                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4525                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4526                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4527                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4528                "        > ccccccccccccccccccccccccccccccccccccccccc;",
4529                Style);
4530 
4531   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4532                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4533                "    + cc;",
4534                Style);
4535   verifyFormat("int a = aa\n"
4536                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4537                "        * cccccccccccccccccccccccccccccccccccc;\n",
4538                Style);
4539 
4540   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4541   verifyFormat("return (a > b\n"
4542                "    // comment1\n"
4543                "    // comment2\n"
4544                "    || c);",
4545                Style);
4546 }
4547 
4548 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4549   FormatStyle Style = getLLVMStyle();
4550   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4551   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4552                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4553                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4554                Style);
4555 }
4556 
4557 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4558   FormatStyle Style = getLLVMStyle();
4559   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4560   Style.BinPackArguments = false;
4561   Style.ColumnLimit = 40;
4562   verifyFormat("void test() {\n"
4563                "  someFunction(\n"
4564                "      this + argument + is + quite\n"
4565                "      + long + so + it + gets + wrapped\n"
4566                "      + but + remains + bin - packed);\n"
4567                "}",
4568                Style);
4569   verifyFormat("void test() {\n"
4570                "  someFunction(arg1,\n"
4571                "               this + argument + is\n"
4572                "                   + quite + long + so\n"
4573                "                   + it + gets + wrapped\n"
4574                "                   + but + remains + bin\n"
4575                "                   - packed,\n"
4576                "               arg3);\n"
4577                "}",
4578                Style);
4579   verifyFormat("void test() {\n"
4580                "  someFunction(\n"
4581                "      arg1,\n"
4582                "      this + argument + has\n"
4583                "          + anotherFunc(nested,\n"
4584                "                        calls + whose\n"
4585                "                            + arguments\n"
4586                "                            + are + also\n"
4587                "                            + wrapped,\n"
4588                "                        in + addition)\n"
4589                "          + to + being + bin - packed,\n"
4590                "      arg3);\n"
4591                "}",
4592                Style);
4593 
4594   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4595   verifyFormat("void test() {\n"
4596                "  someFunction(\n"
4597                "      arg1,\n"
4598                "      this + argument + has +\n"
4599                "          anotherFunc(nested,\n"
4600                "                      calls + whose +\n"
4601                "                          arguments +\n"
4602                "                          are + also +\n"
4603                "                          wrapped,\n"
4604                "                      in + addition) +\n"
4605                "          to + being + bin - packed,\n"
4606                "      arg3);\n"
4607                "}",
4608                Style);
4609 }
4610 
4611 TEST_F(FormatTest, ConstructorInitializers) {
4612   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4613   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4614                getLLVMStyleWithColumns(45));
4615   verifyFormat("Constructor()\n"
4616                "    : Inttializer(FitsOnTheLine) {}",
4617                getLLVMStyleWithColumns(44));
4618   verifyFormat("Constructor()\n"
4619                "    : Inttializer(FitsOnTheLine) {}",
4620                getLLVMStyleWithColumns(43));
4621 
4622   verifyFormat("template <typename T>\n"
4623                "Constructor() : Initializer(FitsOnTheLine) {}",
4624                getLLVMStyleWithColumns(45));
4625 
4626   verifyFormat(
4627       "SomeClass::Constructor()\n"
4628       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4629 
4630   verifyFormat(
4631       "SomeClass::Constructor()\n"
4632       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4633       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4634   verifyFormat(
4635       "SomeClass::Constructor()\n"
4636       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4637       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4638   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4639                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4640                "    : aaaaaaaaaa(aaaaaa) {}");
4641 
4642   verifyFormat("Constructor()\n"
4643                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4644                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4645                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4646                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
4647 
4648   verifyFormat("Constructor()\n"
4649                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4650                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4651 
4652   verifyFormat("Constructor(int Parameter = 0)\n"
4653                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4654                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4655   verifyFormat("Constructor()\n"
4656                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4657                "}",
4658                getLLVMStyleWithColumns(60));
4659   verifyFormat("Constructor()\n"
4660                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4661                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4662 
4663   // Here a line could be saved by splitting the second initializer onto two
4664   // lines, but that is not desirable.
4665   verifyFormat("Constructor()\n"
4666                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4667                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
4668                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4669 
4670   FormatStyle OnePerLine = getLLVMStyle();
4671   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4672   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4673   verifyFormat("SomeClass::Constructor()\n"
4674                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4675                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4676                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4677                OnePerLine);
4678   verifyFormat("SomeClass::Constructor()\n"
4679                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4680                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4681                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4682                OnePerLine);
4683   verifyFormat("MyClass::MyClass(int var)\n"
4684                "    : some_var_(var),            // 4 space indent\n"
4685                "      some_other_var_(var + 1) { // lined up\n"
4686                "}",
4687                OnePerLine);
4688   verifyFormat("Constructor()\n"
4689                "    : aaaaa(aaaaaa),\n"
4690                "      aaaaa(aaaaaa),\n"
4691                "      aaaaa(aaaaaa),\n"
4692                "      aaaaa(aaaaaa),\n"
4693                "      aaaaa(aaaaaa) {}",
4694                OnePerLine);
4695   verifyFormat("Constructor()\n"
4696                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4697                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
4698                OnePerLine);
4699   OnePerLine.BinPackParameters = false;
4700   verifyFormat(
4701       "Constructor()\n"
4702       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4703       "          aaaaaaaaaaa().aaa(),\n"
4704       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4705       OnePerLine);
4706   OnePerLine.ColumnLimit = 60;
4707   verifyFormat("Constructor()\n"
4708                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4709                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4710                OnePerLine);
4711 
4712   EXPECT_EQ("Constructor()\n"
4713             "    : // Comment forcing unwanted break.\n"
4714             "      aaaa(aaaa) {}",
4715             format("Constructor() :\n"
4716                    "    // Comment forcing unwanted break.\n"
4717                    "    aaaa(aaaa) {}"));
4718 }
4719 
4720 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4721   FormatStyle Style = getLLVMStyle();
4722   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4723   Style.ColumnLimit = 60;
4724   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4725   Style.AllowAllConstructorInitializersOnNextLine = true;
4726   Style.BinPackParameters = false;
4727 
4728   for (int i = 0; i < 4; ++i) {
4729     // Test all combinations of parameters that should not have an effect.
4730     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4731     Style.AllowAllArgumentsOnNextLine = i & 2;
4732 
4733     Style.AllowAllConstructorInitializersOnNextLine = true;
4734     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4735     verifyFormat("Constructor()\n"
4736                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4737                  Style);
4738     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4739 
4740     Style.AllowAllConstructorInitializersOnNextLine = false;
4741     verifyFormat("Constructor()\n"
4742                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4743                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4744                  Style);
4745     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4746 
4747     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4748     Style.AllowAllConstructorInitializersOnNextLine = true;
4749     verifyFormat("Constructor()\n"
4750                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4751                  Style);
4752 
4753     Style.AllowAllConstructorInitializersOnNextLine = false;
4754     verifyFormat("Constructor()\n"
4755                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4756                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4757                  Style);
4758 
4759     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4760     Style.AllowAllConstructorInitializersOnNextLine = true;
4761     verifyFormat("Constructor() :\n"
4762                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4763                  Style);
4764 
4765     Style.AllowAllConstructorInitializersOnNextLine = false;
4766     verifyFormat("Constructor() :\n"
4767                  "    aaaaaaaaaaaaaaaaaa(a),\n"
4768                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4769                  Style);
4770   }
4771 
4772   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4773   // AllowAllConstructorInitializersOnNextLine in all
4774   // BreakConstructorInitializers modes
4775   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4776   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4777   Style.AllowAllConstructorInitializersOnNextLine = false;
4778   verifyFormat("SomeClassWithALongName::Constructor(\n"
4779                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4780                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4781                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4782                Style);
4783 
4784   Style.AllowAllConstructorInitializersOnNextLine = true;
4785   verifyFormat("SomeClassWithALongName::Constructor(\n"
4786                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4787                "    int bbbbbbbbbbbbb,\n"
4788                "    int cccccccccccccccc)\n"
4789                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4790                Style);
4791 
4792   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4793   Style.AllowAllConstructorInitializersOnNextLine = false;
4794   verifyFormat("SomeClassWithALongName::Constructor(\n"
4795                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4796                "    int bbbbbbbbbbbbb)\n"
4797                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4798                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4799                Style);
4800 
4801   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4802 
4803   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4804   verifyFormat("SomeClassWithALongName::Constructor(\n"
4805                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4806                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4807                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4808                Style);
4809 
4810   Style.AllowAllConstructorInitializersOnNextLine = true;
4811   verifyFormat("SomeClassWithALongName::Constructor(\n"
4812                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4813                "    int bbbbbbbbbbbbb,\n"
4814                "    int cccccccccccccccc)\n"
4815                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4816                Style);
4817 
4818   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4819   Style.AllowAllConstructorInitializersOnNextLine = false;
4820   verifyFormat("SomeClassWithALongName::Constructor(\n"
4821                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4822                "    int bbbbbbbbbbbbb)\n"
4823                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4824                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4825                Style);
4826 
4827   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4828   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4829   verifyFormat("SomeClassWithALongName::Constructor(\n"
4830                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4831                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4832                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4833                Style);
4834 
4835   Style.AllowAllConstructorInitializersOnNextLine = true;
4836   verifyFormat("SomeClassWithALongName::Constructor(\n"
4837                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4838                "    int bbbbbbbbbbbbb,\n"
4839                "    int cccccccccccccccc) :\n"
4840                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4841                Style);
4842 
4843   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4844   Style.AllowAllConstructorInitializersOnNextLine = false;
4845   verifyFormat("SomeClassWithALongName::Constructor(\n"
4846                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4847                "    int bbbbbbbbbbbbb) :\n"
4848                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4849                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4850                Style);
4851 }
4852 
4853 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4854   FormatStyle Style = getLLVMStyle();
4855   Style.ColumnLimit = 60;
4856   Style.BinPackArguments = false;
4857   for (int i = 0; i < 4; ++i) {
4858     // Test all combinations of parameters that should not have an effect.
4859     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4860     Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4861 
4862     Style.AllowAllArgumentsOnNextLine = true;
4863     verifyFormat("void foo() {\n"
4864                  "  FunctionCallWithReallyLongName(\n"
4865                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4866                  "}",
4867                  Style);
4868     Style.AllowAllArgumentsOnNextLine = false;
4869     verifyFormat("void foo() {\n"
4870                  "  FunctionCallWithReallyLongName(\n"
4871                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4872                  "      bbbbbbbbbbbb);\n"
4873                  "}",
4874                  Style);
4875 
4876     Style.AllowAllArgumentsOnNextLine = true;
4877     verifyFormat("void foo() {\n"
4878                  "  auto VariableWithReallyLongName = {\n"
4879                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4880                  "}",
4881                  Style);
4882     Style.AllowAllArgumentsOnNextLine = false;
4883     verifyFormat("void foo() {\n"
4884                  "  auto VariableWithReallyLongName = {\n"
4885                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4886                  "      bbbbbbbbbbbb};\n"
4887                  "}",
4888                  Style);
4889   }
4890 
4891   // This parameter should not affect declarations.
4892   Style.BinPackParameters = false;
4893   Style.AllowAllArgumentsOnNextLine = false;
4894   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4895   verifyFormat("void FunctionCallWithReallyLongName(\n"
4896                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
4897                Style);
4898   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4899   verifyFormat("void FunctionCallWithReallyLongName(\n"
4900                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
4901                "    int bbbbbbbbbbbb);",
4902                Style);
4903 }
4904 
4905 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
4906   FormatStyle Style = getLLVMStyle();
4907   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4908 
4909   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4910   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
4911                getStyleWithColumns(Style, 45));
4912   verifyFormat("Constructor() :\n"
4913                "    Initializer(FitsOnTheLine) {}",
4914                getStyleWithColumns(Style, 44));
4915   verifyFormat("Constructor() :\n"
4916                "    Initializer(FitsOnTheLine) {}",
4917                getStyleWithColumns(Style, 43));
4918 
4919   verifyFormat("template <typename T>\n"
4920                "Constructor() : Initializer(FitsOnTheLine) {}",
4921                getStyleWithColumns(Style, 50));
4922   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4923   verifyFormat(
4924       "SomeClass::Constructor() :\n"
4925       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4926       Style);
4927 
4928   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
4929   verifyFormat(
4930       "SomeClass::Constructor() :\n"
4931       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4932       Style);
4933 
4934   verifyFormat(
4935       "SomeClass::Constructor() :\n"
4936       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4937       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4938       Style);
4939   verifyFormat(
4940       "SomeClass::Constructor() :\n"
4941       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4942       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4943       Style);
4944   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4945                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4946                "    aaaaaaaaaa(aaaaaa) {}",
4947                Style);
4948 
4949   verifyFormat("Constructor() :\n"
4950                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4951                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4952                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4953                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
4954                Style);
4955 
4956   verifyFormat("Constructor() :\n"
4957                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4958                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4959                Style);
4960 
4961   verifyFormat("Constructor(int Parameter = 0) :\n"
4962                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4963                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
4964                Style);
4965   verifyFormat("Constructor() :\n"
4966                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4967                "}",
4968                getStyleWithColumns(Style, 60));
4969   verifyFormat("Constructor() :\n"
4970                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4971                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
4972                Style);
4973 
4974   // Here a line could be saved by splitting the second initializer onto two
4975   // lines, but that is not desirable.
4976   verifyFormat("Constructor() :\n"
4977                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4978                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
4979                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4980                Style);
4981 
4982   FormatStyle OnePerLine = Style;
4983   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4984   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
4985   verifyFormat("SomeClass::Constructor() :\n"
4986                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4987                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4988                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4989                OnePerLine);
4990   verifyFormat("SomeClass::Constructor() :\n"
4991                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4992                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4993                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4994                OnePerLine);
4995   verifyFormat("MyClass::MyClass(int var) :\n"
4996                "    some_var_(var),            // 4 space indent\n"
4997                "    some_other_var_(var + 1) { // lined up\n"
4998                "}",
4999                OnePerLine);
5000   verifyFormat("Constructor() :\n"
5001                "    aaaaa(aaaaaa),\n"
5002                "    aaaaa(aaaaaa),\n"
5003                "    aaaaa(aaaaaa),\n"
5004                "    aaaaa(aaaaaa),\n"
5005                "    aaaaa(aaaaaa) {}",
5006                OnePerLine);
5007   verifyFormat("Constructor() :\n"
5008                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5009                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
5010                OnePerLine);
5011   OnePerLine.BinPackParameters = false;
5012   verifyFormat("Constructor() :\n"
5013                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5014                "        aaaaaaaaaaa().aaa(),\n"
5015                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5016                OnePerLine);
5017   OnePerLine.ColumnLimit = 60;
5018   verifyFormat("Constructor() :\n"
5019                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
5020                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
5021                OnePerLine);
5022 
5023   EXPECT_EQ("Constructor() :\n"
5024             "    // Comment forcing unwanted break.\n"
5025             "    aaaa(aaaa) {}",
5026             format("Constructor() :\n"
5027                    "    // Comment forcing unwanted break.\n"
5028                    "    aaaa(aaaa) {}",
5029                    Style));
5030 
5031   Style.ColumnLimit = 0;
5032   verifyFormat("SomeClass::Constructor() :\n"
5033                "    a(a) {}",
5034                Style);
5035   verifyFormat("SomeClass::Constructor() noexcept :\n"
5036                "    a(a) {}",
5037                Style);
5038   verifyFormat("SomeClass::Constructor() :\n"
5039                "    a(a), b(b), c(c) {}",
5040                Style);
5041   verifyFormat("SomeClass::Constructor() :\n"
5042                "    a(a) {\n"
5043                "  foo();\n"
5044                "  bar();\n"
5045                "}",
5046                Style);
5047 
5048   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5049   verifyFormat("SomeClass::Constructor() :\n"
5050                "    a(a), b(b), c(c) {\n"
5051                "}",
5052                Style);
5053   verifyFormat("SomeClass::Constructor() :\n"
5054                "    a(a) {\n"
5055                "}",
5056                Style);
5057 
5058   Style.ColumnLimit = 80;
5059   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5060   Style.ConstructorInitializerIndentWidth = 2;
5061   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5062   verifyFormat("SomeClass::Constructor() :\n"
5063                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5064                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5065                Style);
5066 
5067   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5068   // well
5069   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5070   verifyFormat(
5071       "class SomeClass\n"
5072       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5073       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5074       Style);
5075   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5076   verifyFormat(
5077       "class SomeClass\n"
5078       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5079       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5080       Style);
5081   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5082   verifyFormat(
5083       "class SomeClass :\n"
5084       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5085       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5086       Style);
5087 }
5088 
5089 #ifndef EXPENSIVE_CHECKS
5090 // Expensive checks enables libstdc++ checking which includes validating the
5091 // state of ranges used in std::priority_queue - this blows out the
5092 // runtime/scalability of the function and makes this test unacceptably slow.
5093 TEST_F(FormatTest, MemoizationTests) {
5094   // This breaks if the memoization lookup does not take \c Indent and
5095   // \c LastSpace into account.
5096   verifyFormat(
5097       "extern CFRunLoopTimerRef\n"
5098       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5099       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
5100       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
5101       "                     CFRunLoopTimerContext *context) {}");
5102 
5103   // Deep nesting somewhat works around our memoization.
5104   verifyFormat(
5105       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5106       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5107       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5108       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5109       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
5110       getLLVMStyleWithColumns(65));
5111   verifyFormat(
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,\n"
5122       "                    aaaaa(\n"
5123       "                        aaaaa,\n"
5124       "                        aaaaa(\n"
5125       "                            aaaaa,\n"
5126       "                            aaaaa(\n"
5127       "                                aaaaa,\n"
5128       "                                aaaaa(\n"
5129       "                                    aaaaa,\n"
5130       "                                    aaaaa(\n"
5131       "                                        aaaaa,\n"
5132       "                                        aaaaa(\n"
5133       "                                            aaaaa,\n"
5134       "                                            aaaaa(\n"
5135       "                                                aaaaa,\n"
5136       "                                                aaaaa))))))))))));",
5137       getLLVMStyleWithColumns(65));
5138   verifyFormat(
5139       "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"
5140       "                                  a),\n"
5141       "                                a),\n"
5142       "                              a),\n"
5143       "                            a),\n"
5144       "                          a),\n"
5145       "                        a),\n"
5146       "                      a),\n"
5147       "                    a),\n"
5148       "                  a),\n"
5149       "                a),\n"
5150       "              a),\n"
5151       "            a),\n"
5152       "          a),\n"
5153       "        a),\n"
5154       "      a),\n"
5155       "    a),\n"
5156       "  a)",
5157       getLLVMStyleWithColumns(65));
5158 
5159   // This test takes VERY long when memoization is broken.
5160   FormatStyle OnePerLine = getLLVMStyle();
5161   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5162   OnePerLine.BinPackParameters = false;
5163   std::string input = "Constructor()\n"
5164                       "    : aaaa(a,\n";
5165   for (unsigned i = 0, e = 80; i != e; ++i) {
5166     input += "           a,\n";
5167   }
5168   input += "           a) {}";
5169   verifyFormat(input, OnePerLine);
5170 }
5171 #endif
5172 
5173 TEST_F(FormatTest, BreaksAsHighAsPossible) {
5174   verifyFormat(
5175       "void f() {\n"
5176       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5177       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5178       "    f();\n"
5179       "}");
5180   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5181                "    Intervals[i - 1].getRange().getLast()) {\n}");
5182 }
5183 
5184 TEST_F(FormatTest, BreaksFunctionDeclarations) {
5185   // Principially, we break function declarations in a certain order:
5186   // 1) break amongst arguments.
5187   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5188                "                              Cccccccccccccc cccccccccccccc);");
5189   verifyFormat("template <class TemplateIt>\n"
5190                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5191                "                            TemplateIt *stop) {}");
5192 
5193   // 2) break after return type.
5194   verifyFormat(
5195       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5196       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5197       getGoogleStyle());
5198 
5199   // 3) break after (.
5200   verifyFormat(
5201       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5202       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5203       getGoogleStyle());
5204 
5205   // 4) break before after nested name specifiers.
5206   verifyFormat(
5207       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5208       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5209       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5210       getGoogleStyle());
5211 
5212   // However, there are exceptions, if a sufficient amount of lines can be
5213   // saved.
5214   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5215   // more adjusting.
5216   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5217                "                                  Cccccccccccccc cccccccccc,\n"
5218                "                                  Cccccccccccccc cccccccccc,\n"
5219                "                                  Cccccccccccccc cccccccccc,\n"
5220                "                                  Cccccccccccccc cccccccccc);");
5221   verifyFormat(
5222       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5223       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5224       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5225       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5226       getGoogleStyle());
5227   verifyFormat(
5228       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5229       "                                          Cccccccccccccc cccccccccc,\n"
5230       "                                          Cccccccccccccc cccccccccc,\n"
5231       "                                          Cccccccccccccc cccccccccc,\n"
5232       "                                          Cccccccccccccc cccccccccc,\n"
5233       "                                          Cccccccccccccc cccccccccc,\n"
5234       "                                          Cccccccccccccc cccccccccc);");
5235   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5236                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5237                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5238                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5239                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5240 
5241   // Break after multi-line parameters.
5242   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5243                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5244                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5245                "    bbbb bbbb);");
5246   verifyFormat("void SomeLoooooooooooongFunction(\n"
5247                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5248                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5249                "    int bbbbbbbbbbbbb);");
5250 
5251   // Treat overloaded operators like other functions.
5252   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5253                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5254   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5255                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5256   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5257                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5258   verifyGoogleFormat(
5259       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5260       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5261   verifyGoogleFormat(
5262       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5263       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5264   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5265                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5266   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5267                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5268   verifyGoogleFormat(
5269       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5270       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5271       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5272   verifyGoogleFormat("template <typename T>\n"
5273                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5274                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5275                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5276 
5277   FormatStyle Style = getLLVMStyle();
5278   Style.PointerAlignment = FormatStyle::PAS_Left;
5279   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5280                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5281                Style);
5282   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5283                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5284                Style);
5285 }
5286 
5287 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5288   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5289   // Prefer keeping `::` followed by `operator` together.
5290   EXPECT_EQ("const aaaa::bbbbbbb &\n"
5291             "ccccccccc::operator++() {\n"
5292             "  stuff();\n"
5293             "}",
5294             format("const aaaa::bbbbbbb\n"
5295                    "&ccccccccc::operator++() { stuff(); }",
5296                    getLLVMStyleWithColumns(40)));
5297 }
5298 
5299 TEST_F(FormatTest, TrailingReturnType) {
5300   verifyFormat("auto foo() -> int;\n");
5301   // correct trailing return type spacing
5302   verifyFormat("auto operator->() -> int;\n");
5303   verifyFormat("auto operator++(int) -> int;\n");
5304 
5305   verifyFormat("struct S {\n"
5306                "  auto bar() const -> int;\n"
5307                "};");
5308   verifyFormat("template <size_t Order, typename T>\n"
5309                "auto load_img(const std::string &filename)\n"
5310                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
5311   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5312                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5313   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5314   verifyFormat("template <typename T>\n"
5315                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5316                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5317 
5318   // Not trailing return types.
5319   verifyFormat("void f() { auto a = b->c(); }");
5320 }
5321 
5322 TEST_F(FormatTest, DeductionGuides) {
5323   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5324   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5325   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5326   verifyFormat(
5327       "template <class... T>\n"
5328       "array(T &&... t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5329   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5330   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5331   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5332   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5333   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5334   verifyFormat("template <class T> x() -> x<1>;");
5335   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5336 
5337   // Ensure not deduction guides.
5338   verifyFormat("c()->f<int>();");
5339   verifyFormat("x()->foo<1>;");
5340   verifyFormat("x = p->foo<3>();");
5341   verifyFormat("x()->x<1>();");
5342   verifyFormat("x()->x<1>;");
5343 }
5344 
5345 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5346   // Avoid breaking before trailing 'const' or other trailing annotations, if
5347   // they are not function-like.
5348   FormatStyle Style = getGoogleStyle();
5349   Style.ColumnLimit = 47;
5350   verifyFormat("void someLongFunction(\n"
5351                "    int someLoooooooooooooongParameter) const {\n}",
5352                getLLVMStyleWithColumns(47));
5353   verifyFormat("LoooooongReturnType\n"
5354                "someLoooooooongFunction() const {}",
5355                getLLVMStyleWithColumns(47));
5356   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5357                "    const {}",
5358                Style);
5359   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5360                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5361   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5362                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5363   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5364                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5365   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5366                "                   aaaaaaaaaaa aaaaa) const override;");
5367   verifyGoogleFormat(
5368       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5369       "    const override;");
5370 
5371   // Even if the first parameter has to be wrapped.
5372   verifyFormat("void someLongFunction(\n"
5373                "    int someLongParameter) const {}",
5374                getLLVMStyleWithColumns(46));
5375   verifyFormat("void someLongFunction(\n"
5376                "    int someLongParameter) const {}",
5377                Style);
5378   verifyFormat("void someLongFunction(\n"
5379                "    int someLongParameter) override {}",
5380                Style);
5381   verifyFormat("void someLongFunction(\n"
5382                "    int someLongParameter) OVERRIDE {}",
5383                Style);
5384   verifyFormat("void someLongFunction(\n"
5385                "    int someLongParameter) final {}",
5386                Style);
5387   verifyFormat("void someLongFunction(\n"
5388                "    int someLongParameter) FINAL {}",
5389                Style);
5390   verifyFormat("void someLongFunction(\n"
5391                "    int parameter) const override {}",
5392                Style);
5393 
5394   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5395   verifyFormat("void someLongFunction(\n"
5396                "    int someLongParameter) const\n"
5397                "{\n"
5398                "}",
5399                Style);
5400 
5401   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5402   verifyFormat("void someLongFunction(\n"
5403                "    int someLongParameter) const\n"
5404                "  {\n"
5405                "  }",
5406                Style);
5407 
5408   // Unless these are unknown annotations.
5409   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5410                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5411                "    LONG_AND_UGLY_ANNOTATION;");
5412 
5413   // Breaking before function-like trailing annotations is fine to keep them
5414   // close to their arguments.
5415   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5416                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5417   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5418                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5419   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5420                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5421   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5422                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5423   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5424 
5425   verifyFormat(
5426       "void aaaaaaaaaaaaaaaaaa()\n"
5427       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5428       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5429   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5430                "    __attribute__((unused));");
5431   verifyGoogleFormat(
5432       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5433       "    GUARDED_BY(aaaaaaaaaaaa);");
5434   verifyGoogleFormat(
5435       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5436       "    GUARDED_BY(aaaaaaaaaaaa);");
5437   verifyGoogleFormat(
5438       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5439       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5440   verifyGoogleFormat(
5441       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5442       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5443 }
5444 
5445 TEST_F(FormatTest, FunctionAnnotations) {
5446   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5447                "int OldFunction(const string &parameter) {}");
5448   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5449                "string OldFunction(const string &parameter) {}");
5450   verifyFormat("template <typename T>\n"
5451                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5452                "string OldFunction(const string &parameter) {}");
5453 
5454   // Not function annotations.
5455   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5456                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5457   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5458                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5459   verifyFormat("MACRO(abc).function() // wrap\n"
5460                "    << abc;");
5461   verifyFormat("MACRO(abc)->function() // wrap\n"
5462                "    << abc;");
5463   verifyFormat("MACRO(abc)::function() // wrap\n"
5464                "    << abc;");
5465 }
5466 
5467 TEST_F(FormatTest, BreaksDesireably) {
5468   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5469                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5470                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5471   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5472                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5473                "}");
5474 
5475   verifyFormat(
5476       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5477       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5478 
5479   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5480                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5481                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5482 
5483   verifyFormat(
5484       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5485       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5486       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5487       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5488       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5489 
5490   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5491                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5492 
5493   verifyFormat(
5494       "void f() {\n"
5495       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5496       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5497       "}");
5498   verifyFormat(
5499       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5500       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5501   verifyFormat(
5502       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5503       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5504   verifyFormat(
5505       "aaaaaa(aaa,\n"
5506       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5507       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5508       "       aaaa);");
5509   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5510                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5511                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5512 
5513   // Indent consistently independent of call expression and unary operator.
5514   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5515                "    dddddddddddddddddddddddddddddd));");
5516   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5517                "    dddddddddddddddddddddddddddddd));");
5518   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5519                "    dddddddddddddddddddddddddddddd));");
5520 
5521   // This test case breaks on an incorrect memoization, i.e. an optimization not
5522   // taking into account the StopAt value.
5523   verifyFormat(
5524       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5525       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5526       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5527       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5528 
5529   verifyFormat("{\n  {\n    {\n"
5530                "      Annotation.SpaceRequiredBefore =\n"
5531                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5532                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5533                "    }\n  }\n}");
5534 
5535   // Break on an outer level if there was a break on an inner level.
5536   EXPECT_EQ("f(g(h(a, // comment\n"
5537             "      b, c),\n"
5538             "    d, e),\n"
5539             "  x, y);",
5540             format("f(g(h(a, // comment\n"
5541                    "    b, c), d, e), x, y);"));
5542 
5543   // Prefer breaking similar line breaks.
5544   verifyFormat(
5545       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5546       "                             NSTrackingMouseEnteredAndExited |\n"
5547       "                             NSTrackingActiveAlways;");
5548 }
5549 
5550 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5551   FormatStyle NoBinPacking = getGoogleStyle();
5552   NoBinPacking.BinPackParameters = false;
5553   NoBinPacking.BinPackArguments = true;
5554   verifyFormat("void f() {\n"
5555                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5556                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5557                "}",
5558                NoBinPacking);
5559   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5560                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5561                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5562                NoBinPacking);
5563 
5564   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5565   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5566                "                        vector<int> bbbbbbbbbbbbbbb);",
5567                NoBinPacking);
5568   // FIXME: This behavior difference is probably not wanted. However, currently
5569   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5570   // template arguments from BreakBeforeParameter being set because of the
5571   // one-per-line formatting.
5572   verifyFormat(
5573       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5574       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5575       NoBinPacking);
5576   verifyFormat(
5577       "void fffffffffff(\n"
5578       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5579       "        aaaaaaaaaa);");
5580 }
5581 
5582 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5583   FormatStyle NoBinPacking = getGoogleStyle();
5584   NoBinPacking.BinPackParameters = false;
5585   NoBinPacking.BinPackArguments = false;
5586   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5587                "  aaaaaaaaaaaaaaaaaaaa,\n"
5588                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5589                NoBinPacking);
5590   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5591                "        aaaaaaaaaaaaa,\n"
5592                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5593                NoBinPacking);
5594   verifyFormat(
5595       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5596       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5597       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5598       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5599       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5600       NoBinPacking);
5601   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5602                "    .aaaaaaaaaaaaaaaaaa();",
5603                NoBinPacking);
5604   verifyFormat("void f() {\n"
5605                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5606                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5607                "}",
5608                NoBinPacking);
5609 
5610   verifyFormat(
5611       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5612       "             aaaaaaaaaaaa,\n"
5613       "             aaaaaaaaaaaa);",
5614       NoBinPacking);
5615   verifyFormat(
5616       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5617       "                               ddddddddddddddddddddddddddddd),\n"
5618       "             test);",
5619       NoBinPacking);
5620 
5621   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5622                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5623                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5624                "    aaaaaaaaaaaaaaaaaa;",
5625                NoBinPacking);
5626   verifyFormat("a(\"a\"\n"
5627                "  \"a\",\n"
5628                "  a);");
5629 
5630   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5631   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5632                "                aaaaaaaaa,\n"
5633                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5634                NoBinPacking);
5635   verifyFormat(
5636       "void f() {\n"
5637       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5638       "      .aaaaaaa();\n"
5639       "}",
5640       NoBinPacking);
5641   verifyFormat(
5642       "template <class SomeType, class SomeOtherType>\n"
5643       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5644       NoBinPacking);
5645 }
5646 
5647 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5648   FormatStyle Style = getLLVMStyleWithColumns(15);
5649   Style.ExperimentalAutoDetectBinPacking = true;
5650   EXPECT_EQ("aaa(aaaa,\n"
5651             "    aaaa,\n"
5652             "    aaaa);\n"
5653             "aaa(aaaa,\n"
5654             "    aaaa,\n"
5655             "    aaaa);",
5656             format("aaa(aaaa,\n" // one-per-line
5657                    "  aaaa,\n"
5658                    "    aaaa  );\n"
5659                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5660                    Style));
5661   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5662             "    aaaa);\n"
5663             "aaa(aaaa, aaaa,\n"
5664             "    aaaa);",
5665             format("aaa(aaaa,  aaaa,\n" // bin-packed
5666                    "    aaaa  );\n"
5667                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5668                    Style));
5669 }
5670 
5671 TEST_F(FormatTest, FormatsBuilderPattern) {
5672   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5673                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5674                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5675                "    .StartsWith(\".init\", ORDER_INIT)\n"
5676                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5677                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5678                "    .Default(ORDER_TEXT);\n");
5679 
5680   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5681                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5682   verifyFormat("aaaaaaa->aaaaaaa\n"
5683                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5684                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5685                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5686   verifyFormat(
5687       "aaaaaaa->aaaaaaa\n"
5688       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5689       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5690   verifyFormat(
5691       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5692       "    aaaaaaaaaaaaaa);");
5693   verifyFormat(
5694       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5695       "    aaaaaa->aaaaaaaaaaaa()\n"
5696       "        ->aaaaaaaaaaaaaaaa(\n"
5697       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5698       "        ->aaaaaaaaaaaaaaaaa();");
5699   verifyGoogleFormat(
5700       "void f() {\n"
5701       "  someo->Add((new util::filetools::Handler(dir))\n"
5702       "                 ->OnEvent1(NewPermanentCallback(\n"
5703       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5704       "                 ->OnEvent2(NewPermanentCallback(\n"
5705       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5706       "                 ->OnEvent3(NewPermanentCallback(\n"
5707       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5708       "                 ->OnEvent5(NewPermanentCallback(\n"
5709       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5710       "                 ->OnEvent6(NewPermanentCallback(\n"
5711       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5712       "}");
5713 
5714   verifyFormat(
5715       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5716   verifyFormat("aaaaaaaaaaaaaaa()\n"
5717                "    .aaaaaaaaaaaaaaa()\n"
5718                "    .aaaaaaaaaaaaaaa()\n"
5719                "    .aaaaaaaaaaaaaaa()\n"
5720                "    .aaaaaaaaaaaaaaa();");
5721   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5722                "    .aaaaaaaaaaaaaaa()\n"
5723                "    .aaaaaaaaaaaaaaa()\n"
5724                "    .aaaaaaaaaaaaaaa();");
5725   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5726                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5727                "    .aaaaaaaaaaaaaaa();");
5728   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5729                "    ->aaaaaaaaaaaaaae(0)\n"
5730                "    ->aaaaaaaaaaaaaaa();");
5731 
5732   // Don't linewrap after very short segments.
5733   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5734                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5735                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5736   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5737                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5738                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5739   verifyFormat("aaa()\n"
5740                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5741                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5742                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5743 
5744   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5745                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5746                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5747   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5748                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5749                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5750 
5751   // Prefer not to break after empty parentheses.
5752   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5753                "    First->LastNewlineOffset);");
5754 
5755   // Prefer not to create "hanging" indents.
5756   verifyFormat(
5757       "return !soooooooooooooome_map\n"
5758       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5759       "            .second;");
5760   verifyFormat(
5761       "return aaaaaaaaaaaaaaaa\n"
5762       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5763       "    .aaaa(aaaaaaaaaaaaaa);");
5764   // No hanging indent here.
5765   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5766                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5767   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5768                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5769   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5770                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5771                getLLVMStyleWithColumns(60));
5772   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5773                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5774                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5775                getLLVMStyleWithColumns(59));
5776   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5777                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5778                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5779 
5780   // Dont break if only closing statements before member call
5781   verifyFormat("test() {\n"
5782                "  ([]() -> {\n"
5783                "    int b = 32;\n"
5784                "    return 3;\n"
5785                "  }).foo();\n"
5786                "}");
5787   verifyFormat("test() {\n"
5788                "  (\n"
5789                "      []() -> {\n"
5790                "        int b = 32;\n"
5791                "        return 3;\n"
5792                "      },\n"
5793                "      foo, bar)\n"
5794                "      .foo();\n"
5795                "}");
5796   verifyFormat("test() {\n"
5797                "  ([]() -> {\n"
5798                "    int b = 32;\n"
5799                "    return 3;\n"
5800                "  })\n"
5801                "      .foo()\n"
5802                "      .bar();\n"
5803                "}");
5804   verifyFormat("test() {\n"
5805                "  ([]() -> {\n"
5806                "    int b = 32;\n"
5807                "    return 3;\n"
5808                "  })\n"
5809                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5810                "           \"bbbb\");\n"
5811                "}",
5812                getLLVMStyleWithColumns(30));
5813 }
5814 
5815 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5816   verifyFormat(
5817       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5818       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5819   verifyFormat(
5820       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5821       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5822 
5823   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5824                "    ccccccccccccccccccccccccc) {\n}");
5825   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5826                "    ccccccccccccccccccccccccc) {\n}");
5827 
5828   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5829                "    ccccccccccccccccccccccccc) {\n}");
5830   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5831                "    ccccccccccccccccccccccccc) {\n}");
5832 
5833   verifyFormat(
5834       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
5835       "    ccccccccccccccccccccccccc) {\n}");
5836   verifyFormat(
5837       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
5838       "    ccccccccccccccccccccccccc) {\n}");
5839 
5840   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5841                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
5842                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
5843                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5844   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5845                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
5846                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
5847                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5848 
5849   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5850                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
5851                "    aaaaaaaaaaaaaaa != aa) {\n}");
5852   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5853                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
5854                "    aaaaaaaaaaaaaaa != aa) {\n}");
5855 }
5856 
5857 TEST_F(FormatTest, BreaksAfterAssignments) {
5858   verifyFormat(
5859       "unsigned Cost =\n"
5860       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
5861       "                        SI->getPointerAddressSpaceee());\n");
5862   verifyFormat(
5863       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
5864       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
5865 
5866   verifyFormat(
5867       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
5868       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
5869   verifyFormat("unsigned OriginalStartColumn =\n"
5870                "    SourceMgr.getSpellingColumnNumber(\n"
5871                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
5872                "    1;");
5873 }
5874 
5875 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
5876   FormatStyle Style = getLLVMStyle();
5877   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5878                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
5879                Style);
5880 
5881   Style.PenaltyBreakAssignment = 20;
5882   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5883                "                                 cccccccccccccccccccccccccc;",
5884                Style);
5885 }
5886 
5887 TEST_F(FormatTest, AlignsAfterAssignments) {
5888   verifyFormat(
5889       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5890       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
5891   verifyFormat(
5892       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5893       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
5894   verifyFormat(
5895       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5896       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
5897   verifyFormat(
5898       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5899       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
5900   verifyFormat(
5901       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5902       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5903       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
5904 }
5905 
5906 TEST_F(FormatTest, AlignsAfterReturn) {
5907   verifyFormat(
5908       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5909       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
5910   verifyFormat(
5911       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5912       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
5913   verifyFormat(
5914       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5915       "       aaaaaaaaaaaaaaaaaaaaaa();");
5916   verifyFormat(
5917       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5918       "        aaaaaaaaaaaaaaaaaaaaaa());");
5919   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5920                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5921   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5922                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
5923                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5924   verifyFormat("return\n"
5925                "    // true if code is one of a or b.\n"
5926                "    code == a || code == b;");
5927 }
5928 
5929 TEST_F(FormatTest, AlignsAfterOpenBracket) {
5930   verifyFormat(
5931       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5932       "                                                aaaaaaaaa aaaaaaa) {}");
5933   verifyFormat(
5934       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5935       "                                               aaaaaaaaaaa aaaaaaaaa);");
5936   verifyFormat(
5937       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5938       "                                             aaaaaaaaaaaaaaaaaaaaa));");
5939   FormatStyle Style = getLLVMStyle();
5940   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5941   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5942                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
5943                Style);
5944   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5945                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
5946                Style);
5947   verifyFormat("SomeLongVariableName->someFunction(\n"
5948                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
5949                Style);
5950   verifyFormat(
5951       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5952       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5953       Style);
5954   verifyFormat(
5955       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5956       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5957       Style);
5958   verifyFormat(
5959       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5960       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
5961       Style);
5962 
5963   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
5964                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
5965                "        b));",
5966                Style);
5967 
5968   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5969   Style.BinPackArguments = false;
5970   Style.BinPackParameters = false;
5971   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5972                "    aaaaaaaaaaa aaaaaaaa,\n"
5973                "    aaaaaaaaa aaaaaaa,\n"
5974                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5975                Style);
5976   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5977                "    aaaaaaaaaaa aaaaaaaaa,\n"
5978                "    aaaaaaaaaaa aaaaaaaaa,\n"
5979                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5980                Style);
5981   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
5982                "    aaaaaaaaaaaaaaa,\n"
5983                "    aaaaaaaaaaaaaaaaaaaaa,\n"
5984                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
5985                Style);
5986   verifyFormat(
5987       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
5988       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
5989       Style);
5990   verifyFormat(
5991       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
5992       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
5993       Style);
5994   verifyFormat(
5995       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5996       "    aaaaaaaaaaaaaaaaaaaaa(\n"
5997       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
5998       "    aaaaaaaaaaaaaaaa);",
5999       Style);
6000   verifyFormat(
6001       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6002       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6003       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
6004       "    aaaaaaaaaaaaaaaa);",
6005       Style);
6006 }
6007 
6008 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
6009   FormatStyle Style = getLLVMStyleWithColumns(40);
6010   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6011                "          bbbbbbbbbbbbbbbbbbbbbb);",
6012                Style);
6013   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6014   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6015   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6016                "          bbbbbbbbbbbbbbbbbbbbbb);",
6017                Style);
6018   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6019   Style.AlignOperands = FormatStyle::OAS_Align;
6020   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6021                "          bbbbbbbbbbbbbbbbbbbbbb);",
6022                Style);
6023   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6024   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6025   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6026                "    bbbbbbbbbbbbbbbbbbbbbb);",
6027                Style);
6028 }
6029 
6030 TEST_F(FormatTest, BreaksConditionalExpressions) {
6031   verifyFormat(
6032       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6033       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6034       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6035   verifyFormat(
6036       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6037       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6038       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6039   verifyFormat(
6040       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6041       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6042   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6043                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6044                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6045   verifyFormat(
6046       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6047       "                                                    : aaaaaaaaaaaaa);");
6048   verifyFormat(
6049       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6050       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6051       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6052       "                   aaaaaaaaaaaaa);");
6053   verifyFormat(
6054       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6055       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6056       "                   aaaaaaaaaaaaa);");
6057   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6058                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6059                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6060                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6061                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6062   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6063                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6064                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6065                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6066                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6067                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6068                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6069   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6070                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6071                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6072                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6073                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6074   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6075                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6076                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6077   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6078                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6079                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6080                "        : aaaaaaaaaaaaaaaa;");
6081   verifyFormat(
6082       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6083       "    ? aaaaaaaaaaaaaaa\n"
6084       "    : aaaaaaaaaaaaaaa;");
6085   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6086                "          aaaaaaaaa\n"
6087                "      ? b\n"
6088                "      : c);");
6089   verifyFormat("return aaaa == bbbb\n"
6090                "           // comment\n"
6091                "           ? aaaa\n"
6092                "           : bbbb;");
6093   verifyFormat("unsigned Indent =\n"
6094                "    format(TheLine.First,\n"
6095                "           IndentForLevel[TheLine.Level] >= 0\n"
6096                "               ? IndentForLevel[TheLine.Level]\n"
6097                "               : TheLine * 2,\n"
6098                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6099                getLLVMStyleWithColumns(60));
6100   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6101                "                  ? aaaaaaaaaaaaaaa\n"
6102                "                  : bbbbbbbbbbbbbbb //\n"
6103                "                        ? ccccccccccccccc\n"
6104                "                        : ddddddddddddddd;");
6105   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6106                "                  ? aaaaaaaaaaaaaaa\n"
6107                "                  : (bbbbbbbbbbbbbbb //\n"
6108                "                         ? ccccccccccccccc\n"
6109                "                         : ddddddddddddddd);");
6110   verifyFormat(
6111       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6112       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6113       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
6114       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
6115       "                                      : aaaaaaaaaa;");
6116   verifyFormat(
6117       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6118       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
6119       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6120 
6121   FormatStyle NoBinPacking = getLLVMStyle();
6122   NoBinPacking.BinPackArguments = false;
6123   verifyFormat(
6124       "void f() {\n"
6125       "  g(aaa,\n"
6126       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6127       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6128       "        ? aaaaaaaaaaaaaaa\n"
6129       "        : aaaaaaaaaaaaaaa);\n"
6130       "}",
6131       NoBinPacking);
6132   verifyFormat(
6133       "void f() {\n"
6134       "  g(aaa,\n"
6135       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6136       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6137       "        ?: aaaaaaaaaaaaaaa);\n"
6138       "}",
6139       NoBinPacking);
6140 
6141   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6142                "             // comment.\n"
6143                "             ccccccccccccccccccccccccccccccccccccccc\n"
6144                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6145                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6146 
6147   // Assignments in conditional expressions. Apparently not uncommon :-(.
6148   verifyFormat("return a != b\n"
6149                "           // comment\n"
6150                "           ? a = b\n"
6151                "           : a = b;");
6152   verifyFormat("return a != b\n"
6153                "           // comment\n"
6154                "           ? a = a != b\n"
6155                "                     // comment\n"
6156                "                     ? a = b\n"
6157                "                     : a\n"
6158                "           : a;\n");
6159   verifyFormat("return a != b\n"
6160                "           // comment\n"
6161                "           ? a\n"
6162                "           : a = a != b\n"
6163                "                     // comment\n"
6164                "                     ? a = b\n"
6165                "                     : a;");
6166 
6167   // Chained conditionals
6168   FormatStyle Style = getLLVMStyle();
6169   Style.ColumnLimit = 70;
6170   Style.AlignOperands = FormatStyle::OAS_Align;
6171   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6172                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6173                "                        : 3333333333333333;",
6174                Style);
6175   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6176                "       : bbbbbbbbbb     ? 2222222222222222\n"
6177                "                        : 3333333333333333;",
6178                Style);
6179   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
6180                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6181                "                          : 3333333333333333;",
6182                Style);
6183   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6184                "       : bbbbbbbbbbbbbb ? 222222\n"
6185                "                        : 333333;",
6186                Style);
6187   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6188                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6189                "       : cccccccccccccc ? 3333333333333333\n"
6190                "                        : 4444444444444444;",
6191                Style);
6192   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6193                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6194                "                        : 3333333333333333;",
6195                Style);
6196   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6197                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6198                "                        : (aaa ? bbb : ccc);",
6199                Style);
6200   verifyFormat(
6201       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6202       "                                             : cccccccccccccccccc)\n"
6203       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6204       "                        : 3333333333333333;",
6205       Style);
6206   verifyFormat(
6207       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6208       "                                             : cccccccccccccccccc)\n"
6209       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6210       "                        : 3333333333333333;",
6211       Style);
6212   verifyFormat(
6213       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6214       "                                             : dddddddddddddddddd)\n"
6215       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6216       "                        : 3333333333333333;",
6217       Style);
6218   verifyFormat(
6219       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6220       "                                             : dddddddddddddddddd)\n"
6221       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6222       "                        : 3333333333333333;",
6223       Style);
6224   verifyFormat(
6225       "return aaaaaaaaa        ? 1111111111111111\n"
6226       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6227       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6228       "                                             : dddddddddddddddddd)\n",
6229       Style);
6230   verifyFormat(
6231       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6232       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6233       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6234       "                                             : cccccccccccccccccc);",
6235       Style);
6236   verifyFormat(
6237       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6238       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6239       "                                             : eeeeeeeeeeeeeeeeee)\n"
6240       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6241       "                        : 3333333333333333;",
6242       Style);
6243   verifyFormat(
6244       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
6245       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6246       "                                             : eeeeeeeeeeeeeeeeee)\n"
6247       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6248       "                        : 3333333333333333;",
6249       Style);
6250   verifyFormat(
6251       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6252       "                           : cccccccccccc    ? dddddddddddddddddd\n"
6253       "                                             : eeeeeeeeeeeeeeeeee)\n"
6254       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6255       "                        : 3333333333333333;",
6256       Style);
6257   verifyFormat(
6258       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6259       "                                             : cccccccccccccccccc\n"
6260       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6261       "                        : 3333333333333333;",
6262       Style);
6263   verifyFormat(
6264       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6265       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
6266       "                                             : eeeeeeeeeeeeeeeeee\n"
6267       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6268       "                        : 3333333333333333;",
6269       Style);
6270   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6271                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
6272                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
6273                "                                   : eeeeeeeeeeeeeeeeee)\n"
6274                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6275                "                             : 3333333333333333;",
6276                Style);
6277   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6278                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6279                "             : cccccccccccccccc ? dddddddddddddddddd\n"
6280                "                                : eeeeeeeeeeeeeeeeee\n"
6281                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6282                "                                 : 3333333333333333;",
6283                Style);
6284 }
6285 
6286 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6287   FormatStyle Style = getLLVMStyle();
6288   Style.BreakBeforeTernaryOperators = false;
6289   Style.ColumnLimit = 70;
6290   verifyFormat(
6291       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6292       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6293       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6294       Style);
6295   verifyFormat(
6296       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6297       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6298       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6299       Style);
6300   verifyFormat(
6301       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6302       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6303       Style);
6304   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6305                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6306                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6307                Style);
6308   verifyFormat(
6309       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6310       "                                                      aaaaaaaaaaaaa);",
6311       Style);
6312   verifyFormat(
6313       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6314       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6315       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6316       "                   aaaaaaaaaaaaa);",
6317       Style);
6318   verifyFormat(
6319       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6320       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6321       "                   aaaaaaaaaaaaa);",
6322       Style);
6323   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6324                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6325                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6326                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6327                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6328                Style);
6329   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6330                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6331                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6332                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6333                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6334                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6335                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6336                Style);
6337   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6338                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6339                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6340                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6341                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6342                Style);
6343   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6344                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6345                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6346                Style);
6347   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6348                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6349                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6350                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6351                Style);
6352   verifyFormat(
6353       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6354       "    aaaaaaaaaaaaaaa :\n"
6355       "    aaaaaaaaaaaaaaa;",
6356       Style);
6357   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6358                "          aaaaaaaaa ?\n"
6359                "      b :\n"
6360                "      c);",
6361                Style);
6362   verifyFormat("unsigned Indent =\n"
6363                "    format(TheLine.First,\n"
6364                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
6365                "               IndentForLevel[TheLine.Level] :\n"
6366                "               TheLine * 2,\n"
6367                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6368                Style);
6369   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6370                "                  aaaaaaaaaaaaaaa :\n"
6371                "                  bbbbbbbbbbbbbbb ? //\n"
6372                "                      ccccccccccccccc :\n"
6373                "                      ddddddddddddddd;",
6374                Style);
6375   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6376                "                  aaaaaaaaaaaaaaa :\n"
6377                "                  (bbbbbbbbbbbbbbb ? //\n"
6378                "                       ccccccccccccccc :\n"
6379                "                       ddddddddddddddd);",
6380                Style);
6381   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6382                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6383                "            ccccccccccccccccccccccccccc;",
6384                Style);
6385   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6386                "           aaaaa :\n"
6387                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
6388                Style);
6389 
6390   // Chained conditionals
6391   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6392                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6393                "                          3333333333333333;",
6394                Style);
6395   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6396                "       bbbbbbbbbb       ? 2222222222222222 :\n"
6397                "                          3333333333333333;",
6398                Style);
6399   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
6400                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6401                "                          3333333333333333;",
6402                Style);
6403   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6404                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
6405                "                          333333;",
6406                Style);
6407   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6408                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6409                "       cccccccccccccccc ? 3333333333333333 :\n"
6410                "                          4444444444444444;",
6411                Style);
6412   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6413                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6414                "                          3333333333333333;",
6415                Style);
6416   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6417                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6418                "                          (aaa ? bbb : ccc);",
6419                Style);
6420   verifyFormat(
6421       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6422       "                                               cccccccccccccccccc) :\n"
6423       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6424       "                          3333333333333333;",
6425       Style);
6426   verifyFormat(
6427       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6428       "                                               cccccccccccccccccc) :\n"
6429       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6430       "                          3333333333333333;",
6431       Style);
6432   verifyFormat(
6433       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6434       "                                               dddddddddddddddddd) :\n"
6435       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6436       "                          3333333333333333;",
6437       Style);
6438   verifyFormat(
6439       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6440       "                                               dddddddddddddddddd) :\n"
6441       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6442       "                          3333333333333333;",
6443       Style);
6444   verifyFormat(
6445       "return aaaaaaaaa        ? 1111111111111111 :\n"
6446       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6447       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6448       "                                               dddddddddddddddddd)\n",
6449       Style);
6450   verifyFormat(
6451       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6452       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6453       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6454       "                                               cccccccccccccccccc);",
6455       Style);
6456   verifyFormat(
6457       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6458       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6459       "                                               eeeeeeeeeeeeeeeeee) :\n"
6460       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6461       "                          3333333333333333;",
6462       Style);
6463   verifyFormat(
6464       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6465       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
6466       "                                               eeeeeeeeeeeeeeeeee) :\n"
6467       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6468       "                          3333333333333333;",
6469       Style);
6470   verifyFormat(
6471       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
6472       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6473       "                                               eeeeeeeeeeeeeeeeee) :\n"
6474       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6475       "                          3333333333333333;",
6476       Style);
6477   verifyFormat(
6478       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6479       "                                               cccccccccccccccccc :\n"
6480       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6481       "                          3333333333333333;",
6482       Style);
6483   verifyFormat(
6484       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6485       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
6486       "                                               eeeeeeeeeeeeeeeeee :\n"
6487       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6488       "                          3333333333333333;",
6489       Style);
6490   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6491                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6492                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
6493                "                                 eeeeeeeeeeeeeeeeee) :\n"
6494                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6495                "                               3333333333333333;",
6496                Style);
6497   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6498                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6499                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
6500                "                                  eeeeeeeeeeeeeeeeee :\n"
6501                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6502                "                               3333333333333333;",
6503                Style);
6504 }
6505 
6506 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6507   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6508                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6509   verifyFormat("bool a = true, b = false;");
6510 
6511   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6512                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6513                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6514                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6515   verifyFormat(
6516       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6517       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6518       "     d = e && f;");
6519   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6520                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6521   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6522                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6523   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6524                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6525 
6526   FormatStyle Style = getGoogleStyle();
6527   Style.PointerAlignment = FormatStyle::PAS_Left;
6528   Style.DerivePointerAlignment = false;
6529   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6530                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6531                "    *b = bbbbbbbbbbbbbbbbbbb;",
6532                Style);
6533   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6534                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6535                Style);
6536   verifyFormat("vector<int*> a, b;", Style);
6537   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6538 }
6539 
6540 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6541   verifyFormat("arr[foo ? bar : baz];");
6542   verifyFormat("f()[foo ? bar : baz];");
6543   verifyFormat("(a + b)[foo ? bar : baz];");
6544   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6545 }
6546 
6547 TEST_F(FormatTest, AlignsStringLiterals) {
6548   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6549                "                                      \"short literal\");");
6550   verifyFormat(
6551       "looooooooooooooooooooooooongFunction(\n"
6552       "    \"short literal\"\n"
6553       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6554   verifyFormat("someFunction(\"Always break between multi-line\"\n"
6555                "             \" string literals\",\n"
6556                "             and, other, parameters);");
6557   EXPECT_EQ("fun + \"1243\" /* comment */\n"
6558             "      \"5678\";",
6559             format("fun + \"1243\" /* comment */\n"
6560                    "    \"5678\";",
6561                    getLLVMStyleWithColumns(28)));
6562   EXPECT_EQ(
6563       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6564       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6565       "         \"aaaaaaaaaaaaaaaa\";",
6566       format("aaaaaa ="
6567              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6568              "aaaaaaaaaaaaaaaaaaaaa\" "
6569              "\"aaaaaaaaaaaaaaaa\";"));
6570   verifyFormat("a = a + \"a\"\n"
6571                "        \"a\"\n"
6572                "        \"a\";");
6573   verifyFormat("f(\"a\", \"b\"\n"
6574                "       \"c\");");
6575 
6576   verifyFormat(
6577       "#define LL_FORMAT \"ll\"\n"
6578       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6579       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6580 
6581   verifyFormat("#define A(X)          \\\n"
6582                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
6583                "  \"ccccc\"",
6584                getLLVMStyleWithColumns(23));
6585   verifyFormat("#define A \"def\"\n"
6586                "f(\"abc\" A \"ghi\"\n"
6587                "  \"jkl\");");
6588 
6589   verifyFormat("f(L\"a\"\n"
6590                "  L\"b\");");
6591   verifyFormat("#define A(X)            \\\n"
6592                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6593                "  L\"ccccc\"",
6594                getLLVMStyleWithColumns(25));
6595 
6596   verifyFormat("f(@\"a\"\n"
6597                "  @\"b\");");
6598   verifyFormat("NSString s = @\"a\"\n"
6599                "             @\"b\"\n"
6600                "             @\"c\";");
6601   verifyFormat("NSString s = @\"a\"\n"
6602                "              \"b\"\n"
6603                "              \"c\";");
6604 }
6605 
6606 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6607   FormatStyle Style = getLLVMStyle();
6608   // No declarations or definitions should be moved to own line.
6609   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6610   verifyFormat("class A {\n"
6611                "  int f() { return 1; }\n"
6612                "  int g();\n"
6613                "};\n"
6614                "int f() { return 1; }\n"
6615                "int g();\n",
6616                Style);
6617 
6618   // All declarations and definitions should have the return type moved to its
6619   // own
6620   // line.
6621   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6622   verifyFormat("class E {\n"
6623                "  int\n"
6624                "  f() {\n"
6625                "    return 1;\n"
6626                "  }\n"
6627                "  int\n"
6628                "  g();\n"
6629                "};\n"
6630                "int\n"
6631                "f() {\n"
6632                "  return 1;\n"
6633                "}\n"
6634                "int\n"
6635                "g();\n",
6636                Style);
6637 
6638   // Top-level definitions, and no kinds of declarations should have the
6639   // return type moved to its own line.
6640   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6641   verifyFormat("class B {\n"
6642                "  int f() { return 1; }\n"
6643                "  int g();\n"
6644                "};\n"
6645                "int\n"
6646                "f() {\n"
6647                "  return 1;\n"
6648                "}\n"
6649                "int g();\n",
6650                Style);
6651 
6652   // Top-level definitions and declarations should have the return type moved
6653   // to its own line.
6654   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6655   verifyFormat("class C {\n"
6656                "  int f() { return 1; }\n"
6657                "  int g();\n"
6658                "};\n"
6659                "int\n"
6660                "f() {\n"
6661                "  return 1;\n"
6662                "}\n"
6663                "int\n"
6664                "g();\n",
6665                Style);
6666 
6667   // All definitions should have the return type moved to its own line, but no
6668   // kinds of declarations.
6669   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6670   verifyFormat("class D {\n"
6671                "  int\n"
6672                "  f() {\n"
6673                "    return 1;\n"
6674                "  }\n"
6675                "  int g();\n"
6676                "};\n"
6677                "int\n"
6678                "f() {\n"
6679                "  return 1;\n"
6680                "}\n"
6681                "int g();\n",
6682                Style);
6683   verifyFormat("const char *\n"
6684                "f(void) {\n" // Break here.
6685                "  return \"\";\n"
6686                "}\n"
6687                "const char *bar(void);\n", // No break here.
6688                Style);
6689   verifyFormat("template <class T>\n"
6690                "T *\n"
6691                "f(T &c) {\n" // Break here.
6692                "  return NULL;\n"
6693                "}\n"
6694                "template <class T> T *f(T &c);\n", // No break here.
6695                Style);
6696   verifyFormat("class C {\n"
6697                "  int\n"
6698                "  operator+() {\n"
6699                "    return 1;\n"
6700                "  }\n"
6701                "  int\n"
6702                "  operator()() {\n"
6703                "    return 1;\n"
6704                "  }\n"
6705                "};\n",
6706                Style);
6707   verifyFormat("void\n"
6708                "A::operator()() {}\n"
6709                "void\n"
6710                "A::operator>>() {}\n"
6711                "void\n"
6712                "A::operator+() {}\n"
6713                "void\n"
6714                "A::operator*() {}\n"
6715                "void\n"
6716                "A::operator->() {}\n"
6717                "void\n"
6718                "A::operator void *() {}\n"
6719                "void\n"
6720                "A::operator void &() {}\n"
6721                "void\n"
6722                "A::operator void &&() {}\n"
6723                "void\n"
6724                "A::operator char *() {}\n"
6725                "void\n"
6726                "A::operator[]() {}\n"
6727                "void\n"
6728                "A::operator!() {}\n"
6729                "void\n"
6730                "A::operator**() {}\n"
6731                "void\n"
6732                "A::operator<Foo> *() {}\n"
6733                "void\n"
6734                "A::operator<Foo> **() {}\n"
6735                "void\n"
6736                "A::operator<Foo> &() {}\n"
6737                "void\n"
6738                "A::operator void **() {}\n",
6739                Style);
6740   verifyFormat("constexpr auto\n"
6741                "operator()() const -> reference {}\n"
6742                "constexpr auto\n"
6743                "operator>>() const -> reference {}\n"
6744                "constexpr auto\n"
6745                "operator+() const -> reference {}\n"
6746                "constexpr auto\n"
6747                "operator*() const -> reference {}\n"
6748                "constexpr auto\n"
6749                "operator->() const -> reference {}\n"
6750                "constexpr auto\n"
6751                "operator++() const -> reference {}\n"
6752                "constexpr auto\n"
6753                "operator void *() const -> reference {}\n"
6754                "constexpr auto\n"
6755                "operator void **() const -> reference {}\n"
6756                "constexpr auto\n"
6757                "operator void *() const -> reference {}\n"
6758                "constexpr auto\n"
6759                "operator void &() const -> reference {}\n"
6760                "constexpr auto\n"
6761                "operator void &&() const -> reference {}\n"
6762                "constexpr auto\n"
6763                "operator char *() const -> reference {}\n"
6764                "constexpr auto\n"
6765                "operator!() const -> reference {}\n"
6766                "constexpr auto\n"
6767                "operator[]() const -> reference {}\n",
6768                Style);
6769   verifyFormat("void *operator new(std::size_t s);", // No break here.
6770                Style);
6771   verifyFormat("void *\n"
6772                "operator new(std::size_t s) {}",
6773                Style);
6774   verifyFormat("void *\n"
6775                "operator delete[](void *ptr) {}",
6776                Style);
6777   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6778   verifyFormat("const char *\n"
6779                "f(void)\n" // Break here.
6780                "{\n"
6781                "  return \"\";\n"
6782                "}\n"
6783                "const char *bar(void);\n", // No break here.
6784                Style);
6785   verifyFormat("template <class T>\n"
6786                "T *\n"     // Problem here: no line break
6787                "f(T &c)\n" // Break here.
6788                "{\n"
6789                "  return NULL;\n"
6790                "}\n"
6791                "template <class T> T *f(T &c);\n", // No break here.
6792                Style);
6793   verifyFormat("int\n"
6794                "foo(A<bool> a)\n"
6795                "{\n"
6796                "  return a;\n"
6797                "}\n",
6798                Style);
6799   verifyFormat("int\n"
6800                "foo(A<8> a)\n"
6801                "{\n"
6802                "  return a;\n"
6803                "}\n",
6804                Style);
6805   verifyFormat("int\n"
6806                "foo(A<B<bool>, 8> a)\n"
6807                "{\n"
6808                "  return a;\n"
6809                "}\n",
6810                Style);
6811   verifyFormat("int\n"
6812                "foo(A<B<8>, bool> a)\n"
6813                "{\n"
6814                "  return a;\n"
6815                "}\n",
6816                Style);
6817   verifyFormat("int\n"
6818                "foo(A<B<bool>, bool> a)\n"
6819                "{\n"
6820                "  return a;\n"
6821                "}\n",
6822                Style);
6823   verifyFormat("int\n"
6824                "foo(A<B<8>, 8> a)\n"
6825                "{\n"
6826                "  return a;\n"
6827                "}\n",
6828                Style);
6829 
6830   Style = getGNUStyle();
6831 
6832   // Test for comments at the end of function declarations.
6833   verifyFormat("void\n"
6834                "foo (int a, /*abc*/ int b) // def\n"
6835                "{\n"
6836                "}\n",
6837                Style);
6838 
6839   verifyFormat("void\n"
6840                "foo (int a, /* abc */ int b) /* def */\n"
6841                "{\n"
6842                "}\n",
6843                Style);
6844 
6845   // Definitions that should not break after return type
6846   verifyFormat("void foo (int a, int b); // def\n", Style);
6847   verifyFormat("void foo (int a, int b); /* def */\n", Style);
6848   verifyFormat("void foo (int a, int b);\n", Style);
6849 }
6850 
6851 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
6852   FormatStyle NoBreak = getLLVMStyle();
6853   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
6854   FormatStyle Break = getLLVMStyle();
6855   Break.AlwaysBreakBeforeMultilineStrings = true;
6856   verifyFormat("aaaa = \"bbbb\"\n"
6857                "       \"cccc\";",
6858                NoBreak);
6859   verifyFormat("aaaa =\n"
6860                "    \"bbbb\"\n"
6861                "    \"cccc\";",
6862                Break);
6863   verifyFormat("aaaa(\"bbbb\"\n"
6864                "     \"cccc\");",
6865                NoBreak);
6866   verifyFormat("aaaa(\n"
6867                "    \"bbbb\"\n"
6868                "    \"cccc\");",
6869                Break);
6870   verifyFormat("aaaa(qqq, \"bbbb\"\n"
6871                "          \"cccc\");",
6872                NoBreak);
6873   verifyFormat("aaaa(qqq,\n"
6874                "     \"bbbb\"\n"
6875                "     \"cccc\");",
6876                Break);
6877   verifyFormat("aaaa(qqq,\n"
6878                "     L\"bbbb\"\n"
6879                "     L\"cccc\");",
6880                Break);
6881   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
6882                "                      \"bbbb\"));",
6883                Break);
6884   verifyFormat("string s = someFunction(\n"
6885                "    \"abc\"\n"
6886                "    \"abc\");",
6887                Break);
6888 
6889   // As we break before unary operators, breaking right after them is bad.
6890   verifyFormat("string foo = abc ? \"x\"\n"
6891                "                   \"blah blah blah blah blah blah\"\n"
6892                "                 : \"y\";",
6893                Break);
6894 
6895   // Don't break if there is no column gain.
6896   verifyFormat("f(\"aaaa\"\n"
6897                "  \"bbbb\");",
6898                Break);
6899 
6900   // Treat literals with escaped newlines like multi-line string literals.
6901   EXPECT_EQ("x = \"a\\\n"
6902             "b\\\n"
6903             "c\";",
6904             format("x = \"a\\\n"
6905                    "b\\\n"
6906                    "c\";",
6907                    NoBreak));
6908   EXPECT_EQ("xxxx =\n"
6909             "    \"a\\\n"
6910             "b\\\n"
6911             "c\";",
6912             format("xxxx = \"a\\\n"
6913                    "b\\\n"
6914                    "c\";",
6915                    Break));
6916 
6917   EXPECT_EQ("NSString *const kString =\n"
6918             "    @\"aaaa\"\n"
6919             "    @\"bbbb\";",
6920             format("NSString *const kString = @\"aaaa\"\n"
6921                    "@\"bbbb\";",
6922                    Break));
6923 
6924   Break.ColumnLimit = 0;
6925   verifyFormat("const char *hello = \"hello llvm\";", Break);
6926 }
6927 
6928 TEST_F(FormatTest, AlignsPipes) {
6929   verifyFormat(
6930       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6931       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6932       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6933   verifyFormat(
6934       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
6935       "                     << aaaaaaaaaaaaaaaaaaaa;");
6936   verifyFormat(
6937       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6938       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6939   verifyFormat(
6940       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
6941       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6942   verifyFormat(
6943       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
6944       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
6945       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
6946   verifyFormat(
6947       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6948       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6949       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6950   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6951                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6952                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6953                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
6954   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
6955                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
6956   verifyFormat(
6957       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6958       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6959   verifyFormat(
6960       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
6961       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
6962 
6963   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
6964                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
6965   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6966                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6967                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
6968                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
6969   verifyFormat("LOG_IF(aaa == //\n"
6970                "       bbb)\n"
6971                "    << a << b;");
6972 
6973   // But sometimes, breaking before the first "<<" is desirable.
6974   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6975                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
6976   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
6977                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6978                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6979   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
6980                "    << BEF << IsTemplate << Description << E->getType();");
6981   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6982                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6983                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6984   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6985                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6986                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6987                "    << aaa;");
6988 
6989   verifyFormat(
6990       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6991       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
6992 
6993   // Incomplete string literal.
6994   EXPECT_EQ("llvm::errs() << \"\n"
6995             "             << a;",
6996             format("llvm::errs() << \"\n<<a;"));
6997 
6998   verifyFormat("void f() {\n"
6999                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
7000                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
7001                "}");
7002 
7003   // Handle 'endl'.
7004   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
7005                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7006   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7007 
7008   // Handle '\n'.
7009   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
7010                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7011   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
7012                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
7013   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
7014                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
7015   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7016 }
7017 
7018 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
7019   verifyFormat("return out << \"somepacket = {\\n\"\n"
7020                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
7021                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
7022                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
7023                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
7024                "           << \"}\";");
7025 
7026   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7027                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7028                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7029   verifyFormat(
7030       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7031       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7032       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7033       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7034       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7035   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7036                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7037   verifyFormat(
7038       "void f() {\n"
7039       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7040       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7041       "}");
7042 
7043   // Breaking before the first "<<" is generally not desirable.
7044   verifyFormat(
7045       "llvm::errs()\n"
7046       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7047       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7048       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7049       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7050       getLLVMStyleWithColumns(70));
7051   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7052                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7053                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7054                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7055                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7056                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7057                getLLVMStyleWithColumns(70));
7058 
7059   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7060                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7061                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7062   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7063                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7064                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7065   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7066                "           (aaaa + aaaa);",
7067                getLLVMStyleWithColumns(40));
7068   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7069                "                  (aaaaaaa + aaaaa));",
7070                getLLVMStyleWithColumns(40));
7071   verifyFormat(
7072       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7073       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7074       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
7075 }
7076 
7077 TEST_F(FormatTest, UnderstandsEquals) {
7078   verifyFormat(
7079       "aaaaaaaaaaaaaaaaa =\n"
7080       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7081   verifyFormat(
7082       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7083       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7084   verifyFormat(
7085       "if (a) {\n"
7086       "  f();\n"
7087       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7088       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7089       "}");
7090 
7091   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7092                "        100000000 + 10000000) {\n}");
7093 }
7094 
7095 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7096   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7097                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
7098 
7099   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7100                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
7101 
7102   verifyFormat(
7103       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7104       "                                                          Parameter2);");
7105 
7106   verifyFormat(
7107       "ShortObject->shortFunction(\n"
7108       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7109       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7110 
7111   verifyFormat("loooooooooooooongFunction(\n"
7112                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
7113 
7114   verifyFormat(
7115       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7116       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7117 
7118   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7119                "    .WillRepeatedly(Return(SomeValue));");
7120   verifyFormat("void f() {\n"
7121                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7122                "      .Times(2)\n"
7123                "      .WillRepeatedly(Return(SomeValue));\n"
7124                "}");
7125   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7126                "    ccccccccccccccccccccccc);");
7127   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7128                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7129                "          .aaaaa(aaaaa),\n"
7130                "      aaaaaaaaaaaaaaaaaaaaa);");
7131   verifyFormat("void f() {\n"
7132                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7133                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7134                "}");
7135   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7136                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7137                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7138                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7139                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7140   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7141                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7142                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7143                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7144                "}");
7145 
7146   // Here, it is not necessary to wrap at "." or "->".
7147   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7148                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7149   verifyFormat(
7150       "aaaaaaaaaaa->aaaaaaaaa(\n"
7151       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7152       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7153 
7154   verifyFormat(
7155       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7156       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7157   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7158                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7159   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7160                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7161 
7162   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7163                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7164                "    .a();");
7165 
7166   FormatStyle NoBinPacking = getLLVMStyle();
7167   NoBinPacking.BinPackParameters = false;
7168   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7169                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7170                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7171                "                         aaaaaaaaaaaaaaaaaaa,\n"
7172                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7173                NoBinPacking);
7174 
7175   // If there is a subsequent call, change to hanging indentation.
7176   verifyFormat(
7177       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7178       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7179       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7180   verifyFormat(
7181       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7182       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7183   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7184                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7185                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7186   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7187                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7188                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7189 }
7190 
7191 TEST_F(FormatTest, WrapsTemplateDeclarations) {
7192   verifyFormat("template <typename T>\n"
7193                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7194   verifyFormat("template <typename T>\n"
7195                "// T should be one of {A, B}.\n"
7196                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7197   verifyFormat(
7198       "template <typename T>\n"
7199       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7200   verifyFormat("template <typename T>\n"
7201                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7202                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7203   verifyFormat(
7204       "template <typename T>\n"
7205       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7206       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
7207   verifyFormat(
7208       "template <typename T>\n"
7209       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7210       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7211       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7212   verifyFormat("template <typename T>\n"
7213                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7214                "    int aaaaaaaaaaaaaaaaaaaaaa);");
7215   verifyFormat(
7216       "template <typename T1, typename T2 = char, typename T3 = char,\n"
7217       "          typename T4 = char>\n"
7218       "void f();");
7219   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7220                "          template <typename> class cccccccccccccccccccccc,\n"
7221                "          typename ddddddddddddd>\n"
7222                "class C {};");
7223   verifyFormat(
7224       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7225       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7226 
7227   verifyFormat("void f() {\n"
7228                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7229                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7230                "}");
7231 
7232   verifyFormat("template <typename T> class C {};");
7233   verifyFormat("template <typename T> void f();");
7234   verifyFormat("template <typename T> void f() {}");
7235   verifyFormat(
7236       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7237       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7238       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7239       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7240       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7241       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7242       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
7243       getLLVMStyleWithColumns(72));
7244   EXPECT_EQ("static_cast<A< //\n"
7245             "    B> *>(\n"
7246             "\n"
7247             ");",
7248             format("static_cast<A<//\n"
7249                    "    B>*>(\n"
7250                    "\n"
7251                    "    );"));
7252   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7253                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7254 
7255   FormatStyle AlwaysBreak = getLLVMStyle();
7256   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7257   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7258   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7259   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7260   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7261                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7262                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
7263   verifyFormat("template <template <typename> class Fooooooo,\n"
7264                "          template <typename> class Baaaaaaar>\n"
7265                "struct C {};",
7266                AlwaysBreak);
7267   verifyFormat("template <typename T> // T can be A, B or C.\n"
7268                "struct C {};",
7269                AlwaysBreak);
7270   verifyFormat("template <enum E> class A {\n"
7271                "public:\n"
7272                "  E *f();\n"
7273                "};");
7274 
7275   FormatStyle NeverBreak = getLLVMStyle();
7276   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7277   verifyFormat("template <typename T> class C {};", NeverBreak);
7278   verifyFormat("template <typename T> void f();", NeverBreak);
7279   verifyFormat("template <typename T> void f() {}", NeverBreak);
7280   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7281                "bbbbbbbbbbbbbbbbbbbb) {}",
7282                NeverBreak);
7283   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7284                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7285                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
7286                NeverBreak);
7287   verifyFormat("template <template <typename> class Fooooooo,\n"
7288                "          template <typename> class Baaaaaaar>\n"
7289                "struct C {};",
7290                NeverBreak);
7291   verifyFormat("template <typename T> // T can be A, B or C.\n"
7292                "struct C {};",
7293                NeverBreak);
7294   verifyFormat("template <enum E> class A {\n"
7295                "public:\n"
7296                "  E *f();\n"
7297                "};",
7298                NeverBreak);
7299   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7300   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7301                "bbbbbbbbbbbbbbbbbbbb) {}",
7302                NeverBreak);
7303 }
7304 
7305 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7306   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7307   Style.ColumnLimit = 60;
7308   EXPECT_EQ("// Baseline - no comments.\n"
7309             "template <\n"
7310             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7311             "void f() {}",
7312             format("// Baseline - no comments.\n"
7313                    "template <\n"
7314                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7315                    "void f() {}",
7316                    Style));
7317 
7318   EXPECT_EQ("template <\n"
7319             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7320             "void f() {}",
7321             format("template <\n"
7322                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7323                    "void f() {}",
7324                    Style));
7325 
7326   EXPECT_EQ(
7327       "template <\n"
7328       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7329       "void f() {}",
7330       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
7331              "void f() {}",
7332              Style));
7333 
7334   EXPECT_EQ(
7335       "template <\n"
7336       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7337       "                                               // multiline\n"
7338       "void f() {}",
7339       format("template <\n"
7340              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7341              "                                              // multiline\n"
7342              "void f() {}",
7343              Style));
7344 
7345   EXPECT_EQ(
7346       "template <typename aaaaaaaaaa<\n"
7347       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
7348       "void f() {}",
7349       format(
7350           "template <\n"
7351           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7352           "void f() {}",
7353           Style));
7354 }
7355 
7356 TEST_F(FormatTest, WrapsTemplateParameters) {
7357   FormatStyle Style = getLLVMStyle();
7358   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7359   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7360   verifyFormat(
7361       "template <typename... a> struct q {};\n"
7362       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7363       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7364       "    y;",
7365       Style);
7366   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7367   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7368   verifyFormat(
7369       "template <typename... a> struct r {};\n"
7370       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7371       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7372       "    y;",
7373       Style);
7374   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7375   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7376   verifyFormat("template <typename... a> struct s {};\n"
7377                "extern s<\n"
7378                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7379                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7380                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7381                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7382                "    y;",
7383                Style);
7384   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7385   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7386   verifyFormat("template <typename... a> struct t {};\n"
7387                "extern t<\n"
7388                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7389                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7390                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7391                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7392                "    y;",
7393                Style);
7394 }
7395 
7396 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7397   verifyFormat(
7398       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7399       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7400   verifyFormat(
7401       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7402       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7403       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7404 
7405   // FIXME: Should we have the extra indent after the second break?
7406   verifyFormat(
7407       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7408       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7409       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7410 
7411   verifyFormat(
7412       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7413       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
7414 
7415   // Breaking at nested name specifiers is generally not desirable.
7416   verifyFormat(
7417       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7418       "    aaaaaaaaaaaaaaaaaaaaaaa);");
7419 
7420   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7421                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7422                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7423                "                   aaaaaaaaaaaaaaaaaaaaa);",
7424                getLLVMStyleWithColumns(74));
7425 
7426   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7427                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7428                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7429 }
7430 
7431 TEST_F(FormatTest, UnderstandsTemplateParameters) {
7432   verifyFormat("A<int> a;");
7433   verifyFormat("A<A<A<int>>> a;");
7434   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7435   verifyFormat("bool x = a < 1 || 2 > a;");
7436   verifyFormat("bool x = 5 < f<int>();");
7437   verifyFormat("bool x = f<int>() > 5;");
7438   verifyFormat("bool x = 5 < a<int>::x;");
7439   verifyFormat("bool x = a < 4 ? a > 2 : false;");
7440   verifyFormat("bool x = f() ? a < 2 : a > 2;");
7441 
7442   verifyGoogleFormat("A<A<int>> a;");
7443   verifyGoogleFormat("A<A<A<int>>> a;");
7444   verifyGoogleFormat("A<A<A<A<int>>>> a;");
7445   verifyGoogleFormat("A<A<int> > a;");
7446   verifyGoogleFormat("A<A<A<int> > > a;");
7447   verifyGoogleFormat("A<A<A<A<int> > > > a;");
7448   verifyGoogleFormat("A<::A<int>> a;");
7449   verifyGoogleFormat("A<::A> a;");
7450   verifyGoogleFormat("A< ::A> a;");
7451   verifyGoogleFormat("A< ::A<int> > a;");
7452   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7453   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7454   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7455   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7456   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7457             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7458 
7459   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7460 
7461   // template closer followed by a token that starts with > or =
7462   verifyFormat("bool b = a<1> > 1;");
7463   verifyFormat("bool b = a<1> >= 1;");
7464   verifyFormat("int i = a<1> >> 1;");
7465   FormatStyle Style = getLLVMStyle();
7466   Style.SpaceBeforeAssignmentOperators = false;
7467   verifyFormat("bool b= a<1> == 1;", Style);
7468   verifyFormat("a<int> = 1;", Style);
7469   verifyFormat("a<int> >>= 1;", Style);
7470 
7471   verifyFormat("test >> a >> b;");
7472   verifyFormat("test << a >> b;");
7473 
7474   verifyFormat("f<int>();");
7475   verifyFormat("template <typename T> void f() {}");
7476   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7477   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7478                "sizeof(char)>::type>;");
7479   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7480   verifyFormat("f(a.operator()<A>());");
7481   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7482                "      .template operator()<A>());",
7483                getLLVMStyleWithColumns(35));
7484 
7485   // Not template parameters.
7486   verifyFormat("return a < b && c > d;");
7487   verifyFormat("void f() {\n"
7488                "  while (a < b && c > d) {\n"
7489                "  }\n"
7490                "}");
7491   verifyFormat("template <typename... Types>\n"
7492                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7493 
7494   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7495                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7496                getLLVMStyleWithColumns(60));
7497   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7498   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7499   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7500 }
7501 
7502 TEST_F(FormatTest, BitshiftOperatorWidth) {
7503   EXPECT_EQ("int a = 1 << 2; /* foo\n"
7504             "                   bar */",
7505             format("int    a=1<<2;  /* foo\n"
7506                    "                   bar */"));
7507 
7508   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7509             "                     bar */",
7510             format("int  b  =256>>1 ;  /* foo\n"
7511                    "                      bar */"));
7512 }
7513 
7514 TEST_F(FormatTest, UnderstandsBinaryOperators) {
7515   verifyFormat("COMPARE(a, ==, b);");
7516   verifyFormat("auto s = sizeof...(Ts) - 1;");
7517 }
7518 
7519 TEST_F(FormatTest, UnderstandsPointersToMembers) {
7520   verifyFormat("int A::*x;");
7521   verifyFormat("int (S::*func)(void *);");
7522   verifyFormat("void f() { int (S::*func)(void *); }");
7523   verifyFormat("typedef bool *(Class::*Member)() const;");
7524   verifyFormat("void f() {\n"
7525                "  (a->*f)();\n"
7526                "  a->*x;\n"
7527                "  (a.*f)();\n"
7528                "  ((*a).*f)();\n"
7529                "  a.*x;\n"
7530                "}");
7531   verifyFormat("void f() {\n"
7532                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7533                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7534                "}");
7535   verifyFormat(
7536       "(aaaaaaaaaa->*bbbbbbb)(\n"
7537       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7538   FormatStyle Style = getLLVMStyle();
7539   Style.PointerAlignment = FormatStyle::PAS_Left;
7540   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7541 }
7542 
7543 TEST_F(FormatTest, UnderstandsUnaryOperators) {
7544   verifyFormat("int a = -2;");
7545   verifyFormat("f(-1, -2, -3);");
7546   verifyFormat("a[-1] = 5;");
7547   verifyFormat("int a = 5 + -2;");
7548   verifyFormat("if (i == -1) {\n}");
7549   verifyFormat("if (i != -1) {\n}");
7550   verifyFormat("if (i > -1) {\n}");
7551   verifyFormat("if (i < -1) {\n}");
7552   verifyFormat("++(a->f());");
7553   verifyFormat("--(a->f());");
7554   verifyFormat("(a->f())++;");
7555   verifyFormat("a[42]++;");
7556   verifyFormat("if (!(a->f())) {\n}");
7557   verifyFormat("if (!+i) {\n}");
7558   verifyFormat("~&a;");
7559 
7560   verifyFormat("a-- > b;");
7561   verifyFormat("b ? -a : c;");
7562   verifyFormat("n * sizeof char16;");
7563   verifyFormat("n * alignof char16;", getGoogleStyle());
7564   verifyFormat("sizeof(char);");
7565   verifyFormat("alignof(char);", getGoogleStyle());
7566 
7567   verifyFormat("return -1;");
7568   verifyFormat("throw -1;");
7569   verifyFormat("switch (a) {\n"
7570                "case -1:\n"
7571                "  break;\n"
7572                "}");
7573   verifyFormat("#define X -1");
7574   verifyFormat("#define X -kConstant");
7575 
7576   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7577   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7578 
7579   verifyFormat("int a = /* confusing comment */ -1;");
7580   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7581   verifyFormat("int a = i /* confusing comment */++;");
7582 
7583   verifyFormat("co_yield -1;");
7584   verifyFormat("co_return -1;");
7585 }
7586 
7587 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7588   verifyFormat("if (!aaaaaaaaaa( // break\n"
7589                "        aaaaa)) {\n"
7590                "}");
7591   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7592                "    aaaaa));");
7593   verifyFormat("*aaa = aaaaaaa( // break\n"
7594                "    bbbbbb);");
7595 }
7596 
7597 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7598   verifyFormat("bool operator<();");
7599   verifyFormat("bool operator>();");
7600   verifyFormat("bool operator=();");
7601   verifyFormat("bool operator==();");
7602   verifyFormat("bool operator!=();");
7603   verifyFormat("int operator+();");
7604   verifyFormat("int operator++();");
7605   verifyFormat("int operator++(int) volatile noexcept;");
7606   verifyFormat("bool operator,();");
7607   verifyFormat("bool operator();");
7608   verifyFormat("bool operator()();");
7609   verifyFormat("bool operator[]();");
7610   verifyFormat("operator bool();");
7611   verifyFormat("operator int();");
7612   verifyFormat("operator void *();");
7613   verifyFormat("operator SomeType<int>();");
7614   verifyFormat("operator SomeType<int, int>();");
7615   verifyFormat("operator SomeType<SomeType<int>>();");
7616   verifyFormat("void *operator new(std::size_t size);");
7617   verifyFormat("void *operator new[](std::size_t size);");
7618   verifyFormat("void operator delete(void *ptr);");
7619   verifyFormat("void operator delete[](void *ptr);");
7620   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7621                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7622   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7623                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7624 
7625   verifyFormat(
7626       "ostream &operator<<(ostream &OutputStream,\n"
7627       "                    SomeReallyLongType WithSomeReallyLongValue);");
7628   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7629                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7630                "  return left.group < right.group;\n"
7631                "}");
7632   verifyFormat("SomeType &operator=(const SomeType &S);");
7633   verifyFormat("f.template operator()<int>();");
7634 
7635   verifyGoogleFormat("operator void*();");
7636   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7637   verifyGoogleFormat("operator ::A();");
7638 
7639   verifyFormat("using A::operator+;");
7640   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7641                "int i;");
7642 }
7643 
7644 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7645   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7646   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7647   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7648   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7649   verifyFormat("Deleted &operator=(const Deleted &) &;");
7650   verifyFormat("Deleted &operator=(const Deleted &) &&;");
7651   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7652   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7653   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7654   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7655   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7656   verifyFormat("void Fn(T const &) const &;");
7657   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7658   verifyFormat("template <typename T>\n"
7659                "void F(T) && = delete;",
7660                getGoogleStyle());
7661 
7662   FormatStyle AlignLeft = getLLVMStyle();
7663   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7664   verifyFormat("void A::b() && {}", AlignLeft);
7665   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7666   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7667                AlignLeft);
7668   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7669   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7670   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7671   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7672   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7673   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7674   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7675   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7676 
7677   FormatStyle Spaces = getLLVMStyle();
7678   Spaces.SpacesInCStyleCastParentheses = true;
7679   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7680   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7681   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7682   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7683 
7684   Spaces.SpacesInCStyleCastParentheses = false;
7685   Spaces.SpacesInParentheses = true;
7686   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7687   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7688                Spaces);
7689   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7690   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7691 
7692   FormatStyle BreakTemplate = getLLVMStyle();
7693   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7694 
7695   verifyFormat("struct f {\n"
7696                "  template <class T>\n"
7697                "  int &foo(const std::string &str) &noexcept {}\n"
7698                "};",
7699                BreakTemplate);
7700 
7701   verifyFormat("struct f {\n"
7702                "  template <class T>\n"
7703                "  int &foo(const std::string &str) &&noexcept {}\n"
7704                "};",
7705                BreakTemplate);
7706 
7707   verifyFormat("struct f {\n"
7708                "  template <class T>\n"
7709                "  int &foo(const std::string &str) const &noexcept {}\n"
7710                "};",
7711                BreakTemplate);
7712 
7713   verifyFormat("struct f {\n"
7714                "  template <class T>\n"
7715                "  int &foo(const std::string &str) const &noexcept {}\n"
7716                "};",
7717                BreakTemplate);
7718 
7719   verifyFormat("struct f {\n"
7720                "  template <class T>\n"
7721                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
7722                "};",
7723                BreakTemplate);
7724 
7725   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7726   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7727       FormatStyle::BTDS_Yes;
7728   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7729 
7730   verifyFormat("struct f {\n"
7731                "  template <class T>\n"
7732                "  int& foo(const std::string& str) & noexcept {}\n"
7733                "};",
7734                AlignLeftBreakTemplate);
7735 
7736   verifyFormat("struct f {\n"
7737                "  template <class T>\n"
7738                "  int& foo(const std::string& str) && noexcept {}\n"
7739                "};",
7740                AlignLeftBreakTemplate);
7741 
7742   verifyFormat("struct f {\n"
7743                "  template <class T>\n"
7744                "  int& foo(const std::string& str) const& noexcept {}\n"
7745                "};",
7746                AlignLeftBreakTemplate);
7747 
7748   verifyFormat("struct f {\n"
7749                "  template <class T>\n"
7750                "  int& foo(const std::string& str) const&& noexcept {}\n"
7751                "};",
7752                AlignLeftBreakTemplate);
7753 
7754   verifyFormat("struct f {\n"
7755                "  template <class T>\n"
7756                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7757                "};",
7758                AlignLeftBreakTemplate);
7759 
7760   // The `&` in `Type&` should not be confused with a trailing `&` of
7761   // DEPRECATED(reason) member function.
7762   verifyFormat("struct f {\n"
7763                "  template <class T>\n"
7764                "  DEPRECATED(reason)\n"
7765                "  Type &foo(arguments) {}\n"
7766                "};",
7767                BreakTemplate);
7768 
7769   verifyFormat("struct f {\n"
7770                "  template <class T>\n"
7771                "  DEPRECATED(reason)\n"
7772                "  Type& foo(arguments) {}\n"
7773                "};",
7774                AlignLeftBreakTemplate);
7775 
7776   verifyFormat("void (*foopt)(int) = &func;");
7777 }
7778 
7779 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7780   verifyFormat("void f() {\n"
7781                "  A *a = new A;\n"
7782                "  A *a = new (placement) A;\n"
7783                "  delete a;\n"
7784                "  delete (A *)a;\n"
7785                "}");
7786   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7787                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7788   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7789                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7790                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7791   verifyFormat("delete[] h->p;");
7792 }
7793 
7794 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
7795   verifyFormat("int *f(int *a) {}");
7796   verifyFormat("int main(int argc, char **argv) {}");
7797   verifyFormat("Test::Test(int b) : a(b * b) {}");
7798   verifyIndependentOfContext("f(a, *a);");
7799   verifyFormat("void g() { f(*a); }");
7800   verifyIndependentOfContext("int a = b * 10;");
7801   verifyIndependentOfContext("int a = 10 * b;");
7802   verifyIndependentOfContext("int a = b * c;");
7803   verifyIndependentOfContext("int a += b * c;");
7804   verifyIndependentOfContext("int a -= b * c;");
7805   verifyIndependentOfContext("int a *= b * c;");
7806   verifyIndependentOfContext("int a /= b * c;");
7807   verifyIndependentOfContext("int a = *b;");
7808   verifyIndependentOfContext("int a = *b * c;");
7809   verifyIndependentOfContext("int a = b * *c;");
7810   verifyIndependentOfContext("int a = b * (10);");
7811   verifyIndependentOfContext("S << b * (10);");
7812   verifyIndependentOfContext("return 10 * b;");
7813   verifyIndependentOfContext("return *b * *c;");
7814   verifyIndependentOfContext("return a & ~b;");
7815   verifyIndependentOfContext("f(b ? *c : *d);");
7816   verifyIndependentOfContext("int a = b ? *c : *d;");
7817   verifyIndependentOfContext("*b = a;");
7818   verifyIndependentOfContext("a * ~b;");
7819   verifyIndependentOfContext("a * !b;");
7820   verifyIndependentOfContext("a * +b;");
7821   verifyIndependentOfContext("a * -b;");
7822   verifyIndependentOfContext("a * ++b;");
7823   verifyIndependentOfContext("a * --b;");
7824   verifyIndependentOfContext("a[4] * b;");
7825   verifyIndependentOfContext("a[a * a] = 1;");
7826   verifyIndependentOfContext("f() * b;");
7827   verifyIndependentOfContext("a * [self dostuff];");
7828   verifyIndependentOfContext("int x = a * (a + b);");
7829   verifyIndependentOfContext("(a *)(a + b);");
7830   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
7831   verifyIndependentOfContext("int *pa = (int *)&a;");
7832   verifyIndependentOfContext("return sizeof(int **);");
7833   verifyIndependentOfContext("return sizeof(int ******);");
7834   verifyIndependentOfContext("return (int **&)a;");
7835   verifyIndependentOfContext("f((*PointerToArray)[10]);");
7836   verifyFormat("void f(Type (*parameter)[10]) {}");
7837   verifyFormat("void f(Type (&parameter)[10]) {}");
7838   verifyGoogleFormat("return sizeof(int**);");
7839   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
7840   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
7841   verifyFormat("auto a = [](int **&, int ***) {};");
7842   verifyFormat("auto PointerBinding = [](const char *S) {};");
7843   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
7844   verifyFormat("[](const decltype(*a) &value) {}");
7845   verifyFormat("decltype(a * b) F();");
7846   verifyFormat("#define MACRO() [](A *a) { return 1; }");
7847   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
7848   verifyIndependentOfContext("typedef void (*f)(int *a);");
7849   verifyIndependentOfContext("int i{a * b};");
7850   verifyIndependentOfContext("aaa && aaa->f();");
7851   verifyIndependentOfContext("int x = ~*p;");
7852   verifyFormat("Constructor() : a(a), area(width * height) {}");
7853   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
7854   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
7855   verifyFormat("void f() { f(a, c * d); }");
7856   verifyFormat("void f() { f(new a(), c * d); }");
7857   verifyFormat("void f(const MyOverride &override);");
7858   verifyFormat("void f(const MyFinal &final);");
7859   verifyIndependentOfContext("bool a = f() && override.f();");
7860   verifyIndependentOfContext("bool a = f() && final.f();");
7861 
7862   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
7863 
7864   verifyIndependentOfContext("A<int *> a;");
7865   verifyIndependentOfContext("A<int **> a;");
7866   verifyIndependentOfContext("A<int *, int *> a;");
7867   verifyIndependentOfContext("A<int *[]> a;");
7868   verifyIndependentOfContext(
7869       "const char *const p = reinterpret_cast<const char *const>(q);");
7870   verifyIndependentOfContext("A<int **, int **> a;");
7871   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
7872   verifyFormat("for (char **a = b; *a; ++a) {\n}");
7873   verifyFormat("for (; a && b;) {\n}");
7874   verifyFormat("bool foo = true && [] { return false; }();");
7875 
7876   verifyFormat(
7877       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7878       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7879 
7880   verifyGoogleFormat("int const* a = &b;");
7881   verifyGoogleFormat("**outparam = 1;");
7882   verifyGoogleFormat("*outparam = a * b;");
7883   verifyGoogleFormat("int main(int argc, char** argv) {}");
7884   verifyGoogleFormat("A<int*> a;");
7885   verifyGoogleFormat("A<int**> a;");
7886   verifyGoogleFormat("A<int*, int*> a;");
7887   verifyGoogleFormat("A<int**, int**> a;");
7888   verifyGoogleFormat("f(b ? *c : *d);");
7889   verifyGoogleFormat("int a = b ? *c : *d;");
7890   verifyGoogleFormat("Type* t = **x;");
7891   verifyGoogleFormat("Type* t = *++*x;");
7892   verifyGoogleFormat("*++*x;");
7893   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
7894   verifyGoogleFormat("Type* t = x++ * y;");
7895   verifyGoogleFormat(
7896       "const char* const p = reinterpret_cast<const char* const>(q);");
7897   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
7898   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
7899   verifyGoogleFormat("template <typename T>\n"
7900                      "void f(int i = 0, SomeType** temps = NULL);");
7901 
7902   FormatStyle Left = getLLVMStyle();
7903   Left.PointerAlignment = FormatStyle::PAS_Left;
7904   verifyFormat("x = *a(x) = *a(y);", Left);
7905   verifyFormat("for (;; *a = b) {\n}", Left);
7906   verifyFormat("return *this += 1;", Left);
7907   verifyFormat("throw *x;", Left);
7908   verifyFormat("delete *x;", Left);
7909   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
7910   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
7911   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
7912   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
7913   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
7914   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
7915 
7916   verifyIndependentOfContext("a = *(x + y);");
7917   verifyIndependentOfContext("a = &(x + y);");
7918   verifyIndependentOfContext("*(x + y).call();");
7919   verifyIndependentOfContext("&(x + y)->call();");
7920   verifyFormat("void f() { &(*I).first; }");
7921 
7922   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
7923   verifyFormat(
7924       "int *MyValues = {\n"
7925       "    *A, // Operator detection might be confused by the '{'\n"
7926       "    *BB // Operator detection might be confused by previous comment\n"
7927       "};");
7928 
7929   verifyIndependentOfContext("if (int *a = &b)");
7930   verifyIndependentOfContext("if (int &a = *b)");
7931   verifyIndependentOfContext("if (a & b[i])");
7932   verifyIndependentOfContext("if constexpr (a & b[i])");
7933   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
7934   verifyIndependentOfContext("if (a * (b * c))");
7935   verifyIndependentOfContext("if constexpr (a * (b * c))");
7936   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
7937   verifyIndependentOfContext("if (a::b::c::d & b[i])");
7938   verifyIndependentOfContext("if (*b[i])");
7939   verifyIndependentOfContext("if (int *a = (&b))");
7940   verifyIndependentOfContext("while (int *a = &b)");
7941   verifyIndependentOfContext("while (a * (b * c))");
7942   verifyIndependentOfContext("size = sizeof *a;");
7943   verifyIndependentOfContext("if (a && (b = c))");
7944   verifyFormat("void f() {\n"
7945                "  for (const int &v : Values) {\n"
7946                "  }\n"
7947                "}");
7948   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
7949   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
7950   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
7951 
7952   verifyFormat("#define A (!a * b)");
7953   verifyFormat("#define MACRO     \\\n"
7954                "  int *i = a * b; \\\n"
7955                "  void f(a *b);",
7956                getLLVMStyleWithColumns(19));
7957 
7958   verifyIndependentOfContext("A = new SomeType *[Length];");
7959   verifyIndependentOfContext("A = new SomeType *[Length]();");
7960   verifyIndependentOfContext("T **t = new T *;");
7961   verifyIndependentOfContext("T **t = new T *();");
7962   verifyGoogleFormat("A = new SomeType*[Length]();");
7963   verifyGoogleFormat("A = new SomeType*[Length];");
7964   verifyGoogleFormat("T** t = new T*;");
7965   verifyGoogleFormat("T** t = new T*();");
7966 
7967   verifyFormat("STATIC_ASSERT((a & b) == 0);");
7968   verifyFormat("STATIC_ASSERT(0 == (a & b));");
7969   verifyFormat("template <bool a, bool b> "
7970                "typename t::if<x && y>::type f() {}");
7971   verifyFormat("template <int *y> f() {}");
7972   verifyFormat("vector<int *> v;");
7973   verifyFormat("vector<int *const> v;");
7974   verifyFormat("vector<int *const **const *> v;");
7975   verifyFormat("vector<int *volatile> v;");
7976   verifyFormat("vector<a * b> v;");
7977   verifyFormat("foo<b && false>();");
7978   verifyFormat("foo<b & 1>();");
7979   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
7980   verifyFormat(
7981       "template <class T, class = typename std::enable_if<\n"
7982       "                       std::is_integral<T>::value &&\n"
7983       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
7984       "void F();",
7985       getLLVMStyleWithColumns(70));
7986   verifyFormat("template <class T,\n"
7987                "          class = typename std::enable_if<\n"
7988                "              std::is_integral<T>::value &&\n"
7989                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
7990                "          class U>\n"
7991                "void F();",
7992                getLLVMStyleWithColumns(70));
7993   verifyFormat(
7994       "template <class T,\n"
7995       "          class = typename ::std::enable_if<\n"
7996       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
7997       "void F();",
7998       getGoogleStyleWithColumns(68));
7999 
8000   verifyIndependentOfContext("MACRO(int *i);");
8001   verifyIndependentOfContext("MACRO(auto *a);");
8002   verifyIndependentOfContext("MACRO(const A *a);");
8003   verifyIndependentOfContext("MACRO(A *const a);");
8004   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
8005   verifyFormat("void f() { f(float{1}, a * a); }");
8006   // FIXME: Is there a way to make this work?
8007   // verifyIndependentOfContext("MACRO(A *a);");
8008 
8009   verifyFormat("DatumHandle const *operator->() const { return input_; }");
8010   verifyFormat("return options != nullptr && operator==(*options);");
8011 
8012   EXPECT_EQ("#define OP(x)                                    \\\n"
8013             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
8014             "    return s << a.DebugString();                 \\\n"
8015             "  }",
8016             format("#define OP(x) \\\n"
8017                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
8018                    "    return s << a.DebugString(); \\\n"
8019                    "  }",
8020                    getLLVMStyleWithColumns(50)));
8021 
8022   // FIXME: We cannot handle this case yet; we might be able to figure out that
8023   // foo<x> d > v; doesn't make sense.
8024   verifyFormat("foo<a<b && c> d> v;");
8025 
8026   FormatStyle PointerMiddle = getLLVMStyle();
8027   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8028   verifyFormat("delete *x;", PointerMiddle);
8029   verifyFormat("int * x;", PointerMiddle);
8030   verifyFormat("int *[] x;", PointerMiddle);
8031   verifyFormat("template <int * y> f() {}", PointerMiddle);
8032   verifyFormat("int * f(int * a) {}", PointerMiddle);
8033   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8034   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8035   verifyFormat("A<int *> a;", PointerMiddle);
8036   verifyFormat("A<int **> a;", PointerMiddle);
8037   verifyFormat("A<int *, int *> a;", PointerMiddle);
8038   verifyFormat("A<int *[]> a;", PointerMiddle);
8039   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8040   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8041   verifyFormat("T ** t = new T *;", PointerMiddle);
8042 
8043   // Member function reference qualifiers aren't binary operators.
8044   verifyFormat("string // break\n"
8045                "operator()() & {}");
8046   verifyFormat("string // break\n"
8047                "operator()() && {}");
8048   verifyGoogleFormat("template <typename T>\n"
8049                      "auto x() & -> int {}");
8050 }
8051 
8052 TEST_F(FormatTest, UnderstandsAttributes) {
8053   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8054   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8055                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8056   FormatStyle AfterType = getLLVMStyle();
8057   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
8058   verifyFormat("__attribute__((nodebug)) void\n"
8059                "foo() {}\n",
8060                AfterType);
8061 }
8062 
8063 TEST_F(FormatTest, UnderstandsSquareAttributes) {
8064   verifyFormat("SomeType s [[unused]] (InitValue);");
8065   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8066   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8067   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8068   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8069   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8070                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8071   verifyFormat("[[nodiscard]] bool f() { return false; }");
8072   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
8073   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
8074   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
8075 
8076   // Make sure we do not mistake attributes for array subscripts.
8077   verifyFormat("int a() {}\n"
8078                "[[unused]] int b() {}\n");
8079   verifyFormat("NSArray *arr;\n"
8080                "arr[[Foo() bar]];");
8081 
8082   // On the other hand, we still need to correctly find array subscripts.
8083   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8084 
8085   // Make sure that we do not mistake Objective-C method inside array literals
8086   // as attributes, even if those method names are also keywords.
8087   verifyFormat("@[ [foo bar] ];");
8088   verifyFormat("@[ [NSArray class] ];");
8089   verifyFormat("@[ [foo enum] ];");
8090 
8091   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8092 
8093   // Make sure we do not parse attributes as lambda introducers.
8094   FormatStyle MultiLineFunctions = getLLVMStyle();
8095   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8096   verifyFormat("[[unused]] int b() {\n"
8097                "  return 42;\n"
8098                "}\n",
8099                MultiLineFunctions);
8100 }
8101 
8102 TEST_F(FormatTest, AttributeClass) {
8103   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8104   verifyFormat("class S {\n"
8105                "  S(S&&) = default;\n"
8106                "};",
8107                Style);
8108   verifyFormat("class [[nodiscard]] S {\n"
8109                "  S(S&&) = default;\n"
8110                "};",
8111                Style);
8112   verifyFormat("class __attribute((maybeunused)) S {\n"
8113                "  S(S&&) = default;\n"
8114                "};",
8115                Style);
8116   verifyFormat("struct S {\n"
8117                "  S(S&&) = default;\n"
8118                "};",
8119                Style);
8120   verifyFormat("struct [[nodiscard]] S {\n"
8121                "  S(S&&) = default;\n"
8122                "};",
8123                Style);
8124 }
8125 
8126 TEST_F(FormatTest, AttributesAfterMacro) {
8127   FormatStyle Style = getLLVMStyle();
8128   verifyFormat("MACRO;\n"
8129                "__attribute__((maybe_unused)) int foo() {\n"
8130                "  //...\n"
8131                "}");
8132 
8133   verifyFormat("MACRO;\n"
8134                "[[nodiscard]] int foo() {\n"
8135                "  //...\n"
8136                "}");
8137 
8138   EXPECT_EQ("MACRO\n\n"
8139             "__attribute__((maybe_unused)) int foo() {\n"
8140             "  //...\n"
8141             "}",
8142             format("MACRO\n\n"
8143                    "__attribute__((maybe_unused)) int foo() {\n"
8144                    "  //...\n"
8145                    "}"));
8146 
8147   EXPECT_EQ("MACRO\n\n"
8148             "[[nodiscard]] int foo() {\n"
8149             "  //...\n"
8150             "}",
8151             format("MACRO\n\n"
8152                    "[[nodiscard]] int foo() {\n"
8153                    "  //...\n"
8154                    "}"));
8155 }
8156 
8157 TEST_F(FormatTest, AttributePenaltyBreaking) {
8158   FormatStyle Style = getLLVMStyle();
8159   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8160                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8161                Style);
8162   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8163                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8164                Style);
8165   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8166                "shared_ptr<ALongTypeName> &C d) {\n}",
8167                Style);
8168 }
8169 
8170 TEST_F(FormatTest, UnderstandsEllipsis) {
8171   verifyFormat("int printf(const char *fmt, ...);");
8172   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8173   verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
8174 
8175   FormatStyle PointersLeft = getLLVMStyle();
8176   PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
8177   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
8178 }
8179 
8180 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8181   EXPECT_EQ("int *a;\n"
8182             "int *a;\n"
8183             "int *a;",
8184             format("int *a;\n"
8185                    "int* a;\n"
8186                    "int *a;",
8187                    getGoogleStyle()));
8188   EXPECT_EQ("int* a;\n"
8189             "int* a;\n"
8190             "int* a;",
8191             format("int* a;\n"
8192                    "int* a;\n"
8193                    "int *a;",
8194                    getGoogleStyle()));
8195   EXPECT_EQ("int *a;\n"
8196             "int *a;\n"
8197             "int *a;",
8198             format("int *a;\n"
8199                    "int * a;\n"
8200                    "int *  a;",
8201                    getGoogleStyle()));
8202   EXPECT_EQ("auto x = [] {\n"
8203             "  int *a;\n"
8204             "  int *a;\n"
8205             "  int *a;\n"
8206             "};",
8207             format("auto x=[]{int *a;\n"
8208                    "int * a;\n"
8209                    "int *  a;};",
8210                    getGoogleStyle()));
8211 }
8212 
8213 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8214   verifyFormat("int f(int &&a) {}");
8215   verifyFormat("int f(int a, char &&b) {}");
8216   verifyFormat("void f() { int &&a = b; }");
8217   verifyGoogleFormat("int f(int a, char&& b) {}");
8218   verifyGoogleFormat("void f() { int&& a = b; }");
8219 
8220   verifyIndependentOfContext("A<int &&> a;");
8221   verifyIndependentOfContext("A<int &&, int &&> a;");
8222   verifyGoogleFormat("A<int&&> a;");
8223   verifyGoogleFormat("A<int&&, int&&> a;");
8224 
8225   // Not rvalue references:
8226   verifyFormat("template <bool B, bool C> class A {\n"
8227                "  static_assert(B && C, \"Something is wrong\");\n"
8228                "};");
8229   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8230   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8231   verifyFormat("#define A(a, b) (a && b)");
8232 }
8233 
8234 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8235   verifyFormat("void f() {\n"
8236                "  x[aaaaaaaaa -\n"
8237                "    b] = 23;\n"
8238                "}",
8239                getLLVMStyleWithColumns(15));
8240 }
8241 
8242 TEST_F(FormatTest, FormatsCasts) {
8243   verifyFormat("Type *A = static_cast<Type *>(P);");
8244   verifyFormat("Type *A = (Type *)P;");
8245   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8246   verifyFormat("int a = (int)(2.0f);");
8247   verifyFormat("int a = (int)2.0f;");
8248   verifyFormat("x[(int32)y];");
8249   verifyFormat("x = (int32)y;");
8250   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8251   verifyFormat("int a = (int)*b;");
8252   verifyFormat("int a = (int)2.0f;");
8253   verifyFormat("int a = (int)~0;");
8254   verifyFormat("int a = (int)++a;");
8255   verifyFormat("int a = (int)sizeof(int);");
8256   verifyFormat("int a = (int)+2;");
8257   verifyFormat("my_int a = (my_int)2.0f;");
8258   verifyFormat("my_int a = (my_int)sizeof(int);");
8259   verifyFormat("return (my_int)aaa;");
8260   verifyFormat("#define x ((int)-1)");
8261   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8262   verifyFormat("#define p(q) ((int *)&q)");
8263   verifyFormat("fn(a)(b) + 1;");
8264 
8265   verifyFormat("void f() { my_int a = (my_int)*b; }");
8266   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8267   verifyFormat("my_int a = (my_int)~0;");
8268   verifyFormat("my_int a = (my_int)++a;");
8269   verifyFormat("my_int a = (my_int)-2;");
8270   verifyFormat("my_int a = (my_int)1;");
8271   verifyFormat("my_int a = (my_int *)1;");
8272   verifyFormat("my_int a = (const my_int)-1;");
8273   verifyFormat("my_int a = (const my_int *)-1;");
8274   verifyFormat("my_int a = (my_int)(my_int)-1;");
8275   verifyFormat("my_int a = (ns::my_int)-2;");
8276   verifyFormat("case (my_int)ONE:");
8277   verifyFormat("auto x = (X)this;");
8278   // Casts in Obj-C style calls used to not be recognized as such.
8279   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8280 
8281   // FIXME: single value wrapped with paren will be treated as cast.
8282   verifyFormat("void f(int i = (kValue)*kMask) {}");
8283 
8284   verifyFormat("{ (void)F; }");
8285 
8286   // Don't break after a cast's
8287   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8288                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8289                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8290 
8291   // These are not casts.
8292   verifyFormat("void f(int *) {}");
8293   verifyFormat("f(foo)->b;");
8294   verifyFormat("f(foo).b;");
8295   verifyFormat("f(foo)(b);");
8296   verifyFormat("f(foo)[b];");
8297   verifyFormat("[](foo) { return 4; }(bar);");
8298   verifyFormat("(*funptr)(foo)[4];");
8299   verifyFormat("funptrs[4](foo)[4];");
8300   verifyFormat("void f(int *);");
8301   verifyFormat("void f(int *) = 0;");
8302   verifyFormat("void f(SmallVector<int>) {}");
8303   verifyFormat("void f(SmallVector<int>);");
8304   verifyFormat("void f(SmallVector<int>) = 0;");
8305   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8306   verifyFormat("int a = sizeof(int) * b;");
8307   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8308   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8309   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8310   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8311 
8312   // These are not casts, but at some point were confused with casts.
8313   verifyFormat("virtual void foo(int *) override;");
8314   verifyFormat("virtual void foo(char &) const;");
8315   verifyFormat("virtual void foo(int *a, char *) const;");
8316   verifyFormat("int a = sizeof(int *) + b;");
8317   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8318   verifyFormat("bool b = f(g<int>) && c;");
8319   verifyFormat("typedef void (*f)(int i) func;");
8320   verifyFormat("void operator++(int) noexcept;");
8321   verifyFormat("void operator++(int &) noexcept;");
8322   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8323                "&) noexcept;");
8324   verifyFormat(
8325       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8326   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8327   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8328   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8329   verifyFormat("void operator delete(foo &) noexcept;");
8330   verifyFormat("void operator delete(foo) noexcept;");
8331   verifyFormat("void operator delete(int) noexcept;");
8332   verifyFormat("void operator delete(int &) noexcept;");
8333   verifyFormat("void operator delete(int &) volatile noexcept;");
8334   verifyFormat("void operator delete(int &) const");
8335   verifyFormat("void operator delete(int &) = default");
8336   verifyFormat("void operator delete(int &) = delete");
8337   verifyFormat("void operator delete(int &) [[noreturn]]");
8338   verifyFormat("void operator delete(int &) throw();");
8339   verifyFormat("void operator delete(int &) throw(int);");
8340   verifyFormat("auto operator delete(int &) -> int;");
8341   verifyFormat("auto operator delete(int &) override");
8342   verifyFormat("auto operator delete(int &) final");
8343 
8344   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8345                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8346   // FIXME: The indentation here is not ideal.
8347   verifyFormat(
8348       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8349       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8350       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8351 }
8352 
8353 TEST_F(FormatTest, FormatsFunctionTypes) {
8354   verifyFormat("A<bool()> a;");
8355   verifyFormat("A<SomeType()> a;");
8356   verifyFormat("A<void (*)(int, std::string)> a;");
8357   verifyFormat("A<void *(int)>;");
8358   verifyFormat("void *(*a)(int *, SomeType *);");
8359   verifyFormat("int (*func)(void *);");
8360   verifyFormat("void f() { int (*func)(void *); }");
8361   verifyFormat("template <class CallbackClass>\n"
8362                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8363 
8364   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8365   verifyGoogleFormat("void* (*a)(int);");
8366   verifyGoogleFormat(
8367       "template <class CallbackClass>\n"
8368       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8369 
8370   // Other constructs can look somewhat like function types:
8371   verifyFormat("A<sizeof(*x)> a;");
8372   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8373   verifyFormat("some_var = function(*some_pointer_var)[0];");
8374   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8375   verifyFormat("int x = f(&h)();");
8376   verifyFormat("returnsFunction(&param1, &param2)(param);");
8377   verifyFormat("std::function<\n"
8378                "    LooooooooooongTemplatedType<\n"
8379                "        SomeType>*(\n"
8380                "        LooooooooooooooooongType type)>\n"
8381                "    function;",
8382                getGoogleStyleWithColumns(40));
8383 }
8384 
8385 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8386   verifyFormat("A (*foo_)[6];");
8387   verifyFormat("vector<int> (*foo_)[6];");
8388 }
8389 
8390 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8391   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8392                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8393   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8394                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8395   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8396                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8397 
8398   // Different ways of ()-initializiation.
8399   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8400                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8401   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8402                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8403   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8404                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8405   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8406                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8407 
8408   // Lambdas should not confuse the variable declaration heuristic.
8409   verifyFormat("LooooooooooooooooongType\n"
8410                "    variable(nullptr, [](A *a) {});",
8411                getLLVMStyleWithColumns(40));
8412 }
8413 
8414 TEST_F(FormatTest, BreaksLongDeclarations) {
8415   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8416                "    AnotherNameForTheLongType;");
8417   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8418                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8419   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8420                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8421   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8422                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8423   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8424                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8425   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8426                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8427   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8428                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8429   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8430                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8431   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8432                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8433   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8434                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8435   FormatStyle Indented = getLLVMStyle();
8436   Indented.IndentWrappedFunctionNames = true;
8437   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8438                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8439                Indented);
8440   verifyFormat(
8441       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8442       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8443       Indented);
8444   verifyFormat(
8445       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8446       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8447       Indented);
8448   verifyFormat(
8449       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8450       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8451       Indented);
8452 
8453   // FIXME: Without the comment, this breaks after "(".
8454   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8455                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8456                getGoogleStyle());
8457 
8458   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8459                "                  int LoooooooooooooooooooongParam2) {}");
8460   verifyFormat(
8461       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8462       "                                   SourceLocation L, IdentifierIn *II,\n"
8463       "                                   Type *T) {}");
8464   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8465                "ReallyReaaallyLongFunctionName(\n"
8466                "    const std::string &SomeParameter,\n"
8467                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8468                "        &ReallyReallyLongParameterName,\n"
8469                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8470                "        &AnotherLongParameterName) {}");
8471   verifyFormat("template <typename A>\n"
8472                "SomeLoooooooooooooooooooooongType<\n"
8473                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8474                "Function() {}");
8475 
8476   verifyGoogleFormat(
8477       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8478       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8479   verifyGoogleFormat(
8480       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8481       "                                   SourceLocation L) {}");
8482   verifyGoogleFormat(
8483       "some_namespace::LongReturnType\n"
8484       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8485       "    int first_long_parameter, int second_parameter) {}");
8486 
8487   verifyGoogleFormat("template <typename T>\n"
8488                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8489                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8490   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8491                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8492 
8493   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8494                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8495                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8496   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8497                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8498                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8499   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8500                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8501                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8502                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8503 
8504   verifyFormat("template <typename T> // Templates on own line.\n"
8505                "static int            // Some comment.\n"
8506                "MyFunction(int a);",
8507                getLLVMStyle());
8508 }
8509 
8510 TEST_F(FormatTest, FormatsArrays) {
8511   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8512                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8513   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8514                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8515   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8516                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8517   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8518                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8519   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8520                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8521   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8522                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8523                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8524   verifyFormat(
8525       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8526       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8527       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8528   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8529                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8530 
8531   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8532                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8533   verifyFormat(
8534       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8535       "                                  .aaaaaaa[0]\n"
8536       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8537   verifyFormat("a[::b::c];");
8538 
8539   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8540 
8541   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8542   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8543 }
8544 
8545 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8546   verifyFormat("(a)->b();");
8547   verifyFormat("--a;");
8548 }
8549 
8550 TEST_F(FormatTest, HandlesIncludeDirectives) {
8551   verifyFormat("#include <string>\n"
8552                "#include <a/b/c.h>\n"
8553                "#include \"a/b/string\"\n"
8554                "#include \"string.h\"\n"
8555                "#include \"string.h\"\n"
8556                "#include <a-a>\n"
8557                "#include < path with space >\n"
8558                "#include_next <test.h>"
8559                "#include \"abc.h\" // this is included for ABC\n"
8560                "#include \"some long include\" // with a comment\n"
8561                "#include \"some very long include path\"\n"
8562                "#include <some/very/long/include/path>\n",
8563                getLLVMStyleWithColumns(35));
8564   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8565   EXPECT_EQ("#include <a>", format("#include<a>"));
8566 
8567   verifyFormat("#import <string>");
8568   verifyFormat("#import <a/b/c.h>");
8569   verifyFormat("#import \"a/b/string\"");
8570   verifyFormat("#import \"string.h\"");
8571   verifyFormat("#import \"string.h\"");
8572   verifyFormat("#if __has_include(<strstream>)\n"
8573                "#include <strstream>\n"
8574                "#endif");
8575 
8576   verifyFormat("#define MY_IMPORT <a/b>");
8577 
8578   verifyFormat("#if __has_include(<a/b>)");
8579   verifyFormat("#if __has_include_next(<a/b>)");
8580   verifyFormat("#define F __has_include(<a/b>)");
8581   verifyFormat("#define F __has_include_next(<a/b>)");
8582 
8583   // Protocol buffer definition or missing "#".
8584   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8585                getLLVMStyleWithColumns(30));
8586 
8587   FormatStyle Style = getLLVMStyle();
8588   Style.AlwaysBreakBeforeMultilineStrings = true;
8589   Style.ColumnLimit = 0;
8590   verifyFormat("#import \"abc.h\"", Style);
8591 
8592   // But 'import' might also be a regular C++ namespace.
8593   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8594                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8595 }
8596 
8597 //===----------------------------------------------------------------------===//
8598 // Error recovery tests.
8599 //===----------------------------------------------------------------------===//
8600 
8601 TEST_F(FormatTest, IncompleteParameterLists) {
8602   FormatStyle NoBinPacking = getLLVMStyle();
8603   NoBinPacking.BinPackParameters = false;
8604   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8605                "                        double *min_x,\n"
8606                "                        double *max_x,\n"
8607                "                        double *min_y,\n"
8608                "                        double *max_y,\n"
8609                "                        double *min_z,\n"
8610                "                        double *max_z, ) {}",
8611                NoBinPacking);
8612 }
8613 
8614 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8615   verifyFormat("void f() { return; }\n42");
8616   verifyFormat("void f() {\n"
8617                "  if (0)\n"
8618                "    return;\n"
8619                "}\n"
8620                "42");
8621   verifyFormat("void f() { return }\n42");
8622   verifyFormat("void f() {\n"
8623                "  if (0)\n"
8624                "    return\n"
8625                "}\n"
8626                "42");
8627 }
8628 
8629 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
8630   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
8631   EXPECT_EQ("void f() {\n"
8632             "  if (a)\n"
8633             "    return\n"
8634             "}",
8635             format("void  f  (  )  {  if  ( a )  return  }"));
8636   EXPECT_EQ("namespace N {\n"
8637             "void f()\n"
8638             "}",
8639             format("namespace  N  {  void f()  }"));
8640   EXPECT_EQ("namespace N {\n"
8641             "void f() {}\n"
8642             "void g()\n"
8643             "} // namespace N",
8644             format("namespace N  { void f( ) { } void g( ) }"));
8645 }
8646 
8647 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
8648   verifyFormat("int aaaaaaaa =\n"
8649                "    // Overlylongcomment\n"
8650                "    b;",
8651                getLLVMStyleWithColumns(20));
8652   verifyFormat("function(\n"
8653                "    ShortArgument,\n"
8654                "    LoooooooooooongArgument);\n",
8655                getLLVMStyleWithColumns(20));
8656 }
8657 
8658 TEST_F(FormatTest, IncorrectAccessSpecifier) {
8659   verifyFormat("public:");
8660   verifyFormat("class A {\n"
8661                "public\n"
8662                "  void f() {}\n"
8663                "};");
8664   verifyFormat("public\n"
8665                "int qwerty;");
8666   verifyFormat("public\n"
8667                "B {}");
8668   verifyFormat("public\n"
8669                "{}");
8670   verifyFormat("public\n"
8671                "B { int x; }");
8672 }
8673 
8674 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
8675   verifyFormat("{");
8676   verifyFormat("#})");
8677   verifyNoCrash("(/**/[:!] ?[).");
8678 }
8679 
8680 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
8681   // Found by oss-fuzz:
8682   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
8683   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
8684   Style.ColumnLimit = 60;
8685   verifyNoCrash(
8686       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
8687       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
8688       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
8689       Style);
8690 }
8691 
8692 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
8693   verifyFormat("do {\n}");
8694   verifyFormat("do {\n}\n"
8695                "f();");
8696   verifyFormat("do {\n}\n"
8697                "wheeee(fun);");
8698   verifyFormat("do {\n"
8699                "  f();\n"
8700                "}");
8701 }
8702 
8703 TEST_F(FormatTest, IncorrectCodeMissingParens) {
8704   verifyFormat("if {\n  foo;\n  foo();\n}");
8705   verifyFormat("switch {\n  foo;\n  foo();\n}");
8706   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
8707   verifyFormat("while {\n  foo;\n  foo();\n}");
8708   verifyFormat("do {\n  foo;\n  foo();\n} while;");
8709 }
8710 
8711 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
8712   verifyIncompleteFormat("namespace {\n"
8713                          "class Foo { Foo (\n"
8714                          "};\n"
8715                          "} // namespace");
8716 }
8717 
8718 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
8719   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
8720   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
8721   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
8722   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
8723 
8724   EXPECT_EQ("{\n"
8725             "  {\n"
8726             "    breakme(\n"
8727             "        qwe);\n"
8728             "  }\n",
8729             format("{\n"
8730                    "    {\n"
8731                    " breakme(qwe);\n"
8732                    "}\n",
8733                    getLLVMStyleWithColumns(10)));
8734 }
8735 
8736 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
8737   verifyFormat("int x = {\n"
8738                "    avariable,\n"
8739                "    b(alongervariable)};",
8740                getLLVMStyleWithColumns(25));
8741 }
8742 
8743 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
8744   verifyFormat("return (a)(b){1, 2, 3};");
8745 }
8746 
8747 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
8748   verifyFormat("vector<int> x{1, 2, 3, 4};");
8749   verifyFormat("vector<int> x{\n"
8750                "    1,\n"
8751                "    2,\n"
8752                "    3,\n"
8753                "    4,\n"
8754                "};");
8755   verifyFormat("vector<T> x{{}, {}, {}, {}};");
8756   verifyFormat("f({1, 2});");
8757   verifyFormat("auto v = Foo{-1};");
8758   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
8759   verifyFormat("Class::Class : member{1, 2, 3} {}");
8760   verifyFormat("new vector<int>{1, 2, 3};");
8761   verifyFormat("new int[3]{1, 2, 3};");
8762   verifyFormat("new int{1};");
8763   verifyFormat("return {arg1, arg2};");
8764   verifyFormat("return {arg1, SomeType{parameter}};");
8765   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
8766   verifyFormat("new T{arg1, arg2};");
8767   verifyFormat("f(MyMap[{composite, key}]);");
8768   verifyFormat("class Class {\n"
8769                "  T member = {arg1, arg2};\n"
8770                "};");
8771   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
8772   verifyFormat("const struct A a = {.a = 1, .b = 2};");
8773   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
8774   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
8775   verifyFormat("int a = std::is_integral<int>{} + 0;");
8776 
8777   verifyFormat("int foo(int i) { return fo1{}(i); }");
8778   verifyFormat("int foo(int i) { return fo1{}(i); }");
8779   verifyFormat("auto i = decltype(x){};");
8780   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
8781   verifyFormat("Node n{1, Node{1000}, //\n"
8782                "       2};");
8783   verifyFormat("Aaaa aaaaaaa{\n"
8784                "    {\n"
8785                "        aaaa,\n"
8786                "    },\n"
8787                "};");
8788   verifyFormat("class C : public D {\n"
8789                "  SomeClass SC{2};\n"
8790                "};");
8791   verifyFormat("class C : public A {\n"
8792                "  class D : public B {\n"
8793                "    void f() { int i{2}; }\n"
8794                "  };\n"
8795                "};");
8796   verifyFormat("#define A {a, a},");
8797 
8798   // Avoid breaking between equal sign and opening brace
8799   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
8800   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
8801   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
8802                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
8803                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
8804                "     {\"ccccccccccccccccccccc\", 2}};",
8805                AvoidBreakingFirstArgument);
8806 
8807   // Binpacking only if there is no trailing comma
8808   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
8809                "                      cccccccccc, dddddddddd};",
8810                getLLVMStyleWithColumns(50));
8811   verifyFormat("const Aaaaaa aaaaa = {\n"
8812                "    aaaaaaaaaaa,\n"
8813                "    bbbbbbbbbbb,\n"
8814                "    ccccccccccc,\n"
8815                "    ddddddddddd,\n"
8816                "};",
8817                getLLVMStyleWithColumns(50));
8818 
8819   // Cases where distinguising braced lists and blocks is hard.
8820   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
8821   verifyFormat("void f() {\n"
8822                "  return; // comment\n"
8823                "}\n"
8824                "SomeType t;");
8825   verifyFormat("void f() {\n"
8826                "  if (a) {\n"
8827                "    f();\n"
8828                "  }\n"
8829                "}\n"
8830                "SomeType t;");
8831 
8832   // In combination with BinPackArguments = false.
8833   FormatStyle NoBinPacking = getLLVMStyle();
8834   NoBinPacking.BinPackArguments = false;
8835   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
8836                "                      bbbbb,\n"
8837                "                      ccccc,\n"
8838                "                      ddddd,\n"
8839                "                      eeeee,\n"
8840                "                      ffffff,\n"
8841                "                      ggggg,\n"
8842                "                      hhhhhh,\n"
8843                "                      iiiiii,\n"
8844                "                      jjjjjj,\n"
8845                "                      kkkkkk};",
8846                NoBinPacking);
8847   verifyFormat("const Aaaaaa aaaaa = {\n"
8848                "    aaaaa,\n"
8849                "    bbbbb,\n"
8850                "    ccccc,\n"
8851                "    ddddd,\n"
8852                "    eeeee,\n"
8853                "    ffffff,\n"
8854                "    ggggg,\n"
8855                "    hhhhhh,\n"
8856                "    iiiiii,\n"
8857                "    jjjjjj,\n"
8858                "    kkkkkk,\n"
8859                "};",
8860                NoBinPacking);
8861   verifyFormat(
8862       "const Aaaaaa aaaaa = {\n"
8863       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
8864       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
8865       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
8866       "};",
8867       NoBinPacking);
8868 
8869   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
8870   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
8871             "    CDDDP83848_BMCR_REGISTER,\n"
8872             "    CDDDP83848_BMSR_REGISTER,\n"
8873             "    CDDDP83848_RBR_REGISTER};",
8874             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
8875                    "                                CDDDP83848_BMSR_REGISTER,\n"
8876                    "                                CDDDP83848_RBR_REGISTER};",
8877                    NoBinPacking));
8878 
8879   // FIXME: The alignment of these trailing comments might be bad. Then again,
8880   // this might be utterly useless in real code.
8881   verifyFormat("Constructor::Constructor()\n"
8882                "    : some_value{         //\n"
8883                "                 aaaaaaa, //\n"
8884                "                 bbbbbbb} {}");
8885 
8886   // In braced lists, the first comment is always assumed to belong to the
8887   // first element. Thus, it can be moved to the next or previous line as
8888   // appropriate.
8889   EXPECT_EQ("function({// First element:\n"
8890             "          1,\n"
8891             "          // Second element:\n"
8892             "          2});",
8893             format("function({\n"
8894                    "    // First element:\n"
8895                    "    1,\n"
8896                    "    // Second element:\n"
8897                    "    2});"));
8898   EXPECT_EQ("std::vector<int> MyNumbers{\n"
8899             "    // First element:\n"
8900             "    1,\n"
8901             "    // Second element:\n"
8902             "    2};",
8903             format("std::vector<int> MyNumbers{// First element:\n"
8904                    "                           1,\n"
8905                    "                           // Second element:\n"
8906                    "                           2};",
8907                    getLLVMStyleWithColumns(30)));
8908   // A trailing comma should still lead to an enforced line break and no
8909   // binpacking.
8910   EXPECT_EQ("vector<int> SomeVector = {\n"
8911             "    // aaa\n"
8912             "    1,\n"
8913             "    2,\n"
8914             "};",
8915             format("vector<int> SomeVector = { // aaa\n"
8916                    "    1, 2, };"));
8917 
8918   // C++11 brace initializer list l-braces should not be treated any differently
8919   // when breaking before lambda bodies is enabled
8920   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
8921   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
8922   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
8923   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
8924   verifyFormat(
8925       "std::runtime_error{\n"
8926       "    \"Long string which will force a break onto the next line...\"};",
8927       BreakBeforeLambdaBody);
8928 
8929   FormatStyle ExtraSpaces = getLLVMStyle();
8930   ExtraSpaces.Cpp11BracedListStyle = false;
8931   ExtraSpaces.ColumnLimit = 75;
8932   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
8933   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
8934   verifyFormat("f({ 1, 2 });", ExtraSpaces);
8935   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
8936   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
8937   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
8938   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
8939   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
8940   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
8941   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
8942   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
8943   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
8944   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
8945   verifyFormat("class Class {\n"
8946                "  T member = { arg1, arg2 };\n"
8947                "};",
8948                ExtraSpaces);
8949   verifyFormat(
8950       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8951       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
8952       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
8953       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
8954       ExtraSpaces);
8955   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
8956   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
8957                ExtraSpaces);
8958   verifyFormat(
8959       "someFunction(OtherParam,\n"
8960       "             BracedList{ // comment 1 (Forcing interesting break)\n"
8961       "                         param1, param2,\n"
8962       "                         // comment 2\n"
8963       "                         param3, param4 });",
8964       ExtraSpaces);
8965   verifyFormat(
8966       "std::this_thread::sleep_for(\n"
8967       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
8968       ExtraSpaces);
8969   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
8970                "    aaaaaaa,\n"
8971                "    aaaaaaaaaa,\n"
8972                "    aaaaa,\n"
8973                "    aaaaaaaaaaaaaaa,\n"
8974                "    aaa,\n"
8975                "    aaaaaaaaaa,\n"
8976                "    a,\n"
8977                "    aaaaaaaaaaaaaaaaaaaaa,\n"
8978                "    aaaaaaaaaaaa,\n"
8979                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
8980                "    aaaaaaa,\n"
8981                "    a};");
8982   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
8983   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
8984   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
8985 
8986   // Avoid breaking between initializer/equal sign and opening brace
8987   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
8988   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
8989                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
8990                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
8991                "  { \"ccccccccccccccccccccc\", 2 }\n"
8992                "};",
8993                ExtraSpaces);
8994   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
8995                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
8996                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
8997                "  { \"ccccccccccccccccccccc\", 2 }\n"
8998                "};",
8999                ExtraSpaces);
9000 
9001   FormatStyle SpaceBeforeBrace = getLLVMStyle();
9002   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9003   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9004   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9005 
9006   FormatStyle SpaceBetweenBraces = getLLVMStyle();
9007   SpaceBetweenBraces.SpacesInAngles = true;
9008   SpaceBetweenBraces.SpacesInParentheses = true;
9009   SpaceBetweenBraces.SpacesInSquareBrackets = true;
9010   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9011   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9012   verifyFormat("vector< int > x{ // comment 1\n"
9013                "                 1, 2, 3, 4 };",
9014                SpaceBetweenBraces);
9015   SpaceBetweenBraces.ColumnLimit = 20;
9016   EXPECT_EQ("vector< int > x{\n"
9017             "    1, 2, 3, 4 };",
9018             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9019   SpaceBetweenBraces.ColumnLimit = 24;
9020   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9021             "                 3, 4 };",
9022             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9023   EXPECT_EQ("vector< int > x{\n"
9024             "    1,\n"
9025             "    2,\n"
9026             "    3,\n"
9027             "    4,\n"
9028             "};",
9029             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9030   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9031   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9032   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9033 }
9034 
9035 TEST_F(FormatTest, FormatSpacesInAngles) {
9036   FormatStyle SpaceInAngles = getLLVMStyle();
9037   SpaceInAngles.SpacesInAngles = true;
9038   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9039   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9040   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9041 
9042   SpaceInAngles.SpacesInAngles = false;
9043   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9044   verifyFormat("vector<int> x5;", SpaceInAngles);
9045   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9046   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9047 }
9048 
9049 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9050   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9051                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9052                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9053                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9054                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9055                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9056   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9057                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9058                "                 1, 22, 333, 4444, 55555, //\n"
9059                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9060                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9061   verifyFormat(
9062       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9063       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9064       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9065       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9066       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9067       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9068       "                 7777777};");
9069   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9070                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9071                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9072   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9073                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9074                "    // Separating comment.\n"
9075                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9076   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9077                "    // Leading comment\n"
9078                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9079                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9080   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9081                "                 1, 1, 1, 1};",
9082                getLLVMStyleWithColumns(39));
9083   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9084                "                 1, 1, 1, 1};",
9085                getLLVMStyleWithColumns(38));
9086   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9087                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9088                getLLVMStyleWithColumns(43));
9089   verifyFormat(
9090       "static unsigned SomeValues[10][3] = {\n"
9091       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9092       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9093   verifyFormat("static auto fields = new vector<string>{\n"
9094                "    \"aaaaaaaaaaaaa\",\n"
9095                "    \"aaaaaaaaaaaaa\",\n"
9096                "    \"aaaaaaaaaaaa\",\n"
9097                "    \"aaaaaaaaaaaaaa\",\n"
9098                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9099                "    \"aaaaaaaaaaaa\",\n"
9100                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9101                "};");
9102   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9103   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9104                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9105                "                 3, cccccccccccccccccccccc};",
9106                getLLVMStyleWithColumns(60));
9107 
9108   // Trailing commas.
9109   verifyFormat("vector<int> x = {\n"
9110                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9111                "};",
9112                getLLVMStyleWithColumns(39));
9113   verifyFormat("vector<int> x = {\n"
9114                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9115                "};",
9116                getLLVMStyleWithColumns(39));
9117   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9118                "                 1, 1, 1, 1,\n"
9119                "                 /**/ /**/};",
9120                getLLVMStyleWithColumns(39));
9121 
9122   // Trailing comment in the first line.
9123   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9124                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9125                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9126                "    11111111,   22222222,   333333333,   44444444};");
9127   // Trailing comment in the last line.
9128   verifyFormat("int aaaaa[] = {\n"
9129                "    1, 2, 3, // comment\n"
9130                "    4, 5, 6  // comment\n"
9131                "};");
9132 
9133   // With nested lists, we should either format one item per line or all nested
9134   // lists one on line.
9135   // FIXME: For some nested lists, we can do better.
9136   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9137                "        {aaaaaaaaaaaaaaaaaaa},\n"
9138                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9139                "        {aaaaaaaaaaaaaaaaa}};",
9140                getLLVMStyleWithColumns(60));
9141   verifyFormat(
9142       "SomeStruct my_struct_array = {\n"
9143       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9144       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9145       "    {aaa, aaa},\n"
9146       "    {aaa, aaa},\n"
9147       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9148       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9149       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9150 
9151   // No column layout should be used here.
9152   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9153                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9154 
9155   verifyNoCrash("a<,");
9156 
9157   // No braced initializer here.
9158   verifyFormat("void f() {\n"
9159                "  struct Dummy {};\n"
9160                "  f(v);\n"
9161                "}");
9162 
9163   // Long lists should be formatted in columns even if they are nested.
9164   verifyFormat(
9165       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9166       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9167       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9168       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9169       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9170       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9171 
9172   // Allow "single-column" layout even if that violates the column limit. There
9173   // isn't going to be a better way.
9174   verifyFormat("std::vector<int> a = {\n"
9175                "    aaaaaaaa,\n"
9176                "    aaaaaaaa,\n"
9177                "    aaaaaaaa,\n"
9178                "    aaaaaaaa,\n"
9179                "    aaaaaaaaaa,\n"
9180                "    aaaaaaaa,\n"
9181                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9182                getLLVMStyleWithColumns(30));
9183   verifyFormat("vector<int> aaaa = {\n"
9184                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9185                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9186                "    aaaaaa.aaaaaaa,\n"
9187                "    aaaaaa.aaaaaaa,\n"
9188                "    aaaaaa.aaaaaaa,\n"
9189                "    aaaaaa.aaaaaaa,\n"
9190                "};");
9191 
9192   // Don't create hanging lists.
9193   verifyFormat("someFunction(Param, {List1, List2,\n"
9194                "                     List3});",
9195                getLLVMStyleWithColumns(35));
9196   verifyFormat("someFunction(Param, Param,\n"
9197                "             {List1, List2,\n"
9198                "              List3});",
9199                getLLVMStyleWithColumns(35));
9200   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9201                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9202 }
9203 
9204 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9205   FormatStyle DoNotMerge = getLLVMStyle();
9206   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9207 
9208   verifyFormat("void f() { return 42; }");
9209   verifyFormat("void f() {\n"
9210                "  return 42;\n"
9211                "}",
9212                DoNotMerge);
9213   verifyFormat("void f() {\n"
9214                "  // Comment\n"
9215                "}");
9216   verifyFormat("{\n"
9217                "#error {\n"
9218                "  int a;\n"
9219                "}");
9220   verifyFormat("{\n"
9221                "  int a;\n"
9222                "#error {\n"
9223                "}");
9224   verifyFormat("void f() {} // comment");
9225   verifyFormat("void f() { int a; } // comment");
9226   verifyFormat("void f() {\n"
9227                "} // comment",
9228                DoNotMerge);
9229   verifyFormat("void f() {\n"
9230                "  int a;\n"
9231                "} // comment",
9232                DoNotMerge);
9233   verifyFormat("void f() {\n"
9234                "} // comment",
9235                getLLVMStyleWithColumns(15));
9236 
9237   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9238   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9239 
9240   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9241   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9242   verifyFormat("class C {\n"
9243                "  C()\n"
9244                "      : iiiiiiii(nullptr),\n"
9245                "        kkkkkkk(nullptr),\n"
9246                "        mmmmmmm(nullptr),\n"
9247                "        nnnnnnn(nullptr) {}\n"
9248                "};",
9249                getGoogleStyle());
9250 
9251   FormatStyle NoColumnLimit = getLLVMStyle();
9252   NoColumnLimit.ColumnLimit = 0;
9253   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9254   EXPECT_EQ("class C {\n"
9255             "  A() : b(0) {}\n"
9256             "};",
9257             format("class C{A():b(0){}};", NoColumnLimit));
9258   EXPECT_EQ("A()\n"
9259             "    : b(0) {\n"
9260             "}",
9261             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9262 
9263   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9264   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9265       FormatStyle::SFS_None;
9266   EXPECT_EQ("A()\n"
9267             "    : b(0) {\n"
9268             "}",
9269             format("A():b(0){}", DoNotMergeNoColumnLimit));
9270   EXPECT_EQ("A()\n"
9271             "    : b(0) {\n"
9272             "}",
9273             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9274 
9275   verifyFormat("#define A          \\\n"
9276                "  void f() {       \\\n"
9277                "    int i;         \\\n"
9278                "  }",
9279                getLLVMStyleWithColumns(20));
9280   verifyFormat("#define A           \\\n"
9281                "  void f() { int i; }",
9282                getLLVMStyleWithColumns(21));
9283   verifyFormat("#define A            \\\n"
9284                "  void f() {         \\\n"
9285                "    int i;           \\\n"
9286                "  }                  \\\n"
9287                "  int j;",
9288                getLLVMStyleWithColumns(22));
9289   verifyFormat("#define A             \\\n"
9290                "  void f() { int i; } \\\n"
9291                "  int j;",
9292                getLLVMStyleWithColumns(23));
9293 }
9294 
9295 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9296   FormatStyle MergeEmptyOnly = getLLVMStyle();
9297   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9298   verifyFormat("class C {\n"
9299                "  int f() {}\n"
9300                "};",
9301                MergeEmptyOnly);
9302   verifyFormat("class C {\n"
9303                "  int f() {\n"
9304                "    return 42;\n"
9305                "  }\n"
9306                "};",
9307                MergeEmptyOnly);
9308   verifyFormat("int f() {}", MergeEmptyOnly);
9309   verifyFormat("int f() {\n"
9310                "  return 42;\n"
9311                "}",
9312                MergeEmptyOnly);
9313 
9314   // Also verify behavior when BraceWrapping.AfterFunction = true
9315   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9316   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9317   verifyFormat("int f() {}", MergeEmptyOnly);
9318   verifyFormat("class C {\n"
9319                "  int f() {}\n"
9320                "};",
9321                MergeEmptyOnly);
9322 }
9323 
9324 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9325   FormatStyle MergeInlineOnly = getLLVMStyle();
9326   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9327   verifyFormat("class C {\n"
9328                "  int f() { return 42; }\n"
9329                "};",
9330                MergeInlineOnly);
9331   verifyFormat("int f() {\n"
9332                "  return 42;\n"
9333                "}",
9334                MergeInlineOnly);
9335 
9336   // SFS_Inline implies SFS_Empty
9337   verifyFormat("class C {\n"
9338                "  int f() {}\n"
9339                "};",
9340                MergeInlineOnly);
9341   verifyFormat("int f() {}", MergeInlineOnly);
9342 
9343   // Also verify behavior when BraceWrapping.AfterFunction = true
9344   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9345   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9346   verifyFormat("class C {\n"
9347                "  int f() { return 42; }\n"
9348                "};",
9349                MergeInlineOnly);
9350   verifyFormat("int f()\n"
9351                "{\n"
9352                "  return 42;\n"
9353                "}",
9354                MergeInlineOnly);
9355 
9356   // SFS_Inline implies SFS_Empty
9357   verifyFormat("int f() {}", MergeInlineOnly);
9358   verifyFormat("class C {\n"
9359                "  int f() {}\n"
9360                "};",
9361                MergeInlineOnly);
9362 }
9363 
9364 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9365   FormatStyle MergeInlineOnly = getLLVMStyle();
9366   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9367       FormatStyle::SFS_InlineOnly;
9368   verifyFormat("class C {\n"
9369                "  int f() { return 42; }\n"
9370                "};",
9371                MergeInlineOnly);
9372   verifyFormat("int f() {\n"
9373                "  return 42;\n"
9374                "}",
9375                MergeInlineOnly);
9376 
9377   // SFS_InlineOnly does not imply SFS_Empty
9378   verifyFormat("class C {\n"
9379                "  int f() {}\n"
9380                "};",
9381                MergeInlineOnly);
9382   verifyFormat("int f() {\n"
9383                "}",
9384                MergeInlineOnly);
9385 
9386   // Also verify behavior when BraceWrapping.AfterFunction = true
9387   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9388   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9389   verifyFormat("class C {\n"
9390                "  int f() { return 42; }\n"
9391                "};",
9392                MergeInlineOnly);
9393   verifyFormat("int f()\n"
9394                "{\n"
9395                "  return 42;\n"
9396                "}",
9397                MergeInlineOnly);
9398 
9399   // SFS_InlineOnly does not imply SFS_Empty
9400   verifyFormat("int f()\n"
9401                "{\n"
9402                "}",
9403                MergeInlineOnly);
9404   verifyFormat("class C {\n"
9405                "  int f() {}\n"
9406                "};",
9407                MergeInlineOnly);
9408 }
9409 
9410 TEST_F(FormatTest, SplitEmptyFunction) {
9411   FormatStyle Style = getLLVMStyle();
9412   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9413   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9414   Style.BraceWrapping.AfterFunction = true;
9415   Style.BraceWrapping.SplitEmptyFunction = false;
9416   Style.ColumnLimit = 40;
9417 
9418   verifyFormat("int f()\n"
9419                "{}",
9420                Style);
9421   verifyFormat("int f()\n"
9422                "{\n"
9423                "  return 42;\n"
9424                "}",
9425                Style);
9426   verifyFormat("int f()\n"
9427                "{\n"
9428                "  // some comment\n"
9429                "}",
9430                Style);
9431 
9432   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9433   verifyFormat("int f() {}", Style);
9434   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9435                "{}",
9436                Style);
9437   verifyFormat("int f()\n"
9438                "{\n"
9439                "  return 0;\n"
9440                "}",
9441                Style);
9442 
9443   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9444   verifyFormat("class Foo {\n"
9445                "  int f() {}\n"
9446                "};\n",
9447                Style);
9448   verifyFormat("class Foo {\n"
9449                "  int f() { return 0; }\n"
9450                "};\n",
9451                Style);
9452   verifyFormat("class Foo {\n"
9453                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9454                "  {}\n"
9455                "};\n",
9456                Style);
9457   verifyFormat("class Foo {\n"
9458                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9459                "  {\n"
9460                "    return 0;\n"
9461                "  }\n"
9462                "};\n",
9463                Style);
9464 
9465   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9466   verifyFormat("int f() {}", Style);
9467   verifyFormat("int f() { return 0; }", Style);
9468   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9469                "{}",
9470                Style);
9471   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9472                "{\n"
9473                "  return 0;\n"
9474                "}",
9475                Style);
9476 }
9477 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9478   FormatStyle Style = getLLVMStyle();
9479   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9480   verifyFormat("#ifdef A\n"
9481                "int f() {}\n"
9482                "#else\n"
9483                "int g() {}\n"
9484                "#endif",
9485                Style);
9486 }
9487 
9488 TEST_F(FormatTest, SplitEmptyClass) {
9489   FormatStyle Style = getLLVMStyle();
9490   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9491   Style.BraceWrapping.AfterClass = true;
9492   Style.BraceWrapping.SplitEmptyRecord = false;
9493 
9494   verifyFormat("class Foo\n"
9495                "{};",
9496                Style);
9497   verifyFormat("/* something */ class Foo\n"
9498                "{};",
9499                Style);
9500   verifyFormat("template <typename X> class Foo\n"
9501                "{};",
9502                Style);
9503   verifyFormat("class Foo\n"
9504                "{\n"
9505                "  Foo();\n"
9506                "};",
9507                Style);
9508   verifyFormat("typedef class Foo\n"
9509                "{\n"
9510                "} Foo_t;",
9511                Style);
9512 }
9513 
9514 TEST_F(FormatTest, SplitEmptyStruct) {
9515   FormatStyle Style = getLLVMStyle();
9516   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9517   Style.BraceWrapping.AfterStruct = true;
9518   Style.BraceWrapping.SplitEmptyRecord = false;
9519 
9520   verifyFormat("struct Foo\n"
9521                "{};",
9522                Style);
9523   verifyFormat("/* something */ struct Foo\n"
9524                "{};",
9525                Style);
9526   verifyFormat("template <typename X> struct Foo\n"
9527                "{};",
9528                Style);
9529   verifyFormat("struct Foo\n"
9530                "{\n"
9531                "  Foo();\n"
9532                "};",
9533                Style);
9534   verifyFormat("typedef struct Foo\n"
9535                "{\n"
9536                "} Foo_t;",
9537                Style);
9538   // typedef struct Bar {} Bar_t;
9539 }
9540 
9541 TEST_F(FormatTest, SplitEmptyUnion) {
9542   FormatStyle Style = getLLVMStyle();
9543   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9544   Style.BraceWrapping.AfterUnion = true;
9545   Style.BraceWrapping.SplitEmptyRecord = false;
9546 
9547   verifyFormat("union Foo\n"
9548                "{};",
9549                Style);
9550   verifyFormat("/* something */ union Foo\n"
9551                "{};",
9552                Style);
9553   verifyFormat("union Foo\n"
9554                "{\n"
9555                "  A,\n"
9556                "};",
9557                Style);
9558   verifyFormat("typedef union Foo\n"
9559                "{\n"
9560                "} Foo_t;",
9561                Style);
9562 }
9563 
9564 TEST_F(FormatTest, SplitEmptyNamespace) {
9565   FormatStyle Style = getLLVMStyle();
9566   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9567   Style.BraceWrapping.AfterNamespace = true;
9568   Style.BraceWrapping.SplitEmptyNamespace = false;
9569 
9570   verifyFormat("namespace Foo\n"
9571                "{};",
9572                Style);
9573   verifyFormat("/* something */ namespace Foo\n"
9574                "{};",
9575                Style);
9576   verifyFormat("inline namespace Foo\n"
9577                "{};",
9578                Style);
9579   verifyFormat("/* something */ inline namespace Foo\n"
9580                "{};",
9581                Style);
9582   verifyFormat("export namespace Foo\n"
9583                "{};",
9584                Style);
9585   verifyFormat("namespace Foo\n"
9586                "{\n"
9587                "void Bar();\n"
9588                "};",
9589                Style);
9590 }
9591 
9592 TEST_F(FormatTest, NeverMergeShortRecords) {
9593   FormatStyle Style = getLLVMStyle();
9594 
9595   verifyFormat("class Foo {\n"
9596                "  Foo();\n"
9597                "};",
9598                Style);
9599   verifyFormat("typedef class Foo {\n"
9600                "  Foo();\n"
9601                "} Foo_t;",
9602                Style);
9603   verifyFormat("struct Foo {\n"
9604                "  Foo();\n"
9605                "};",
9606                Style);
9607   verifyFormat("typedef struct Foo {\n"
9608                "  Foo();\n"
9609                "} Foo_t;",
9610                Style);
9611   verifyFormat("union Foo {\n"
9612                "  A,\n"
9613                "};",
9614                Style);
9615   verifyFormat("typedef union Foo {\n"
9616                "  A,\n"
9617                "} Foo_t;",
9618                Style);
9619   verifyFormat("namespace Foo {\n"
9620                "void Bar();\n"
9621                "};",
9622                Style);
9623 
9624   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9625   Style.BraceWrapping.AfterClass = true;
9626   Style.BraceWrapping.AfterStruct = true;
9627   Style.BraceWrapping.AfterUnion = true;
9628   Style.BraceWrapping.AfterNamespace = true;
9629   verifyFormat("class Foo\n"
9630                "{\n"
9631                "  Foo();\n"
9632                "};",
9633                Style);
9634   verifyFormat("typedef class Foo\n"
9635                "{\n"
9636                "  Foo();\n"
9637                "} Foo_t;",
9638                Style);
9639   verifyFormat("struct Foo\n"
9640                "{\n"
9641                "  Foo();\n"
9642                "};",
9643                Style);
9644   verifyFormat("typedef struct Foo\n"
9645                "{\n"
9646                "  Foo();\n"
9647                "} Foo_t;",
9648                Style);
9649   verifyFormat("union Foo\n"
9650                "{\n"
9651                "  A,\n"
9652                "};",
9653                Style);
9654   verifyFormat("typedef union Foo\n"
9655                "{\n"
9656                "  A,\n"
9657                "} Foo_t;",
9658                Style);
9659   verifyFormat("namespace Foo\n"
9660                "{\n"
9661                "void Bar();\n"
9662                "};",
9663                Style);
9664 }
9665 
9666 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
9667   // Elaborate type variable declarations.
9668   verifyFormat("struct foo a = {bar};\nint n;");
9669   verifyFormat("class foo a = {bar};\nint n;");
9670   verifyFormat("union foo a = {bar};\nint n;");
9671 
9672   // Elaborate types inside function definitions.
9673   verifyFormat("struct foo f() {}\nint n;");
9674   verifyFormat("class foo f() {}\nint n;");
9675   verifyFormat("union foo f() {}\nint n;");
9676 
9677   // Templates.
9678   verifyFormat("template <class X> void f() {}\nint n;");
9679   verifyFormat("template <struct X> void f() {}\nint n;");
9680   verifyFormat("template <union X> void f() {}\nint n;");
9681 
9682   // Actual definitions...
9683   verifyFormat("struct {\n} n;");
9684   verifyFormat(
9685       "template <template <class T, class Y>, class Z> class X {\n} n;");
9686   verifyFormat("union Z {\n  int n;\n} x;");
9687   verifyFormat("class MACRO Z {\n} n;");
9688   verifyFormat("class MACRO(X) Z {\n} n;");
9689   verifyFormat("class __attribute__(X) Z {\n} n;");
9690   verifyFormat("class __declspec(X) Z {\n} n;");
9691   verifyFormat("class A##B##C {\n} n;");
9692   verifyFormat("class alignas(16) Z {\n} n;");
9693   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
9694   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
9695 
9696   // Redefinition from nested context:
9697   verifyFormat("class A::B::C {\n} n;");
9698 
9699   // Template definitions.
9700   verifyFormat(
9701       "template <typename F>\n"
9702       "Matcher(const Matcher<F> &Other,\n"
9703       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
9704       "                             !is_same<F, T>::value>::type * = 0)\n"
9705       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
9706 
9707   // FIXME: This is still incorrectly handled at the formatter side.
9708   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
9709   verifyFormat("int i = SomeFunction(a<b, a> b);");
9710 
9711   // FIXME:
9712   // This now gets parsed incorrectly as class definition.
9713   // verifyFormat("class A<int> f() {\n}\nint n;");
9714 
9715   // Elaborate types where incorrectly parsing the structural element would
9716   // break the indent.
9717   verifyFormat("if (true)\n"
9718                "  class X x;\n"
9719                "else\n"
9720                "  f();\n");
9721 
9722   // This is simply incomplete. Formatting is not important, but must not crash.
9723   verifyFormat("class A:");
9724 }
9725 
9726 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
9727   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
9728             format("#error Leave     all         white!!!!! space* alone!\n"));
9729   EXPECT_EQ(
9730       "#warning Leave     all         white!!!!! space* alone!\n",
9731       format("#warning Leave     all         white!!!!! space* alone!\n"));
9732   EXPECT_EQ("#error 1", format("  #  error   1"));
9733   EXPECT_EQ("#warning 1", format("  #  warning 1"));
9734 }
9735 
9736 TEST_F(FormatTest, FormatHashIfExpressions) {
9737   verifyFormat("#if AAAA && BBBB");
9738   verifyFormat("#if (AAAA && BBBB)");
9739   verifyFormat("#elif (AAAA && BBBB)");
9740   // FIXME: Come up with a better indentation for #elif.
9741   verifyFormat(
9742       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
9743       "    defined(BBBBBBBB)\n"
9744       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
9745       "    defined(BBBBBBBB)\n"
9746       "#endif",
9747       getLLVMStyleWithColumns(65));
9748 }
9749 
9750 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
9751   FormatStyle AllowsMergedIf = getGoogleStyle();
9752   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
9753       FormatStyle::SIS_WithoutElse;
9754   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
9755   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
9756   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
9757   EXPECT_EQ("if (true) return 42;",
9758             format("if (true)\nreturn 42;", AllowsMergedIf));
9759   FormatStyle ShortMergedIf = AllowsMergedIf;
9760   ShortMergedIf.ColumnLimit = 25;
9761   verifyFormat("#define A \\\n"
9762                "  if (true) return 42;",
9763                ShortMergedIf);
9764   verifyFormat("#define A \\\n"
9765                "  f();    \\\n"
9766                "  if (true)\n"
9767                "#define B",
9768                ShortMergedIf);
9769   verifyFormat("#define A \\\n"
9770                "  f();    \\\n"
9771                "  if (true)\n"
9772                "g();",
9773                ShortMergedIf);
9774   verifyFormat("{\n"
9775                "#ifdef A\n"
9776                "  // Comment\n"
9777                "  if (true) continue;\n"
9778                "#endif\n"
9779                "  // Comment\n"
9780                "  if (true) continue;\n"
9781                "}",
9782                ShortMergedIf);
9783   ShortMergedIf.ColumnLimit = 33;
9784   verifyFormat("#define A \\\n"
9785                "  if constexpr (true) return 42;",
9786                ShortMergedIf);
9787   verifyFormat("#define A \\\n"
9788                "  if CONSTEXPR (true) return 42;",
9789                ShortMergedIf);
9790   ShortMergedIf.ColumnLimit = 29;
9791   verifyFormat("#define A                   \\\n"
9792                "  if (aaaaaaaaaa) return 1; \\\n"
9793                "  return 2;",
9794                ShortMergedIf);
9795   ShortMergedIf.ColumnLimit = 28;
9796   verifyFormat("#define A         \\\n"
9797                "  if (aaaaaaaaaa) \\\n"
9798                "    return 1;     \\\n"
9799                "  return 2;",
9800                ShortMergedIf);
9801   verifyFormat("#define A                \\\n"
9802                "  if constexpr (aaaaaaa) \\\n"
9803                "    return 1;            \\\n"
9804                "  return 2;",
9805                ShortMergedIf);
9806   verifyFormat("#define A                \\\n"
9807                "  if CONSTEXPR (aaaaaaa) \\\n"
9808                "    return 1;            \\\n"
9809                "  return 2;",
9810                ShortMergedIf);
9811 }
9812 
9813 TEST_F(FormatTest, FormatStarDependingOnContext) {
9814   verifyFormat("void f(int *a);");
9815   verifyFormat("void f() { f(fint * b); }");
9816   verifyFormat("class A {\n  void f(int *a);\n};");
9817   verifyFormat("class A {\n  int *a;\n};");
9818   verifyFormat("namespace a {\n"
9819                "namespace b {\n"
9820                "class A {\n"
9821                "  void f() {}\n"
9822                "  int *a;\n"
9823                "};\n"
9824                "} // namespace b\n"
9825                "} // namespace a");
9826 }
9827 
9828 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
9829   verifyFormat("while");
9830   verifyFormat("operator");
9831 }
9832 
9833 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
9834   // This code would be painfully slow to format if we didn't skip it.
9835   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
9836                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9837                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9838                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9839                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9840                    "A(1, 1)\n"
9841                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
9842                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9843                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9844                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9845                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9846                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9847                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9848                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9849                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9850                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
9851   // Deeply nested part is untouched, rest is formatted.
9852   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
9853             format(std::string("int    i;\n") + Code + "int    j;\n",
9854                    getLLVMStyle(), SC_ExpectIncomplete));
9855 }
9856 
9857 //===----------------------------------------------------------------------===//
9858 // Objective-C tests.
9859 //===----------------------------------------------------------------------===//
9860 
9861 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
9862   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
9863   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
9864             format("-(NSUInteger)indexOfObject:(id)anObject;"));
9865   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
9866   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
9867   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
9868             format("-(NSInteger)Method3:(id)anObject;"));
9869   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
9870             format("-(NSInteger)Method4:(id)anObject;"));
9871   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
9872             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
9873   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
9874             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
9875   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9876             "forAllCells:(BOOL)flag;",
9877             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9878                    "forAllCells:(BOOL)flag;"));
9879 
9880   // Very long objectiveC method declaration.
9881   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
9882                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
9883   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
9884                "                    inRange:(NSRange)range\n"
9885                "                   outRange:(NSRange)out_range\n"
9886                "                  outRange1:(NSRange)out_range1\n"
9887                "                  outRange2:(NSRange)out_range2\n"
9888                "                  outRange3:(NSRange)out_range3\n"
9889                "                  outRange4:(NSRange)out_range4\n"
9890                "                  outRange5:(NSRange)out_range5\n"
9891                "                  outRange6:(NSRange)out_range6\n"
9892                "                  outRange7:(NSRange)out_range7\n"
9893                "                  outRange8:(NSRange)out_range8\n"
9894                "                  outRange9:(NSRange)out_range9;");
9895 
9896   // When the function name has to be wrapped.
9897   FormatStyle Style = getLLVMStyle();
9898   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
9899   // and always indents instead.
9900   Style.IndentWrappedFunctionNames = false;
9901   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9902                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
9903                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
9904                "}",
9905                Style);
9906   Style.IndentWrappedFunctionNames = true;
9907   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9908                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
9909                "               anotherName:(NSString)dddddddddddddd {\n"
9910                "}",
9911                Style);
9912 
9913   verifyFormat("- (int)sum:(vector<int>)numbers;");
9914   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
9915   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
9916   // protocol lists (but not for template classes):
9917   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
9918 
9919   verifyFormat("- (int (*)())foo:(int (*)())f;");
9920   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
9921 
9922   // If there's no return type (very rare in practice!), LLVM and Google style
9923   // agree.
9924   verifyFormat("- foo;");
9925   verifyFormat("- foo:(int)f;");
9926   verifyGoogleFormat("- foo:(int)foo;");
9927 }
9928 
9929 TEST_F(FormatTest, BreaksStringLiterals) {
9930   EXPECT_EQ("\"some text \"\n"
9931             "\"other\";",
9932             format("\"some text other\";", getLLVMStyleWithColumns(12)));
9933   EXPECT_EQ("\"some text \"\n"
9934             "\"other\";",
9935             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
9936   EXPECT_EQ(
9937       "#define A  \\\n"
9938       "  \"some \"  \\\n"
9939       "  \"text \"  \\\n"
9940       "  \"other\";",
9941       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
9942   EXPECT_EQ(
9943       "#define A  \\\n"
9944       "  \"so \"    \\\n"
9945       "  \"text \"  \\\n"
9946       "  \"other\";",
9947       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
9948 
9949   EXPECT_EQ("\"some text\"",
9950             format("\"some text\"", getLLVMStyleWithColumns(1)));
9951   EXPECT_EQ("\"some text\"",
9952             format("\"some text\"", getLLVMStyleWithColumns(11)));
9953   EXPECT_EQ("\"some \"\n"
9954             "\"text\"",
9955             format("\"some text\"", getLLVMStyleWithColumns(10)));
9956   EXPECT_EQ("\"some \"\n"
9957             "\"text\"",
9958             format("\"some text\"", getLLVMStyleWithColumns(7)));
9959   EXPECT_EQ("\"some\"\n"
9960             "\" tex\"\n"
9961             "\"t\"",
9962             format("\"some text\"", getLLVMStyleWithColumns(6)));
9963   EXPECT_EQ("\"some\"\n"
9964             "\" tex\"\n"
9965             "\" and\"",
9966             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
9967   EXPECT_EQ("\"some\"\n"
9968             "\"/tex\"\n"
9969             "\"/and\"",
9970             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
9971 
9972   EXPECT_EQ("variable =\n"
9973             "    \"long string \"\n"
9974             "    \"literal\";",
9975             format("variable = \"long string literal\";",
9976                    getLLVMStyleWithColumns(20)));
9977 
9978   EXPECT_EQ("variable = f(\n"
9979             "    \"long string \"\n"
9980             "    \"literal\",\n"
9981             "    short,\n"
9982             "    loooooooooooooooooooong);",
9983             format("variable = f(\"long string literal\", short, "
9984                    "loooooooooooooooooooong);",
9985                    getLLVMStyleWithColumns(20)));
9986 
9987   EXPECT_EQ(
9988       "f(g(\"long string \"\n"
9989       "    \"literal\"),\n"
9990       "  b);",
9991       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
9992   EXPECT_EQ("f(g(\"long string \"\n"
9993             "    \"literal\",\n"
9994             "    a),\n"
9995             "  b);",
9996             format("f(g(\"long string literal\", a), b);",
9997                    getLLVMStyleWithColumns(20)));
9998   EXPECT_EQ(
9999       "f(\"one two\".split(\n"
10000       "    variable));",
10001       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10002   EXPECT_EQ("f(\"one two three four five six \"\n"
10003             "  \"seven\".split(\n"
10004             "      really_looooong_variable));",
10005             format("f(\"one two three four five six seven\"."
10006                    "split(really_looooong_variable));",
10007                    getLLVMStyleWithColumns(33)));
10008 
10009   EXPECT_EQ("f(\"some \"\n"
10010             "  \"text\",\n"
10011             "  other);",
10012             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10013 
10014   // Only break as a last resort.
10015   verifyFormat(
10016       "aaaaaaaaaaaaaaaaaaaa(\n"
10017       "    aaaaaaaaaaaaaaaaaaaa,\n"
10018       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10019 
10020   EXPECT_EQ("\"splitmea\"\n"
10021             "\"trandomp\"\n"
10022             "\"oint\"",
10023             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10024 
10025   EXPECT_EQ("\"split/\"\n"
10026             "\"pathat/\"\n"
10027             "\"slashes\"",
10028             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10029 
10030   EXPECT_EQ("\"split/\"\n"
10031             "\"pathat/\"\n"
10032             "\"slashes\"",
10033             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10034   EXPECT_EQ("\"split at \"\n"
10035             "\"spaces/at/\"\n"
10036             "\"slashes.at.any$\"\n"
10037             "\"non-alphanumeric%\"\n"
10038             "\"1111111111characte\"\n"
10039             "\"rs\"",
10040             format("\"split at "
10041                    "spaces/at/"
10042                    "slashes.at."
10043                    "any$non-"
10044                    "alphanumeric%"
10045                    "1111111111characte"
10046                    "rs\"",
10047                    getLLVMStyleWithColumns(20)));
10048 
10049   // Verify that splitting the strings understands
10050   // Style::AlwaysBreakBeforeMultilineStrings.
10051   EXPECT_EQ("aaaaaaaaaaaa(\n"
10052             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10053             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10054             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10055                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10056                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10057                    getGoogleStyle()));
10058   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10059             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10060             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10061                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10062                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10063                    getGoogleStyle()));
10064   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10065             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10066             format("llvm::outs() << "
10067                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10068                    "aaaaaaaaaaaaaaaaaaa\";"));
10069   EXPECT_EQ("ffff(\n"
10070             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10071             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10072             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10073                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10074                    getGoogleStyle()));
10075 
10076   FormatStyle Style = getLLVMStyleWithColumns(12);
10077   Style.BreakStringLiterals = false;
10078   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10079 
10080   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10081   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10082   EXPECT_EQ("#define A \\\n"
10083             "  \"some \" \\\n"
10084             "  \"text \" \\\n"
10085             "  \"other\";",
10086             format("#define A \"some text other\";", AlignLeft));
10087 }
10088 
10089 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10090   EXPECT_EQ("C a = \"some more \"\n"
10091             "      \"text\";",
10092             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10093 }
10094 
10095 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10096   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10097   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10098   EXPECT_EQ("int i = a(b());",
10099             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10100 }
10101 
10102 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10103   EXPECT_EQ(
10104       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10105       "(\n"
10106       "    \"x\t\");",
10107       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10108              "aaaaaaa("
10109              "\"x\t\");"));
10110 }
10111 
10112 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10113   EXPECT_EQ(
10114       "u8\"utf8 string \"\n"
10115       "u8\"literal\";",
10116       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10117   EXPECT_EQ(
10118       "u\"utf16 string \"\n"
10119       "u\"literal\";",
10120       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10121   EXPECT_EQ(
10122       "U\"utf32 string \"\n"
10123       "U\"literal\";",
10124       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10125   EXPECT_EQ("L\"wide string \"\n"
10126             "L\"literal\";",
10127             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10128   EXPECT_EQ("@\"NSString \"\n"
10129             "@\"literal\";",
10130             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10131   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10132 
10133   // This input makes clang-format try to split the incomplete unicode escape
10134   // sequence, which used to lead to a crasher.
10135   verifyNoCrash(
10136       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10137       getLLVMStyleWithColumns(60));
10138 }
10139 
10140 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10141   FormatStyle Style = getGoogleStyleWithColumns(15);
10142   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10143   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10144   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10145   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10146   EXPECT_EQ("u8R\"x(raw literal)x\";",
10147             format("u8R\"x(raw literal)x\";", Style));
10148 }
10149 
10150 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10151   FormatStyle Style = getLLVMStyleWithColumns(20);
10152   EXPECT_EQ(
10153       "_T(\"aaaaaaaaaaaaaa\")\n"
10154       "_T(\"aaaaaaaaaaaaaa\")\n"
10155       "_T(\"aaaaaaaaaaaa\")",
10156       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10157   EXPECT_EQ("f(x,\n"
10158             "  _T(\"aaaaaaaaaaaa\")\n"
10159             "  _T(\"aaa\"),\n"
10160             "  z);",
10161             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10162 
10163   // FIXME: Handle embedded spaces in one iteration.
10164   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10165   //            "_T(\"aaaaaaaaaaaaa\")\n"
10166   //            "_T(\"aaaaaaaaaaaaa\")\n"
10167   //            "_T(\"a\")",
10168   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10169   //                   getLLVMStyleWithColumns(20)));
10170   EXPECT_EQ(
10171       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10172       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10173   EXPECT_EQ("f(\n"
10174             "#if !TEST\n"
10175             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10176             "#endif\n"
10177             ");",
10178             format("f(\n"
10179                    "#if !TEST\n"
10180                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10181                    "#endif\n"
10182                    ");"));
10183   EXPECT_EQ("f(\n"
10184             "\n"
10185             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10186             format("f(\n"
10187                    "\n"
10188                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10189 }
10190 
10191 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10192   // In a function call with two operands, the second can be broken with no line
10193   // break before it.
10194   EXPECT_EQ(
10195       "func(a, \"long long \"\n"
10196       "        \"long long\");",
10197       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10198   // In a function call with three operands, the second must be broken with a
10199   // line break before it.
10200   EXPECT_EQ("func(a,\n"
10201             "     \"long long long \"\n"
10202             "     \"long\",\n"
10203             "     c);",
10204             format("func(a, \"long long long long\", c);",
10205                    getLLVMStyleWithColumns(24)));
10206   // In a function call with three operands, the third must be broken with a
10207   // line break before it.
10208   EXPECT_EQ("func(a, b,\n"
10209             "     \"long long long \"\n"
10210             "     \"long\");",
10211             format("func(a, b, \"long long long long\");",
10212                    getLLVMStyleWithColumns(24)));
10213   // In a function call with three operands, both the second and the third must
10214   // be broken with a line break before them.
10215   EXPECT_EQ("func(a,\n"
10216             "     \"long long long \"\n"
10217             "     \"long\",\n"
10218             "     \"long long long \"\n"
10219             "     \"long\");",
10220             format("func(a, \"long long long long\", \"long long long long\");",
10221                    getLLVMStyleWithColumns(24)));
10222   // In a chain of << with two operands, the second can be broken with no line
10223   // break before it.
10224   EXPECT_EQ("a << \"line line \"\n"
10225             "     \"line\";",
10226             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10227   // In a chain of << with three operands, the second can be broken with no line
10228   // break before it.
10229   EXPECT_EQ(
10230       "abcde << \"line \"\n"
10231       "         \"line line\"\n"
10232       "      << c;",
10233       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10234   // In a chain of << with three operands, the third must be broken with a line
10235   // break before it.
10236   EXPECT_EQ(
10237       "a << b\n"
10238       "  << \"line line \"\n"
10239       "     \"line\";",
10240       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10241   // In a chain of << with three operands, the second can be broken with no line
10242   // break before it and the third must be broken with a line break before it.
10243   EXPECT_EQ("abcd << \"line line \"\n"
10244             "        \"line\"\n"
10245             "     << \"line line \"\n"
10246             "        \"line\";",
10247             format("abcd << \"line line line\" << \"line line line\";",
10248                    getLLVMStyleWithColumns(20)));
10249   // In a chain of binary operators with two operands, the second can be broken
10250   // with no line break before it.
10251   EXPECT_EQ(
10252       "abcd + \"line line \"\n"
10253       "       \"line line\";",
10254       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10255   // In a chain of binary operators with three operands, the second must be
10256   // broken with a line break before it.
10257   EXPECT_EQ("abcd +\n"
10258             "    \"line line \"\n"
10259             "    \"line line\" +\n"
10260             "    e;",
10261             format("abcd + \"line line line line\" + e;",
10262                    getLLVMStyleWithColumns(20)));
10263   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10264   // the first must be broken with a line break before it.
10265   FormatStyle Style = getLLVMStyleWithColumns(25);
10266   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10267   EXPECT_EQ("someFunction(\n"
10268             "    \"long long long \"\n"
10269             "    \"long\",\n"
10270             "    a);",
10271             format("someFunction(\"long long long long\", a);", Style));
10272 }
10273 
10274 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10275   EXPECT_EQ(
10276       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10277       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10278       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10279       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10280              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10281              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10282 }
10283 
10284 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10285   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10286             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10287   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10288             "multiline raw string literal xxxxxxxxxxxxxx\n"
10289             ")x\",\n"
10290             "              a),\n"
10291             "            b);",
10292             format("fffffffffff(g(R\"x(\n"
10293                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10294                    ")x\", a), b);",
10295                    getGoogleStyleWithColumns(20)));
10296   EXPECT_EQ("fffffffffff(\n"
10297             "    g(R\"x(qqq\n"
10298             "multiline raw string literal xxxxxxxxxxxxxx\n"
10299             ")x\",\n"
10300             "      a),\n"
10301             "    b);",
10302             format("fffffffffff(g(R\"x(qqq\n"
10303                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10304                    ")x\", a), b);",
10305                    getGoogleStyleWithColumns(20)));
10306 
10307   EXPECT_EQ("fffffffffff(R\"x(\n"
10308             "multiline raw string literal xxxxxxxxxxxxxx\n"
10309             ")x\");",
10310             format("fffffffffff(R\"x(\n"
10311                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10312                    ")x\");",
10313                    getGoogleStyleWithColumns(20)));
10314   EXPECT_EQ("fffffffffff(R\"x(\n"
10315             "multiline raw string literal xxxxxxxxxxxxxx\n"
10316             ")x\" + bbbbbb);",
10317             format("fffffffffff(R\"x(\n"
10318                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10319                    ")x\" +   bbbbbb);",
10320                    getGoogleStyleWithColumns(20)));
10321   EXPECT_EQ("fffffffffff(\n"
10322             "    R\"x(\n"
10323             "multiline raw string literal xxxxxxxxxxxxxx\n"
10324             ")x\" +\n"
10325             "    bbbbbb);",
10326             format("fffffffffff(\n"
10327                    " R\"x(\n"
10328                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10329                    ")x\" + bbbbbb);",
10330                    getGoogleStyleWithColumns(20)));
10331   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10332             format("fffffffffff(\n"
10333                    " R\"(single line raw string)\" + bbbbbb);"));
10334 }
10335 
10336 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10337   verifyFormat("string a = \"unterminated;");
10338   EXPECT_EQ("function(\"unterminated,\n"
10339             "         OtherParameter);",
10340             format("function(  \"unterminated,\n"
10341                    "    OtherParameter);"));
10342 }
10343 
10344 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10345   FormatStyle Style = getLLVMStyle();
10346   Style.Standard = FormatStyle::LS_Cpp03;
10347   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10348             format("#define x(_a) printf(\"foo\"_a);", Style));
10349 }
10350 
10351 TEST_F(FormatTest, CppLexVersion) {
10352   FormatStyle Style = getLLVMStyle();
10353   // Formatting of x * y differs if x is a type.
10354   verifyFormat("void foo() { MACRO(a * b); }", Style);
10355   verifyFormat("void foo() { MACRO(int *b); }", Style);
10356 
10357   // LLVM style uses latest lexer.
10358   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10359   Style.Standard = FormatStyle::LS_Cpp17;
10360   // But in c++17, char8_t isn't a keyword.
10361   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10362 }
10363 
10364 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10365 
10366 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10367   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10368             "             \"ddeeefff\");",
10369             format("someFunction(\"aaabbbcccdddeeefff\");",
10370                    getLLVMStyleWithColumns(25)));
10371   EXPECT_EQ("someFunction1234567890(\n"
10372             "    \"aaabbbcccdddeeefff\");",
10373             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10374                    getLLVMStyleWithColumns(26)));
10375   EXPECT_EQ("someFunction1234567890(\n"
10376             "    \"aaabbbcccdddeeeff\"\n"
10377             "    \"f\");",
10378             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10379                    getLLVMStyleWithColumns(25)));
10380   EXPECT_EQ("someFunction1234567890(\n"
10381             "    \"aaabbbcccdddeeeff\"\n"
10382             "    \"f\");",
10383             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10384                    getLLVMStyleWithColumns(24)));
10385   EXPECT_EQ("someFunction(\n"
10386             "    \"aaabbbcc ddde \"\n"
10387             "    \"efff\");",
10388             format("someFunction(\"aaabbbcc ddde efff\");",
10389                    getLLVMStyleWithColumns(25)));
10390   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10391             "             \"ddeeefff\");",
10392             format("someFunction(\"aaabbbccc ddeeefff\");",
10393                    getLLVMStyleWithColumns(25)));
10394   EXPECT_EQ("someFunction1234567890(\n"
10395             "    \"aaabb \"\n"
10396             "    \"cccdddeeefff\");",
10397             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10398                    getLLVMStyleWithColumns(25)));
10399   EXPECT_EQ("#define A          \\\n"
10400             "  string s =       \\\n"
10401             "      \"123456789\"  \\\n"
10402             "      \"0\";         \\\n"
10403             "  int i;",
10404             format("#define A string s = \"1234567890\"; int i;",
10405                    getLLVMStyleWithColumns(20)));
10406   EXPECT_EQ("someFunction(\n"
10407             "    \"aaabbbcc \"\n"
10408             "    \"dddeeefff\");",
10409             format("someFunction(\"aaabbbcc dddeeefff\");",
10410                    getLLVMStyleWithColumns(25)));
10411 }
10412 
10413 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10414   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10415   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10416   EXPECT_EQ("\"test\"\n"
10417             "\"\\n\"",
10418             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10419   EXPECT_EQ("\"tes\\\\\"\n"
10420             "\"n\"",
10421             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10422   EXPECT_EQ("\"\\\\\\\\\"\n"
10423             "\"\\n\"",
10424             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10425   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10426   EXPECT_EQ("\"\\uff01\"\n"
10427             "\"test\"",
10428             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10429   EXPECT_EQ("\"\\Uff01ff02\"",
10430             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10431   EXPECT_EQ("\"\\x000000000001\"\n"
10432             "\"next\"",
10433             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10434   EXPECT_EQ("\"\\x000000000001next\"",
10435             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10436   EXPECT_EQ("\"\\x000000000001\"",
10437             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10438   EXPECT_EQ("\"test\"\n"
10439             "\"\\000000\"\n"
10440             "\"000001\"",
10441             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10442   EXPECT_EQ("\"test\\000\"\n"
10443             "\"00000000\"\n"
10444             "\"1\"",
10445             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10446 }
10447 
10448 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10449   verifyFormat("void f() {\n"
10450                "  return g() {}\n"
10451                "  void h() {}");
10452   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10453                "g();\n"
10454                "}");
10455 }
10456 
10457 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10458   verifyFormat(
10459       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10460 }
10461 
10462 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10463   verifyFormat("class X {\n"
10464                "  void f() {\n"
10465                "  }\n"
10466                "};",
10467                getLLVMStyleWithColumns(12));
10468 }
10469 
10470 TEST_F(FormatTest, ConfigurableIndentWidth) {
10471   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10472   EightIndent.IndentWidth = 8;
10473   EightIndent.ContinuationIndentWidth = 8;
10474   verifyFormat("void f() {\n"
10475                "        someFunction();\n"
10476                "        if (true) {\n"
10477                "                f();\n"
10478                "        }\n"
10479                "}",
10480                EightIndent);
10481   verifyFormat("class X {\n"
10482                "        void f() {\n"
10483                "        }\n"
10484                "};",
10485                EightIndent);
10486   verifyFormat("int x[] = {\n"
10487                "        call(),\n"
10488                "        call()};",
10489                EightIndent);
10490 }
10491 
10492 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10493   verifyFormat("double\n"
10494                "f();",
10495                getLLVMStyleWithColumns(8));
10496 }
10497 
10498 TEST_F(FormatTest, ConfigurableUseOfTab) {
10499   FormatStyle Tab = getLLVMStyleWithColumns(42);
10500   Tab.IndentWidth = 8;
10501   Tab.UseTab = FormatStyle::UT_Always;
10502   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10503 
10504   EXPECT_EQ("if (aaaaaaaa && // q\n"
10505             "    bb)\t\t// w\n"
10506             "\t;",
10507             format("if (aaaaaaaa &&// q\n"
10508                    "bb)// w\n"
10509                    ";",
10510                    Tab));
10511   EXPECT_EQ("if (aaa && bbb) // w\n"
10512             "\t;",
10513             format("if(aaa&&bbb)// w\n"
10514                    ";",
10515                    Tab));
10516 
10517   verifyFormat("class X {\n"
10518                "\tvoid f() {\n"
10519                "\t\tsomeFunction(parameter1,\n"
10520                "\t\t\t     parameter2);\n"
10521                "\t}\n"
10522                "};",
10523                Tab);
10524   verifyFormat("#define A                        \\\n"
10525                "\tvoid f() {               \\\n"
10526                "\t\tsomeFunction(    \\\n"
10527                "\t\t    parameter1,  \\\n"
10528                "\t\t    parameter2); \\\n"
10529                "\t}",
10530                Tab);
10531   verifyFormat("int a;\t      // x\n"
10532                "int bbbbbbbb; // x\n",
10533                Tab);
10534 
10535   Tab.TabWidth = 4;
10536   Tab.IndentWidth = 8;
10537   verifyFormat("class TabWidth4Indent8 {\n"
10538                "\t\tvoid f() {\n"
10539                "\t\t\t\tsomeFunction(parameter1,\n"
10540                "\t\t\t\t\t\t\t parameter2);\n"
10541                "\t\t}\n"
10542                "};",
10543                Tab);
10544 
10545   Tab.TabWidth = 4;
10546   Tab.IndentWidth = 4;
10547   verifyFormat("class TabWidth4Indent4 {\n"
10548                "\tvoid f() {\n"
10549                "\t\tsomeFunction(parameter1,\n"
10550                "\t\t\t\t\t parameter2);\n"
10551                "\t}\n"
10552                "};",
10553                Tab);
10554 
10555   Tab.TabWidth = 8;
10556   Tab.IndentWidth = 4;
10557   verifyFormat("class TabWidth8Indent4 {\n"
10558                "    void f() {\n"
10559                "\tsomeFunction(parameter1,\n"
10560                "\t\t     parameter2);\n"
10561                "    }\n"
10562                "};",
10563                Tab);
10564 
10565   Tab.TabWidth = 8;
10566   Tab.IndentWidth = 8;
10567   EXPECT_EQ("/*\n"
10568             "\t      a\t\tcomment\n"
10569             "\t      in multiple lines\n"
10570             "       */",
10571             format("   /*\t \t \n"
10572                    " \t \t a\t\tcomment\t \t\n"
10573                    " \t \t in multiple lines\t\n"
10574                    " \t  */",
10575                    Tab));
10576 
10577   Tab.UseTab = FormatStyle::UT_ForIndentation;
10578   verifyFormat("{\n"
10579                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10580                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10581                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10582                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10583                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10584                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10585                "};",
10586                Tab);
10587   verifyFormat("enum AA {\n"
10588                "\ta1, // Force multiple lines\n"
10589                "\ta2,\n"
10590                "\ta3\n"
10591                "};",
10592                Tab);
10593   EXPECT_EQ("if (aaaaaaaa && // q\n"
10594             "    bb)         // w\n"
10595             "\t;",
10596             format("if (aaaaaaaa &&// q\n"
10597                    "bb)// w\n"
10598                    ";",
10599                    Tab));
10600   verifyFormat("class X {\n"
10601                "\tvoid f() {\n"
10602                "\t\tsomeFunction(parameter1,\n"
10603                "\t\t             parameter2);\n"
10604                "\t}\n"
10605                "};",
10606                Tab);
10607   verifyFormat("{\n"
10608                "\tQ(\n"
10609                "\t    {\n"
10610                "\t\t    int a;\n"
10611                "\t\t    someFunction(aaaaaaaa,\n"
10612                "\t\t                 bbbbbbb);\n"
10613                "\t    },\n"
10614                "\t    p);\n"
10615                "}",
10616                Tab);
10617   EXPECT_EQ("{\n"
10618             "\t/* aaaa\n"
10619             "\t   bbbb */\n"
10620             "}",
10621             format("{\n"
10622                    "/* aaaa\n"
10623                    "   bbbb */\n"
10624                    "}",
10625                    Tab));
10626   EXPECT_EQ("{\n"
10627             "\t/*\n"
10628             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10629             "\t  bbbbbbbbbbbbb\n"
10630             "\t*/\n"
10631             "}",
10632             format("{\n"
10633                    "/*\n"
10634                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10635                    "*/\n"
10636                    "}",
10637                    Tab));
10638   EXPECT_EQ("{\n"
10639             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10640             "\t// bbbbbbbbbbbbb\n"
10641             "}",
10642             format("{\n"
10643                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10644                    "}",
10645                    Tab));
10646   EXPECT_EQ("{\n"
10647             "\t/*\n"
10648             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10649             "\t  bbbbbbbbbbbbb\n"
10650             "\t*/\n"
10651             "}",
10652             format("{\n"
10653                    "\t/*\n"
10654                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10655                    "\t*/\n"
10656                    "}",
10657                    Tab));
10658   EXPECT_EQ("{\n"
10659             "\t/*\n"
10660             "\n"
10661             "\t*/\n"
10662             "}",
10663             format("{\n"
10664                    "\t/*\n"
10665                    "\n"
10666                    "\t*/\n"
10667                    "}",
10668                    Tab));
10669   EXPECT_EQ("{\n"
10670             "\t/*\n"
10671             " asdf\n"
10672             "\t*/\n"
10673             "}",
10674             format("{\n"
10675                    "\t/*\n"
10676                    " asdf\n"
10677                    "\t*/\n"
10678                    "}",
10679                    Tab));
10680 
10681   Tab.UseTab = FormatStyle::UT_Never;
10682   EXPECT_EQ("/*\n"
10683             "              a\t\tcomment\n"
10684             "              in multiple lines\n"
10685             "       */",
10686             format("   /*\t \t \n"
10687                    " \t \t a\t\tcomment\t \t\n"
10688                    " \t \t in multiple lines\t\n"
10689                    " \t  */",
10690                    Tab));
10691   EXPECT_EQ("/* some\n"
10692             "   comment */",
10693             format(" \t \t /* some\n"
10694                    " \t \t    comment */",
10695                    Tab));
10696   EXPECT_EQ("int a; /* some\n"
10697             "   comment */",
10698             format(" \t \t int a; /* some\n"
10699                    " \t \t    comment */",
10700                    Tab));
10701 
10702   EXPECT_EQ("int a; /* some\n"
10703             "comment */",
10704             format(" \t \t int\ta; /* some\n"
10705                    " \t \t    comment */",
10706                    Tab));
10707   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10708             "    comment */",
10709             format(" \t \t f(\"\t\t\"); /* some\n"
10710                    " \t \t    comment */",
10711                    Tab));
10712   EXPECT_EQ("{\n"
10713             "        /*\n"
10714             "         * Comment\n"
10715             "         */\n"
10716             "        int i;\n"
10717             "}",
10718             format("{\n"
10719                    "\t/*\n"
10720                    "\t * Comment\n"
10721                    "\t */\n"
10722                    "\t int i;\n"
10723                    "}",
10724                    Tab));
10725 
10726   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
10727   Tab.TabWidth = 8;
10728   Tab.IndentWidth = 8;
10729   EXPECT_EQ("if (aaaaaaaa && // q\n"
10730             "    bb)         // w\n"
10731             "\t;",
10732             format("if (aaaaaaaa &&// q\n"
10733                    "bb)// w\n"
10734                    ";",
10735                    Tab));
10736   EXPECT_EQ("if (aaa && bbb) // w\n"
10737             "\t;",
10738             format("if(aaa&&bbb)// w\n"
10739                    ";",
10740                    Tab));
10741   verifyFormat("class X {\n"
10742                "\tvoid f() {\n"
10743                "\t\tsomeFunction(parameter1,\n"
10744                "\t\t\t     parameter2);\n"
10745                "\t}\n"
10746                "};",
10747                Tab);
10748   verifyFormat("#define A                        \\\n"
10749                "\tvoid f() {               \\\n"
10750                "\t\tsomeFunction(    \\\n"
10751                "\t\t    parameter1,  \\\n"
10752                "\t\t    parameter2); \\\n"
10753                "\t}",
10754                Tab);
10755   Tab.TabWidth = 4;
10756   Tab.IndentWidth = 8;
10757   verifyFormat("class TabWidth4Indent8 {\n"
10758                "\t\tvoid f() {\n"
10759                "\t\t\t\tsomeFunction(parameter1,\n"
10760                "\t\t\t\t\t\t\t parameter2);\n"
10761                "\t\t}\n"
10762                "};",
10763                Tab);
10764   Tab.TabWidth = 4;
10765   Tab.IndentWidth = 4;
10766   verifyFormat("class TabWidth4Indent4 {\n"
10767                "\tvoid f() {\n"
10768                "\t\tsomeFunction(parameter1,\n"
10769                "\t\t\t\t\t parameter2);\n"
10770                "\t}\n"
10771                "};",
10772                Tab);
10773   Tab.TabWidth = 8;
10774   Tab.IndentWidth = 4;
10775   verifyFormat("class TabWidth8Indent4 {\n"
10776                "    void f() {\n"
10777                "\tsomeFunction(parameter1,\n"
10778                "\t\t     parameter2);\n"
10779                "    }\n"
10780                "};",
10781                Tab);
10782   Tab.TabWidth = 8;
10783   Tab.IndentWidth = 8;
10784   EXPECT_EQ("/*\n"
10785             "\t      a\t\tcomment\n"
10786             "\t      in multiple lines\n"
10787             "       */",
10788             format("   /*\t \t \n"
10789                    " \t \t a\t\tcomment\t \t\n"
10790                    " \t \t in multiple lines\t\n"
10791                    " \t  */",
10792                    Tab));
10793   verifyFormat("{\n"
10794                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10795                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10796                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10797                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10798                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10799                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10800                "};",
10801                Tab);
10802   verifyFormat("enum AA {\n"
10803                "\ta1, // Force multiple lines\n"
10804                "\ta2,\n"
10805                "\ta3\n"
10806                "};",
10807                Tab);
10808   EXPECT_EQ("if (aaaaaaaa && // q\n"
10809             "    bb)         // w\n"
10810             "\t;",
10811             format("if (aaaaaaaa &&// q\n"
10812                    "bb)// w\n"
10813                    ";",
10814                    Tab));
10815   verifyFormat("class X {\n"
10816                "\tvoid f() {\n"
10817                "\t\tsomeFunction(parameter1,\n"
10818                "\t\t\t     parameter2);\n"
10819                "\t}\n"
10820                "};",
10821                Tab);
10822   verifyFormat("{\n"
10823                "\tQ(\n"
10824                "\t    {\n"
10825                "\t\t    int a;\n"
10826                "\t\t    someFunction(aaaaaaaa,\n"
10827                "\t\t\t\t bbbbbbb);\n"
10828                "\t    },\n"
10829                "\t    p);\n"
10830                "}",
10831                Tab);
10832   EXPECT_EQ("{\n"
10833             "\t/* aaaa\n"
10834             "\t   bbbb */\n"
10835             "}",
10836             format("{\n"
10837                    "/* aaaa\n"
10838                    "   bbbb */\n"
10839                    "}",
10840                    Tab));
10841   EXPECT_EQ("{\n"
10842             "\t/*\n"
10843             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10844             "\t  bbbbbbbbbbbbb\n"
10845             "\t*/\n"
10846             "}",
10847             format("{\n"
10848                    "/*\n"
10849                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10850                    "*/\n"
10851                    "}",
10852                    Tab));
10853   EXPECT_EQ("{\n"
10854             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10855             "\t// bbbbbbbbbbbbb\n"
10856             "}",
10857             format("{\n"
10858                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10859                    "}",
10860                    Tab));
10861   EXPECT_EQ("{\n"
10862             "\t/*\n"
10863             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10864             "\t  bbbbbbbbbbbbb\n"
10865             "\t*/\n"
10866             "}",
10867             format("{\n"
10868                    "\t/*\n"
10869                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10870                    "\t*/\n"
10871                    "}",
10872                    Tab));
10873   EXPECT_EQ("{\n"
10874             "\t/*\n"
10875             "\n"
10876             "\t*/\n"
10877             "}",
10878             format("{\n"
10879                    "\t/*\n"
10880                    "\n"
10881                    "\t*/\n"
10882                    "}",
10883                    Tab));
10884   EXPECT_EQ("{\n"
10885             "\t/*\n"
10886             " asdf\n"
10887             "\t*/\n"
10888             "}",
10889             format("{\n"
10890                    "\t/*\n"
10891                    " asdf\n"
10892                    "\t*/\n"
10893                    "}",
10894                    Tab));
10895   EXPECT_EQ("/* some\n"
10896             "   comment */",
10897             format(" \t \t /* some\n"
10898                    " \t \t    comment */",
10899                    Tab));
10900   EXPECT_EQ("int a; /* some\n"
10901             "   comment */",
10902             format(" \t \t int a; /* some\n"
10903                    " \t \t    comment */",
10904                    Tab));
10905   EXPECT_EQ("int a; /* some\n"
10906             "comment */",
10907             format(" \t \t int\ta; /* some\n"
10908                    " \t \t    comment */",
10909                    Tab));
10910   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10911             "    comment */",
10912             format(" \t \t f(\"\t\t\"); /* some\n"
10913                    " \t \t    comment */",
10914                    Tab));
10915   EXPECT_EQ("{\n"
10916             "\t/*\n"
10917             "\t * Comment\n"
10918             "\t */\n"
10919             "\tint i;\n"
10920             "}",
10921             format("{\n"
10922                    "\t/*\n"
10923                    "\t * Comment\n"
10924                    "\t */\n"
10925                    "\t int i;\n"
10926                    "}",
10927                    Tab));
10928   Tab.TabWidth = 2;
10929   Tab.IndentWidth = 2;
10930   EXPECT_EQ("{\n"
10931             "\t/* aaaa\n"
10932             "\t\t bbbb */\n"
10933             "}",
10934             format("{\n"
10935                    "/* aaaa\n"
10936                    "\t bbbb */\n"
10937                    "}",
10938                    Tab));
10939   EXPECT_EQ("{\n"
10940             "\t/*\n"
10941             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10942             "\t\tbbbbbbbbbbbbb\n"
10943             "\t*/\n"
10944             "}",
10945             format("{\n"
10946                    "/*\n"
10947                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10948                    "*/\n"
10949                    "}",
10950                    Tab));
10951   Tab.AlignConsecutiveAssignments = true;
10952   Tab.AlignConsecutiveDeclarations = true;
10953   Tab.TabWidth = 4;
10954   Tab.IndentWidth = 4;
10955   verifyFormat("class Assign {\n"
10956                "\tvoid f() {\n"
10957                "\t\tint         x      = 123;\n"
10958                "\t\tint         random = 4;\n"
10959                "\t\tstd::string alphabet =\n"
10960                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
10961                "\t}\n"
10962                "};",
10963                Tab);
10964 
10965   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
10966   Tab.TabWidth = 8;
10967   Tab.IndentWidth = 8;
10968   EXPECT_EQ("if (aaaaaaaa && // q\n"
10969             "    bb)         // w\n"
10970             "\t;",
10971             format("if (aaaaaaaa &&// q\n"
10972                    "bb)// w\n"
10973                    ";",
10974                    Tab));
10975   EXPECT_EQ("if (aaa && bbb) // w\n"
10976             "\t;",
10977             format("if(aaa&&bbb)// w\n"
10978                    ";",
10979                    Tab));
10980   verifyFormat("class X {\n"
10981                "\tvoid f() {\n"
10982                "\t\tsomeFunction(parameter1,\n"
10983                "\t\t             parameter2);\n"
10984                "\t}\n"
10985                "};",
10986                Tab);
10987   verifyFormat("#define A                        \\\n"
10988                "\tvoid f() {               \\\n"
10989                "\t\tsomeFunction(    \\\n"
10990                "\t\t    parameter1,  \\\n"
10991                "\t\t    parameter2); \\\n"
10992                "\t}",
10993                Tab);
10994   Tab.TabWidth = 4;
10995   Tab.IndentWidth = 8;
10996   verifyFormat("class TabWidth4Indent8 {\n"
10997                "\t\tvoid f() {\n"
10998                "\t\t\t\tsomeFunction(parameter1,\n"
10999                "\t\t\t\t             parameter2);\n"
11000                "\t\t}\n"
11001                "};",
11002                Tab);
11003   Tab.TabWidth = 4;
11004   Tab.IndentWidth = 4;
11005   verifyFormat("class TabWidth4Indent4 {\n"
11006                "\tvoid f() {\n"
11007                "\t\tsomeFunction(parameter1,\n"
11008                "\t\t             parameter2);\n"
11009                "\t}\n"
11010                "};",
11011                Tab);
11012   Tab.TabWidth = 8;
11013   Tab.IndentWidth = 4;
11014   verifyFormat("class TabWidth8Indent4 {\n"
11015                "    void f() {\n"
11016                "\tsomeFunction(parameter1,\n"
11017                "\t             parameter2);\n"
11018                "    }\n"
11019                "};",
11020                Tab);
11021   Tab.TabWidth = 8;
11022   Tab.IndentWidth = 8;
11023   EXPECT_EQ("/*\n"
11024             "              a\t\tcomment\n"
11025             "              in multiple lines\n"
11026             "       */",
11027             format("   /*\t \t \n"
11028                    " \t \t a\t\tcomment\t \t\n"
11029                    " \t \t in multiple lines\t\n"
11030                    " \t  */",
11031                    Tab));
11032   verifyFormat("{\n"
11033                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11034                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11035                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11036                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11037                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11038                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11039                "};",
11040                Tab);
11041   verifyFormat("enum AA {\n"
11042                "\ta1, // Force multiple lines\n"
11043                "\ta2,\n"
11044                "\ta3\n"
11045                "};",
11046                Tab);
11047   EXPECT_EQ("if (aaaaaaaa && // q\n"
11048             "    bb)         // w\n"
11049             "\t;",
11050             format("if (aaaaaaaa &&// q\n"
11051                    "bb)// w\n"
11052                    ";",
11053                    Tab));
11054   verifyFormat("class X {\n"
11055                "\tvoid f() {\n"
11056                "\t\tsomeFunction(parameter1,\n"
11057                "\t\t             parameter2);\n"
11058                "\t}\n"
11059                "};",
11060                Tab);
11061   verifyFormat("{\n"
11062                "\tQ(\n"
11063                "\t    {\n"
11064                "\t\t    int a;\n"
11065                "\t\t    someFunction(aaaaaaaa,\n"
11066                "\t\t                 bbbbbbb);\n"
11067                "\t    },\n"
11068                "\t    p);\n"
11069                "}",
11070                Tab);
11071   EXPECT_EQ("{\n"
11072             "\t/* aaaa\n"
11073             "\t   bbbb */\n"
11074             "}",
11075             format("{\n"
11076                    "/* aaaa\n"
11077                    "   bbbb */\n"
11078                    "}",
11079                    Tab));
11080   EXPECT_EQ("{\n"
11081             "\t/*\n"
11082             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11083             "\t  bbbbbbbbbbbbb\n"
11084             "\t*/\n"
11085             "}",
11086             format("{\n"
11087                    "/*\n"
11088                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11089                    "*/\n"
11090                    "}",
11091                    Tab));
11092   EXPECT_EQ("{\n"
11093             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11094             "\t// bbbbbbbbbbbbb\n"
11095             "}",
11096             format("{\n"
11097                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11098                    "}",
11099                    Tab));
11100   EXPECT_EQ("{\n"
11101             "\t/*\n"
11102             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11103             "\t  bbbbbbbbbbbbb\n"
11104             "\t*/\n"
11105             "}",
11106             format("{\n"
11107                    "\t/*\n"
11108                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11109                    "\t*/\n"
11110                    "}",
11111                    Tab));
11112   EXPECT_EQ("{\n"
11113             "\t/*\n"
11114             "\n"
11115             "\t*/\n"
11116             "}",
11117             format("{\n"
11118                    "\t/*\n"
11119                    "\n"
11120                    "\t*/\n"
11121                    "}",
11122                    Tab));
11123   EXPECT_EQ("{\n"
11124             "\t/*\n"
11125             " asdf\n"
11126             "\t*/\n"
11127             "}",
11128             format("{\n"
11129                    "\t/*\n"
11130                    " asdf\n"
11131                    "\t*/\n"
11132                    "}",
11133                    Tab));
11134   EXPECT_EQ("/* some\n"
11135             "   comment */",
11136             format(" \t \t /* some\n"
11137                    " \t \t    comment */",
11138                    Tab));
11139   EXPECT_EQ("int a; /* some\n"
11140             "   comment */",
11141             format(" \t \t int a; /* some\n"
11142                    " \t \t    comment */",
11143                    Tab));
11144   EXPECT_EQ("int a; /* some\n"
11145             "comment */",
11146             format(" \t \t int\ta; /* some\n"
11147                    " \t \t    comment */",
11148                    Tab));
11149   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11150             "    comment */",
11151             format(" \t \t f(\"\t\t\"); /* some\n"
11152                    " \t \t    comment */",
11153                    Tab));
11154   EXPECT_EQ("{\n"
11155             "\t/*\n"
11156             "\t * Comment\n"
11157             "\t */\n"
11158             "\tint i;\n"
11159             "}",
11160             format("{\n"
11161                    "\t/*\n"
11162                    "\t * Comment\n"
11163                    "\t */\n"
11164                    "\t int i;\n"
11165                    "}",
11166                    Tab));
11167   Tab.TabWidth = 2;
11168   Tab.IndentWidth = 2;
11169   EXPECT_EQ("{\n"
11170             "\t/* aaaa\n"
11171             "\t   bbbb */\n"
11172             "}",
11173             format("{\n"
11174                    "/* aaaa\n"
11175                    "   bbbb */\n"
11176                    "}",
11177                    Tab));
11178   EXPECT_EQ("{\n"
11179             "\t/*\n"
11180             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11181             "\t  bbbbbbbbbbbbb\n"
11182             "\t*/\n"
11183             "}",
11184             format("{\n"
11185                    "/*\n"
11186                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11187                    "*/\n"
11188                    "}",
11189                    Tab));
11190   Tab.AlignConsecutiveAssignments = true;
11191   Tab.AlignConsecutiveDeclarations = true;
11192   Tab.TabWidth = 4;
11193   Tab.IndentWidth = 4;
11194   verifyFormat("class Assign {\n"
11195                "\tvoid f() {\n"
11196                "\t\tint         x      = 123;\n"
11197                "\t\tint         random = 4;\n"
11198                "\t\tstd::string alphabet =\n"
11199                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11200                "\t}\n"
11201                "};",
11202                Tab);
11203 }
11204 
11205 TEST_F(FormatTest, ZeroTabWidth) {
11206   FormatStyle Tab = getLLVMStyleWithColumns(42);
11207   Tab.IndentWidth = 8;
11208   Tab.UseTab = FormatStyle::UT_Never;
11209   Tab.TabWidth = 0;
11210   EXPECT_EQ("void a(){\n"
11211             "    // line starts with '\t'\n"
11212             "};",
11213             format("void a(){\n"
11214                    "\t// line starts with '\t'\n"
11215                    "};",
11216                    Tab));
11217 
11218   EXPECT_EQ("void a(){\n"
11219             "    // line starts with '\t'\n"
11220             "};",
11221             format("void a(){\n"
11222                    "\t\t// line starts with '\t'\n"
11223                    "};",
11224                    Tab));
11225 
11226   Tab.UseTab = FormatStyle::UT_ForIndentation;
11227   EXPECT_EQ("void a(){\n"
11228             "    // line starts with '\t'\n"
11229             "};",
11230             format("void a(){\n"
11231                    "\t// line starts with '\t'\n"
11232                    "};",
11233                    Tab));
11234 
11235   EXPECT_EQ("void a(){\n"
11236             "    // line starts with '\t'\n"
11237             "};",
11238             format("void a(){\n"
11239                    "\t\t// line starts with '\t'\n"
11240                    "};",
11241                    Tab));
11242 
11243   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11244   EXPECT_EQ("void a(){\n"
11245             "    // line starts with '\t'\n"
11246             "};",
11247             format("void a(){\n"
11248                    "\t// line starts with '\t'\n"
11249                    "};",
11250                    Tab));
11251 
11252   EXPECT_EQ("void a(){\n"
11253             "    // line starts with '\t'\n"
11254             "};",
11255             format("void a(){\n"
11256                    "\t\t// line starts with '\t'\n"
11257                    "};",
11258                    Tab));
11259 
11260   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11261   EXPECT_EQ("void a(){\n"
11262             "    // line starts with '\t'\n"
11263             "};",
11264             format("void a(){\n"
11265                    "\t// line starts with '\t'\n"
11266                    "};",
11267                    Tab));
11268 
11269   EXPECT_EQ("void a(){\n"
11270             "    // line starts with '\t'\n"
11271             "};",
11272             format("void a(){\n"
11273                    "\t\t// line starts with '\t'\n"
11274                    "};",
11275                    Tab));
11276 
11277   Tab.UseTab = FormatStyle::UT_Always;
11278   EXPECT_EQ("void a(){\n"
11279             "// line starts with '\t'\n"
11280             "};",
11281             format("void a(){\n"
11282                    "\t// line starts with '\t'\n"
11283                    "};",
11284                    Tab));
11285 
11286   EXPECT_EQ("void a(){\n"
11287             "// line starts with '\t'\n"
11288             "};",
11289             format("void a(){\n"
11290                    "\t\t// line starts with '\t'\n"
11291                    "};",
11292                    Tab));
11293 }
11294 
11295 TEST_F(FormatTest, CalculatesOriginalColumn) {
11296   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11297             "q\"; /* some\n"
11298             "       comment */",
11299             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11300                    "q\"; /* some\n"
11301                    "       comment */",
11302                    getLLVMStyle()));
11303   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11304             "/* some\n"
11305             "   comment */",
11306             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11307                    " /* some\n"
11308                    "    comment */",
11309                    getLLVMStyle()));
11310   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11311             "qqq\n"
11312             "/* some\n"
11313             "   comment */",
11314             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11315                    "qqq\n"
11316                    " /* some\n"
11317                    "    comment */",
11318                    getLLVMStyle()));
11319   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11320             "wwww; /* some\n"
11321             "         comment */",
11322             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11323                    "wwww; /* some\n"
11324                    "         comment */",
11325                    getLLVMStyle()));
11326 }
11327 
11328 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11329   FormatStyle NoSpace = getLLVMStyle();
11330   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11331 
11332   verifyFormat("while(true)\n"
11333                "  continue;",
11334                NoSpace);
11335   verifyFormat("for(;;)\n"
11336                "  continue;",
11337                NoSpace);
11338   verifyFormat("if(true)\n"
11339                "  f();\n"
11340                "else if(true)\n"
11341                "  f();",
11342                NoSpace);
11343   verifyFormat("do {\n"
11344                "  do_something();\n"
11345                "} while(something());",
11346                NoSpace);
11347   verifyFormat("switch(x) {\n"
11348                "default:\n"
11349                "  break;\n"
11350                "}",
11351                NoSpace);
11352   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11353   verifyFormat("size_t x = sizeof(x);", NoSpace);
11354   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11355   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11356   verifyFormat("alignas(128) char a[128];", NoSpace);
11357   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11358   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11359   verifyFormat("int f() throw(Deprecated);", NoSpace);
11360   verifyFormat("typedef void (*cb)(int);", NoSpace);
11361   verifyFormat("T A::operator()();", NoSpace);
11362   verifyFormat("X A::operator++(T);", NoSpace);
11363   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11364 
11365   FormatStyle Space = getLLVMStyle();
11366   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11367 
11368   verifyFormat("int f ();", Space);
11369   verifyFormat("void f (int a, T b) {\n"
11370                "  while (true)\n"
11371                "    continue;\n"
11372                "}",
11373                Space);
11374   verifyFormat("if (true)\n"
11375                "  f ();\n"
11376                "else if (true)\n"
11377                "  f ();",
11378                Space);
11379   verifyFormat("do {\n"
11380                "  do_something ();\n"
11381                "} while (something ());",
11382                Space);
11383   verifyFormat("switch (x) {\n"
11384                "default:\n"
11385                "  break;\n"
11386                "}",
11387                Space);
11388   verifyFormat("A::A () : a (1) {}", Space);
11389   verifyFormat("void f () __attribute__ ((asdf));", Space);
11390   verifyFormat("*(&a + 1);\n"
11391                "&((&a)[1]);\n"
11392                "a[(b + c) * d];\n"
11393                "(((a + 1) * 2) + 3) * 4;",
11394                Space);
11395   verifyFormat("#define A(x) x", Space);
11396   verifyFormat("#define A (x) x", Space);
11397   verifyFormat("#if defined(x)\n"
11398                "#endif",
11399                Space);
11400   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11401   verifyFormat("size_t x = sizeof (x);", Space);
11402   verifyFormat("auto f (int x) -> decltype (x);", Space);
11403   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11404   verifyFormat("alignas (128) char a[128];", Space);
11405   verifyFormat("size_t x = alignof (MyType);", Space);
11406   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11407   verifyFormat("int f () throw (Deprecated);", Space);
11408   verifyFormat("typedef void (*cb) (int);", Space);
11409   verifyFormat("T A::operator() ();", Space);
11410   verifyFormat("X A::operator++ (T);", Space);
11411   verifyFormat("auto lambda = [] () { return 0; };", Space);
11412   verifyFormat("int x = int (y);", Space);
11413 
11414   FormatStyle SomeSpace = getLLVMStyle();
11415   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11416 
11417   verifyFormat("[]() -> float {}", SomeSpace);
11418   verifyFormat("[] (auto foo) {}", SomeSpace);
11419   verifyFormat("[foo]() -> int {}", SomeSpace);
11420   verifyFormat("int f();", SomeSpace);
11421   verifyFormat("void f (int a, T b) {\n"
11422                "  while (true)\n"
11423                "    continue;\n"
11424                "}",
11425                SomeSpace);
11426   verifyFormat("if (true)\n"
11427                "  f();\n"
11428                "else if (true)\n"
11429                "  f();",
11430                SomeSpace);
11431   verifyFormat("do {\n"
11432                "  do_something();\n"
11433                "} while (something());",
11434                SomeSpace);
11435   verifyFormat("switch (x) {\n"
11436                "default:\n"
11437                "  break;\n"
11438                "}",
11439                SomeSpace);
11440   verifyFormat("A::A() : a (1) {}", SomeSpace);
11441   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11442   verifyFormat("*(&a + 1);\n"
11443                "&((&a)[1]);\n"
11444                "a[(b + c) * d];\n"
11445                "(((a + 1) * 2) + 3) * 4;",
11446                SomeSpace);
11447   verifyFormat("#define A(x) x", SomeSpace);
11448   verifyFormat("#define A (x) x", SomeSpace);
11449   verifyFormat("#if defined(x)\n"
11450                "#endif",
11451                SomeSpace);
11452   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11453   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11454   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11455   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11456   verifyFormat("alignas (128) char a[128];", SomeSpace);
11457   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11458   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11459                SomeSpace);
11460   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11461   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11462   verifyFormat("T A::operator()();", SomeSpace);
11463   verifyFormat("X A::operator++ (T);", SomeSpace);
11464   verifyFormat("int x = int (y);", SomeSpace);
11465   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11466 }
11467 
11468 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11469   FormatStyle Spaces = getLLVMStyle();
11470   Spaces.SpaceAfterLogicalNot = true;
11471 
11472   verifyFormat("bool x = ! y", Spaces);
11473   verifyFormat("if (! isFailure())", Spaces);
11474   verifyFormat("if (! (a && b))", Spaces);
11475   verifyFormat("\"Error!\"", Spaces);
11476   verifyFormat("! ! x", Spaces);
11477 }
11478 
11479 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11480   FormatStyle Spaces = getLLVMStyle();
11481 
11482   Spaces.SpacesInParentheses = true;
11483   verifyFormat("do_something( ::globalVar );", Spaces);
11484   verifyFormat("call( x, y, z );", Spaces);
11485   verifyFormat("call();", Spaces);
11486   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11487   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11488                Spaces);
11489   verifyFormat("while ( (bool)1 )\n"
11490                "  continue;",
11491                Spaces);
11492   verifyFormat("for ( ;; )\n"
11493                "  continue;",
11494                Spaces);
11495   verifyFormat("if ( true )\n"
11496                "  f();\n"
11497                "else if ( true )\n"
11498                "  f();",
11499                Spaces);
11500   verifyFormat("do {\n"
11501                "  do_something( (int)i );\n"
11502                "} while ( something() );",
11503                Spaces);
11504   verifyFormat("switch ( x ) {\n"
11505                "default:\n"
11506                "  break;\n"
11507                "}",
11508                Spaces);
11509 
11510   Spaces.SpacesInParentheses = false;
11511   Spaces.SpacesInCStyleCastParentheses = true;
11512   verifyFormat("Type *A = ( Type * )P;", Spaces);
11513   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11514   verifyFormat("x = ( int32 )y;", Spaces);
11515   verifyFormat("int a = ( int )(2.0f);", Spaces);
11516   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11517   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11518   verifyFormat("#define x (( int )-1)", Spaces);
11519 
11520   // Run the first set of tests again with:
11521   Spaces.SpacesInParentheses = false;
11522   Spaces.SpaceInEmptyParentheses = true;
11523   Spaces.SpacesInCStyleCastParentheses = true;
11524   verifyFormat("call(x, y, z);", Spaces);
11525   verifyFormat("call( );", Spaces);
11526   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11527   verifyFormat("while (( bool )1)\n"
11528                "  continue;",
11529                Spaces);
11530   verifyFormat("for (;;)\n"
11531                "  continue;",
11532                Spaces);
11533   verifyFormat("if (true)\n"
11534                "  f( );\n"
11535                "else if (true)\n"
11536                "  f( );",
11537                Spaces);
11538   verifyFormat("do {\n"
11539                "  do_something(( int )i);\n"
11540                "} while (something( ));",
11541                Spaces);
11542   verifyFormat("switch (x) {\n"
11543                "default:\n"
11544                "  break;\n"
11545                "}",
11546                Spaces);
11547 
11548   // Run the first set of tests again with:
11549   Spaces.SpaceAfterCStyleCast = true;
11550   verifyFormat("call(x, y, z);", Spaces);
11551   verifyFormat("call( );", Spaces);
11552   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11553   verifyFormat("while (( bool ) 1)\n"
11554                "  continue;",
11555                Spaces);
11556   verifyFormat("for (;;)\n"
11557                "  continue;",
11558                Spaces);
11559   verifyFormat("if (true)\n"
11560                "  f( );\n"
11561                "else if (true)\n"
11562                "  f( );",
11563                Spaces);
11564   verifyFormat("do {\n"
11565                "  do_something(( int ) i);\n"
11566                "} while (something( ));",
11567                Spaces);
11568   verifyFormat("switch (x) {\n"
11569                "default:\n"
11570                "  break;\n"
11571                "}",
11572                Spaces);
11573 
11574   // Run subset of tests again with:
11575   Spaces.SpacesInCStyleCastParentheses = false;
11576   Spaces.SpaceAfterCStyleCast = true;
11577   verifyFormat("while ((bool) 1)\n"
11578                "  continue;",
11579                Spaces);
11580   verifyFormat("do {\n"
11581                "  do_something((int) i);\n"
11582                "} while (something( ));",
11583                Spaces);
11584 }
11585 
11586 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
11587   verifyFormat("int a[5];");
11588   verifyFormat("a[3] += 42;");
11589 
11590   FormatStyle Spaces = getLLVMStyle();
11591   Spaces.SpacesInSquareBrackets = true;
11592   // Not lambdas.
11593   verifyFormat("int a[ 5 ];", Spaces);
11594   verifyFormat("a[ 3 ] += 42;", Spaces);
11595   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
11596   verifyFormat("double &operator[](int i) { return 0; }\n"
11597                "int i;",
11598                Spaces);
11599   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
11600   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
11601   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
11602   // Lambdas.
11603   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
11604   verifyFormat("return [ i, args... ] {};", Spaces);
11605   verifyFormat("int foo = [ &bar ]() {};", Spaces);
11606   verifyFormat("int foo = [ = ]() {};", Spaces);
11607   verifyFormat("int foo = [ & ]() {};", Spaces);
11608   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
11609   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
11610 }
11611 
11612 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
11613   FormatStyle NoSpaceStyle = getLLVMStyle();
11614   verifyFormat("int a[5];", NoSpaceStyle);
11615   verifyFormat("a[3] += 42;", NoSpaceStyle);
11616 
11617   verifyFormat("int a[1];", NoSpaceStyle);
11618   verifyFormat("int 1 [a];", NoSpaceStyle);
11619   verifyFormat("int a[1][2];", NoSpaceStyle);
11620   verifyFormat("a[7] = 5;", NoSpaceStyle);
11621   verifyFormat("int a = (f())[23];", NoSpaceStyle);
11622   verifyFormat("f([] {})", NoSpaceStyle);
11623 
11624   FormatStyle Space = getLLVMStyle();
11625   Space.SpaceBeforeSquareBrackets = true;
11626   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
11627   verifyFormat("return [i, args...] {};", Space);
11628 
11629   verifyFormat("int a [5];", Space);
11630   verifyFormat("a [3] += 42;", Space);
11631   verifyFormat("constexpr char hello []{\"hello\"};", Space);
11632   verifyFormat("double &operator[](int i) { return 0; }\n"
11633                "int i;",
11634                Space);
11635   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
11636   verifyFormat("int i = a [a][a]->f();", Space);
11637   verifyFormat("int i = (*b) [a]->f();", Space);
11638 
11639   verifyFormat("int a [1];", Space);
11640   verifyFormat("int 1 [a];", Space);
11641   verifyFormat("int a [1][2];", Space);
11642   verifyFormat("a [7] = 5;", Space);
11643   verifyFormat("int a = (f()) [23];", Space);
11644   verifyFormat("f([] {})", Space);
11645 }
11646 
11647 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
11648   verifyFormat("int a = 5;");
11649   verifyFormat("a += 42;");
11650   verifyFormat("a or_eq 8;");
11651 
11652   FormatStyle Spaces = getLLVMStyle();
11653   Spaces.SpaceBeforeAssignmentOperators = false;
11654   verifyFormat("int a= 5;", Spaces);
11655   verifyFormat("a+= 42;", Spaces);
11656   verifyFormat("a or_eq 8;", Spaces);
11657 }
11658 
11659 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
11660   verifyFormat("class Foo : public Bar {};");
11661   verifyFormat("Foo::Foo() : foo(1) {}");
11662   verifyFormat("for (auto a : b) {\n}");
11663   verifyFormat("int x = a ? b : c;");
11664   verifyFormat("{\n"
11665                "label0:\n"
11666                "  int x = 0;\n"
11667                "}");
11668   verifyFormat("switch (x) {\n"
11669                "case 1:\n"
11670                "default:\n"
11671                "}");
11672 
11673   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
11674   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
11675   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
11676   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
11677   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
11678   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
11679   verifyFormat("{\n"
11680                "label1:\n"
11681                "  int x = 0;\n"
11682                "}",
11683                CtorInitializerStyle);
11684   verifyFormat("switch (x) {\n"
11685                "case 1:\n"
11686                "default:\n"
11687                "}",
11688                CtorInitializerStyle);
11689   CtorInitializerStyle.BreakConstructorInitializers =
11690       FormatStyle::BCIS_AfterColon;
11691   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
11692                "    aaaaaaaaaaaaaaaa(1),\n"
11693                "    bbbbbbbbbbbbbbbb(2) {}",
11694                CtorInitializerStyle);
11695   CtorInitializerStyle.BreakConstructorInitializers =
11696       FormatStyle::BCIS_BeforeComma;
11697   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11698                "    : aaaaaaaaaaaaaaaa(1)\n"
11699                "    , bbbbbbbbbbbbbbbb(2) {}",
11700                CtorInitializerStyle);
11701   CtorInitializerStyle.BreakConstructorInitializers =
11702       FormatStyle::BCIS_BeforeColon;
11703   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11704                "    : aaaaaaaaaaaaaaaa(1),\n"
11705                "      bbbbbbbbbbbbbbbb(2) {}",
11706                CtorInitializerStyle);
11707   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
11708   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11709                ": aaaaaaaaaaaaaaaa(1),\n"
11710                "  bbbbbbbbbbbbbbbb(2) {}",
11711                CtorInitializerStyle);
11712 
11713   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
11714   InheritanceStyle.SpaceBeforeInheritanceColon = false;
11715   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
11716   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
11717   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
11718   verifyFormat("int x = a ? b : c;", InheritanceStyle);
11719   verifyFormat("{\n"
11720                "label2:\n"
11721                "  int x = 0;\n"
11722                "}",
11723                InheritanceStyle);
11724   verifyFormat("switch (x) {\n"
11725                "case 1:\n"
11726                "default:\n"
11727                "}",
11728                InheritanceStyle);
11729   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
11730   verifyFormat("class Foooooooooooooooooooooo:\n"
11731                "    public aaaaaaaaaaaaaaaaaa,\n"
11732                "    public bbbbbbbbbbbbbbbbbb {\n"
11733                "}",
11734                InheritanceStyle);
11735   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
11736   verifyFormat("class Foooooooooooooooooooooo\n"
11737                "    : public aaaaaaaaaaaaaaaaaa\n"
11738                "    , public bbbbbbbbbbbbbbbbbb {\n"
11739                "}",
11740                InheritanceStyle);
11741   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
11742   verifyFormat("class Foooooooooooooooooooooo\n"
11743                "    : public aaaaaaaaaaaaaaaaaa,\n"
11744                "      public bbbbbbbbbbbbbbbbbb {\n"
11745                "}",
11746                InheritanceStyle);
11747   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
11748   verifyFormat("class Foooooooooooooooooooooo\n"
11749                ": public aaaaaaaaaaaaaaaaaa,\n"
11750                "  public bbbbbbbbbbbbbbbbbb {}",
11751                InheritanceStyle);
11752 
11753   FormatStyle ForLoopStyle = getLLVMStyle();
11754   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
11755   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
11756   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
11757   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
11758   verifyFormat("int x = a ? b : c;", ForLoopStyle);
11759   verifyFormat("{\n"
11760                "label2:\n"
11761                "  int x = 0;\n"
11762                "}",
11763                ForLoopStyle);
11764   verifyFormat("switch (x) {\n"
11765                "case 1:\n"
11766                "default:\n"
11767                "}",
11768                ForLoopStyle);
11769 
11770   FormatStyle NoSpaceStyle = getLLVMStyle();
11771   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
11772   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
11773   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
11774   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
11775   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
11776   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
11777   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
11778   verifyFormat("{\n"
11779                "label3:\n"
11780                "  int x = 0;\n"
11781                "}",
11782                NoSpaceStyle);
11783   verifyFormat("switch (x) {\n"
11784                "case 1:\n"
11785                "default:\n"
11786                "}",
11787                NoSpaceStyle);
11788 }
11789 
11790 TEST_F(FormatTest, AlignConsecutiveMacros) {
11791   FormatStyle Style = getLLVMStyle();
11792   Style.AlignConsecutiveAssignments = true;
11793   Style.AlignConsecutiveDeclarations = true;
11794   Style.AlignConsecutiveMacros = false;
11795 
11796   verifyFormat("#define a 3\n"
11797                "#define bbbb 4\n"
11798                "#define ccc (5)",
11799                Style);
11800 
11801   verifyFormat("#define f(x) (x * x)\n"
11802                "#define fff(x, y, z) (x * y + z)\n"
11803                "#define ffff(x, y) (x - y)",
11804                Style);
11805 
11806   verifyFormat("#define foo(x, y) (x + y)\n"
11807                "#define bar (5, 6)(2 + 2)",
11808                Style);
11809 
11810   verifyFormat("#define a 3\n"
11811                "#define bbbb 4\n"
11812                "#define ccc (5)\n"
11813                "#define f(x) (x * x)\n"
11814                "#define fff(x, y, z) (x * y + z)\n"
11815                "#define ffff(x, y) (x - y)",
11816                Style);
11817 
11818   Style.AlignConsecutiveMacros = true;
11819   verifyFormat("#define a    3\n"
11820                "#define bbbb 4\n"
11821                "#define ccc  (5)",
11822                Style);
11823 
11824   verifyFormat("#define f(x)         (x * x)\n"
11825                "#define fff(x, y, z) (x * y + z)\n"
11826                "#define ffff(x, y)   (x - y)",
11827                Style);
11828 
11829   verifyFormat("#define foo(x, y) (x + y)\n"
11830                "#define bar       (5, 6)(2 + 2)",
11831                Style);
11832 
11833   verifyFormat("#define a            3\n"
11834                "#define bbbb         4\n"
11835                "#define ccc          (5)\n"
11836                "#define f(x)         (x * x)\n"
11837                "#define fff(x, y, z) (x * y + z)\n"
11838                "#define ffff(x, y)   (x - y)",
11839                Style);
11840 
11841   verifyFormat("#define a         5\n"
11842                "#define foo(x, y) (x + y)\n"
11843                "#define CCC       (6)\n"
11844                "auto lambda = []() {\n"
11845                "  auto  ii = 0;\n"
11846                "  float j  = 0;\n"
11847                "  return 0;\n"
11848                "};\n"
11849                "int   i  = 0;\n"
11850                "float i2 = 0;\n"
11851                "auto  v  = type{\n"
11852                "    i = 1,   //\n"
11853                "    (i = 2), //\n"
11854                "    i = 3    //\n"
11855                "};",
11856                Style);
11857 
11858   Style.AlignConsecutiveMacros = false;
11859   Style.ColumnLimit = 20;
11860 
11861   verifyFormat("#define a          \\\n"
11862                "  \"aabbbbbbbbbbbb\"\n"
11863                "#define D          \\\n"
11864                "  \"aabbbbbbbbbbbb\" \\\n"
11865                "  \"ccddeeeeeeeee\"\n"
11866                "#define B          \\\n"
11867                "  \"QQQQQQQQQQQQQ\"  \\\n"
11868                "  \"FFFFFFFFFFFFF\"  \\\n"
11869                "  \"LLLLLLLL\"\n",
11870                Style);
11871 
11872   Style.AlignConsecutiveMacros = true;
11873   verifyFormat("#define a          \\\n"
11874                "  \"aabbbbbbbbbbbb\"\n"
11875                "#define D          \\\n"
11876                "  \"aabbbbbbbbbbbb\" \\\n"
11877                "  \"ccddeeeeeeeee\"\n"
11878                "#define B          \\\n"
11879                "  \"QQQQQQQQQQQQQ\"  \\\n"
11880                "  \"FFFFFFFFFFFFF\"  \\\n"
11881                "  \"LLLLLLLL\"\n",
11882                Style);
11883 }
11884 
11885 TEST_F(FormatTest, AlignConsecutiveAssignments) {
11886   FormatStyle Alignment = getLLVMStyle();
11887   Alignment.AlignConsecutiveMacros = true;
11888   Alignment.AlignConsecutiveAssignments = false;
11889   verifyFormat("int a = 5;\n"
11890                "int oneTwoThree = 123;",
11891                Alignment);
11892   verifyFormat("int a = 5;\n"
11893                "int oneTwoThree = 123;",
11894                Alignment);
11895 
11896   Alignment.AlignConsecutiveAssignments = true;
11897   verifyFormat("int a           = 5;\n"
11898                "int oneTwoThree = 123;",
11899                Alignment);
11900   verifyFormat("int a           = method();\n"
11901                "int oneTwoThree = 133;",
11902                Alignment);
11903   verifyFormat("a &= 5;\n"
11904                "bcd *= 5;\n"
11905                "ghtyf += 5;\n"
11906                "dvfvdb -= 5;\n"
11907                "a /= 5;\n"
11908                "vdsvsv %= 5;\n"
11909                "sfdbddfbdfbb ^= 5;\n"
11910                "dvsdsv |= 5;\n"
11911                "int dsvvdvsdvvv = 123;",
11912                Alignment);
11913   verifyFormat("int i = 1, j = 10;\n"
11914                "something = 2000;",
11915                Alignment);
11916   verifyFormat("something = 2000;\n"
11917                "int i = 1, j = 10;\n",
11918                Alignment);
11919   verifyFormat("something = 2000;\n"
11920                "another   = 911;\n"
11921                "int i = 1, j = 10;\n"
11922                "oneMore = 1;\n"
11923                "i       = 2;",
11924                Alignment);
11925   verifyFormat("int a   = 5;\n"
11926                "int one = 1;\n"
11927                "method();\n"
11928                "int oneTwoThree = 123;\n"
11929                "int oneTwo      = 12;",
11930                Alignment);
11931   verifyFormat("int oneTwoThree = 123;\n"
11932                "int oneTwo      = 12;\n"
11933                "method();\n",
11934                Alignment);
11935   verifyFormat("int oneTwoThree = 123; // comment\n"
11936                "int oneTwo      = 12;  // comment",
11937                Alignment);
11938 
11939   // Bug 25167
11940   verifyFormat("#if A\n"
11941                "#else\n"
11942                "int aaaaaaaa = 12;\n"
11943                "#endif\n"
11944                "#if B\n"
11945                "#else\n"
11946                "int a = 12;\n"
11947                "#endif\n",
11948                Alignment);
11949   verifyFormat("enum foo {\n"
11950                "#if A\n"
11951                "#else\n"
11952                "  aaaaaaaa = 12;\n"
11953                "#endif\n"
11954                "#if B\n"
11955                "#else\n"
11956                "  a = 12;\n"
11957                "#endif\n"
11958                "};\n",
11959                Alignment);
11960 
11961   EXPECT_EQ("int a = 5;\n"
11962             "\n"
11963             "int oneTwoThree = 123;",
11964             format("int a       = 5;\n"
11965                    "\n"
11966                    "int oneTwoThree= 123;",
11967                    Alignment));
11968   EXPECT_EQ("int a   = 5;\n"
11969             "int one = 1;\n"
11970             "\n"
11971             "int oneTwoThree = 123;",
11972             format("int a = 5;\n"
11973                    "int one = 1;\n"
11974                    "\n"
11975                    "int oneTwoThree = 123;",
11976                    Alignment));
11977   EXPECT_EQ("int a   = 5;\n"
11978             "int one = 1;\n"
11979             "\n"
11980             "int oneTwoThree = 123;\n"
11981             "int oneTwo      = 12;",
11982             format("int a = 5;\n"
11983                    "int one = 1;\n"
11984                    "\n"
11985                    "int oneTwoThree = 123;\n"
11986                    "int oneTwo = 12;",
11987                    Alignment));
11988   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
11989   verifyFormat("#define A \\\n"
11990                "  int aaaa       = 12; \\\n"
11991                "  int b          = 23; \\\n"
11992                "  int ccc        = 234; \\\n"
11993                "  int dddddddddd = 2345;",
11994                Alignment);
11995   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
11996   verifyFormat("#define A               \\\n"
11997                "  int aaaa       = 12;  \\\n"
11998                "  int b          = 23;  \\\n"
11999                "  int ccc        = 234; \\\n"
12000                "  int dddddddddd = 2345;",
12001                Alignment);
12002   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12003   verifyFormat("#define A                                                      "
12004                "                \\\n"
12005                "  int aaaa       = 12;                                         "
12006                "                \\\n"
12007                "  int b          = 23;                                         "
12008                "                \\\n"
12009                "  int ccc        = 234;                                        "
12010                "                \\\n"
12011                "  int dddddddddd = 2345;",
12012                Alignment);
12013   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12014                "k = 4, int l = 5,\n"
12015                "                  int m = 6) {\n"
12016                "  int j      = 10;\n"
12017                "  otherThing = 1;\n"
12018                "}",
12019                Alignment);
12020   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12021                "  int i   = 1;\n"
12022                "  int j   = 2;\n"
12023                "  int big = 10000;\n"
12024                "}",
12025                Alignment);
12026   verifyFormat("class C {\n"
12027                "public:\n"
12028                "  int i            = 1;\n"
12029                "  virtual void f() = 0;\n"
12030                "};",
12031                Alignment);
12032   verifyFormat("int i = 1;\n"
12033                "if (SomeType t = getSomething()) {\n"
12034                "}\n"
12035                "int j   = 2;\n"
12036                "int big = 10000;",
12037                Alignment);
12038   verifyFormat("int j = 7;\n"
12039                "for (int k = 0; k < N; ++k) {\n"
12040                "}\n"
12041                "int j   = 2;\n"
12042                "int big = 10000;\n"
12043                "}",
12044                Alignment);
12045   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12046   verifyFormat("int i = 1;\n"
12047                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12048                "    = someLooooooooooooooooongFunction();\n"
12049                "int j = 2;",
12050                Alignment);
12051   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12052   verifyFormat("int i = 1;\n"
12053                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12054                "    someLooooooooooooooooongFunction();\n"
12055                "int j = 2;",
12056                Alignment);
12057 
12058   verifyFormat("auto lambda = []() {\n"
12059                "  auto i = 0;\n"
12060                "  return 0;\n"
12061                "};\n"
12062                "int i  = 0;\n"
12063                "auto v = type{\n"
12064                "    i = 1,   //\n"
12065                "    (i = 2), //\n"
12066                "    i = 3    //\n"
12067                "};",
12068                Alignment);
12069 
12070   verifyFormat(
12071       "int i      = 1;\n"
12072       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12073       "                          loooooooooooooooooooooongParameterB);\n"
12074       "int j      = 2;",
12075       Alignment);
12076 
12077   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12078                "          typename B   = very_long_type_name_1,\n"
12079                "          typename T_2 = very_long_type_name_2>\n"
12080                "auto foo() {}\n",
12081                Alignment);
12082   verifyFormat("int a, b = 1;\n"
12083                "int c  = 2;\n"
12084                "int dd = 3;\n",
12085                Alignment);
12086   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12087                "float b[1][] = {{3.f}};\n",
12088                Alignment);
12089   verifyFormat("for (int i = 0; i < 1; i++)\n"
12090                "  int x = 1;\n",
12091                Alignment);
12092   verifyFormat("for (i = 0; i < 1; i++)\n"
12093                "  x = 1;\n"
12094                "y = 1;\n",
12095                Alignment);
12096 
12097   Alignment.ReflowComments = true;
12098   Alignment.ColumnLimit = 50;
12099   EXPECT_EQ("int x   = 0;\n"
12100             "int yy  = 1; /// specificlennospace\n"
12101             "int zzz = 2;\n",
12102             format("int x   = 0;\n"
12103                    "int yy  = 1; ///specificlennospace\n"
12104                    "int zzz = 2;\n",
12105                    Alignment));
12106 }
12107 
12108 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12109   FormatStyle Alignment = getLLVMStyle();
12110   Alignment.AlignConsecutiveBitFields = true;
12111   verifyFormat("int const a     : 5;\n"
12112                "int oneTwoThree : 23;",
12113                Alignment);
12114 
12115   // Initializers are allowed starting with c++2a
12116   verifyFormat("int const a     : 5 = 1;\n"
12117                "int oneTwoThree : 23 = 0;",
12118                Alignment);
12119 
12120   Alignment.AlignConsecutiveDeclarations = true;
12121   verifyFormat("int const a           : 5;\n"
12122                "int       oneTwoThree : 23;",
12123                Alignment);
12124 
12125   verifyFormat("int const a           : 5;  // comment\n"
12126                "int       oneTwoThree : 23; // comment",
12127                Alignment);
12128 
12129   verifyFormat("int const a           : 5 = 1;\n"
12130                "int       oneTwoThree : 23 = 0;",
12131                Alignment);
12132 
12133   Alignment.AlignConsecutiveAssignments = true;
12134   verifyFormat("int const a           : 5  = 1;\n"
12135                "int       oneTwoThree : 23 = 0;",
12136                Alignment);
12137   verifyFormat("int const a           : 5  = {1};\n"
12138                "int       oneTwoThree : 23 = 0;",
12139                Alignment);
12140 
12141   // Known limitations: ':' is only recognized as a bitfield colon when
12142   // followed by a number.
12143   /*
12144   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12145                "int a           : 5;",
12146                Alignment);
12147   */
12148 }
12149 
12150 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12151   FormatStyle Alignment = getLLVMStyle();
12152   Alignment.AlignConsecutiveMacros = true;
12153   Alignment.AlignConsecutiveDeclarations = false;
12154   verifyFormat("float const a = 5;\n"
12155                "int oneTwoThree = 123;",
12156                Alignment);
12157   verifyFormat("int a = 5;\n"
12158                "float const oneTwoThree = 123;",
12159                Alignment);
12160 
12161   Alignment.AlignConsecutiveDeclarations = true;
12162   verifyFormat("float const a = 5;\n"
12163                "int         oneTwoThree = 123;",
12164                Alignment);
12165   verifyFormat("int         a = method();\n"
12166                "float const oneTwoThree = 133;",
12167                Alignment);
12168   verifyFormat("int i = 1, j = 10;\n"
12169                "something = 2000;",
12170                Alignment);
12171   verifyFormat("something = 2000;\n"
12172                "int i = 1, j = 10;\n",
12173                Alignment);
12174   verifyFormat("float      something = 2000;\n"
12175                "double     another = 911;\n"
12176                "int        i = 1, j = 10;\n"
12177                "const int *oneMore = 1;\n"
12178                "unsigned   i = 2;",
12179                Alignment);
12180   verifyFormat("float a = 5;\n"
12181                "int   one = 1;\n"
12182                "method();\n"
12183                "const double       oneTwoThree = 123;\n"
12184                "const unsigned int oneTwo = 12;",
12185                Alignment);
12186   verifyFormat("int      oneTwoThree{0}; // comment\n"
12187                "unsigned oneTwo;         // comment",
12188                Alignment);
12189   EXPECT_EQ("float const a = 5;\n"
12190             "\n"
12191             "int oneTwoThree = 123;",
12192             format("float const   a = 5;\n"
12193                    "\n"
12194                    "int           oneTwoThree= 123;",
12195                    Alignment));
12196   EXPECT_EQ("float a = 5;\n"
12197             "int   one = 1;\n"
12198             "\n"
12199             "unsigned oneTwoThree = 123;",
12200             format("float    a = 5;\n"
12201                    "int      one = 1;\n"
12202                    "\n"
12203                    "unsigned oneTwoThree = 123;",
12204                    Alignment));
12205   EXPECT_EQ("float a = 5;\n"
12206             "int   one = 1;\n"
12207             "\n"
12208             "unsigned oneTwoThree = 123;\n"
12209             "int      oneTwo = 12;",
12210             format("float    a = 5;\n"
12211                    "int one = 1;\n"
12212                    "\n"
12213                    "unsigned oneTwoThree = 123;\n"
12214                    "int oneTwo = 12;",
12215                    Alignment));
12216   // Function prototype alignment
12217   verifyFormat("int    a();\n"
12218                "double b();",
12219                Alignment);
12220   verifyFormat("int    a(int x);\n"
12221                "double b();",
12222                Alignment);
12223   unsigned OldColumnLimit = Alignment.ColumnLimit;
12224   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12225   // otherwise the function parameters will be re-flowed onto a single line.
12226   Alignment.ColumnLimit = 0;
12227   EXPECT_EQ("int    a(int   x,\n"
12228             "         float y);\n"
12229             "double b(int    x,\n"
12230             "         double y);",
12231             format("int a(int x,\n"
12232                    " float y);\n"
12233                    "double b(int x,\n"
12234                    " double y);",
12235                    Alignment));
12236   // This ensures that function parameters of function declarations are
12237   // correctly indented when their owning functions are indented.
12238   // The failure case here is for 'double y' to not be indented enough.
12239   EXPECT_EQ("double a(int x);\n"
12240             "int    b(int    y,\n"
12241             "         double z);",
12242             format("double a(int x);\n"
12243                    "int b(int y,\n"
12244                    " double z);",
12245                    Alignment));
12246   // Set ColumnLimit low so that we induce wrapping immediately after
12247   // the function name and opening paren.
12248   Alignment.ColumnLimit = 13;
12249   verifyFormat("int function(\n"
12250                "    int  x,\n"
12251                "    bool y);",
12252                Alignment);
12253   Alignment.ColumnLimit = OldColumnLimit;
12254   // Ensure function pointers don't screw up recursive alignment
12255   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12256                "double b();",
12257                Alignment);
12258   Alignment.AlignConsecutiveAssignments = true;
12259   // Ensure recursive alignment is broken by function braces, so that the
12260   // "a = 1" does not align with subsequent assignments inside the function
12261   // body.
12262   verifyFormat("int func(int a = 1) {\n"
12263                "  int b  = 2;\n"
12264                "  int cc = 3;\n"
12265                "}",
12266                Alignment);
12267   verifyFormat("float      something = 2000;\n"
12268                "double     another   = 911;\n"
12269                "int        i = 1, j = 10;\n"
12270                "const int *oneMore = 1;\n"
12271                "unsigned   i       = 2;",
12272                Alignment);
12273   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12274                "unsigned oneTwo      = 0;   // comment",
12275                Alignment);
12276   // Make sure that scope is correctly tracked, in the absence of braces
12277   verifyFormat("for (int i = 0; i < n; i++)\n"
12278                "  j = i;\n"
12279                "double x = 1;\n",
12280                Alignment);
12281   verifyFormat("if (int i = 0)\n"
12282                "  j = i;\n"
12283                "double x = 1;\n",
12284                Alignment);
12285   // Ensure operator[] and operator() are comprehended
12286   verifyFormat("struct test {\n"
12287                "  long long int foo();\n"
12288                "  int           operator[](int a);\n"
12289                "  double        bar();\n"
12290                "};\n",
12291                Alignment);
12292   verifyFormat("struct test {\n"
12293                "  long long int foo();\n"
12294                "  int           operator()(int a);\n"
12295                "  double        bar();\n"
12296                "};\n",
12297                Alignment);
12298   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12299             "  int const i   = 1;\n"
12300             "  int *     j   = 2;\n"
12301             "  int       big = 10000;\n"
12302             "\n"
12303             "  unsigned oneTwoThree = 123;\n"
12304             "  int      oneTwo      = 12;\n"
12305             "  method();\n"
12306             "  float k  = 2;\n"
12307             "  int   ll = 10000;\n"
12308             "}",
12309             format("void SomeFunction(int parameter= 0) {\n"
12310                    " int const  i= 1;\n"
12311                    "  int *j=2;\n"
12312                    " int big  =  10000;\n"
12313                    "\n"
12314                    "unsigned oneTwoThree  =123;\n"
12315                    "int oneTwo = 12;\n"
12316                    "  method();\n"
12317                    "float k= 2;\n"
12318                    "int ll=10000;\n"
12319                    "}",
12320                    Alignment));
12321   Alignment.AlignConsecutiveAssignments = false;
12322   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12323   verifyFormat("#define A \\\n"
12324                "  int       aaaa = 12; \\\n"
12325                "  float     b = 23; \\\n"
12326                "  const int ccc = 234; \\\n"
12327                "  unsigned  dddddddddd = 2345;",
12328                Alignment);
12329   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12330   verifyFormat("#define A              \\\n"
12331                "  int       aaaa = 12; \\\n"
12332                "  float     b = 23;    \\\n"
12333                "  const int ccc = 234; \\\n"
12334                "  unsigned  dddddddddd = 2345;",
12335                Alignment);
12336   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12337   Alignment.ColumnLimit = 30;
12338   verifyFormat("#define A                    \\\n"
12339                "  int       aaaa = 12;       \\\n"
12340                "  float     b = 23;          \\\n"
12341                "  const int ccc = 234;       \\\n"
12342                "  int       dddddddddd = 2345;",
12343                Alignment);
12344   Alignment.ColumnLimit = 80;
12345   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12346                "k = 4, int l = 5,\n"
12347                "                  int m = 6) {\n"
12348                "  const int j = 10;\n"
12349                "  otherThing = 1;\n"
12350                "}",
12351                Alignment);
12352   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12353                "  int const i = 1;\n"
12354                "  int *     j = 2;\n"
12355                "  int       big = 10000;\n"
12356                "}",
12357                Alignment);
12358   verifyFormat("class C {\n"
12359                "public:\n"
12360                "  int          i = 1;\n"
12361                "  virtual void f() = 0;\n"
12362                "};",
12363                Alignment);
12364   verifyFormat("float i = 1;\n"
12365                "if (SomeType t = getSomething()) {\n"
12366                "}\n"
12367                "const unsigned j = 2;\n"
12368                "int            big = 10000;",
12369                Alignment);
12370   verifyFormat("float j = 7;\n"
12371                "for (int k = 0; k < N; ++k) {\n"
12372                "}\n"
12373                "unsigned j = 2;\n"
12374                "int      big = 10000;\n"
12375                "}",
12376                Alignment);
12377   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12378   verifyFormat("float              i = 1;\n"
12379                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12380                "    = someLooooooooooooooooongFunction();\n"
12381                "int j = 2;",
12382                Alignment);
12383   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12384   verifyFormat("int                i = 1;\n"
12385                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12386                "    someLooooooooooooooooongFunction();\n"
12387                "int j = 2;",
12388                Alignment);
12389 
12390   Alignment.AlignConsecutiveAssignments = true;
12391   verifyFormat("auto lambda = []() {\n"
12392                "  auto  ii = 0;\n"
12393                "  float j  = 0;\n"
12394                "  return 0;\n"
12395                "};\n"
12396                "int   i  = 0;\n"
12397                "float i2 = 0;\n"
12398                "auto  v  = type{\n"
12399                "    i = 1,   //\n"
12400                "    (i = 2), //\n"
12401                "    i = 3    //\n"
12402                "};",
12403                Alignment);
12404   Alignment.AlignConsecutiveAssignments = false;
12405 
12406   verifyFormat(
12407       "int      i = 1;\n"
12408       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12409       "                          loooooooooooooooooooooongParameterB);\n"
12410       "int      j = 2;",
12411       Alignment);
12412 
12413   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12414   // We expect declarations and assignments to align, as long as it doesn't
12415   // exceed the column limit, starting a new alignment sequence whenever it
12416   // happens.
12417   Alignment.AlignConsecutiveAssignments = true;
12418   Alignment.ColumnLimit = 30;
12419   verifyFormat("float    ii              = 1;\n"
12420                "unsigned j               = 2;\n"
12421                "int someVerylongVariable = 1;\n"
12422                "AnotherLongType  ll = 123456;\n"
12423                "VeryVeryLongType k  = 2;\n"
12424                "int              myvar = 1;",
12425                Alignment);
12426   Alignment.ColumnLimit = 80;
12427   Alignment.AlignConsecutiveAssignments = false;
12428 
12429   verifyFormat(
12430       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12431       "          typename LongType, typename B>\n"
12432       "auto foo() {}\n",
12433       Alignment);
12434   verifyFormat("float a, b = 1;\n"
12435                "int   c = 2;\n"
12436                "int   dd = 3;\n",
12437                Alignment);
12438   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12439                "float b[1][] = {{3.f}};\n",
12440                Alignment);
12441   Alignment.AlignConsecutiveAssignments = true;
12442   verifyFormat("float a, b = 1;\n"
12443                "int   c  = 2;\n"
12444                "int   dd = 3;\n",
12445                Alignment);
12446   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12447                "float b[1][] = {{3.f}};\n",
12448                Alignment);
12449   Alignment.AlignConsecutiveAssignments = false;
12450 
12451   Alignment.ColumnLimit = 30;
12452   Alignment.BinPackParameters = false;
12453   verifyFormat("void foo(float     a,\n"
12454                "         float     b,\n"
12455                "         int       c,\n"
12456                "         uint32_t *d) {\n"
12457                "  int *  e = 0;\n"
12458                "  float  f = 0;\n"
12459                "  double g = 0;\n"
12460                "}\n"
12461                "void bar(ino_t     a,\n"
12462                "         int       b,\n"
12463                "         uint32_t *c,\n"
12464                "         bool      d) {}\n",
12465                Alignment);
12466   Alignment.BinPackParameters = true;
12467   Alignment.ColumnLimit = 80;
12468 
12469   // Bug 33507
12470   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12471   verifyFormat(
12472       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12473       "  static const Version verVs2017;\n"
12474       "  return true;\n"
12475       "});\n",
12476       Alignment);
12477   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12478 
12479   // See llvm.org/PR35641
12480   Alignment.AlignConsecutiveDeclarations = true;
12481   verifyFormat("int func() { //\n"
12482                "  int      b;\n"
12483                "  unsigned c;\n"
12484                "}",
12485                Alignment);
12486 
12487   // See PR37175
12488   FormatStyle Style = getMozillaStyle();
12489   Style.AlignConsecutiveDeclarations = true;
12490   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12491             "foo(int a);",
12492             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12493 }
12494 
12495 TEST_F(FormatTest, LinuxBraceBreaking) {
12496   FormatStyle LinuxBraceStyle = getLLVMStyle();
12497   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12498   verifyFormat("namespace a\n"
12499                "{\n"
12500                "class A\n"
12501                "{\n"
12502                "  void f()\n"
12503                "  {\n"
12504                "    if (true) {\n"
12505                "      a();\n"
12506                "      b();\n"
12507                "    } else {\n"
12508                "      a();\n"
12509                "    }\n"
12510                "  }\n"
12511                "  void g() { return; }\n"
12512                "};\n"
12513                "struct B {\n"
12514                "  int x;\n"
12515                "};\n"
12516                "} // namespace a\n",
12517                LinuxBraceStyle);
12518   verifyFormat("enum X {\n"
12519                "  Y = 0,\n"
12520                "}\n",
12521                LinuxBraceStyle);
12522   verifyFormat("struct S {\n"
12523                "  int Type;\n"
12524                "  union {\n"
12525                "    int x;\n"
12526                "    double y;\n"
12527                "  } Value;\n"
12528                "  class C\n"
12529                "  {\n"
12530                "    MyFavoriteType Value;\n"
12531                "  } Class;\n"
12532                "}\n",
12533                LinuxBraceStyle);
12534 }
12535 
12536 TEST_F(FormatTest, MozillaBraceBreaking) {
12537   FormatStyle MozillaBraceStyle = getLLVMStyle();
12538   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
12539   MozillaBraceStyle.FixNamespaceComments = false;
12540   verifyFormat("namespace a {\n"
12541                "class A\n"
12542                "{\n"
12543                "  void f()\n"
12544                "  {\n"
12545                "    if (true) {\n"
12546                "      a();\n"
12547                "      b();\n"
12548                "    }\n"
12549                "  }\n"
12550                "  void g() { return; }\n"
12551                "};\n"
12552                "enum E\n"
12553                "{\n"
12554                "  A,\n"
12555                "  // foo\n"
12556                "  B,\n"
12557                "  C\n"
12558                "};\n"
12559                "struct B\n"
12560                "{\n"
12561                "  int x;\n"
12562                "};\n"
12563                "}\n",
12564                MozillaBraceStyle);
12565   verifyFormat("struct S\n"
12566                "{\n"
12567                "  int Type;\n"
12568                "  union\n"
12569                "  {\n"
12570                "    int x;\n"
12571                "    double y;\n"
12572                "  } Value;\n"
12573                "  class C\n"
12574                "  {\n"
12575                "    MyFavoriteType Value;\n"
12576                "  } Class;\n"
12577                "}\n",
12578                MozillaBraceStyle);
12579 }
12580 
12581 TEST_F(FormatTest, StroustrupBraceBreaking) {
12582   FormatStyle StroustrupBraceStyle = getLLVMStyle();
12583   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12584   verifyFormat("namespace a {\n"
12585                "class A {\n"
12586                "  void f()\n"
12587                "  {\n"
12588                "    if (true) {\n"
12589                "      a();\n"
12590                "      b();\n"
12591                "    }\n"
12592                "  }\n"
12593                "  void g() { return; }\n"
12594                "};\n"
12595                "struct B {\n"
12596                "  int x;\n"
12597                "};\n"
12598                "} // namespace a\n",
12599                StroustrupBraceStyle);
12600 
12601   verifyFormat("void foo()\n"
12602                "{\n"
12603                "  if (a) {\n"
12604                "    a();\n"
12605                "  }\n"
12606                "  else {\n"
12607                "    b();\n"
12608                "  }\n"
12609                "}\n",
12610                StroustrupBraceStyle);
12611 
12612   verifyFormat("#ifdef _DEBUG\n"
12613                "int foo(int i = 0)\n"
12614                "#else\n"
12615                "int foo(int i = 5)\n"
12616                "#endif\n"
12617                "{\n"
12618                "  return i;\n"
12619                "}",
12620                StroustrupBraceStyle);
12621 
12622   verifyFormat("void foo() {}\n"
12623                "void bar()\n"
12624                "#ifdef _DEBUG\n"
12625                "{\n"
12626                "  foo();\n"
12627                "}\n"
12628                "#else\n"
12629                "{\n"
12630                "}\n"
12631                "#endif",
12632                StroustrupBraceStyle);
12633 
12634   verifyFormat("void foobar() { int i = 5; }\n"
12635                "#ifdef _DEBUG\n"
12636                "void bar() {}\n"
12637                "#else\n"
12638                "void bar() { foobar(); }\n"
12639                "#endif",
12640                StroustrupBraceStyle);
12641 }
12642 
12643 TEST_F(FormatTest, AllmanBraceBreaking) {
12644   FormatStyle AllmanBraceStyle = getLLVMStyle();
12645   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
12646 
12647   EXPECT_EQ("namespace a\n"
12648             "{\n"
12649             "void f();\n"
12650             "void g();\n"
12651             "} // namespace a\n",
12652             format("namespace a\n"
12653                    "{\n"
12654                    "void f();\n"
12655                    "void g();\n"
12656                    "}\n",
12657                    AllmanBraceStyle));
12658 
12659   verifyFormat("namespace a\n"
12660                "{\n"
12661                "class A\n"
12662                "{\n"
12663                "  void f()\n"
12664                "  {\n"
12665                "    if (true)\n"
12666                "    {\n"
12667                "      a();\n"
12668                "      b();\n"
12669                "    }\n"
12670                "  }\n"
12671                "  void g() { return; }\n"
12672                "};\n"
12673                "struct B\n"
12674                "{\n"
12675                "  int x;\n"
12676                "};\n"
12677                "union C\n"
12678                "{\n"
12679                "};\n"
12680                "} // namespace a",
12681                AllmanBraceStyle);
12682 
12683   verifyFormat("void f()\n"
12684                "{\n"
12685                "  if (true)\n"
12686                "  {\n"
12687                "    a();\n"
12688                "  }\n"
12689                "  else if (false)\n"
12690                "  {\n"
12691                "    b();\n"
12692                "  }\n"
12693                "  else\n"
12694                "  {\n"
12695                "    c();\n"
12696                "  }\n"
12697                "}\n",
12698                AllmanBraceStyle);
12699 
12700   verifyFormat("void f()\n"
12701                "{\n"
12702                "  for (int i = 0; i < 10; ++i)\n"
12703                "  {\n"
12704                "    a();\n"
12705                "  }\n"
12706                "  while (false)\n"
12707                "  {\n"
12708                "    b();\n"
12709                "  }\n"
12710                "  do\n"
12711                "  {\n"
12712                "    c();\n"
12713                "  } while (false)\n"
12714                "}\n",
12715                AllmanBraceStyle);
12716 
12717   verifyFormat("void f(int a)\n"
12718                "{\n"
12719                "  switch (a)\n"
12720                "  {\n"
12721                "  case 0:\n"
12722                "    break;\n"
12723                "  case 1:\n"
12724                "  {\n"
12725                "    break;\n"
12726                "  }\n"
12727                "  case 2:\n"
12728                "  {\n"
12729                "  }\n"
12730                "  break;\n"
12731                "  default:\n"
12732                "    break;\n"
12733                "  }\n"
12734                "}\n",
12735                AllmanBraceStyle);
12736 
12737   verifyFormat("enum X\n"
12738                "{\n"
12739                "  Y = 0,\n"
12740                "}\n",
12741                AllmanBraceStyle);
12742   verifyFormat("enum X\n"
12743                "{\n"
12744                "  Y = 0\n"
12745                "}\n",
12746                AllmanBraceStyle);
12747 
12748   verifyFormat("@interface BSApplicationController ()\n"
12749                "{\n"
12750                "@private\n"
12751                "  id _extraIvar;\n"
12752                "}\n"
12753                "@end\n",
12754                AllmanBraceStyle);
12755 
12756   verifyFormat("#ifdef _DEBUG\n"
12757                "int foo(int i = 0)\n"
12758                "#else\n"
12759                "int foo(int i = 5)\n"
12760                "#endif\n"
12761                "{\n"
12762                "  return i;\n"
12763                "}",
12764                AllmanBraceStyle);
12765 
12766   verifyFormat("void foo() {}\n"
12767                "void bar()\n"
12768                "#ifdef _DEBUG\n"
12769                "{\n"
12770                "  foo();\n"
12771                "}\n"
12772                "#else\n"
12773                "{\n"
12774                "}\n"
12775                "#endif",
12776                AllmanBraceStyle);
12777 
12778   verifyFormat("void foobar() { int i = 5; }\n"
12779                "#ifdef _DEBUG\n"
12780                "void bar() {}\n"
12781                "#else\n"
12782                "void bar() { foobar(); }\n"
12783                "#endif",
12784                AllmanBraceStyle);
12785 
12786   // This shouldn't affect ObjC blocks..
12787   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
12788                "  // ...\n"
12789                "  int i;\n"
12790                "}];",
12791                AllmanBraceStyle);
12792   verifyFormat("void (^block)(void) = ^{\n"
12793                "  // ...\n"
12794                "  int i;\n"
12795                "};",
12796                AllmanBraceStyle);
12797   // .. or dict literals.
12798   verifyFormat("void f()\n"
12799                "{\n"
12800                "  // ...\n"
12801                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
12802                "}",
12803                AllmanBraceStyle);
12804   verifyFormat("void f()\n"
12805                "{\n"
12806                "  // ...\n"
12807                "  [object someMethod:@{a : @\"b\"}];\n"
12808                "}",
12809                AllmanBraceStyle);
12810   verifyFormat("int f()\n"
12811                "{ // comment\n"
12812                "  return 42;\n"
12813                "}",
12814                AllmanBraceStyle);
12815 
12816   AllmanBraceStyle.ColumnLimit = 19;
12817   verifyFormat("void f() { int i; }", AllmanBraceStyle);
12818   AllmanBraceStyle.ColumnLimit = 18;
12819   verifyFormat("void f()\n"
12820                "{\n"
12821                "  int i;\n"
12822                "}",
12823                AllmanBraceStyle);
12824   AllmanBraceStyle.ColumnLimit = 80;
12825 
12826   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
12827   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
12828       FormatStyle::SIS_WithoutElse;
12829   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
12830   verifyFormat("void f(bool b)\n"
12831                "{\n"
12832                "  if (b)\n"
12833                "  {\n"
12834                "    return;\n"
12835                "  }\n"
12836                "}\n",
12837                BreakBeforeBraceShortIfs);
12838   verifyFormat("void f(bool b)\n"
12839                "{\n"
12840                "  if constexpr (b)\n"
12841                "  {\n"
12842                "    return;\n"
12843                "  }\n"
12844                "}\n",
12845                BreakBeforeBraceShortIfs);
12846   verifyFormat("void f(bool b)\n"
12847                "{\n"
12848                "  if CONSTEXPR (b)\n"
12849                "  {\n"
12850                "    return;\n"
12851                "  }\n"
12852                "}\n",
12853                BreakBeforeBraceShortIfs);
12854   verifyFormat("void f(bool b)\n"
12855                "{\n"
12856                "  if (b) return;\n"
12857                "}\n",
12858                BreakBeforeBraceShortIfs);
12859   verifyFormat("void f(bool b)\n"
12860                "{\n"
12861                "  if constexpr (b) return;\n"
12862                "}\n",
12863                BreakBeforeBraceShortIfs);
12864   verifyFormat("void f(bool b)\n"
12865                "{\n"
12866                "  if CONSTEXPR (b) return;\n"
12867                "}\n",
12868                BreakBeforeBraceShortIfs);
12869   verifyFormat("void f(bool b)\n"
12870                "{\n"
12871                "  while (b)\n"
12872                "  {\n"
12873                "    return;\n"
12874                "  }\n"
12875                "}\n",
12876                BreakBeforeBraceShortIfs);
12877 }
12878 
12879 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
12880   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
12881   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
12882 
12883   // Make a few changes to the style for testing purposes
12884   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
12885       FormatStyle::SFS_Empty;
12886   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
12887   WhitesmithsBraceStyle.ColumnLimit = 0;
12888 
12889   // FIXME: this test case can't decide whether there should be a blank line
12890   // after the ~D() line or not. It adds one if one doesn't exist in the test
12891   // and it removes the line if one exists.
12892   /*
12893   verifyFormat("class A;\n"
12894                "namespace B\n"
12895                "  {\n"
12896                "class C;\n"
12897                "// Comment\n"
12898                "class D\n"
12899                "  {\n"
12900                "public:\n"
12901                "  D();\n"
12902                "  ~D() {}\n"
12903                "private:\n"
12904                "  enum E\n"
12905                "    {\n"
12906                "    F\n"
12907                "    }\n"
12908                "  };\n"
12909                "  } // namespace B\n",
12910                WhitesmithsBraceStyle);
12911   */
12912 
12913   verifyFormat("namespace a\n"
12914                "  {\n"
12915                "class A\n"
12916                "  {\n"
12917                "  void f()\n"
12918                "    {\n"
12919                "    if (true)\n"
12920                "      {\n"
12921                "      a();\n"
12922                "      b();\n"
12923                "      }\n"
12924                "    }\n"
12925                "  void g()\n"
12926                "    {\n"
12927                "    return;\n"
12928                "    }\n"
12929                "  };\n"
12930                "struct B\n"
12931                "  {\n"
12932                "  int x;\n"
12933                "  };\n"
12934                "  } // namespace a",
12935                WhitesmithsBraceStyle);
12936 
12937   verifyFormat("void f()\n"
12938                "  {\n"
12939                "  if (true)\n"
12940                "    {\n"
12941                "    a();\n"
12942                "    }\n"
12943                "  else if (false)\n"
12944                "    {\n"
12945                "    b();\n"
12946                "    }\n"
12947                "  else\n"
12948                "    {\n"
12949                "    c();\n"
12950                "    }\n"
12951                "  }\n",
12952                WhitesmithsBraceStyle);
12953 
12954   verifyFormat("void f()\n"
12955                "  {\n"
12956                "  for (int i = 0; i < 10; ++i)\n"
12957                "    {\n"
12958                "    a();\n"
12959                "    }\n"
12960                "  while (false)\n"
12961                "    {\n"
12962                "    b();\n"
12963                "    }\n"
12964                "  do\n"
12965                "    {\n"
12966                "    c();\n"
12967                "    } while (false)\n"
12968                "  }\n",
12969                WhitesmithsBraceStyle);
12970 
12971   // FIXME: the block and the break under case 2 in this test don't get indented
12972   // correctly
12973   /*
12974   verifyFormat("void switchTest1(int a)\n"
12975                "  {\n"
12976                "  switch (a)\n"
12977                "    {\n"
12978                "    case 2:\n"
12979                "      {\n"
12980                "      }\n"
12981                "      break;\n"
12982                "    }\n"
12983                "  }\n",
12984                WhitesmithsBraceStyle);
12985   */
12986 
12987   // FIXME: the block and the break under case 2 in this test don't get indented
12988   // correctly
12989   /*
12990   verifyFormat("void switchTest2(int a)\n"
12991                "  {\n"
12992                "  switch (a)\n"
12993                "    {\n"
12994                "  case 0:\n"
12995                "    break;\n"
12996                "  case 1:\n"
12997                "    {\n"
12998                "    break;\n"
12999                "    }\n"
13000                "  case 2:\n"
13001                "    {\n"
13002                "    }\n"
13003                "    break;\n"
13004                "  default:\n"
13005                "    break;\n"
13006                "    }\n"
13007                "  }\n",
13008                WhitesmithsBraceStyle);
13009   */
13010 
13011   verifyFormat("enum X\n"
13012                "  {\n"
13013                "  Y = 0, // testing\n"
13014                "  }\n",
13015                WhitesmithsBraceStyle);
13016 
13017   verifyFormat("enum X\n"
13018                "  {\n"
13019                "  Y = 0\n"
13020                "  }\n",
13021                WhitesmithsBraceStyle);
13022   verifyFormat("enum X\n"
13023                "  {\n"
13024                "  Y = 0,\n"
13025                "  Z = 1\n"
13026                "  };\n",
13027                WhitesmithsBraceStyle);
13028 
13029   verifyFormat("@interface BSApplicationController ()\n"
13030                "  {\n"
13031                "@private\n"
13032                "  id _extraIvar;\n"
13033                "  }\n"
13034                "@end\n",
13035                WhitesmithsBraceStyle);
13036 
13037   verifyFormat("#ifdef _DEBUG\n"
13038                "int foo(int i = 0)\n"
13039                "#else\n"
13040                "int foo(int i = 5)\n"
13041                "#endif\n"
13042                "  {\n"
13043                "  return i;\n"
13044                "  }",
13045                WhitesmithsBraceStyle);
13046 
13047   verifyFormat("void foo() {}\n"
13048                "void bar()\n"
13049                "#ifdef _DEBUG\n"
13050                "  {\n"
13051                "  foo();\n"
13052                "  }\n"
13053                "#else\n"
13054                "  {\n"
13055                "  }\n"
13056                "#endif",
13057                WhitesmithsBraceStyle);
13058 
13059   verifyFormat("void foobar()\n"
13060                "  {\n"
13061                "  int i = 5;\n"
13062                "  }\n"
13063                "#ifdef _DEBUG\n"
13064                "void bar()\n"
13065                "  {\n"
13066                "  }\n"
13067                "#else\n"
13068                "void bar()\n"
13069                "  {\n"
13070                "  foobar();\n"
13071                "  }\n"
13072                "#endif",
13073                WhitesmithsBraceStyle);
13074 
13075   // This shouldn't affect ObjC blocks..
13076   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13077                "  // ...\n"
13078                "  int i;\n"
13079                "}];",
13080                WhitesmithsBraceStyle);
13081   verifyFormat("void (^block)(void) = ^{\n"
13082                "  // ...\n"
13083                "  int i;\n"
13084                "};",
13085                WhitesmithsBraceStyle);
13086   // .. or dict literals.
13087   verifyFormat("void f()\n"
13088                "  {\n"
13089                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13090                "  }",
13091                WhitesmithsBraceStyle);
13092 
13093   verifyFormat("int f()\n"
13094                "  { // comment\n"
13095                "  return 42;\n"
13096                "  }",
13097                WhitesmithsBraceStyle);
13098 
13099   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13100   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13101       FormatStyle::SIS_Always;
13102   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13103   verifyFormat("void f(bool b)\n"
13104                "  {\n"
13105                "  if (b)\n"
13106                "    {\n"
13107                "    return;\n"
13108                "    }\n"
13109                "  }\n",
13110                BreakBeforeBraceShortIfs);
13111   verifyFormat("void f(bool b)\n"
13112                "  {\n"
13113                "  if (b) return;\n"
13114                "  }\n",
13115                BreakBeforeBraceShortIfs);
13116   verifyFormat("void f(bool b)\n"
13117                "  {\n"
13118                "  while (b)\n"
13119                "    {\n"
13120                "    return;\n"
13121                "    }\n"
13122                "  }\n",
13123                BreakBeforeBraceShortIfs);
13124 }
13125 
13126 TEST_F(FormatTest, GNUBraceBreaking) {
13127   FormatStyle GNUBraceStyle = getLLVMStyle();
13128   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13129   verifyFormat("namespace a\n"
13130                "{\n"
13131                "class A\n"
13132                "{\n"
13133                "  void f()\n"
13134                "  {\n"
13135                "    int a;\n"
13136                "    {\n"
13137                "      int b;\n"
13138                "    }\n"
13139                "    if (true)\n"
13140                "      {\n"
13141                "        a();\n"
13142                "        b();\n"
13143                "      }\n"
13144                "  }\n"
13145                "  void g() { return; }\n"
13146                "}\n"
13147                "} // namespace a",
13148                GNUBraceStyle);
13149 
13150   verifyFormat("void f()\n"
13151                "{\n"
13152                "  if (true)\n"
13153                "    {\n"
13154                "      a();\n"
13155                "    }\n"
13156                "  else if (false)\n"
13157                "    {\n"
13158                "      b();\n"
13159                "    }\n"
13160                "  else\n"
13161                "    {\n"
13162                "      c();\n"
13163                "    }\n"
13164                "}\n",
13165                GNUBraceStyle);
13166 
13167   verifyFormat("void f()\n"
13168                "{\n"
13169                "  for (int i = 0; i < 10; ++i)\n"
13170                "    {\n"
13171                "      a();\n"
13172                "    }\n"
13173                "  while (false)\n"
13174                "    {\n"
13175                "      b();\n"
13176                "    }\n"
13177                "  do\n"
13178                "    {\n"
13179                "      c();\n"
13180                "    }\n"
13181                "  while (false);\n"
13182                "}\n",
13183                GNUBraceStyle);
13184 
13185   verifyFormat("void f(int a)\n"
13186                "{\n"
13187                "  switch (a)\n"
13188                "    {\n"
13189                "    case 0:\n"
13190                "      break;\n"
13191                "    case 1:\n"
13192                "      {\n"
13193                "        break;\n"
13194                "      }\n"
13195                "    case 2:\n"
13196                "      {\n"
13197                "      }\n"
13198                "      break;\n"
13199                "    default:\n"
13200                "      break;\n"
13201                "    }\n"
13202                "}\n",
13203                GNUBraceStyle);
13204 
13205   verifyFormat("enum X\n"
13206                "{\n"
13207                "  Y = 0,\n"
13208                "}\n",
13209                GNUBraceStyle);
13210 
13211   verifyFormat("@interface BSApplicationController ()\n"
13212                "{\n"
13213                "@private\n"
13214                "  id _extraIvar;\n"
13215                "}\n"
13216                "@end\n",
13217                GNUBraceStyle);
13218 
13219   verifyFormat("#ifdef _DEBUG\n"
13220                "int foo(int i = 0)\n"
13221                "#else\n"
13222                "int foo(int i = 5)\n"
13223                "#endif\n"
13224                "{\n"
13225                "  return i;\n"
13226                "}",
13227                GNUBraceStyle);
13228 
13229   verifyFormat("void foo() {}\n"
13230                "void bar()\n"
13231                "#ifdef _DEBUG\n"
13232                "{\n"
13233                "  foo();\n"
13234                "}\n"
13235                "#else\n"
13236                "{\n"
13237                "}\n"
13238                "#endif",
13239                GNUBraceStyle);
13240 
13241   verifyFormat("void foobar() { int i = 5; }\n"
13242                "#ifdef _DEBUG\n"
13243                "void bar() {}\n"
13244                "#else\n"
13245                "void bar() { foobar(); }\n"
13246                "#endif",
13247                GNUBraceStyle);
13248 }
13249 
13250 TEST_F(FormatTest, WebKitBraceBreaking) {
13251   FormatStyle WebKitBraceStyle = getLLVMStyle();
13252   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13253   WebKitBraceStyle.FixNamespaceComments = false;
13254   verifyFormat("namespace a {\n"
13255                "class A {\n"
13256                "  void f()\n"
13257                "  {\n"
13258                "    if (true) {\n"
13259                "      a();\n"
13260                "      b();\n"
13261                "    }\n"
13262                "  }\n"
13263                "  void g() { return; }\n"
13264                "};\n"
13265                "enum E {\n"
13266                "  A,\n"
13267                "  // foo\n"
13268                "  B,\n"
13269                "  C\n"
13270                "};\n"
13271                "struct B {\n"
13272                "  int x;\n"
13273                "};\n"
13274                "}\n",
13275                WebKitBraceStyle);
13276   verifyFormat("struct S {\n"
13277                "  int Type;\n"
13278                "  union {\n"
13279                "    int x;\n"
13280                "    double y;\n"
13281                "  } Value;\n"
13282                "  class C {\n"
13283                "    MyFavoriteType Value;\n"
13284                "  } Class;\n"
13285                "};\n",
13286                WebKitBraceStyle);
13287 }
13288 
13289 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13290   verifyFormat("void f() {\n"
13291                "  try {\n"
13292                "  } catch (const Exception &e) {\n"
13293                "  }\n"
13294                "}\n",
13295                getLLVMStyle());
13296 }
13297 
13298 TEST_F(FormatTest, UnderstandsPragmas) {
13299   verifyFormat("#pragma omp reduction(| : var)");
13300   verifyFormat("#pragma omp reduction(+ : var)");
13301 
13302   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13303             "(including parentheses).",
13304             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13305                    "(including parentheses)."));
13306 }
13307 
13308 TEST_F(FormatTest, UnderstandPragmaOption) {
13309   verifyFormat("#pragma option -C -A");
13310 
13311   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13312 }
13313 
13314 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13315   FormatStyle Style = getLLVMStyle();
13316   Style.ColumnLimit = 20;
13317 
13318   // See PR41213
13319   EXPECT_EQ("/*\n"
13320             " *\t9012345\n"
13321             " * /8901\n"
13322             " */",
13323             format("/*\n"
13324                    " *\t9012345 /8901\n"
13325                    " */",
13326                    Style));
13327   EXPECT_EQ("/*\n"
13328             " *345678\n"
13329             " *\t/8901\n"
13330             " */",
13331             format("/*\n"
13332                    " *345678\t/8901\n"
13333                    " */",
13334                    Style));
13335 
13336   verifyFormat("int a; // the\n"
13337                "       // comment",
13338                Style);
13339   EXPECT_EQ("int a; /* first line\n"
13340             "        * second\n"
13341             "        * line third\n"
13342             "        * line\n"
13343             "        */",
13344             format("int a; /* first line\n"
13345                    "        * second\n"
13346                    "        * line third\n"
13347                    "        * line\n"
13348                    "        */",
13349                    Style));
13350   EXPECT_EQ("int a; // first line\n"
13351             "       // second\n"
13352             "       // line third\n"
13353             "       // line",
13354             format("int a; // first line\n"
13355                    "       // second line\n"
13356                    "       // third line",
13357                    Style));
13358 
13359   Style.PenaltyExcessCharacter = 90;
13360   verifyFormat("int a; // the comment", Style);
13361   EXPECT_EQ("int a; // the comment\n"
13362             "       // aaa",
13363             format("int a; // the comment aaa", Style));
13364   EXPECT_EQ("int a; /* first line\n"
13365             "        * second line\n"
13366             "        * third line\n"
13367             "        */",
13368             format("int a; /* first line\n"
13369                    "        * second line\n"
13370                    "        * third line\n"
13371                    "        */",
13372                    Style));
13373   EXPECT_EQ("int a; // first line\n"
13374             "       // second line\n"
13375             "       // third line",
13376             format("int a; // first line\n"
13377                    "       // second line\n"
13378                    "       // third line",
13379                    Style));
13380   // FIXME: Investigate why this is not getting the same layout as the test
13381   // above.
13382   EXPECT_EQ("int a; /* first line\n"
13383             "        * second line\n"
13384             "        * third line\n"
13385             "        */",
13386             format("int a; /* first line second line third line"
13387                    "\n*/",
13388                    Style));
13389 
13390   EXPECT_EQ("// foo bar baz bazfoo\n"
13391             "// foo bar foo bar\n",
13392             format("// foo bar baz bazfoo\n"
13393                    "// foo bar foo           bar\n",
13394                    Style));
13395   EXPECT_EQ("// foo bar baz bazfoo\n"
13396             "// foo bar foo bar\n",
13397             format("// foo bar baz      bazfoo\n"
13398                    "// foo            bar foo bar\n",
13399                    Style));
13400 
13401   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13402   // next one.
13403   EXPECT_EQ("// foo bar baz bazfoo\n"
13404             "// bar foo bar\n",
13405             format("// foo bar baz      bazfoo bar\n"
13406                    "// foo            bar\n",
13407                    Style));
13408 
13409   EXPECT_EQ("// foo bar baz bazfoo\n"
13410             "// foo bar baz bazfoo\n"
13411             "// bar foo bar\n",
13412             format("// foo bar baz      bazfoo\n"
13413                    "// foo bar baz      bazfoo bar\n"
13414                    "// foo bar\n",
13415                    Style));
13416 
13417   EXPECT_EQ("// foo bar baz bazfoo\n"
13418             "// foo bar baz bazfoo\n"
13419             "// bar foo bar\n",
13420             format("// foo bar baz      bazfoo\n"
13421                    "// foo bar baz      bazfoo bar\n"
13422                    "// foo           bar\n",
13423                    Style));
13424 
13425   // Make sure we do not keep protruding characters if strict mode reflow is
13426   // cheaper than keeping protruding characters.
13427   Style.ColumnLimit = 21;
13428   EXPECT_EQ(
13429       "// foo foo foo foo\n"
13430       "// foo foo foo foo\n"
13431       "// foo foo foo foo\n",
13432       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13433 
13434   EXPECT_EQ("int a = /* long block\n"
13435             "           comment */\n"
13436             "    42;",
13437             format("int a = /* long block comment */ 42;", Style));
13438 }
13439 
13440 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13441   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13442   EXPECT_EQ(Styles[0], Styles[i])                                              \
13443       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13444 
13445 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13446   SmallVector<FormatStyle, 3> Styles;
13447   Styles.resize(3);
13448 
13449   Styles[0] = getLLVMStyle();
13450   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13451   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13452   EXPECT_ALL_STYLES_EQUAL(Styles);
13453 
13454   Styles[0] = getGoogleStyle();
13455   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13456   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13457   EXPECT_ALL_STYLES_EQUAL(Styles);
13458 
13459   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13460   EXPECT_TRUE(
13461       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13462   EXPECT_TRUE(
13463       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13464   EXPECT_ALL_STYLES_EQUAL(Styles);
13465 
13466   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13467   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13468   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
13469   EXPECT_ALL_STYLES_EQUAL(Styles);
13470 
13471   Styles[0] = getMozillaStyle();
13472   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
13473   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
13474   EXPECT_ALL_STYLES_EQUAL(Styles);
13475 
13476   Styles[0] = getWebKitStyle();
13477   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
13478   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
13479   EXPECT_ALL_STYLES_EQUAL(Styles);
13480 
13481   Styles[0] = getGNUStyle();
13482   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
13483   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
13484   EXPECT_ALL_STYLES_EQUAL(Styles);
13485 
13486   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
13487 }
13488 
13489 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
13490   SmallVector<FormatStyle, 8> Styles;
13491   Styles.resize(2);
13492 
13493   Styles[0] = getGoogleStyle();
13494   Styles[1] = getLLVMStyle();
13495   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13496   EXPECT_ALL_STYLES_EQUAL(Styles);
13497 
13498   Styles.resize(5);
13499   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13500   Styles[1] = getLLVMStyle();
13501   Styles[1].Language = FormatStyle::LK_JavaScript;
13502   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13503 
13504   Styles[2] = getLLVMStyle();
13505   Styles[2].Language = FormatStyle::LK_JavaScript;
13506   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
13507                                   "BasedOnStyle: Google",
13508                                   &Styles[2])
13509                    .value());
13510 
13511   Styles[3] = getLLVMStyle();
13512   Styles[3].Language = FormatStyle::LK_JavaScript;
13513   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
13514                                   "Language: JavaScript",
13515                                   &Styles[3])
13516                    .value());
13517 
13518   Styles[4] = getLLVMStyle();
13519   Styles[4].Language = FormatStyle::LK_JavaScript;
13520   EXPECT_EQ(0, parseConfiguration("---\n"
13521                                   "BasedOnStyle: LLVM\n"
13522                                   "IndentWidth: 123\n"
13523                                   "---\n"
13524                                   "BasedOnStyle: Google\n"
13525                                   "Language: JavaScript",
13526                                   &Styles[4])
13527                    .value());
13528   EXPECT_ALL_STYLES_EQUAL(Styles);
13529 }
13530 
13531 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
13532   Style.FIELD = false;                                                         \
13533   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
13534   EXPECT_TRUE(Style.FIELD);                                                    \
13535   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
13536   EXPECT_FALSE(Style.FIELD);
13537 
13538 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
13539 
13540 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
13541   Style.STRUCT.FIELD = false;                                                  \
13542   EXPECT_EQ(0,                                                                 \
13543             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
13544                 .value());                                                     \
13545   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
13546   EXPECT_EQ(0,                                                                 \
13547             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
13548                 .value());                                                     \
13549   EXPECT_FALSE(Style.STRUCT.FIELD);
13550 
13551 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
13552   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
13553 
13554 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
13555   EXPECT_NE(VALUE, Style.FIELD);                                               \
13556   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
13557   EXPECT_EQ(VALUE, Style.FIELD)
13558 
13559 TEST_F(FormatTest, ParsesConfigurationBools) {
13560   FormatStyle Style = {};
13561   Style.Language = FormatStyle::LK_Cpp;
13562   CHECK_PARSE_BOOL(AlignTrailingComments);
13563   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
13564   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
13565   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
13566   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
13567   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
13568   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
13569   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
13570   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
13571   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
13572   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
13573   CHECK_PARSE_BOOL(BinPackArguments);
13574   CHECK_PARSE_BOOL(BinPackParameters);
13575   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
13576   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
13577   CHECK_PARSE_BOOL(BreakStringLiterals);
13578   CHECK_PARSE_BOOL(CompactNamespaces);
13579   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
13580   CHECK_PARSE_BOOL(DeriveLineEnding);
13581   CHECK_PARSE_BOOL(DerivePointerAlignment);
13582   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
13583   CHECK_PARSE_BOOL(DisableFormat);
13584   CHECK_PARSE_BOOL(IndentCaseLabels);
13585   CHECK_PARSE_BOOL(IndentCaseBlocks);
13586   CHECK_PARSE_BOOL(IndentGotoLabels);
13587   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
13588   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
13589   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
13590   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
13591   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
13592   CHECK_PARSE_BOOL(ReflowComments);
13593   CHECK_PARSE_BOOL(SortIncludes);
13594   CHECK_PARSE_BOOL(SortUsingDeclarations);
13595   CHECK_PARSE_BOOL(SpacesInParentheses);
13596   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
13597   CHECK_PARSE_BOOL(SpacesInAngles);
13598   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
13599   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
13600   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
13601   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
13602   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
13603   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
13604   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
13605   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
13606   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
13607   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
13608   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
13609   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
13610   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
13611   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
13612   CHECK_PARSE_BOOL(UseCRLF);
13613 
13614   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
13615   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
13616   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
13617   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
13618   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
13619   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
13620   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
13621   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
13622   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
13623   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
13624   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
13625   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
13626   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
13627   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
13628   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
13629   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
13630   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
13631 }
13632 
13633 #undef CHECK_PARSE_BOOL
13634 
13635 TEST_F(FormatTest, ParsesConfiguration) {
13636   FormatStyle Style = {};
13637   Style.Language = FormatStyle::LK_Cpp;
13638   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
13639   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
13640               ConstructorInitializerIndentWidth, 1234u);
13641   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
13642   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
13643   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
13644   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
13645   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
13646               PenaltyBreakBeforeFirstCallParameter, 1234u);
13647   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
13648               PenaltyBreakTemplateDeclaration, 1234u);
13649   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
13650   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
13651               PenaltyReturnTypeOnItsOwnLine, 1234u);
13652   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
13653               SpacesBeforeTrailingComments, 1234u);
13654   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
13655   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
13656   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
13657 
13658   Style.PointerAlignment = FormatStyle::PAS_Middle;
13659   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
13660               FormatStyle::PAS_Left);
13661   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
13662               FormatStyle::PAS_Right);
13663   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
13664               FormatStyle::PAS_Middle);
13665   // For backward compatibility:
13666   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
13667               FormatStyle::PAS_Left);
13668   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
13669               FormatStyle::PAS_Right);
13670   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
13671               FormatStyle::PAS_Middle);
13672 
13673   Style.Standard = FormatStyle::LS_Auto;
13674   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
13675   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
13676   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
13677   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
13678   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
13679   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
13680   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
13681   // Legacy aliases:
13682   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
13683   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
13684   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
13685   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
13686 
13687   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13688   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
13689               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
13690   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
13691               FormatStyle::BOS_None);
13692   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
13693               FormatStyle::BOS_All);
13694   // For backward compatibility:
13695   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
13696               FormatStyle::BOS_None);
13697   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
13698               FormatStyle::BOS_All);
13699 
13700   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
13701   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
13702               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13703   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
13704               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
13705   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
13706               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
13707   // For backward compatibility:
13708   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
13709               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13710 
13711   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
13712   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
13713               FormatStyle::BILS_BeforeComma);
13714   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
13715               FormatStyle::BILS_AfterColon);
13716   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
13717               FormatStyle::BILS_BeforeColon);
13718   // For backward compatibility:
13719   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
13720               FormatStyle::BILS_BeforeComma);
13721 
13722   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
13723   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
13724               FormatStyle::BAS_Align);
13725   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
13726               FormatStyle::BAS_DontAlign);
13727   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
13728               FormatStyle::BAS_AlwaysBreak);
13729   // For backward compatibility:
13730   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
13731               FormatStyle::BAS_DontAlign);
13732   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
13733               FormatStyle::BAS_Align);
13734 
13735   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13736   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
13737               FormatStyle::ENAS_DontAlign);
13738   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
13739               FormatStyle::ENAS_Left);
13740   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
13741               FormatStyle::ENAS_Right);
13742   // For backward compatibility:
13743   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
13744               FormatStyle::ENAS_Left);
13745   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
13746               FormatStyle::ENAS_Right);
13747 
13748   Style.AlignOperands = FormatStyle::OAS_Align;
13749   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
13750               FormatStyle::OAS_DontAlign);
13751   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
13752   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
13753               FormatStyle::OAS_AlignAfterOperator);
13754   // For backward compatibility:
13755   CHECK_PARSE("AlignOperands: false", AlignOperands,
13756               FormatStyle::OAS_DontAlign);
13757   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
13758 
13759   Style.UseTab = FormatStyle::UT_ForIndentation;
13760   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
13761   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
13762   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
13763   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
13764               FormatStyle::UT_ForContinuationAndIndentation);
13765   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
13766               FormatStyle::UT_AlignWithSpaces);
13767   // For backward compatibility:
13768   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
13769   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
13770 
13771   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
13772   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
13773               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13774   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
13775               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
13776   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
13777               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13778   // For backward compatibility:
13779   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
13780               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13781   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
13782               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13783 
13784   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
13785   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
13786               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13787   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
13788               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
13789   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
13790               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
13791   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
13792               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13793   // For backward compatibility:
13794   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
13795               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13796   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
13797               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13798 
13799   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
13800   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
13801               FormatStyle::SBPO_Never);
13802   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
13803               FormatStyle::SBPO_Always);
13804   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
13805               FormatStyle::SBPO_ControlStatements);
13806   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
13807               FormatStyle::SBPO_NonEmptyParentheses);
13808   // For backward compatibility:
13809   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
13810               FormatStyle::SBPO_Never);
13811   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
13812               FormatStyle::SBPO_ControlStatements);
13813 
13814   Style.ColumnLimit = 123;
13815   FormatStyle BaseStyle = getLLVMStyle();
13816   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
13817   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
13818 
13819   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
13820   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
13821               FormatStyle::BS_Attach);
13822   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
13823               FormatStyle::BS_Linux);
13824   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
13825               FormatStyle::BS_Mozilla);
13826   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
13827               FormatStyle::BS_Stroustrup);
13828   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
13829               FormatStyle::BS_Allman);
13830   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
13831               FormatStyle::BS_Whitesmiths);
13832   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
13833   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
13834               FormatStyle::BS_WebKit);
13835   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
13836               FormatStyle::BS_Custom);
13837 
13838   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
13839   CHECK_PARSE("BraceWrapping:\n"
13840               "  AfterControlStatement: MultiLine",
13841               BraceWrapping.AfterControlStatement,
13842               FormatStyle::BWACS_MultiLine);
13843   CHECK_PARSE("BraceWrapping:\n"
13844               "  AfterControlStatement: Always",
13845               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13846   CHECK_PARSE("BraceWrapping:\n"
13847               "  AfterControlStatement: Never",
13848               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13849   // For backward compatibility:
13850   CHECK_PARSE("BraceWrapping:\n"
13851               "  AfterControlStatement: true",
13852               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13853   CHECK_PARSE("BraceWrapping:\n"
13854               "  AfterControlStatement: false",
13855               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13856 
13857   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
13858   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
13859               FormatStyle::RTBS_None);
13860   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
13861               FormatStyle::RTBS_All);
13862   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
13863               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
13864   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
13865               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
13866   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
13867               AlwaysBreakAfterReturnType,
13868               FormatStyle::RTBS_TopLevelDefinitions);
13869 
13870   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
13871   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
13872               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
13873   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
13874               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
13875   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
13876               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
13877   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
13878               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
13879   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
13880               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
13881 
13882   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
13883   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
13884               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
13885   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
13886               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
13887   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
13888               AlwaysBreakAfterDefinitionReturnType,
13889               FormatStyle::DRTBS_TopLevel);
13890 
13891   Style.NamespaceIndentation = FormatStyle::NI_All;
13892   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
13893               FormatStyle::NI_None);
13894   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
13895               FormatStyle::NI_Inner);
13896   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
13897               FormatStyle::NI_All);
13898 
13899   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
13900   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
13901               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
13902   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
13903               AllowShortIfStatementsOnASingleLine,
13904               FormatStyle::SIS_WithoutElse);
13905   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
13906               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
13907   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
13908               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
13909   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
13910               AllowShortIfStatementsOnASingleLine,
13911               FormatStyle::SIS_WithoutElse);
13912 
13913   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
13914   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
13915               FormatStyle::IEBS_AfterExternBlock);
13916   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
13917               FormatStyle::IEBS_Indent);
13918   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
13919               FormatStyle::IEBS_NoIndent);
13920   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
13921               FormatStyle::IEBS_Indent);
13922   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
13923               FormatStyle::IEBS_NoIndent);
13924 
13925   // FIXME: This is required because parsing a configuration simply overwrites
13926   // the first N elements of the list instead of resetting it.
13927   Style.ForEachMacros.clear();
13928   std::vector<std::string> BoostForeach;
13929   BoostForeach.push_back("BOOST_FOREACH");
13930   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
13931   std::vector<std::string> BoostAndQForeach;
13932   BoostAndQForeach.push_back("BOOST_FOREACH");
13933   BoostAndQForeach.push_back("Q_FOREACH");
13934   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
13935               BoostAndQForeach);
13936 
13937   Style.StatementMacros.clear();
13938   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
13939               std::vector<std::string>{"QUNUSED"});
13940   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
13941               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
13942 
13943   Style.NamespaceMacros.clear();
13944   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
13945               std::vector<std::string>{"TESTSUITE"});
13946   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
13947               std::vector<std::string>({"TESTSUITE", "SUITE"}));
13948 
13949   Style.IncludeStyle.IncludeCategories.clear();
13950   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
13951       {"abc/.*", 2, 0}, {".*", 1, 0}};
13952   CHECK_PARSE("IncludeCategories:\n"
13953               "  - Regex: abc/.*\n"
13954               "    Priority: 2\n"
13955               "  - Regex: .*\n"
13956               "    Priority: 1",
13957               IncludeStyle.IncludeCategories, ExpectedCategories);
13958   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
13959               "abc$");
13960   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
13961               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
13962 
13963   Style.RawStringFormats.clear();
13964   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
13965       {
13966           FormatStyle::LK_TextProto,
13967           {"pb", "proto"},
13968           {"PARSE_TEXT_PROTO"},
13969           /*CanonicalDelimiter=*/"",
13970           "llvm",
13971       },
13972       {
13973           FormatStyle::LK_Cpp,
13974           {"cc", "cpp"},
13975           {"C_CODEBLOCK", "CPPEVAL"},
13976           /*CanonicalDelimiter=*/"cc",
13977           /*BasedOnStyle=*/"",
13978       },
13979   };
13980 
13981   CHECK_PARSE("RawStringFormats:\n"
13982               "  - Language: TextProto\n"
13983               "    Delimiters:\n"
13984               "      - 'pb'\n"
13985               "      - 'proto'\n"
13986               "    EnclosingFunctions:\n"
13987               "      - 'PARSE_TEXT_PROTO'\n"
13988               "    BasedOnStyle: llvm\n"
13989               "  - Language: Cpp\n"
13990               "    Delimiters:\n"
13991               "      - 'cc'\n"
13992               "      - 'cpp'\n"
13993               "    EnclosingFunctions:\n"
13994               "      - 'C_CODEBLOCK'\n"
13995               "      - 'CPPEVAL'\n"
13996               "    CanonicalDelimiter: 'cc'",
13997               RawStringFormats, ExpectedRawStringFormats);
13998 }
13999 
14000 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
14001   FormatStyle Style = {};
14002   Style.Language = FormatStyle::LK_Cpp;
14003   CHECK_PARSE("Language: Cpp\n"
14004               "IndentWidth: 12",
14005               IndentWidth, 12u);
14006   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
14007                                "IndentWidth: 34",
14008                                &Style),
14009             ParseError::Unsuitable);
14010   FormatStyle BinPackedTCS = {};
14011   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
14012   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
14013                                "InsertTrailingCommas: Wrapped",
14014                                &BinPackedTCS),
14015             ParseError::BinPackTrailingCommaConflict);
14016   EXPECT_EQ(12u, Style.IndentWidth);
14017   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14018   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14019 
14020   Style.Language = FormatStyle::LK_JavaScript;
14021   CHECK_PARSE("Language: JavaScript\n"
14022               "IndentWidth: 12",
14023               IndentWidth, 12u);
14024   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14025   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14026                                "IndentWidth: 34",
14027                                &Style),
14028             ParseError::Unsuitable);
14029   EXPECT_EQ(23u, Style.IndentWidth);
14030   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14031   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14032 
14033   CHECK_PARSE("BasedOnStyle: LLVM\n"
14034               "IndentWidth: 67",
14035               IndentWidth, 67u);
14036 
14037   CHECK_PARSE("---\n"
14038               "Language: JavaScript\n"
14039               "IndentWidth: 12\n"
14040               "---\n"
14041               "Language: Cpp\n"
14042               "IndentWidth: 34\n"
14043               "...\n",
14044               IndentWidth, 12u);
14045 
14046   Style.Language = FormatStyle::LK_Cpp;
14047   CHECK_PARSE("---\n"
14048               "Language: JavaScript\n"
14049               "IndentWidth: 12\n"
14050               "---\n"
14051               "Language: Cpp\n"
14052               "IndentWidth: 34\n"
14053               "...\n",
14054               IndentWidth, 34u);
14055   CHECK_PARSE("---\n"
14056               "IndentWidth: 78\n"
14057               "---\n"
14058               "Language: JavaScript\n"
14059               "IndentWidth: 56\n"
14060               "...\n",
14061               IndentWidth, 78u);
14062 
14063   Style.ColumnLimit = 123;
14064   Style.IndentWidth = 234;
14065   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14066   Style.TabWidth = 345;
14067   EXPECT_FALSE(parseConfiguration("---\n"
14068                                   "IndentWidth: 456\n"
14069                                   "BreakBeforeBraces: Allman\n"
14070                                   "---\n"
14071                                   "Language: JavaScript\n"
14072                                   "IndentWidth: 111\n"
14073                                   "TabWidth: 111\n"
14074                                   "---\n"
14075                                   "Language: Cpp\n"
14076                                   "BreakBeforeBraces: Stroustrup\n"
14077                                   "TabWidth: 789\n"
14078                                   "...\n",
14079                                   &Style));
14080   EXPECT_EQ(123u, Style.ColumnLimit);
14081   EXPECT_EQ(456u, Style.IndentWidth);
14082   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14083   EXPECT_EQ(789u, Style.TabWidth);
14084 
14085   EXPECT_EQ(parseConfiguration("---\n"
14086                                "Language: JavaScript\n"
14087                                "IndentWidth: 56\n"
14088                                "---\n"
14089                                "IndentWidth: 78\n"
14090                                "...\n",
14091                                &Style),
14092             ParseError::Error);
14093   EXPECT_EQ(parseConfiguration("---\n"
14094                                "Language: JavaScript\n"
14095                                "IndentWidth: 56\n"
14096                                "---\n"
14097                                "Language: JavaScript\n"
14098                                "IndentWidth: 78\n"
14099                                "...\n",
14100                                &Style),
14101             ParseError::Error);
14102 
14103   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14104 }
14105 
14106 #undef CHECK_PARSE
14107 
14108 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14109   FormatStyle Style = {};
14110   Style.Language = FormatStyle::LK_JavaScript;
14111   Style.BreakBeforeTernaryOperators = true;
14112   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14113   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14114 
14115   Style.BreakBeforeTernaryOperators = true;
14116   EXPECT_EQ(0, parseConfiguration("---\n"
14117                                   "BasedOnStyle: Google\n"
14118                                   "---\n"
14119                                   "Language: JavaScript\n"
14120                                   "IndentWidth: 76\n"
14121                                   "...\n",
14122                                   &Style)
14123                    .value());
14124   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14125   EXPECT_EQ(76u, Style.IndentWidth);
14126   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14127 }
14128 
14129 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14130   FormatStyle Style = getLLVMStyle();
14131   std::string YAML = configurationAsText(Style);
14132   FormatStyle ParsedStyle = {};
14133   ParsedStyle.Language = FormatStyle::LK_Cpp;
14134   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14135   EXPECT_EQ(Style, ParsedStyle);
14136 }
14137 
14138 TEST_F(FormatTest, WorksFor8bitEncodings) {
14139   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14140             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14141             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14142             "\"\xef\xee\xf0\xf3...\"",
14143             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14144                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14145                    "\xef\xee\xf0\xf3...\"",
14146                    getLLVMStyleWithColumns(12)));
14147 }
14148 
14149 TEST_F(FormatTest, HandlesUTF8BOM) {
14150   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14151   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14152             format("\xef\xbb\xbf#include <iostream>"));
14153   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14154             format("\xef\xbb\xbf\n#include <iostream>"));
14155 }
14156 
14157 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14158 #if !defined(_MSC_VER)
14159 
14160 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14161   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14162                getLLVMStyleWithColumns(35));
14163   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14164                getLLVMStyleWithColumns(31));
14165   verifyFormat("// Однажды в студёную зимнюю пору...",
14166                getLLVMStyleWithColumns(36));
14167   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14168   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14169                getLLVMStyleWithColumns(39));
14170   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14171                getLLVMStyleWithColumns(35));
14172 }
14173 
14174 TEST_F(FormatTest, SplitsUTF8Strings) {
14175   // Non-printable characters' width is currently considered to be the length in
14176   // bytes in UTF8. The characters can be displayed in very different manner
14177   // (zero-width, single width with a substitution glyph, expanded to their code
14178   // (e.g. "<8d>"), so there's no single correct way to handle them.
14179   EXPECT_EQ("\"aaaaÄ\"\n"
14180             "\"\xc2\x8d\";",
14181             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14182   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14183             "\"\xc2\x8d\";",
14184             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14185   EXPECT_EQ("\"Однажды, в \"\n"
14186             "\"студёную \"\n"
14187             "\"зимнюю \"\n"
14188             "\"пору,\"",
14189             format("\"Однажды, в студёную зимнюю пору,\"",
14190                    getLLVMStyleWithColumns(13)));
14191   EXPECT_EQ(
14192       "\"一 二 三 \"\n"
14193       "\"四 五六 \"\n"
14194       "\"七 八 九 \"\n"
14195       "\"十\"",
14196       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14197   EXPECT_EQ("\"一\t\"\n"
14198             "\"二 \t\"\n"
14199             "\"三 四 \"\n"
14200             "\"五\t\"\n"
14201             "\"六 \t\"\n"
14202             "\"七 \"\n"
14203             "\"八九十\tqq\"",
14204             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14205                    getLLVMStyleWithColumns(11)));
14206 
14207   // UTF8 character in an escape sequence.
14208   EXPECT_EQ("\"aaaaaa\"\n"
14209             "\"\\\xC2\x8D\"",
14210             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14211 }
14212 
14213 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14214   EXPECT_EQ("const char *sssss =\n"
14215             "    \"一二三四五六七八\\\n"
14216             " 九 十\";",
14217             format("const char *sssss = \"一二三四五六七八\\\n"
14218                    " 九 十\";",
14219                    getLLVMStyleWithColumns(30)));
14220 }
14221 
14222 TEST_F(FormatTest, SplitsUTF8LineComments) {
14223   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14224             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14225   EXPECT_EQ("// Я из лесу\n"
14226             "// вышел; был\n"
14227             "// сильный\n"
14228             "// мороз.",
14229             format("// Я из лесу вышел; был сильный мороз.",
14230                    getLLVMStyleWithColumns(13)));
14231   EXPECT_EQ("// 一二三\n"
14232             "// 四五六七\n"
14233             "// 八  九\n"
14234             "// 十",
14235             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14236 }
14237 
14238 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14239   EXPECT_EQ("/* Гляжу,\n"
14240             " * поднимается\n"
14241             " * медленно в\n"
14242             " * гору\n"
14243             " * Лошадка,\n"
14244             " * везущая\n"
14245             " * хворосту\n"
14246             " * воз. */",
14247             format("/* Гляжу, поднимается медленно в гору\n"
14248                    " * Лошадка, везущая хворосту воз. */",
14249                    getLLVMStyleWithColumns(13)));
14250   EXPECT_EQ(
14251       "/* 一二三\n"
14252       " * 四五六七\n"
14253       " * 八  九\n"
14254       " * 十  */",
14255       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14256   EXPECT_EQ("/* �������� ��������\n"
14257             " * ��������\n"
14258             " * ������-�� */",
14259             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14260 }
14261 
14262 #endif // _MSC_VER
14263 
14264 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14265   FormatStyle Style = getLLVMStyle();
14266 
14267   Style.ConstructorInitializerIndentWidth = 4;
14268   verifyFormat(
14269       "SomeClass::Constructor()\n"
14270       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14271       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14272       Style);
14273 
14274   Style.ConstructorInitializerIndentWidth = 2;
14275   verifyFormat(
14276       "SomeClass::Constructor()\n"
14277       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14278       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14279       Style);
14280 
14281   Style.ConstructorInitializerIndentWidth = 0;
14282   verifyFormat(
14283       "SomeClass::Constructor()\n"
14284       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14285       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14286       Style);
14287   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14288   verifyFormat(
14289       "SomeLongTemplateVariableName<\n"
14290       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14291       Style);
14292   verifyFormat("bool smaller = 1 < "
14293                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14294                "                       "
14295                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14296                Style);
14297 
14298   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14299   verifyFormat("SomeClass::Constructor() :\n"
14300                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14301                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14302                Style);
14303 }
14304 
14305 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14306   FormatStyle Style = getLLVMStyle();
14307   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14308   Style.ConstructorInitializerIndentWidth = 4;
14309   verifyFormat("SomeClass::Constructor()\n"
14310                "    : a(a)\n"
14311                "    , b(b)\n"
14312                "    , c(c) {}",
14313                Style);
14314   verifyFormat("SomeClass::Constructor()\n"
14315                "    : a(a) {}",
14316                Style);
14317 
14318   Style.ColumnLimit = 0;
14319   verifyFormat("SomeClass::Constructor()\n"
14320                "    : a(a) {}",
14321                Style);
14322   verifyFormat("SomeClass::Constructor() noexcept\n"
14323                "    : a(a) {}",
14324                Style);
14325   verifyFormat("SomeClass::Constructor()\n"
14326                "    : a(a)\n"
14327                "    , b(b)\n"
14328                "    , c(c) {}",
14329                Style);
14330   verifyFormat("SomeClass::Constructor()\n"
14331                "    : a(a) {\n"
14332                "  foo();\n"
14333                "  bar();\n"
14334                "}",
14335                Style);
14336 
14337   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14338   verifyFormat("SomeClass::Constructor()\n"
14339                "    : a(a)\n"
14340                "    , b(b)\n"
14341                "    , c(c) {\n}",
14342                Style);
14343   verifyFormat("SomeClass::Constructor()\n"
14344                "    : a(a) {\n}",
14345                Style);
14346 
14347   Style.ColumnLimit = 80;
14348   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14349   Style.ConstructorInitializerIndentWidth = 2;
14350   verifyFormat("SomeClass::Constructor()\n"
14351                "  : a(a)\n"
14352                "  , b(b)\n"
14353                "  , c(c) {}",
14354                Style);
14355 
14356   Style.ConstructorInitializerIndentWidth = 0;
14357   verifyFormat("SomeClass::Constructor()\n"
14358                ": a(a)\n"
14359                ", b(b)\n"
14360                ", c(c) {}",
14361                Style);
14362 
14363   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14364   Style.ConstructorInitializerIndentWidth = 4;
14365   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14366   verifyFormat(
14367       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14368       Style);
14369   verifyFormat(
14370       "SomeClass::Constructor()\n"
14371       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14372       Style);
14373   Style.ConstructorInitializerIndentWidth = 4;
14374   Style.ColumnLimit = 60;
14375   verifyFormat("SomeClass::Constructor()\n"
14376                "    : aaaaaaaa(aaaaaaaa)\n"
14377                "    , aaaaaaaa(aaaaaaaa)\n"
14378                "    , aaaaaaaa(aaaaaaaa) {}",
14379                Style);
14380 }
14381 
14382 TEST_F(FormatTest, Destructors) {
14383   verifyFormat("void F(int &i) { i.~int(); }");
14384   verifyFormat("void F(int &i) { i->~int(); }");
14385 }
14386 
14387 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14388   FormatStyle Style = getWebKitStyle();
14389 
14390   // Don't indent in outer namespaces.
14391   verifyFormat("namespace outer {\n"
14392                "int i;\n"
14393                "namespace inner {\n"
14394                "    int i;\n"
14395                "} // namespace inner\n"
14396                "} // namespace outer\n"
14397                "namespace other_outer {\n"
14398                "int i;\n"
14399                "}",
14400                Style);
14401 
14402   // Don't indent case labels.
14403   verifyFormat("switch (variable) {\n"
14404                "case 1:\n"
14405                "case 2:\n"
14406                "    doSomething();\n"
14407                "    break;\n"
14408                "default:\n"
14409                "    ++variable;\n"
14410                "}",
14411                Style);
14412 
14413   // Wrap before binary operators.
14414   EXPECT_EQ("void f()\n"
14415             "{\n"
14416             "    if (aaaaaaaaaaaaaaaa\n"
14417             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14418             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14419             "        return;\n"
14420             "}",
14421             format("void f() {\n"
14422                    "if (aaaaaaaaaaaaaaaa\n"
14423                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
14424                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14425                    "return;\n"
14426                    "}",
14427                    Style));
14428 
14429   // Allow functions on a single line.
14430   verifyFormat("void f() { return; }", Style);
14431 
14432   // Allow empty blocks on a single line and insert a space in empty blocks.
14433   EXPECT_EQ("void f() { }", format("void f() {}", Style));
14434   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
14435   // However, don't merge non-empty short loops.
14436   EXPECT_EQ("while (true) {\n"
14437             "    continue;\n"
14438             "}",
14439             format("while (true) { continue; }", Style));
14440 
14441   // Constructor initializers are formatted one per line with the "," on the
14442   // new line.
14443   verifyFormat("Constructor()\n"
14444                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
14445                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
14446                "          aaaaaaaaaaaaaa)\n"
14447                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
14448                "{\n"
14449                "}",
14450                Style);
14451   verifyFormat("SomeClass::Constructor()\n"
14452                "    : a(a)\n"
14453                "{\n"
14454                "}",
14455                Style);
14456   EXPECT_EQ("SomeClass::Constructor()\n"
14457             "    : a(a)\n"
14458             "{\n"
14459             "}",
14460             format("SomeClass::Constructor():a(a){}", Style));
14461   verifyFormat("SomeClass::Constructor()\n"
14462                "    : a(a)\n"
14463                "    , b(b)\n"
14464                "    , c(c)\n"
14465                "{\n"
14466                "}",
14467                Style);
14468   verifyFormat("SomeClass::Constructor()\n"
14469                "    : a(a)\n"
14470                "{\n"
14471                "    foo();\n"
14472                "    bar();\n"
14473                "}",
14474                Style);
14475 
14476   // Access specifiers should be aligned left.
14477   verifyFormat("class C {\n"
14478                "public:\n"
14479                "    int i;\n"
14480                "};",
14481                Style);
14482 
14483   // Do not align comments.
14484   verifyFormat("int a; // Do not\n"
14485                "double b; // align comments.",
14486                Style);
14487 
14488   // Do not align operands.
14489   EXPECT_EQ("ASSERT(aaaa\n"
14490             "    || bbbb);",
14491             format("ASSERT ( aaaa\n||bbbb);", Style));
14492 
14493   // Accept input's line breaks.
14494   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
14495             "    || bbbbbbbbbbbbbbb) {\n"
14496             "    i++;\n"
14497             "}",
14498             format("if (aaaaaaaaaaaaaaa\n"
14499                    "|| bbbbbbbbbbbbbbb) { i++; }",
14500                    Style));
14501   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
14502             "    i++;\n"
14503             "}",
14504             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
14505 
14506   // Don't automatically break all macro definitions (llvm.org/PR17842).
14507   verifyFormat("#define aNumber 10", Style);
14508   // However, generally keep the line breaks that the user authored.
14509   EXPECT_EQ("#define aNumber \\\n"
14510             "    10",
14511             format("#define aNumber \\\n"
14512                    " 10",
14513                    Style));
14514 
14515   // Keep empty and one-element array literals on a single line.
14516   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
14517             "                                  copyItems:YES];",
14518             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
14519                    "copyItems:YES];",
14520                    Style));
14521   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
14522             "                                  copyItems:YES];",
14523             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
14524                    "             copyItems:YES];",
14525                    Style));
14526   // FIXME: This does not seem right, there should be more indentation before
14527   // the array literal's entries. Nested blocks have the same problem.
14528   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14529             "    @\"a\",\n"
14530             "    @\"a\"\n"
14531             "]\n"
14532             "                                  copyItems:YES];",
14533             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14534                    "     @\"a\",\n"
14535                    "     @\"a\"\n"
14536                    "     ]\n"
14537                    "       copyItems:YES];",
14538                    Style));
14539   EXPECT_EQ(
14540       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14541       "                                  copyItems:YES];",
14542       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14543              "   copyItems:YES];",
14544              Style));
14545 
14546   verifyFormat("[self.a b:c c:d];", Style);
14547   EXPECT_EQ("[self.a b:c\n"
14548             "        c:d];",
14549             format("[self.a b:c\n"
14550                    "c:d];",
14551                    Style));
14552 }
14553 
14554 TEST_F(FormatTest, FormatsLambdas) {
14555   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
14556   verifyFormat(
14557       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
14558   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
14559   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
14560   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
14561   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
14562   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
14563   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
14564   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
14565   verifyFormat("int x = f(*+[] {});");
14566   verifyFormat("void f() {\n"
14567                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
14568                "}\n");
14569   verifyFormat("void f() {\n"
14570                "  other(x.begin(), //\n"
14571                "        x.end(),   //\n"
14572                "        [&](int, int) { return 1; });\n"
14573                "}\n");
14574   verifyFormat("void f() {\n"
14575                "  other.other.other.other.other(\n"
14576                "      x.begin(), x.end(),\n"
14577                "      [something, rather](int, int, int, int, int, int, int) { "
14578                "return 1; });\n"
14579                "}\n");
14580   verifyFormat(
14581       "void f() {\n"
14582       "  other.other.other.other.other(\n"
14583       "      x.begin(), x.end(),\n"
14584       "      [something, rather](int, int, int, int, int, int, int) {\n"
14585       "        //\n"
14586       "      });\n"
14587       "}\n");
14588   verifyFormat("SomeFunction([]() { // A cool function...\n"
14589                "  return 43;\n"
14590                "});");
14591   EXPECT_EQ("SomeFunction([]() {\n"
14592             "#define A a\n"
14593             "  return 43;\n"
14594             "});",
14595             format("SomeFunction([](){\n"
14596                    "#define A a\n"
14597                    "return 43;\n"
14598                    "});"));
14599   verifyFormat("void f() {\n"
14600                "  SomeFunction([](decltype(x), A *a) {});\n"
14601                "}");
14602   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14603                "    [](const aaaaaaaaaa &a) { return a; });");
14604   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
14605                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
14606                "});");
14607   verifyFormat("Constructor()\n"
14608                "    : Field([] { // comment\n"
14609                "        int i;\n"
14610                "      }) {}");
14611   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
14612                "  return some_parameter.size();\n"
14613                "};");
14614   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
14615                "    [](const string &s) { return s; };");
14616   verifyFormat("int i = aaaaaa ? 1 //\n"
14617                "               : [] {\n"
14618                "                   return 2; //\n"
14619                "                 }();");
14620   verifyFormat("llvm::errs() << \"number of twos is \"\n"
14621                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
14622                "                  return x == 2; // force break\n"
14623                "                });");
14624   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14625                "    [=](int iiiiiiiiiiii) {\n"
14626                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
14627                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
14628                "    });",
14629                getLLVMStyleWithColumns(60));
14630   verifyFormat("SomeFunction({[&] {\n"
14631                "                // comment\n"
14632                "              },\n"
14633                "              [&] {\n"
14634                "                // comment\n"
14635                "              }});");
14636   verifyFormat("SomeFunction({[&] {\n"
14637                "  // comment\n"
14638                "}});");
14639   verifyFormat(
14640       "virtual aaaaaaaaaaaaaaaa(\n"
14641       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
14642       "    aaaaa aaaaaaaaa);");
14643 
14644   // Lambdas with return types.
14645   verifyFormat("int c = []() -> int { return 2; }();\n");
14646   verifyFormat("int c = []() -> int * { return 2; }();\n");
14647   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
14648   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
14649   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
14650   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
14651   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
14652   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
14653   verifyFormat("[a, a]() -> a<1> {};");
14654   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
14655   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
14656   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
14657   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
14658   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
14659   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
14660   verifyFormat("[]() -> foo<!5> { return {}; };");
14661   verifyFormat("[]() -> foo<~5> { return {}; };");
14662   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
14663   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
14664   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
14665   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
14666   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
14667   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
14668   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
14669   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
14670   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
14671   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
14672   verifyFormat("namespace bar {\n"
14673                "// broken:\n"
14674                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
14675                "} // namespace bar");
14676   verifyFormat("namespace bar {\n"
14677                "// broken:\n"
14678                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
14679                "} // namespace bar");
14680   verifyFormat("namespace bar {\n"
14681                "// broken:\n"
14682                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
14683                "} // namespace bar");
14684   verifyFormat("namespace bar {\n"
14685                "// broken:\n"
14686                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
14687                "} // namespace bar");
14688   verifyFormat("namespace bar {\n"
14689                "// broken:\n"
14690                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
14691                "} // namespace bar");
14692   verifyFormat("namespace bar {\n"
14693                "// broken:\n"
14694                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
14695                "} // namespace bar");
14696   verifyFormat("namespace bar {\n"
14697                "// broken:\n"
14698                "auto foo{[]() -> foo<!5> { return {}; }};\n"
14699                "} // namespace bar");
14700   verifyFormat("namespace bar {\n"
14701                "// broken:\n"
14702                "auto foo{[]() -> foo<~5> { return {}; }};\n"
14703                "} // namespace bar");
14704   verifyFormat("namespace bar {\n"
14705                "// broken:\n"
14706                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
14707                "} // namespace bar");
14708   verifyFormat("namespace bar {\n"
14709                "// broken:\n"
14710                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
14711                "} // namespace bar");
14712   verifyFormat("namespace bar {\n"
14713                "// broken:\n"
14714                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
14715                "} // namespace bar");
14716   verifyFormat("namespace bar {\n"
14717                "// broken:\n"
14718                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
14719                "} // namespace bar");
14720   verifyFormat("namespace bar {\n"
14721                "// broken:\n"
14722                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
14723                "} // namespace bar");
14724   verifyFormat("namespace bar {\n"
14725                "// broken:\n"
14726                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
14727                "} // namespace bar");
14728   verifyFormat("namespace bar {\n"
14729                "// broken:\n"
14730                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
14731                "} // namespace bar");
14732   verifyFormat("namespace bar {\n"
14733                "// broken:\n"
14734                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
14735                "} // namespace bar");
14736   verifyFormat("namespace bar {\n"
14737                "// broken:\n"
14738                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
14739                "} // namespace bar");
14740   verifyFormat("namespace bar {\n"
14741                "// broken:\n"
14742                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
14743                "} // namespace bar");
14744   verifyFormat("[]() -> a<1> {};");
14745   verifyFormat("[]() -> a<1> { ; };");
14746   verifyFormat("[]() -> a<1> { ; }();");
14747   verifyFormat("[a, a]() -> a<true> {};");
14748   verifyFormat("[]() -> a<true> {};");
14749   verifyFormat("[]() -> a<true> { ; };");
14750   verifyFormat("[]() -> a<true> { ; }();");
14751   verifyFormat("[a, a]() -> a<false> {};");
14752   verifyFormat("[]() -> a<false> {};");
14753   verifyFormat("[]() -> a<false> { ; };");
14754   verifyFormat("[]() -> a<false> { ; }();");
14755   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
14756   verifyFormat("namespace bar {\n"
14757                "auto foo{[]() -> foo<false> { ; }};\n"
14758                "} // namespace bar");
14759   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
14760                "                   int j) -> int {\n"
14761                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
14762                "};");
14763   verifyFormat(
14764       "aaaaaaaaaaaaaaaaaaaaaa(\n"
14765       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
14766       "      return aaaaaaaaaaaaaaaaa;\n"
14767       "    });",
14768       getLLVMStyleWithColumns(70));
14769   verifyFormat("[]() //\n"
14770                "    -> int {\n"
14771                "  return 1; //\n"
14772                "};");
14773   verifyFormat("[]() -> Void<T...> {};");
14774   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
14775 
14776   // Lambdas with explicit template argument lists.
14777   verifyFormat(
14778       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
14779 
14780   // Multiple lambdas in the same parentheses change indentation rules. These
14781   // lambdas are forced to start on new lines.
14782   verifyFormat("SomeFunction(\n"
14783                "    []() {\n"
14784                "      //\n"
14785                "    },\n"
14786                "    []() {\n"
14787                "      //\n"
14788                "    });");
14789 
14790   // A lambda passed as arg0 is always pushed to the next line.
14791   verifyFormat("SomeFunction(\n"
14792                "    [this] {\n"
14793                "      //\n"
14794                "    },\n"
14795                "    1);\n");
14796 
14797   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
14798   // the arg0 case above.
14799   auto Style = getGoogleStyle();
14800   Style.BinPackArguments = false;
14801   verifyFormat("SomeFunction(\n"
14802                "    a,\n"
14803                "    [this] {\n"
14804                "      //\n"
14805                "    },\n"
14806                "    b);\n",
14807                Style);
14808   verifyFormat("SomeFunction(\n"
14809                "    a,\n"
14810                "    [this] {\n"
14811                "      //\n"
14812                "    },\n"
14813                "    b);\n");
14814 
14815   // A lambda with a very long line forces arg0 to be pushed out irrespective of
14816   // the BinPackArguments value (as long as the code is wide enough).
14817   verifyFormat(
14818       "something->SomeFunction(\n"
14819       "    a,\n"
14820       "    [this] {\n"
14821       "      "
14822       "D0000000000000000000000000000000000000000000000000000000000001();\n"
14823       "    },\n"
14824       "    b);\n");
14825 
14826   // A multi-line lambda is pulled up as long as the introducer fits on the
14827   // previous line and there are no further args.
14828   verifyFormat("function(1, [this, that] {\n"
14829                "  //\n"
14830                "});\n");
14831   verifyFormat("function([this, that] {\n"
14832                "  //\n"
14833                "});\n");
14834   // FIXME: this format is not ideal and we should consider forcing the first
14835   // arg onto its own line.
14836   verifyFormat("function(a, b, c, //\n"
14837                "         d, [this, that] {\n"
14838                "           //\n"
14839                "         });\n");
14840 
14841   // Multiple lambdas are treated correctly even when there is a short arg0.
14842   verifyFormat("SomeFunction(\n"
14843                "    1,\n"
14844                "    [this] {\n"
14845                "      //\n"
14846                "    },\n"
14847                "    [this] {\n"
14848                "      //\n"
14849                "    },\n"
14850                "    1);\n");
14851 
14852   // More complex introducers.
14853   verifyFormat("return [i, args...] {};");
14854 
14855   // Not lambdas.
14856   verifyFormat("constexpr char hello[]{\"hello\"};");
14857   verifyFormat("double &operator[](int i) { return 0; }\n"
14858                "int i;");
14859   verifyFormat("std::unique_ptr<int[]> foo() {}");
14860   verifyFormat("int i = a[a][a]->f();");
14861   verifyFormat("int i = (*b)[a]->f();");
14862 
14863   // Other corner cases.
14864   verifyFormat("void f() {\n"
14865                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
14866                "  );\n"
14867                "}");
14868 
14869   // Lambdas created through weird macros.
14870   verifyFormat("void f() {\n"
14871                "  MACRO((const AA &a) { return 1; });\n"
14872                "  MACRO((AA &a) { return 1; });\n"
14873                "}");
14874 
14875   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
14876                "      doo_dah();\n"
14877                "      doo_dah();\n"
14878                "    })) {\n"
14879                "}");
14880   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
14881                "                doo_dah();\n"
14882                "                doo_dah();\n"
14883                "              })) {\n"
14884                "}");
14885   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
14886                "                doo_dah();\n"
14887                "                doo_dah();\n"
14888                "              })) {\n"
14889                "}");
14890   verifyFormat("auto lambda = []() {\n"
14891                "  int a = 2\n"
14892                "#if A\n"
14893                "          + 2\n"
14894                "#endif\n"
14895                "      ;\n"
14896                "};");
14897 
14898   // Lambdas with complex multiline introducers.
14899   verifyFormat(
14900       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14901       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
14902       "        -> ::std::unordered_set<\n"
14903       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
14904       "      //\n"
14905       "    });");
14906 
14907   FormatStyle DoNotMerge = getLLVMStyle();
14908   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
14909   verifyFormat("auto c = []() {\n"
14910                "  return b;\n"
14911                "};",
14912                "auto c = []() { return b; };", DoNotMerge);
14913   verifyFormat("auto c = []() {\n"
14914                "};",
14915                " auto c = []() {};", DoNotMerge);
14916 
14917   FormatStyle MergeEmptyOnly = getLLVMStyle();
14918   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
14919   verifyFormat("auto c = []() {\n"
14920                "  return b;\n"
14921                "};",
14922                "auto c = []() {\n"
14923                "  return b;\n"
14924                " };",
14925                MergeEmptyOnly);
14926   verifyFormat("auto c = []() {};",
14927                "auto c = []() {\n"
14928                "};",
14929                MergeEmptyOnly);
14930 
14931   FormatStyle MergeInline = getLLVMStyle();
14932   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
14933   verifyFormat("auto c = []() {\n"
14934                "  return b;\n"
14935                "};",
14936                "auto c = []() { return b; };", MergeInline);
14937   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
14938                MergeInline);
14939   verifyFormat("function([]() { return b; }, a)",
14940                "function([]() { return b; }, a)", MergeInline);
14941   verifyFormat("function(a, []() { return b; })",
14942                "function(a, []() { return b; })", MergeInline);
14943 
14944   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
14945   // AllowShortLambdasOnASingleLine
14946   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
14947   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
14948   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
14949   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
14950       FormatStyle::ShortLambdaStyle::SLS_None;
14951   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
14952                "    []()\n"
14953                "    {\n"
14954                "      return 17;\n"
14955                "    });",
14956                LLVMWithBeforeLambdaBody);
14957   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
14958                "    []()\n"
14959                "    {\n"
14960                "    });",
14961                LLVMWithBeforeLambdaBody);
14962   verifyFormat("auto fct_SLS_None = []()\n"
14963                "{\n"
14964                "  return 17;\n"
14965                "};",
14966                LLVMWithBeforeLambdaBody);
14967   verifyFormat("TwoNestedLambdas_SLS_None(\n"
14968                "    []()\n"
14969                "    {\n"
14970                "      return Call(\n"
14971                "          []()\n"
14972                "          {\n"
14973                "            return 17;\n"
14974                "          });\n"
14975                "    });",
14976                LLVMWithBeforeLambdaBody);
14977   verifyFormat("void Fct()\n"
14978                "{\n"
14979                "  return {[]()\n"
14980                "          {\n"
14981                "            return 17;\n"
14982                "          }};\n"
14983                "}",
14984                LLVMWithBeforeLambdaBody);
14985 
14986   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
14987       FormatStyle::ShortLambdaStyle::SLS_Empty;
14988   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
14989                "    []()\n"
14990                "    {\n"
14991                "      return 17;\n"
14992                "    });",
14993                LLVMWithBeforeLambdaBody);
14994   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
14995                LLVMWithBeforeLambdaBody);
14996   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
14997                "ongFunctionName_SLS_Empty(\n"
14998                "    []() {});",
14999                LLVMWithBeforeLambdaBody);
15000   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
15001                "                                []()\n"
15002                "                                {\n"
15003                "                                  return 17;\n"
15004                "                                });",
15005                LLVMWithBeforeLambdaBody);
15006   verifyFormat("auto fct_SLS_Empty = []()\n"
15007                "{\n"
15008                "  return 17;\n"
15009                "};",
15010                LLVMWithBeforeLambdaBody);
15011   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
15012                "    []()\n"
15013                "    {\n"
15014                "      return Call([]() {});\n"
15015                "    });",
15016                LLVMWithBeforeLambdaBody);
15017   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15018                "                           []()\n"
15019                "                           {\n"
15020                "                             return Call([]() {});\n"
15021                "                           });",
15022                LLVMWithBeforeLambdaBody);
15023   verifyFormat(
15024       "FctWithLongLineInLambda_SLS_Empty(\n"
15025       "    []()\n"
15026       "    {\n"
15027       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15028       "                               AndShouldNotBeConsiderAsInline,\n"
15029       "                               LambdaBodyMustBeBreak);\n"
15030       "    });",
15031       LLVMWithBeforeLambdaBody);
15032 
15033   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15034       FormatStyle::ShortLambdaStyle::SLS_Inline;
15035   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15036                LLVMWithBeforeLambdaBody);
15037   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15038                LLVMWithBeforeLambdaBody);
15039   verifyFormat("auto fct_SLS_Inline = []()\n"
15040                "{\n"
15041                "  return 17;\n"
15042                "};",
15043                LLVMWithBeforeLambdaBody);
15044   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15045                "17; }); });",
15046                LLVMWithBeforeLambdaBody);
15047   verifyFormat(
15048       "FctWithLongLineInLambda_SLS_Inline(\n"
15049       "    []()\n"
15050       "    {\n"
15051       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15052       "                               AndShouldNotBeConsiderAsInline,\n"
15053       "                               LambdaBodyMustBeBreak);\n"
15054       "    });",
15055       LLVMWithBeforeLambdaBody);
15056   verifyFormat("FctWithMultipleParams_SLS_Inline("
15057                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15058                "                                 []() { return 17; });",
15059                LLVMWithBeforeLambdaBody);
15060   verifyFormat(
15061       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15062       LLVMWithBeforeLambdaBody);
15063 
15064   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15065       FormatStyle::ShortLambdaStyle::SLS_All;
15066   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15067                LLVMWithBeforeLambdaBody);
15068   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15069                LLVMWithBeforeLambdaBody);
15070   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15071                LLVMWithBeforeLambdaBody);
15072   verifyFormat("FctWithOneParam_SLS_All(\n"
15073                "    []()\n"
15074                "    {\n"
15075                "      // A cool function...\n"
15076                "      return 43;\n"
15077                "    });",
15078                LLVMWithBeforeLambdaBody);
15079   verifyFormat("FctWithMultipleParams_SLS_All("
15080                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15081                "                              []() { return 17; });",
15082                LLVMWithBeforeLambdaBody);
15083   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15084                LLVMWithBeforeLambdaBody);
15085   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15086                LLVMWithBeforeLambdaBody);
15087   verifyFormat(
15088       "FctWithLongLineInLambda_SLS_All(\n"
15089       "    []()\n"
15090       "    {\n"
15091       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15092       "                               AndShouldNotBeConsiderAsInline,\n"
15093       "                               LambdaBodyMustBeBreak);\n"
15094       "    });",
15095       LLVMWithBeforeLambdaBody);
15096   verifyFormat(
15097       "auto fct_SLS_All = []()\n"
15098       "{\n"
15099       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15100       "                           AndShouldNotBeConsiderAsInline,\n"
15101       "                           LambdaBodyMustBeBreak);\n"
15102       "};",
15103       LLVMWithBeforeLambdaBody);
15104   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15105   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15106                LLVMWithBeforeLambdaBody);
15107   verifyFormat(
15108       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15109       "                                FirstParam,\n"
15110       "                                SecondParam,\n"
15111       "                                ThirdParam,\n"
15112       "                                FourthParam);",
15113       LLVMWithBeforeLambdaBody);
15114   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15115                "    []() { return "
15116                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15117                "    FirstParam,\n"
15118                "    SecondParam,\n"
15119                "    ThirdParam,\n"
15120                "    FourthParam);",
15121                LLVMWithBeforeLambdaBody);
15122   verifyFormat(
15123       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15124       "                                SecondParam,\n"
15125       "                                ThirdParam,\n"
15126       "                                FourthParam,\n"
15127       "                                []() { return SomeValueNotSoLong; });",
15128       LLVMWithBeforeLambdaBody);
15129   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15130                "    []()\n"
15131                "    {\n"
15132                "      return "
15133                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15134                "eConsiderAsInline;\n"
15135                "    });",
15136                LLVMWithBeforeLambdaBody);
15137   verifyFormat(
15138       "FctWithLongLineInLambda_SLS_All(\n"
15139       "    []()\n"
15140       "    {\n"
15141       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15142       "                               AndShouldNotBeConsiderAsInline,\n"
15143       "                               LambdaBodyMustBeBreak);\n"
15144       "    });",
15145       LLVMWithBeforeLambdaBody);
15146   verifyFormat("FctWithTwoParams_SLS_All(\n"
15147                "    []()\n"
15148                "    {\n"
15149                "      // A cool function...\n"
15150                "      return 43;\n"
15151                "    },\n"
15152                "    87);",
15153                LLVMWithBeforeLambdaBody);
15154   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15155                LLVMWithBeforeLambdaBody);
15156   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15157                LLVMWithBeforeLambdaBody);
15158   verifyFormat(
15159       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15160       LLVMWithBeforeLambdaBody);
15161   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15162                "}); }, x);",
15163                LLVMWithBeforeLambdaBody);
15164   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15165                "    []()\n"
15166                "    {\n"
15167                "      // A cool function...\n"
15168                "      return Call([]() { return 17; });\n"
15169                "    });",
15170                LLVMWithBeforeLambdaBody);
15171   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15172                "    []()\n"
15173                "    {\n"
15174                "      return Call(\n"
15175                "          []()\n"
15176                "          {\n"
15177                "            // A cool function...\n"
15178                "            return 17;\n"
15179                "          });\n"
15180                "    });",
15181                LLVMWithBeforeLambdaBody);
15182 }
15183 
15184 TEST_F(FormatTest, LambdaWithLineComments) {
15185   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15186   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15187   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15188   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15189       FormatStyle::ShortLambdaStyle::SLS_All;
15190 
15191   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15192   verifyFormat("auto k = []() // comment\n"
15193                "{ return; }",
15194                LLVMWithBeforeLambdaBody);
15195   verifyFormat("auto k = []() /* comment */ { return; }",
15196                LLVMWithBeforeLambdaBody);
15197   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15198                LLVMWithBeforeLambdaBody);
15199   verifyFormat("auto k = []() // X\n"
15200                "{ return; }",
15201                LLVMWithBeforeLambdaBody);
15202   verifyFormat(
15203       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15204       "{ return; }",
15205       LLVMWithBeforeLambdaBody);
15206 }
15207 
15208 TEST_F(FormatTest, EmptyLinesInLambdas) {
15209   verifyFormat("auto lambda = []() {\n"
15210                "  x(); //\n"
15211                "};",
15212                "auto lambda = []() {\n"
15213                "\n"
15214                "  x(); //\n"
15215                "\n"
15216                "};");
15217 }
15218 
15219 TEST_F(FormatTest, FormatsBlocks) {
15220   FormatStyle ShortBlocks = getLLVMStyle();
15221   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15222   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15223   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15224   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15225   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15226   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15227   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15228 
15229   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15230   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15231   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15232 
15233   verifyFormat("[operation setCompletionBlock:^{\n"
15234                "  [self onOperationDone];\n"
15235                "}];");
15236   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15237                "  [self onOperationDone];\n"
15238                "}]};");
15239   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15240                "  f();\n"
15241                "}];");
15242   verifyFormat("int a = [operation block:^int(int *i) {\n"
15243                "  return 1;\n"
15244                "}];");
15245   verifyFormat("[myObject doSomethingWith:arg1\n"
15246                "                      aaa:^int(int *a) {\n"
15247                "                        return 1;\n"
15248                "                      }\n"
15249                "                      bbb:f(a * bbbbbbbb)];");
15250 
15251   verifyFormat("[operation setCompletionBlock:^{\n"
15252                "  [self.delegate newDataAvailable];\n"
15253                "}];",
15254                getLLVMStyleWithColumns(60));
15255   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15256                "  NSString *path = [self sessionFilePath];\n"
15257                "  if (path) {\n"
15258                "    // ...\n"
15259                "  }\n"
15260                "});");
15261   verifyFormat("[[SessionService sharedService]\n"
15262                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15263                "      if (window) {\n"
15264                "        [self windowDidLoad:window];\n"
15265                "      } else {\n"
15266                "        [self errorLoadingWindow];\n"
15267                "      }\n"
15268                "    }];");
15269   verifyFormat("void (^largeBlock)(void) = ^{\n"
15270                "  // ...\n"
15271                "};\n",
15272                getLLVMStyleWithColumns(40));
15273   verifyFormat("[[SessionService sharedService]\n"
15274                "    loadWindowWithCompletionBlock: //\n"
15275                "        ^(SessionWindow *window) {\n"
15276                "          if (window) {\n"
15277                "            [self windowDidLoad:window];\n"
15278                "          } else {\n"
15279                "            [self errorLoadingWindow];\n"
15280                "          }\n"
15281                "        }];",
15282                getLLVMStyleWithColumns(60));
15283   verifyFormat("[myObject doSomethingWith:arg1\n"
15284                "    firstBlock:^(Foo *a) {\n"
15285                "      // ...\n"
15286                "      int i;\n"
15287                "    }\n"
15288                "    secondBlock:^(Bar *b) {\n"
15289                "      // ...\n"
15290                "      int i;\n"
15291                "    }\n"
15292                "    thirdBlock:^Foo(Bar *b) {\n"
15293                "      // ...\n"
15294                "      int i;\n"
15295                "    }];");
15296   verifyFormat("[myObject doSomethingWith:arg1\n"
15297                "               firstBlock:-1\n"
15298                "              secondBlock:^(Bar *b) {\n"
15299                "                // ...\n"
15300                "                int i;\n"
15301                "              }];");
15302 
15303   verifyFormat("f(^{\n"
15304                "  @autoreleasepool {\n"
15305                "    if (a) {\n"
15306                "      g();\n"
15307                "    }\n"
15308                "  }\n"
15309                "});");
15310   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15311   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15312                "};");
15313 
15314   FormatStyle FourIndent = getLLVMStyle();
15315   FourIndent.ObjCBlockIndentWidth = 4;
15316   verifyFormat("[operation setCompletionBlock:^{\n"
15317                "    [self onOperationDone];\n"
15318                "}];",
15319                FourIndent);
15320 }
15321 
15322 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15323   FormatStyle ZeroColumn = getLLVMStyle();
15324   ZeroColumn.ColumnLimit = 0;
15325 
15326   verifyFormat("[[SessionService sharedService] "
15327                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15328                "  if (window) {\n"
15329                "    [self windowDidLoad:window];\n"
15330                "  } else {\n"
15331                "    [self errorLoadingWindow];\n"
15332                "  }\n"
15333                "}];",
15334                ZeroColumn);
15335   EXPECT_EQ("[[SessionService sharedService]\n"
15336             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15337             "      if (window) {\n"
15338             "        [self windowDidLoad:window];\n"
15339             "      } else {\n"
15340             "        [self errorLoadingWindow];\n"
15341             "      }\n"
15342             "    }];",
15343             format("[[SessionService sharedService]\n"
15344                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15345                    "                if (window) {\n"
15346                    "    [self windowDidLoad:window];\n"
15347                    "  } else {\n"
15348                    "    [self errorLoadingWindow];\n"
15349                    "  }\n"
15350                    "}];",
15351                    ZeroColumn));
15352   verifyFormat("[myObject doSomethingWith:arg1\n"
15353                "    firstBlock:^(Foo *a) {\n"
15354                "      // ...\n"
15355                "      int i;\n"
15356                "    }\n"
15357                "    secondBlock:^(Bar *b) {\n"
15358                "      // ...\n"
15359                "      int i;\n"
15360                "    }\n"
15361                "    thirdBlock:^Foo(Bar *b) {\n"
15362                "      // ...\n"
15363                "      int i;\n"
15364                "    }];",
15365                ZeroColumn);
15366   verifyFormat("f(^{\n"
15367                "  @autoreleasepool {\n"
15368                "    if (a) {\n"
15369                "      g();\n"
15370                "    }\n"
15371                "  }\n"
15372                "});",
15373                ZeroColumn);
15374   verifyFormat("void (^largeBlock)(void) = ^{\n"
15375                "  // ...\n"
15376                "};",
15377                ZeroColumn);
15378 
15379   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15380   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15381             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15382   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15383   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15384             "  int i;\n"
15385             "};",
15386             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15387 }
15388 
15389 TEST_F(FormatTest, SupportsCRLF) {
15390   EXPECT_EQ("int a;\r\n"
15391             "int b;\r\n"
15392             "int c;\r\n",
15393             format("int a;\r\n"
15394                    "  int b;\r\n"
15395                    "    int c;\r\n",
15396                    getLLVMStyle()));
15397   EXPECT_EQ("int a;\r\n"
15398             "int b;\r\n"
15399             "int c;\r\n",
15400             format("int a;\r\n"
15401                    "  int b;\n"
15402                    "    int c;\r\n",
15403                    getLLVMStyle()));
15404   EXPECT_EQ("int a;\n"
15405             "int b;\n"
15406             "int c;\n",
15407             format("int a;\r\n"
15408                    "  int b;\n"
15409                    "    int c;\n",
15410                    getLLVMStyle()));
15411   EXPECT_EQ("\"aaaaaaa \"\r\n"
15412             "\"bbbbbbb\";\r\n",
15413             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15414   EXPECT_EQ("#define A \\\r\n"
15415             "  b;      \\\r\n"
15416             "  c;      \\\r\n"
15417             "  d;\r\n",
15418             format("#define A \\\r\n"
15419                    "  b; \\\r\n"
15420                    "  c; d; \r\n",
15421                    getGoogleStyle()));
15422 
15423   EXPECT_EQ("/*\r\n"
15424             "multi line block comments\r\n"
15425             "should not introduce\r\n"
15426             "an extra carriage return\r\n"
15427             "*/\r\n",
15428             format("/*\r\n"
15429                    "multi line block comments\r\n"
15430                    "should not introduce\r\n"
15431                    "an extra carriage return\r\n"
15432                    "*/\r\n"));
15433   EXPECT_EQ("/*\r\n"
15434             "\r\n"
15435             "*/",
15436             format("/*\r\n"
15437                    "    \r\r\r\n"
15438                    "*/"));
15439 
15440   FormatStyle style = getLLVMStyle();
15441 
15442   style.DeriveLineEnding = true;
15443   style.UseCRLF = false;
15444   EXPECT_EQ("union FooBarBazQux {\n"
15445             "  int foo;\n"
15446             "  int bar;\n"
15447             "  int baz;\n"
15448             "};",
15449             format("union FooBarBazQux {\r\n"
15450                    "  int foo;\n"
15451                    "  int bar;\r\n"
15452                    "  int baz;\n"
15453                    "};",
15454                    style));
15455   style.UseCRLF = true;
15456   EXPECT_EQ("union FooBarBazQux {\r\n"
15457             "  int foo;\r\n"
15458             "  int bar;\r\n"
15459             "  int baz;\r\n"
15460             "};",
15461             format("union FooBarBazQux {\r\n"
15462                    "  int foo;\n"
15463                    "  int bar;\r\n"
15464                    "  int baz;\n"
15465                    "};",
15466                    style));
15467 
15468   style.DeriveLineEnding = false;
15469   style.UseCRLF = false;
15470   EXPECT_EQ("union FooBarBazQux {\n"
15471             "  int foo;\n"
15472             "  int bar;\n"
15473             "  int baz;\n"
15474             "  int qux;\n"
15475             "};",
15476             format("union FooBarBazQux {\r\n"
15477                    "  int foo;\n"
15478                    "  int bar;\r\n"
15479                    "  int baz;\n"
15480                    "  int qux;\r\n"
15481                    "};",
15482                    style));
15483   style.UseCRLF = true;
15484   EXPECT_EQ("union FooBarBazQux {\r\n"
15485             "  int foo;\r\n"
15486             "  int bar;\r\n"
15487             "  int baz;\r\n"
15488             "  int qux;\r\n"
15489             "};",
15490             format("union FooBarBazQux {\r\n"
15491                    "  int foo;\n"
15492                    "  int bar;\r\n"
15493                    "  int baz;\n"
15494                    "  int qux;\n"
15495                    "};",
15496                    style));
15497 
15498   style.DeriveLineEnding = true;
15499   style.UseCRLF = false;
15500   EXPECT_EQ("union FooBarBazQux {\r\n"
15501             "  int foo;\r\n"
15502             "  int bar;\r\n"
15503             "  int baz;\r\n"
15504             "  int qux;\r\n"
15505             "};",
15506             format("union FooBarBazQux {\r\n"
15507                    "  int foo;\n"
15508                    "  int bar;\r\n"
15509                    "  int baz;\n"
15510                    "  int qux;\r\n"
15511                    "};",
15512                    style));
15513   style.UseCRLF = true;
15514   EXPECT_EQ("union FooBarBazQux {\n"
15515             "  int foo;\n"
15516             "  int bar;\n"
15517             "  int baz;\n"
15518             "  int qux;\n"
15519             "};",
15520             format("union FooBarBazQux {\r\n"
15521                    "  int foo;\n"
15522                    "  int bar;\r\n"
15523                    "  int baz;\n"
15524                    "  int qux;\n"
15525                    "};",
15526                    style));
15527 }
15528 
15529 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
15530   verifyFormat("MY_CLASS(C) {\n"
15531                "  int i;\n"
15532                "  int j;\n"
15533                "};");
15534 }
15535 
15536 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
15537   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
15538   TwoIndent.ContinuationIndentWidth = 2;
15539 
15540   EXPECT_EQ("int i =\n"
15541             "  longFunction(\n"
15542             "    arg);",
15543             format("int i = longFunction(arg);", TwoIndent));
15544 
15545   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
15546   SixIndent.ContinuationIndentWidth = 6;
15547 
15548   EXPECT_EQ("int i =\n"
15549             "      longFunction(\n"
15550             "            arg);",
15551             format("int i = longFunction(arg);", SixIndent));
15552 }
15553 
15554 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
15555   FormatStyle Style = getLLVMStyle();
15556   verifyFormat("int Foo::getter(\n"
15557                "    //\n"
15558                ") const {\n"
15559                "  return foo;\n"
15560                "}",
15561                Style);
15562   verifyFormat("void Foo::setter(\n"
15563                "    //\n"
15564                ") {\n"
15565                "  foo = 1;\n"
15566                "}",
15567                Style);
15568 }
15569 
15570 TEST_F(FormatTest, SpacesInAngles) {
15571   FormatStyle Spaces = getLLVMStyle();
15572   Spaces.SpacesInAngles = true;
15573 
15574   verifyFormat("static_cast< int >(arg);", Spaces);
15575   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
15576   verifyFormat("f< int, float >();", Spaces);
15577   verifyFormat("template <> g() {}", Spaces);
15578   verifyFormat("template < std::vector< int > > f() {}", Spaces);
15579   verifyFormat("std::function< void(int, int) > fct;", Spaces);
15580   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
15581                Spaces);
15582 
15583   Spaces.Standard = FormatStyle::LS_Cpp03;
15584   Spaces.SpacesInAngles = true;
15585   verifyFormat("A< A< int > >();", Spaces);
15586 
15587   Spaces.SpacesInAngles = false;
15588   verifyFormat("A<A<int> >();", Spaces);
15589 
15590   Spaces.Standard = FormatStyle::LS_Cpp11;
15591   Spaces.SpacesInAngles = true;
15592   verifyFormat("A< A< int > >();", Spaces);
15593 
15594   Spaces.SpacesInAngles = false;
15595   verifyFormat("A<A<int>>();", Spaces);
15596 }
15597 
15598 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
15599   FormatStyle Style = getLLVMStyle();
15600   Style.SpaceAfterTemplateKeyword = false;
15601   verifyFormat("template<int> void foo();", Style);
15602 }
15603 
15604 TEST_F(FormatTest, TripleAngleBrackets) {
15605   verifyFormat("f<<<1, 1>>>();");
15606   verifyFormat("f<<<1, 1, 1, s>>>();");
15607   verifyFormat("f<<<a, b, c, d>>>();");
15608   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
15609   verifyFormat("f<param><<<1, 1>>>();");
15610   verifyFormat("f<1><<<1, 1>>>();");
15611   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
15612   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15613                "aaaaaaaaaaa<<<\n    1, 1>>>();");
15614   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
15615                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
15616 }
15617 
15618 TEST_F(FormatTest, MergeLessLessAtEnd) {
15619   verifyFormat("<<");
15620   EXPECT_EQ("< < <", format("\\\n<<<"));
15621   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15622                "aaallvm::outs() <<");
15623   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15624                "aaaallvm::outs()\n    <<");
15625 }
15626 
15627 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
15628   std::string code = "#if A\n"
15629                      "#if B\n"
15630                      "a.\n"
15631                      "#endif\n"
15632                      "    a = 1;\n"
15633                      "#else\n"
15634                      "#endif\n"
15635                      "#if C\n"
15636                      "#else\n"
15637                      "#endif\n";
15638   EXPECT_EQ(code, format(code));
15639 }
15640 
15641 TEST_F(FormatTest, HandleConflictMarkers) {
15642   // Git/SVN conflict markers.
15643   EXPECT_EQ("int a;\n"
15644             "void f() {\n"
15645             "  callme(some(parameter1,\n"
15646             "<<<<<<< text by the vcs\n"
15647             "              parameter2),\n"
15648             "||||||| text by the vcs\n"
15649             "              parameter2),\n"
15650             "         parameter3,\n"
15651             "======= text by the vcs\n"
15652             "              parameter2, parameter3),\n"
15653             ">>>>>>> text by the vcs\n"
15654             "         otherparameter);\n",
15655             format("int a;\n"
15656                    "void f() {\n"
15657                    "  callme(some(parameter1,\n"
15658                    "<<<<<<< text by the vcs\n"
15659                    "  parameter2),\n"
15660                    "||||||| text by the vcs\n"
15661                    "  parameter2),\n"
15662                    "  parameter3,\n"
15663                    "======= text by the vcs\n"
15664                    "  parameter2,\n"
15665                    "  parameter3),\n"
15666                    ">>>>>>> text by the vcs\n"
15667                    "  otherparameter);\n"));
15668 
15669   // Perforce markers.
15670   EXPECT_EQ("void f() {\n"
15671             "  function(\n"
15672             ">>>> text by the vcs\n"
15673             "      parameter,\n"
15674             "==== text by the vcs\n"
15675             "      parameter,\n"
15676             "==== text by the vcs\n"
15677             "      parameter,\n"
15678             "<<<< text by the vcs\n"
15679             "      parameter);\n",
15680             format("void f() {\n"
15681                    "  function(\n"
15682                    ">>>> text by the vcs\n"
15683                    "  parameter,\n"
15684                    "==== text by the vcs\n"
15685                    "  parameter,\n"
15686                    "==== text by the vcs\n"
15687                    "  parameter,\n"
15688                    "<<<< text by the vcs\n"
15689                    "  parameter);\n"));
15690 
15691   EXPECT_EQ("<<<<<<<\n"
15692             "|||||||\n"
15693             "=======\n"
15694             ">>>>>>>",
15695             format("<<<<<<<\n"
15696                    "|||||||\n"
15697                    "=======\n"
15698                    ">>>>>>>"));
15699 
15700   EXPECT_EQ("<<<<<<<\n"
15701             "|||||||\n"
15702             "int i;\n"
15703             "=======\n"
15704             ">>>>>>>",
15705             format("<<<<<<<\n"
15706                    "|||||||\n"
15707                    "int i;\n"
15708                    "=======\n"
15709                    ">>>>>>>"));
15710 
15711   // FIXME: Handle parsing of macros around conflict markers correctly:
15712   EXPECT_EQ("#define Macro \\\n"
15713             "<<<<<<<\n"
15714             "Something \\\n"
15715             "|||||||\n"
15716             "Else \\\n"
15717             "=======\n"
15718             "Other \\\n"
15719             ">>>>>>>\n"
15720             "    End int i;\n",
15721             format("#define Macro \\\n"
15722                    "<<<<<<<\n"
15723                    "  Something \\\n"
15724                    "|||||||\n"
15725                    "  Else \\\n"
15726                    "=======\n"
15727                    "  Other \\\n"
15728                    ">>>>>>>\n"
15729                    "  End\n"
15730                    "int i;\n"));
15731 }
15732 
15733 TEST_F(FormatTest, DisableRegions) {
15734   EXPECT_EQ("int i;\n"
15735             "// clang-format off\n"
15736             "  int j;\n"
15737             "// clang-format on\n"
15738             "int k;",
15739             format(" int  i;\n"
15740                    "   // clang-format off\n"
15741                    "  int j;\n"
15742                    " // clang-format on\n"
15743                    "   int   k;"));
15744   EXPECT_EQ("int i;\n"
15745             "/* clang-format off */\n"
15746             "  int j;\n"
15747             "/* clang-format on */\n"
15748             "int k;",
15749             format(" int  i;\n"
15750                    "   /* clang-format off */\n"
15751                    "  int j;\n"
15752                    " /* clang-format on */\n"
15753                    "   int   k;"));
15754 
15755   // Don't reflow comments within disabled regions.
15756   EXPECT_EQ("// clang-format off\n"
15757             "// long long long long long long line\n"
15758             "/* clang-format on */\n"
15759             "/* long long long\n"
15760             " * long long long\n"
15761             " * line */\n"
15762             "int i;\n"
15763             "/* clang-format off */\n"
15764             "/* long long long long long long line */\n",
15765             format("// clang-format off\n"
15766                    "// long long long long long long line\n"
15767                    "/* clang-format on */\n"
15768                    "/* long long long long long long line */\n"
15769                    "int i;\n"
15770                    "/* clang-format off */\n"
15771                    "/* long long long long long long line */\n",
15772                    getLLVMStyleWithColumns(20)));
15773 }
15774 
15775 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
15776   format("? ) =");
15777   verifyNoCrash("#define a\\\n /**/}");
15778 }
15779 
15780 TEST_F(FormatTest, FormatsTableGenCode) {
15781   FormatStyle Style = getLLVMStyle();
15782   Style.Language = FormatStyle::LK_TableGen;
15783   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
15784 }
15785 
15786 TEST_F(FormatTest, ArrayOfTemplates) {
15787   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
15788             format("auto a = new unique_ptr<int > [ 10];"));
15789 
15790   FormatStyle Spaces = getLLVMStyle();
15791   Spaces.SpacesInSquareBrackets = true;
15792   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
15793             format("auto a = new unique_ptr<int > [10];", Spaces));
15794 }
15795 
15796 TEST_F(FormatTest, ArrayAsTemplateType) {
15797   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
15798             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
15799 
15800   FormatStyle Spaces = getLLVMStyle();
15801   Spaces.SpacesInSquareBrackets = true;
15802   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
15803             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
15804 }
15805 
15806 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
15807 
15808 TEST(FormatStyle, GetStyleWithEmptyFileName) {
15809   llvm::vfs::InMemoryFileSystem FS;
15810   auto Style1 = getStyle("file", "", "Google", "", &FS);
15811   ASSERT_TRUE((bool)Style1);
15812   ASSERT_EQ(*Style1, getGoogleStyle());
15813 }
15814 
15815 TEST(FormatStyle, GetStyleOfFile) {
15816   llvm::vfs::InMemoryFileSystem FS;
15817   // Test 1: format file in the same directory.
15818   ASSERT_TRUE(
15819       FS.addFile("/a/.clang-format", 0,
15820                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
15821   ASSERT_TRUE(
15822       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15823   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
15824   ASSERT_TRUE((bool)Style1);
15825   ASSERT_EQ(*Style1, getLLVMStyle());
15826 
15827   // Test 2.1: fallback to default.
15828   ASSERT_TRUE(
15829       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15830   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
15831   ASSERT_TRUE((bool)Style2);
15832   ASSERT_EQ(*Style2, getMozillaStyle());
15833 
15834   // Test 2.2: no format on 'none' fallback style.
15835   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
15836   ASSERT_TRUE((bool)Style2);
15837   ASSERT_EQ(*Style2, getNoStyle());
15838 
15839   // Test 2.3: format if config is found with no based style while fallback is
15840   // 'none'.
15841   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
15842                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
15843   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
15844   ASSERT_TRUE((bool)Style2);
15845   ASSERT_EQ(*Style2, getLLVMStyle());
15846 
15847   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
15848   Style2 = getStyle("{}", "a.h", "none", "", &FS);
15849   ASSERT_TRUE((bool)Style2);
15850   ASSERT_EQ(*Style2, getLLVMStyle());
15851 
15852   // Test 3: format file in parent directory.
15853   ASSERT_TRUE(
15854       FS.addFile("/c/.clang-format", 0,
15855                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
15856   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
15857                          llvm::MemoryBuffer::getMemBuffer("int i;")));
15858   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
15859   ASSERT_TRUE((bool)Style3);
15860   ASSERT_EQ(*Style3, getGoogleStyle());
15861 
15862   // Test 4: error on invalid fallback style
15863   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
15864   ASSERT_FALSE((bool)Style4);
15865   llvm::consumeError(Style4.takeError());
15866 
15867   // Test 5: error on invalid yaml on command line
15868   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
15869   ASSERT_FALSE((bool)Style5);
15870   llvm::consumeError(Style5.takeError());
15871 
15872   // Test 6: error on invalid style
15873   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
15874   ASSERT_FALSE((bool)Style6);
15875   llvm::consumeError(Style6.takeError());
15876 
15877   // Test 7: found config file, error on parsing it
15878   ASSERT_TRUE(
15879       FS.addFile("/d/.clang-format", 0,
15880                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
15881                                                   "InvalidKey: InvalidValue")));
15882   ASSERT_TRUE(
15883       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15884   auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
15885   ASSERT_FALSE((bool)Style7);
15886   llvm::consumeError(Style7.takeError());
15887 
15888   // Test 8: inferred per-language defaults apply.
15889   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
15890   ASSERT_TRUE((bool)StyleTd);
15891   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
15892 }
15893 
15894 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
15895   // Column limit is 20.
15896   std::string Code = "Type *a =\n"
15897                      "    new Type();\n"
15898                      "g(iiiii, 0, jjjjj,\n"
15899                      "  0, kkkkk, 0, mm);\n"
15900                      "int  bad     = format   ;";
15901   std::string Expected = "auto a = new Type();\n"
15902                          "g(iiiii, nullptr,\n"
15903                          "  jjjjj, nullptr,\n"
15904                          "  kkkkk, nullptr,\n"
15905                          "  mm);\n"
15906                          "int  bad     = format   ;";
15907   FileID ID = Context.createInMemoryFile("format.cpp", Code);
15908   tooling::Replacements Replaces = toReplacements(
15909       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
15910                             "auto "),
15911        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
15912                             "nullptr"),
15913        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
15914                             "nullptr"),
15915        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
15916                             "nullptr")});
15917 
15918   format::FormatStyle Style = format::getLLVMStyle();
15919   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
15920   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
15921   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
15922       << llvm::toString(FormattedReplaces.takeError()) << "\n";
15923   auto Result = applyAllReplacements(Code, *FormattedReplaces);
15924   EXPECT_TRUE(static_cast<bool>(Result));
15925   EXPECT_EQ(Expected, *Result);
15926 }
15927 
15928 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
15929   std::string Code = "#include \"a.h\"\n"
15930                      "#include \"c.h\"\n"
15931                      "\n"
15932                      "int main() {\n"
15933                      "  return 0;\n"
15934                      "}";
15935   std::string Expected = "#include \"a.h\"\n"
15936                          "#include \"b.h\"\n"
15937                          "#include \"c.h\"\n"
15938                          "\n"
15939                          "int main() {\n"
15940                          "  return 0;\n"
15941                          "}";
15942   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
15943   tooling::Replacements Replaces = toReplacements(
15944       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
15945                             "#include \"b.h\"\n")});
15946 
15947   format::FormatStyle Style = format::getLLVMStyle();
15948   Style.SortIncludes = true;
15949   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
15950   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
15951       << llvm::toString(FormattedReplaces.takeError()) << "\n";
15952   auto Result = applyAllReplacements(Code, *FormattedReplaces);
15953   EXPECT_TRUE(static_cast<bool>(Result));
15954   EXPECT_EQ(Expected, *Result);
15955 }
15956 
15957 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
15958   EXPECT_EQ("using std::cin;\n"
15959             "using std::cout;",
15960             format("using std::cout;\n"
15961                    "using std::cin;",
15962                    getGoogleStyle()));
15963 }
15964 
15965 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
15966   format::FormatStyle Style = format::getLLVMStyle();
15967   Style.Standard = FormatStyle::LS_Cpp03;
15968   // cpp03 recognize this string as identifier u8 and literal character 'a'
15969   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
15970 }
15971 
15972 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
15973   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
15974   // all modes, including C++11, C++14 and C++17
15975   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
15976 }
15977 
15978 TEST_F(FormatTest, DoNotFormatLikelyXml) {
15979   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
15980   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
15981 }
15982 
15983 TEST_F(FormatTest, StructuredBindings) {
15984   // Structured bindings is a C++17 feature.
15985   // all modes, including C++11, C++14 and C++17
15986   verifyFormat("auto [a, b] = f();");
15987   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
15988   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
15989   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
15990   EXPECT_EQ("auto const volatile [a, b] = f();",
15991             format("auto  const   volatile[a, b] = f();"));
15992   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
15993   EXPECT_EQ("auto &[a, b, c] = f();",
15994             format("auto   &[  a  ,  b,c   ] = f();"));
15995   EXPECT_EQ("auto &&[a, b, c] = f();",
15996             format("auto   &&[  a  ,  b,c   ] = f();"));
15997   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
15998   EXPECT_EQ("auto const volatile &&[a, b] = f();",
15999             format("auto  const  volatile  &&[a, b] = f();"));
16000   EXPECT_EQ("auto const &&[a, b] = f();",
16001             format("auto  const   &&  [a, b] = f();"));
16002   EXPECT_EQ("const auto &[a, b] = f();",
16003             format("const  auto  &  [a, b] = f();"));
16004   EXPECT_EQ("const auto volatile &&[a, b] = f();",
16005             format("const  auto   volatile  &&[a, b] = f();"));
16006   EXPECT_EQ("volatile const auto &&[a, b] = f();",
16007             format("volatile  const  auto   &&[a, b] = f();"));
16008   EXPECT_EQ("const auto &&[a, b] = f();",
16009             format("const  auto  &&  [a, b] = f();"));
16010 
16011   // Make sure we don't mistake structured bindings for lambdas.
16012   FormatStyle PointerMiddle = getLLVMStyle();
16013   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16014   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16015   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16016   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16017   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16018   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16019   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16020   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16021   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16022   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16023   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16024   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16025   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16026 
16027   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16028             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16029   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16030             format("for (const auto   &   [a, b] : some_range) {\n}"));
16031   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16032             format("for (const auto[a, b] : some_range) {\n}"));
16033   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16034   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16035   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16036   EXPECT_EQ("auto const &[x, y](expr);",
16037             format("auto  const  &  [x,y]  (expr);"));
16038   EXPECT_EQ("auto const &&[x, y](expr);",
16039             format("auto  const  &&  [x,y]  (expr);"));
16040   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16041   EXPECT_EQ("auto const &[x, y]{expr};",
16042             format("auto  const  &  [x,y]  {expr};"));
16043   EXPECT_EQ("auto const &&[x, y]{expr};",
16044             format("auto  const  &&  [x,y]  {expr};"));
16045 
16046   format::FormatStyle Spaces = format::getLLVMStyle();
16047   Spaces.SpacesInSquareBrackets = true;
16048   verifyFormat("auto [ a, b ] = f();", Spaces);
16049   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16050   verifyFormat("auto &[ a, b ] = f();", Spaces);
16051   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16052   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16053 }
16054 
16055 TEST_F(FormatTest, FileAndCode) {
16056   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16057   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16058   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16059   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16060   EXPECT_EQ(FormatStyle::LK_ObjC,
16061             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16062   EXPECT_EQ(
16063       FormatStyle::LK_ObjC,
16064       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16065   EXPECT_EQ(FormatStyle::LK_ObjC,
16066             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16067   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16068   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16069   EXPECT_EQ(FormatStyle::LK_ObjC,
16070             guessLanguage("foo", "@interface Foo\n@end\n"));
16071   EXPECT_EQ(FormatStyle::LK_ObjC,
16072             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16073   EXPECT_EQ(
16074       FormatStyle::LK_ObjC,
16075       guessLanguage("foo.h",
16076                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16077   EXPECT_EQ(
16078       FormatStyle::LK_Cpp,
16079       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16080 }
16081 
16082 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16083   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16084   EXPECT_EQ(FormatStyle::LK_ObjC,
16085             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16086   EXPECT_EQ(FormatStyle::LK_Cpp,
16087             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16088   EXPECT_EQ(
16089       FormatStyle::LK_Cpp,
16090       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16091   EXPECT_EQ(FormatStyle::LK_ObjC,
16092             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16093   EXPECT_EQ(FormatStyle::LK_Cpp,
16094             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16095   EXPECT_EQ(FormatStyle::LK_ObjC,
16096             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16097   EXPECT_EQ(FormatStyle::LK_Cpp,
16098             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16099   EXPECT_EQ(FormatStyle::LK_Cpp,
16100             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16101   EXPECT_EQ(FormatStyle::LK_ObjC,
16102             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16103   EXPECT_EQ(FormatStyle::LK_Cpp,
16104             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16105   EXPECT_EQ(
16106       FormatStyle::LK_Cpp,
16107       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16108   EXPECT_EQ(
16109       FormatStyle::LK_Cpp,
16110       guessLanguage("foo.h",
16111                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16112   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16113 }
16114 
16115 TEST_F(FormatTest, GuessLanguageWithCaret) {
16116   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16117   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16118   EXPECT_EQ(FormatStyle::LK_ObjC,
16119             guessLanguage("foo.h", "int(^)(char, float);"));
16120   EXPECT_EQ(FormatStyle::LK_ObjC,
16121             guessLanguage("foo.h", "int(^foo)(char, float);"));
16122   EXPECT_EQ(FormatStyle::LK_ObjC,
16123             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16124   EXPECT_EQ(FormatStyle::LK_ObjC,
16125             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16126   EXPECT_EQ(
16127       FormatStyle::LK_ObjC,
16128       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16129 }
16130 
16131 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16132   // ASM symbolic names are identifiers that must be surrounded by [] without
16133   // space in between:
16134   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16135 
16136   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16137   verifyFormat(R"(//
16138 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16139 )");
16140 
16141   // A list of several ASM symbolic names.
16142   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16143 
16144   // ASM symbolic names in inline ASM with inputs and outputs.
16145   verifyFormat(R"(//
16146 asm("cmoveq %1, %2, %[result]"
16147     : [result] "=r"(result)
16148     : "r"(test), "r"(new), "[result]"(old));
16149 )");
16150 
16151   // ASM symbolic names in inline ASM with no outputs.
16152   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16153 }
16154 
16155 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
16156   EXPECT_EQ(FormatStyle::LK_Cpp,
16157             guessLanguage("foo.h", "void f() {\n"
16158                                    "  asm (\"mov %[e], %[d]\"\n"
16159                                    "     : [d] \"=rm\" (d)\n"
16160                                    "       [e] \"rm\" (*e));\n"
16161                                    "}"));
16162   EXPECT_EQ(FormatStyle::LK_Cpp,
16163             guessLanguage("foo.h", "void f() {\n"
16164                                    "  _asm (\"mov %[e], %[d]\"\n"
16165                                    "     : [d] \"=rm\" (d)\n"
16166                                    "       [e] \"rm\" (*e));\n"
16167                                    "}"));
16168   EXPECT_EQ(FormatStyle::LK_Cpp,
16169             guessLanguage("foo.h", "void f() {\n"
16170                                    "  __asm (\"mov %[e], %[d]\"\n"
16171                                    "     : [d] \"=rm\" (d)\n"
16172                                    "       [e] \"rm\" (*e));\n"
16173                                    "}"));
16174   EXPECT_EQ(FormatStyle::LK_Cpp,
16175             guessLanguage("foo.h", "void f() {\n"
16176                                    "  __asm__ (\"mov %[e], %[d]\"\n"
16177                                    "     : [d] \"=rm\" (d)\n"
16178                                    "       [e] \"rm\" (*e));\n"
16179                                    "}"));
16180   EXPECT_EQ(FormatStyle::LK_Cpp,
16181             guessLanguage("foo.h", "void f() {\n"
16182                                    "  asm (\"mov %[e], %[d]\"\n"
16183                                    "     : [d] \"=rm\" (d),\n"
16184                                    "       [e] \"rm\" (*e));\n"
16185                                    "}"));
16186   EXPECT_EQ(FormatStyle::LK_Cpp,
16187             guessLanguage("foo.h", "void f() {\n"
16188                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16189                                    "     : [d] \"=rm\" (d)\n"
16190                                    "       [e] \"rm\" (*e));\n"
16191                                    "}"));
16192 }
16193 
16194 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16195   EXPECT_EQ(FormatStyle::LK_Cpp,
16196             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16197   EXPECT_EQ(FormatStyle::LK_ObjC,
16198             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16199   EXPECT_EQ(
16200       FormatStyle::LK_Cpp,
16201       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16202   EXPECT_EQ(
16203       FormatStyle::LK_ObjC,
16204       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16205 }
16206 
16207 TEST_F(FormatTest, TypenameMacros) {
16208   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16209 
16210   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16211   FormatStyle Google = getGoogleStyleWithColumns(0);
16212   Google.TypenameMacros = TypenameMacros;
16213   verifyFormat("struct foo {\n"
16214                "  int bar;\n"
16215                "  TAILQ_ENTRY(a) bleh;\n"
16216                "};",
16217                Google);
16218 
16219   FormatStyle Macros = getLLVMStyle();
16220   Macros.TypenameMacros = TypenameMacros;
16221 
16222   verifyFormat("STACK_OF(int) a;", Macros);
16223   verifyFormat("STACK_OF(int) *a;", Macros);
16224   verifyFormat("STACK_OF(int const *) *a;", Macros);
16225   verifyFormat("STACK_OF(int *const) *a;", Macros);
16226   verifyFormat("STACK_OF(int, string) a;", Macros);
16227   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16228   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16229   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16230   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16231 
16232   Macros.PointerAlignment = FormatStyle::PAS_Left;
16233   verifyFormat("STACK_OF(int)* a;", Macros);
16234   verifyFormat("STACK_OF(int*)* a;", Macros);
16235 }
16236 
16237 TEST_F(FormatTest, AmbersandInLamda) {
16238   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16239   FormatStyle AlignStyle = getLLVMStyle();
16240   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16241   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16242   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16243   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16244 }
16245 
16246 TEST_F(FormatTest, SpacesInConditionalStatement) {
16247   FormatStyle Spaces = getLLVMStyle();
16248   Spaces.SpacesInConditionalStatement = true;
16249   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16250   verifyFormat("if ( !a )\n  return;", Spaces);
16251   verifyFormat("if ( a )\n  return;", Spaces);
16252   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16253   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16254   verifyFormat("while ( a )\n  return;", Spaces);
16255   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16256   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16257   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16258   // Check that space on the left of "::" is inserted as expected at beginning
16259   // of condition.
16260   verifyFormat("while ( ::func() )\n  return;", Spaces);
16261 }
16262 
16263 TEST_F(FormatTest, AlternativeOperators) {
16264   // Test case for ensuring alternate operators are not
16265   // combined with their right most neighbour.
16266   verifyFormat("int a and b;");
16267   verifyFormat("int a and_eq b;");
16268   verifyFormat("int a bitand b;");
16269   verifyFormat("int a bitor b;");
16270   verifyFormat("int a compl b;");
16271   verifyFormat("int a not b;");
16272   verifyFormat("int a not_eq b;");
16273   verifyFormat("int a or b;");
16274   verifyFormat("int a xor b;");
16275   verifyFormat("int a xor_eq b;");
16276   verifyFormat("return this not_eq bitand other;");
16277   verifyFormat("bool operator not_eq(const X bitand other)");
16278 
16279   verifyFormat("int a and 5;");
16280   verifyFormat("int a and_eq 5;");
16281   verifyFormat("int a bitand 5;");
16282   verifyFormat("int a bitor 5;");
16283   verifyFormat("int a compl 5;");
16284   verifyFormat("int a not 5;");
16285   verifyFormat("int a not_eq 5;");
16286   verifyFormat("int a or 5;");
16287   verifyFormat("int a xor 5;");
16288   verifyFormat("int a xor_eq 5;");
16289 
16290   verifyFormat("int a compl(5);");
16291   verifyFormat("int a not(5);");
16292 
16293   /* FIXME handle alternate tokens
16294    * https://en.cppreference.com/w/cpp/language/operator_alternative
16295   // alternative tokens
16296   verifyFormat("compl foo();");     //  ~foo();
16297   verifyFormat("foo() <%%>;");      // foo();
16298   verifyFormat("void foo() <%%>;"); // void foo(){}
16299   verifyFormat("int a <:1:>;");     // int a[1];[
16300   verifyFormat("%:define ABC abc"); // #define ABC abc
16301   verifyFormat("%:%:");             // ##
16302   */
16303 }
16304 
16305 TEST_F(FormatTest, STLWhileNotDefineChed) {
16306   verifyFormat("#if defined(while)\n"
16307                "#define while EMIT WARNING C4005\n"
16308                "#endif // while");
16309 }
16310 
16311 TEST_F(FormatTest, OperatorSpacing) {
16312   FormatStyle Style = getLLVMStyle();
16313   Style.PointerAlignment = FormatStyle::PAS_Right;
16314   verifyFormat("Foo::operator*();", Style);
16315   verifyFormat("Foo::operator void *();", Style);
16316   verifyFormat("Foo::operator void **();", Style);
16317   verifyFormat("Foo::operator void *&();", Style);
16318   verifyFormat("Foo::operator void *&&();", Style);
16319   verifyFormat("Foo::operator()(void *);", Style);
16320   verifyFormat("Foo::operator*(void *);", Style);
16321   verifyFormat("Foo::operator*();", Style);
16322   verifyFormat("Foo::operator**();", Style);
16323   verifyFormat("Foo::operator&();", Style);
16324   verifyFormat("Foo::operator<int> *();", Style);
16325   verifyFormat("Foo::operator<Foo> *();", Style);
16326   verifyFormat("Foo::operator<int> **();", Style);
16327   verifyFormat("Foo::operator<Foo> **();", Style);
16328   verifyFormat("Foo::operator<int> &();", Style);
16329   verifyFormat("Foo::operator<Foo> &();", Style);
16330   verifyFormat("Foo::operator<int> &&();", Style);
16331   verifyFormat("Foo::operator<Foo> &&();", Style);
16332   verifyFormat("Foo::operator<int> *&();", Style);
16333   verifyFormat("Foo::operator<Foo> *&();", Style);
16334   verifyFormat("Foo::operator<int> *&&();", Style);
16335   verifyFormat("Foo::operator<Foo> *&&();", Style);
16336   verifyFormat("operator*(int (*)(), class Foo);", Style);
16337 
16338   verifyFormat("Foo::operator&();", Style);
16339   verifyFormat("Foo::operator void &();", Style);
16340   verifyFormat("Foo::operator()(void &);", Style);
16341   verifyFormat("Foo::operator&(void &);", Style);
16342   verifyFormat("Foo::operator&();", Style);
16343   verifyFormat("operator&(int (&)(), class Foo);", Style);
16344 
16345   verifyFormat("Foo::operator&&();", Style);
16346   verifyFormat("Foo::operator**();", Style);
16347   verifyFormat("Foo::operator void &&();", Style);
16348   verifyFormat("Foo::operator()(void &&);", Style);
16349   verifyFormat("Foo::operator&&(void &&);", Style);
16350   verifyFormat("Foo::operator&&();", Style);
16351   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16352   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16353   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16354                Style);
16355   verifyFormat("operator void **()", Style);
16356   verifyFormat("operator const FooRight<Object> &()", Style);
16357   verifyFormat("operator const FooRight<Object> *()", Style);
16358   verifyFormat("operator const FooRight<Object> **()", Style);
16359   verifyFormat("operator const FooRight<Object> *&()", Style);
16360   verifyFormat("operator const FooRight<Object> *&&()", Style);
16361 
16362   Style.PointerAlignment = FormatStyle::PAS_Left;
16363   verifyFormat("Foo::operator*();", Style);
16364   verifyFormat("Foo::operator**();", Style);
16365   verifyFormat("Foo::operator void*();", Style);
16366   verifyFormat("Foo::operator void**();", Style);
16367   verifyFormat("Foo::operator void*&();", Style);
16368   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16369   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16370   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16371   verifyFormat("Foo::operator()(void*);", Style);
16372   verifyFormat("Foo::operator*(void*);", Style);
16373   verifyFormat("Foo::operator*();", Style);
16374   verifyFormat("Foo::operator<int>*();", Style);
16375   verifyFormat("Foo::operator<Foo>*();", Style);
16376   verifyFormat("Foo::operator<int>**();", Style);
16377   verifyFormat("Foo::operator<Foo>**();", Style);
16378   verifyFormat("Foo::operator<Foo>*&();", Style);
16379   verifyFormat("Foo::operator<int>&();", Style);
16380   verifyFormat("Foo::operator<Foo>&();", Style);
16381   verifyFormat("Foo::operator<int>&&();", Style);
16382   verifyFormat("Foo::operator<Foo>&&();", Style);
16383   verifyFormat("Foo::operator<int>*&();", Style);
16384   verifyFormat("Foo::operator<Foo>*&();", Style);
16385   verifyFormat("operator*(int (*)(), class Foo);", Style);
16386 
16387   verifyFormat("Foo::operator&();", Style);
16388   verifyFormat("Foo::operator void&();", Style);
16389   verifyFormat("Foo::operator/*comment*/ void&();", Style);
16390   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
16391   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
16392   verifyFormat("Foo::operator()(void&);", Style);
16393   verifyFormat("Foo::operator&(void&);", Style);
16394   verifyFormat("Foo::operator&();", Style);
16395   verifyFormat("operator&(int (&)(), class Foo);", Style);
16396 
16397   verifyFormat("Foo::operator&&();", Style);
16398   verifyFormat("Foo::operator void&&();", Style);
16399   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
16400   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
16401   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
16402   verifyFormat("Foo::operator()(void&&);", Style);
16403   verifyFormat("Foo::operator&&(void&&);", Style);
16404   verifyFormat("Foo::operator&&();", Style);
16405   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16406   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
16407   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
16408                Style);
16409   verifyFormat("operator void**()", Style);
16410   verifyFormat("operator const FooLeft<Object>&()", Style);
16411   verifyFormat("operator const FooLeft<Object>*()", Style);
16412   verifyFormat("operator const FooLeft<Object>**()", Style);
16413   verifyFormat("operator const FooLeft<Object>*&()", Style);
16414   verifyFormat("operator const FooLeft<Object>*&&()", Style);
16415 
16416   // PR45107
16417   verifyFormat("operator Vector<String>&();", Style);
16418   verifyFormat("operator const Vector<String>&();", Style);
16419   verifyFormat("operator foo::Bar*();", Style);
16420   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
16421   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
16422                Style);
16423 
16424   Style.PointerAlignment = FormatStyle::PAS_Middle;
16425   verifyFormat("Foo::operator*();", Style);
16426   verifyFormat("Foo::operator void *();", Style);
16427   verifyFormat("Foo::operator()(void *);", Style);
16428   verifyFormat("Foo::operator*(void *);", Style);
16429   verifyFormat("Foo::operator*();", Style);
16430   verifyFormat("operator*(int (*)(), class Foo);", Style);
16431 
16432   verifyFormat("Foo::operator&();", Style);
16433   verifyFormat("Foo::operator void &();", Style);
16434   verifyFormat("Foo::operator()(void &);", Style);
16435   verifyFormat("Foo::operator&(void &);", Style);
16436   verifyFormat("Foo::operator&();", Style);
16437   verifyFormat("operator&(int (&)(), class Foo);", Style);
16438 
16439   verifyFormat("Foo::operator&&();", Style);
16440   verifyFormat("Foo::operator void &&();", Style);
16441   verifyFormat("Foo::operator()(void &&);", Style);
16442   verifyFormat("Foo::operator&&(void &&);", Style);
16443   verifyFormat("Foo::operator&&();", Style);
16444   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16445 }
16446 
16447 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
16448   FormatStyle Style = getLLVMStyle();
16449   // PR46157
16450   verifyFormat("foo(operator+, -42);", Style);
16451   verifyFormat("foo(operator++, -42);", Style);
16452   verifyFormat("foo(operator--, -42);", Style);
16453   verifyFormat("foo(-42, operator--);", Style);
16454   verifyFormat("foo(-42, operator, );", Style);
16455   verifyFormat("foo(operator, , -42);", Style);
16456 }
16457 
16458 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
16459   // These tests are not in NamespaceFixer because that doesn't
16460   // test its interaction with line wrapping
16461   FormatStyle Style = getLLVMStyle();
16462   Style.ColumnLimit = 80;
16463   verifyFormat("namespace {\n"
16464                "int i;\n"
16465                "int j;\n"
16466                "} // namespace",
16467                Style);
16468 
16469   verifyFormat("namespace AAA {\n"
16470                "int i;\n"
16471                "int j;\n"
16472                "} // namespace AAA",
16473                Style);
16474 
16475   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
16476             "int i;\n"
16477             "int j;\n"
16478             "} // namespace Averyveryveryverylongnamespace",
16479             format("namespace Averyveryveryverylongnamespace {\n"
16480                    "int i;\n"
16481                    "int j;\n"
16482                    "}",
16483                    Style));
16484 
16485   EXPECT_EQ(
16486       "namespace "
16487       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16488       "    went::mad::now {\n"
16489       "int i;\n"
16490       "int j;\n"
16491       "} // namespace\n"
16492       "  // "
16493       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16494       "went::mad::now",
16495       format("namespace "
16496              "would::it::save::you::a::lot::of::time::if_::i::"
16497              "just::gave::up::and_::went::mad::now {\n"
16498              "int i;\n"
16499              "int j;\n"
16500              "}",
16501              Style));
16502 
16503   // This used to duplicate the comment again and again on subsequent runs
16504   EXPECT_EQ(
16505       "namespace "
16506       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16507       "    went::mad::now {\n"
16508       "int i;\n"
16509       "int j;\n"
16510       "} // namespace\n"
16511       "  // "
16512       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16513       "went::mad::now",
16514       format("namespace "
16515              "would::it::save::you::a::lot::of::time::if_::i::"
16516              "just::gave::up::and_::went::mad::now {\n"
16517              "int i;\n"
16518              "int j;\n"
16519              "} // namespace\n"
16520              "  // "
16521              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
16522              "and_::went::mad::now",
16523              Style));
16524 }
16525 
16526 TEST_F(FormatTest, LikelyUnlikely) {
16527   FormatStyle Style = getLLVMStyle();
16528 
16529   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16530                "  return 29;\n"
16531                "}",
16532                Style);
16533 
16534   verifyFormat("if (argc > 5) [[likely]] {\n"
16535                "  return 29;\n"
16536                "}",
16537                Style);
16538 
16539   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16540                "  return 29;\n"
16541                "} else [[likely]] {\n"
16542                "  return 42;\n"
16543                "}\n",
16544                Style);
16545 
16546   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16547                "  return 29;\n"
16548                "} else if (argc > 10) [[likely]] {\n"
16549                "  return 99;\n"
16550                "} else {\n"
16551                "  return 42;\n"
16552                "}\n",
16553                Style);
16554 
16555   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
16556                "  return 29;\n"
16557                "}",
16558                Style);
16559 }
16560 
16561 TEST_F(FormatTest, LLVMDefaultStyle) {
16562   FormatStyle Style = getLLVMStyle();
16563   verifyFormat("extern \"C\" {\n"
16564                "int foo();\n"
16565                "}",
16566                Style);
16567 }
16568 TEST_F(FormatTest, GNUDefaultStyle) {
16569   FormatStyle Style = getGNUStyle();
16570   verifyFormat("extern \"C\"\n"
16571                "{\n"
16572                "  int foo ();\n"
16573                "}",
16574                Style);
16575 }
16576 TEST_F(FormatTest, MozillaDefaultStyle) {
16577   FormatStyle Style = getMozillaStyle();
16578   verifyFormat("extern \"C\"\n"
16579                "{\n"
16580                "  int foo();\n"
16581                "}",
16582                Style);
16583 }
16584 TEST_F(FormatTest, GoogleDefaultStyle) {
16585   FormatStyle Style = getGoogleStyle();
16586   verifyFormat("extern \"C\" {\n"
16587                "int foo();\n"
16588                "}",
16589                Style);
16590 }
16591 TEST_F(FormatTest, ChromiumDefaultStyle) {
16592   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
16593   verifyFormat("extern \"C\" {\n"
16594                "int foo();\n"
16595                "}",
16596                Style);
16597 }
16598 TEST_F(FormatTest, MicrosoftDefaultStyle) {
16599   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
16600   verifyFormat("extern \"C\"\n"
16601                "{\n"
16602                "    int foo();\n"
16603                "}",
16604                Style);
16605 }
16606 TEST_F(FormatTest, WebKitDefaultStyle) {
16607   FormatStyle Style = getWebKitStyle();
16608   verifyFormat("extern \"C\" {\n"
16609                "int foo();\n"
16610                "}",
16611                Style);
16612 }
16613 } // namespace
16614 } // namespace format
16615 } // namespace clang
16616