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("foreach (int i,\n"
1667             "         list)\n"
1668             "{\n"
1669             "  foo();\n"
1670             "}",
1671             format("foreach(int i, list){foo();}", Style));
1672   Style.ColumnLimit =
1673       40; // to concentrate at brace wrapping, not line wrap due to column limit
1674   EXPECT_EQ("foreach (int i, list) {\n"
1675             "  foo();\n"
1676             "}",
1677             format("foreach(int i, list){foo();}", Style));
1678   Style.ColumnLimit =
1679       20; // to concentrate at brace wrapping, not line wrap due to column limit
1680   EXPECT_EQ("while (foo || bar ||\n"
1681             "       baz)\n"
1682             "{\n"
1683             "  quux();\n"
1684             "}",
1685             format("while(foo||bar||baz){quux();}", Style));
1686   EXPECT_EQ("switch (\n"
1687             "    foo = barbaz)\n"
1688             "{\n"
1689             "case quux:\n"
1690             "  return;\n"
1691             "}",
1692             format("switch(foo=barbaz){case quux:return;}", Style));
1693   EXPECT_EQ("try {\n"
1694             "  foo();\n"
1695             "} catch (\n"
1696             "    Exception &bar)\n"
1697             "{\n"
1698             "  baz();\n"
1699             "}",
1700             format("try{foo();}catch(Exception&bar){baz();}", Style));
1701   Style.ColumnLimit =
1702       40; // to concentrate at brace wrapping, not line wrap due to column limit
1703   EXPECT_EQ("try {\n"
1704             "  foo();\n"
1705             "} catch (Exception &bar) {\n"
1706             "  baz();\n"
1707             "}",
1708             format("try{foo();}catch(Exception&bar){baz();}", Style));
1709   Style.ColumnLimit =
1710       20; // to concentrate at brace wrapping, not line wrap due to column limit
1711 
1712   Style.BraceWrapping.BeforeElse = true;
1713   EXPECT_EQ(
1714       "if (foo) {\n"
1715       "  bar();\n"
1716       "}\n"
1717       "else if (baz ||\n"
1718       "         quux)\n"
1719       "{\n"
1720       "  foobar();\n"
1721       "}\n"
1722       "else {\n"
1723       "  barbaz();\n"
1724       "}",
1725       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1726              Style));
1727 
1728   Style.BraceWrapping.BeforeCatch = true;
1729   EXPECT_EQ("try {\n"
1730             "  foo();\n"
1731             "}\n"
1732             "catch (...) {\n"
1733             "  baz();\n"
1734             "}",
1735             format("try{foo();}catch(...){baz();}", Style));
1736 }
1737 
1738 TEST_F(FormatTest, BeforeWhile) {
1739   FormatStyle Style = getLLVMStyle();
1740   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1741 
1742   verifyFormat("do {\n"
1743                "  foo();\n"
1744                "} while (1);",
1745                Style);
1746   Style.BraceWrapping.BeforeWhile = true;
1747   verifyFormat("do {\n"
1748                "  foo();\n"
1749                "}\n"
1750                "while (1);",
1751                Style);
1752 }
1753 
1754 //===----------------------------------------------------------------------===//
1755 // Tests for classes, namespaces, etc.
1756 //===----------------------------------------------------------------------===//
1757 
1758 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
1759   verifyFormat("class A {};");
1760 }
1761 
1762 TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1763   verifyFormat("class A {\n"
1764                "public:\n"
1765                "public: // comment\n"
1766                "protected:\n"
1767                "private:\n"
1768                "  void f() {}\n"
1769                "};");
1770   verifyFormat("export class A {\n"
1771                "public:\n"
1772                "public: // comment\n"
1773                "protected:\n"
1774                "private:\n"
1775                "  void f() {}\n"
1776                "};");
1777   verifyGoogleFormat("class A {\n"
1778                      " public:\n"
1779                      " protected:\n"
1780                      " private:\n"
1781                      "  void f() {}\n"
1782                      "};");
1783   verifyGoogleFormat("export class A {\n"
1784                      " public:\n"
1785                      " protected:\n"
1786                      " private:\n"
1787                      "  void f() {}\n"
1788                      "};");
1789   verifyFormat("class A {\n"
1790                "public slots:\n"
1791                "  void f1() {}\n"
1792                "public Q_SLOTS:\n"
1793                "  void f2() {}\n"
1794                "protected slots:\n"
1795                "  void f3() {}\n"
1796                "protected Q_SLOTS:\n"
1797                "  void f4() {}\n"
1798                "private slots:\n"
1799                "  void f5() {}\n"
1800                "private Q_SLOTS:\n"
1801                "  void f6() {}\n"
1802                "signals:\n"
1803                "  void g1();\n"
1804                "Q_SIGNALS:\n"
1805                "  void g2();\n"
1806                "};");
1807 
1808   // Don't interpret 'signals' the wrong way.
1809   verifyFormat("signals.set();");
1810   verifyFormat("for (Signals signals : f()) {\n}");
1811   verifyFormat("{\n"
1812                "  signals.set(); // This needs indentation.\n"
1813                "}");
1814   verifyFormat("void f() {\n"
1815                "label:\n"
1816                "  signals.baz();\n"
1817                "}");
1818 }
1819 
1820 TEST_F(FormatTest, SeparatesLogicalBlocks) {
1821   EXPECT_EQ("class A {\n"
1822             "public:\n"
1823             "  void f();\n"
1824             "\n"
1825             "private:\n"
1826             "  void g() {}\n"
1827             "  // test\n"
1828             "protected:\n"
1829             "  int h;\n"
1830             "};",
1831             format("class A {\n"
1832                    "public:\n"
1833                    "void f();\n"
1834                    "private:\n"
1835                    "void g() {}\n"
1836                    "// test\n"
1837                    "protected:\n"
1838                    "int h;\n"
1839                    "};"));
1840   EXPECT_EQ("class A {\n"
1841             "protected:\n"
1842             "public:\n"
1843             "  void f();\n"
1844             "};",
1845             format("class A {\n"
1846                    "protected:\n"
1847                    "\n"
1848                    "public:\n"
1849                    "\n"
1850                    "  void f();\n"
1851                    "};"));
1852 
1853   // Even ensure proper spacing inside macros.
1854   EXPECT_EQ("#define B     \\\n"
1855             "  class A {   \\\n"
1856             "   protected: \\\n"
1857             "   public:    \\\n"
1858             "    void f(); \\\n"
1859             "  };",
1860             format("#define B     \\\n"
1861                    "  class A {   \\\n"
1862                    "   protected: \\\n"
1863                    "              \\\n"
1864                    "   public:    \\\n"
1865                    "              \\\n"
1866                    "    void f(); \\\n"
1867                    "  };",
1868                    getGoogleStyle()));
1869   // But don't remove empty lines after macros ending in access specifiers.
1870   EXPECT_EQ("#define A private:\n"
1871             "\n"
1872             "int i;",
1873             format("#define A         private:\n"
1874                    "\n"
1875                    "int              i;"));
1876 }
1877 
1878 TEST_F(FormatTest, FormatsClasses) {
1879   verifyFormat("class A : public B {};");
1880   verifyFormat("class A : public ::B {};");
1881 
1882   verifyFormat(
1883       "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1884       "                             public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1885   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1886                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1887                "      public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1888   verifyFormat(
1889       "class A : public B, public C, public D, public E, public F {};");
1890   verifyFormat("class AAAAAAAAAAAA : public B,\n"
1891                "                     public C,\n"
1892                "                     public D,\n"
1893                "                     public E,\n"
1894                "                     public F,\n"
1895                "                     public G {};");
1896 
1897   verifyFormat("class\n"
1898                "    ReallyReallyLongClassName {\n"
1899                "  int i;\n"
1900                "};",
1901                getLLVMStyleWithColumns(32));
1902   verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1903                "                           aaaaaaaaaaaaaaaa> {};");
1904   verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1905                "    : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1906                "                                 aaaaaaaaaaaaaaaaaaaaaa> {};");
1907   verifyFormat("template <class R, class C>\n"
1908                "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1909                "    : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
1910   verifyFormat("class ::A::B {};");
1911 }
1912 
1913 TEST_F(FormatTest, BreakInheritanceStyle) {
1914   FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle();
1915   StyleWithInheritanceBreakBeforeComma.BreakInheritanceList =
1916       FormatStyle::BILS_BeforeComma;
1917   verifyFormat("class MyClass : public X {};",
1918                StyleWithInheritanceBreakBeforeComma);
1919   verifyFormat("class MyClass\n"
1920                "    : public X\n"
1921                "    , public Y {};",
1922                StyleWithInheritanceBreakBeforeComma);
1923   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
1924                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"
1925                "    , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1926                StyleWithInheritanceBreakBeforeComma);
1927   verifyFormat("struct aaaaaaaaaaaaa\n"
1928                "    : public aaaaaaaaaaaaaaaaaaa< // break\n"
1929                "          aaaaaaaaaaaaaaaa> {};",
1930                StyleWithInheritanceBreakBeforeComma);
1931 
1932   FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle();
1933   StyleWithInheritanceBreakAfterColon.BreakInheritanceList =
1934       FormatStyle::BILS_AfterColon;
1935   verifyFormat("class MyClass : public X {};",
1936                StyleWithInheritanceBreakAfterColon);
1937   verifyFormat("class MyClass : public X, public Y {};",
1938                StyleWithInheritanceBreakAfterColon);
1939   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
1940                "    public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1941                "    public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1942                StyleWithInheritanceBreakAfterColon);
1943   verifyFormat("struct aaaaaaaaaaaaa :\n"
1944                "    public aaaaaaaaaaaaaaaaaaa< // break\n"
1945                "        aaaaaaaaaaaaaaaa> {};",
1946                StyleWithInheritanceBreakAfterColon);
1947 }
1948 
1949 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
1950   verifyFormat("class A {\n} a, b;");
1951   verifyFormat("struct A {\n} a, b;");
1952   verifyFormat("union A {\n} a;");
1953 }
1954 
1955 TEST_F(FormatTest, FormatsEnum) {
1956   verifyFormat("enum {\n"
1957                "  Zero,\n"
1958                "  One = 1,\n"
1959                "  Two = One + 1,\n"
1960                "  Three = (One + Two),\n"
1961                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1962                "  Five = (One, Two, Three, Four, 5)\n"
1963                "};");
1964   verifyGoogleFormat("enum {\n"
1965                      "  Zero,\n"
1966                      "  One = 1,\n"
1967                      "  Two = One + 1,\n"
1968                      "  Three = (One + Two),\n"
1969                      "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1970                      "  Five = (One, Two, Three, Four, 5)\n"
1971                      "};");
1972   verifyFormat("enum Enum {};");
1973   verifyFormat("enum {};");
1974   verifyFormat("enum X E {} d;");
1975   verifyFormat("enum __attribute__((...)) E {} d;");
1976   verifyFormat("enum __declspec__((...)) E {} d;");
1977   verifyFormat("enum {\n"
1978                "  Bar = Foo<int, int>::value\n"
1979                "};",
1980                getLLVMStyleWithColumns(30));
1981 
1982   verifyFormat("enum ShortEnum { A, B, C };");
1983   verifyGoogleFormat("enum ShortEnum { A, B, C };");
1984 
1985   EXPECT_EQ("enum KeepEmptyLines {\n"
1986             "  ONE,\n"
1987             "\n"
1988             "  TWO,\n"
1989             "\n"
1990             "  THREE\n"
1991             "}",
1992             format("enum KeepEmptyLines {\n"
1993                    "  ONE,\n"
1994                    "\n"
1995                    "  TWO,\n"
1996                    "\n"
1997                    "\n"
1998                    "  THREE\n"
1999                    "}"));
2000   verifyFormat("enum E { // comment\n"
2001                "  ONE,\n"
2002                "  TWO\n"
2003                "};\n"
2004                "int i;");
2005 
2006   FormatStyle EightIndent = getLLVMStyle();
2007   EightIndent.IndentWidth = 8;
2008   verifyFormat("enum {\n"
2009                "        VOID,\n"
2010                "        CHAR,\n"
2011                "        SHORT,\n"
2012                "        INT,\n"
2013                "        LONG,\n"
2014                "        SIGNED,\n"
2015                "        UNSIGNED,\n"
2016                "        BOOL,\n"
2017                "        FLOAT,\n"
2018                "        DOUBLE,\n"
2019                "        COMPLEX\n"
2020                "};",
2021                EightIndent);
2022 
2023   // Not enums.
2024   verifyFormat("enum X f() {\n"
2025                "  a();\n"
2026                "  return 42;\n"
2027                "}");
2028   verifyFormat("enum X Type::f() {\n"
2029                "  a();\n"
2030                "  return 42;\n"
2031                "}");
2032   verifyFormat("enum ::X f() {\n"
2033                "  a();\n"
2034                "  return 42;\n"
2035                "}");
2036   verifyFormat("enum ns::X f() {\n"
2037                "  a();\n"
2038                "  return 42;\n"
2039                "}");
2040 }
2041 
2042 TEST_F(FormatTest, FormatsEnumsWithErrors) {
2043   verifyFormat("enum Type {\n"
2044                "  One = 0; // These semicolons should be commas.\n"
2045                "  Two = 1;\n"
2046                "};");
2047   verifyFormat("namespace n {\n"
2048                "enum Type {\n"
2049                "  One,\n"
2050                "  Two, // missing };\n"
2051                "  int i;\n"
2052                "}\n"
2053                "void g() {}");
2054 }
2055 
2056 TEST_F(FormatTest, FormatsEnumStruct) {
2057   verifyFormat("enum struct {\n"
2058                "  Zero,\n"
2059                "  One = 1,\n"
2060                "  Two = One + 1,\n"
2061                "  Three = (One + Two),\n"
2062                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2063                "  Five = (One, Two, Three, Four, 5)\n"
2064                "};");
2065   verifyFormat("enum struct Enum {};");
2066   verifyFormat("enum struct {};");
2067   verifyFormat("enum struct X E {} d;");
2068   verifyFormat("enum struct __attribute__((...)) E {} d;");
2069   verifyFormat("enum struct __declspec__((...)) E {} d;");
2070   verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
2071 }
2072 
2073 TEST_F(FormatTest, FormatsEnumClass) {
2074   verifyFormat("enum class {\n"
2075                "  Zero,\n"
2076                "  One = 1,\n"
2077                "  Two = One + 1,\n"
2078                "  Three = (One + Two),\n"
2079                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2080                "  Five = (One, Two, Three, Four, 5)\n"
2081                "};");
2082   verifyFormat("enum class Enum {};");
2083   verifyFormat("enum class {};");
2084   verifyFormat("enum class X E {} d;");
2085   verifyFormat("enum class __attribute__((...)) E {} d;");
2086   verifyFormat("enum class __declspec__((...)) E {} d;");
2087   verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
2088 }
2089 
2090 TEST_F(FormatTest, FormatsEnumTypes) {
2091   verifyFormat("enum X : int {\n"
2092                "  A, // Force multiple lines.\n"
2093                "  B\n"
2094                "};");
2095   verifyFormat("enum X : int { A, B };");
2096   verifyFormat("enum X : std::uint32_t { A, B };");
2097 }
2098 
2099 TEST_F(FormatTest, FormatsTypedefEnum) {
2100   FormatStyle Style = getLLVMStyle();
2101   Style.ColumnLimit = 40;
2102   verifyFormat("typedef enum {} EmptyEnum;");
2103   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2104   verifyFormat("typedef enum {\n"
2105                "  ZERO = 0,\n"
2106                "  ONE = 1,\n"
2107                "  TWO = 2,\n"
2108                "  THREE = 3\n"
2109                "} LongEnum;",
2110                Style);
2111   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2112   Style.BraceWrapping.AfterEnum = true;
2113   verifyFormat("typedef enum {} EmptyEnum;");
2114   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2115   verifyFormat("typedef enum\n"
2116                "{\n"
2117                "  ZERO = 0,\n"
2118                "  ONE = 1,\n"
2119                "  TWO = 2,\n"
2120                "  THREE = 3\n"
2121                "} LongEnum;",
2122                Style);
2123 }
2124 
2125 TEST_F(FormatTest, FormatsNSEnums) {
2126   verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
2127   verifyGoogleFormat(
2128       "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }");
2129   verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
2130                      "  // Information about someDecentlyLongValue.\n"
2131                      "  someDecentlyLongValue,\n"
2132                      "  // Information about anotherDecentlyLongValue.\n"
2133                      "  anotherDecentlyLongValue,\n"
2134                      "  // Information about aThirdDecentlyLongValue.\n"
2135                      "  aThirdDecentlyLongValue\n"
2136                      "};");
2137   verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n"
2138                      "  // Information about someDecentlyLongValue.\n"
2139                      "  someDecentlyLongValue,\n"
2140                      "  // Information about anotherDecentlyLongValue.\n"
2141                      "  anotherDecentlyLongValue,\n"
2142                      "  // Information about aThirdDecentlyLongValue.\n"
2143                      "  aThirdDecentlyLongValue\n"
2144                      "};");
2145   verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
2146                      "  a = 1,\n"
2147                      "  b = 2,\n"
2148                      "  c = 3,\n"
2149                      "};");
2150   verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
2151                      "  a = 1,\n"
2152                      "  b = 2,\n"
2153                      "  c = 3,\n"
2154                      "};");
2155   verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n"
2156                      "  a = 1,\n"
2157                      "  b = 2,\n"
2158                      "  c = 3,\n"
2159                      "};");
2160   verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
2161                      "  a = 1,\n"
2162                      "  b = 2,\n"
2163                      "  c = 3,\n"
2164                      "};");
2165 }
2166 
2167 TEST_F(FormatTest, FormatsBitfields) {
2168   verifyFormat("struct Bitfields {\n"
2169                "  unsigned sClass : 8;\n"
2170                "  unsigned ValueKind : 2;\n"
2171                "};");
2172   verifyFormat("struct A {\n"
2173                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
2174                "      bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
2175                "};");
2176   verifyFormat("struct MyStruct {\n"
2177                "  uchar data;\n"
2178                "  uchar : 8;\n"
2179                "  uchar : 8;\n"
2180                "  uchar other;\n"
2181                "};");
2182   FormatStyle Style = getLLVMStyle();
2183   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
2184   verifyFormat("struct Bitfields {\n"
2185                "  unsigned sClass:8;\n"
2186                "  unsigned ValueKind:2;\n"
2187                "  uchar other;\n"
2188                "};",
2189                Style);
2190   verifyFormat("struct A {\n"
2191                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:1,\n"
2192                "      bbbbbbbbbbbbbbbbbbbbbbbbb:2;\n"
2193                "};",
2194                Style);
2195   Style.BitFieldColonSpacing = FormatStyle::BFCS_Before;
2196   verifyFormat("struct Bitfields {\n"
2197                "  unsigned sClass :8;\n"
2198                "  unsigned ValueKind :2;\n"
2199                "  uchar other;\n"
2200                "};",
2201                Style);
2202   Style.BitFieldColonSpacing = FormatStyle::BFCS_After;
2203   verifyFormat("struct Bitfields {\n"
2204                "  unsigned sClass: 8;\n"
2205                "  unsigned ValueKind: 2;\n"
2206                "  uchar other;\n"
2207                "};",
2208                Style);
2209 }
2210 
2211 TEST_F(FormatTest, FormatsNamespaces) {
2212   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
2213   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
2214 
2215   verifyFormat("namespace some_namespace {\n"
2216                "class A {};\n"
2217                "void f() { f(); }\n"
2218                "}",
2219                LLVMWithNoNamespaceFix);
2220   verifyFormat("namespace N::inline D {\n"
2221                "class A {};\n"
2222                "void f() { f(); }\n"
2223                "}",
2224                LLVMWithNoNamespaceFix);
2225   verifyFormat("namespace N::inline D::E {\n"
2226                "class A {};\n"
2227                "void f() { f(); }\n"
2228                "}",
2229                LLVMWithNoNamespaceFix);
2230   verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
2231                "class A {};\n"
2232                "void f() { f(); }\n"
2233                "}",
2234                LLVMWithNoNamespaceFix);
2235   verifyFormat("/* something */ namespace some_namespace {\n"
2236                "class A {};\n"
2237                "void f() { f(); }\n"
2238                "}",
2239                LLVMWithNoNamespaceFix);
2240   verifyFormat("namespace {\n"
2241                "class A {};\n"
2242                "void f() { f(); }\n"
2243                "}",
2244                LLVMWithNoNamespaceFix);
2245   verifyFormat("/* something */ namespace {\n"
2246                "class A {};\n"
2247                "void f() { f(); }\n"
2248                "}",
2249                LLVMWithNoNamespaceFix);
2250   verifyFormat("inline namespace X {\n"
2251                "class A {};\n"
2252                "void f() { f(); }\n"
2253                "}",
2254                LLVMWithNoNamespaceFix);
2255   verifyFormat("/* something */ inline namespace X {\n"
2256                "class A {};\n"
2257                "void f() { f(); }\n"
2258                "}",
2259                LLVMWithNoNamespaceFix);
2260   verifyFormat("export namespace X {\n"
2261                "class A {};\n"
2262                "void f() { f(); }\n"
2263                "}",
2264                LLVMWithNoNamespaceFix);
2265   verifyFormat("using namespace some_namespace;\n"
2266                "class A {};\n"
2267                "void f() { f(); }",
2268                LLVMWithNoNamespaceFix);
2269 
2270   // This code is more common than we thought; if we
2271   // layout this correctly the semicolon will go into
2272   // its own line, which is undesirable.
2273   verifyFormat("namespace {};", LLVMWithNoNamespaceFix);
2274   verifyFormat("namespace {\n"
2275                "class A {};\n"
2276                "};",
2277                LLVMWithNoNamespaceFix);
2278 
2279   verifyFormat("namespace {\n"
2280                "int SomeVariable = 0; // comment\n"
2281                "} // namespace",
2282                LLVMWithNoNamespaceFix);
2283   EXPECT_EQ("#ifndef HEADER_GUARD\n"
2284             "#define HEADER_GUARD\n"
2285             "namespace my_namespace {\n"
2286             "int i;\n"
2287             "} // my_namespace\n"
2288             "#endif // HEADER_GUARD",
2289             format("#ifndef HEADER_GUARD\n"
2290                    " #define HEADER_GUARD\n"
2291                    "   namespace my_namespace {\n"
2292                    "int i;\n"
2293                    "}    // my_namespace\n"
2294                    "#endif    // HEADER_GUARD",
2295                    LLVMWithNoNamespaceFix));
2296 
2297   EXPECT_EQ("namespace A::B {\n"
2298             "class C {};\n"
2299             "}",
2300             format("namespace A::B {\n"
2301                    "class C {};\n"
2302                    "}",
2303                    LLVMWithNoNamespaceFix));
2304 
2305   FormatStyle Style = getLLVMStyle();
2306   Style.NamespaceIndentation = FormatStyle::NI_All;
2307   EXPECT_EQ("namespace out {\n"
2308             "  int i;\n"
2309             "  namespace in {\n"
2310             "    int i;\n"
2311             "  } // namespace in\n"
2312             "} // namespace out",
2313             format("namespace out {\n"
2314                    "int i;\n"
2315                    "namespace in {\n"
2316                    "int i;\n"
2317                    "} // namespace in\n"
2318                    "} // namespace out",
2319                    Style));
2320 
2321   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2322   EXPECT_EQ("namespace out {\n"
2323             "int i;\n"
2324             "namespace in {\n"
2325             "  int i;\n"
2326             "} // namespace in\n"
2327             "} // namespace out",
2328             format("namespace out {\n"
2329                    "int i;\n"
2330                    "namespace in {\n"
2331                    "int i;\n"
2332                    "} // namespace in\n"
2333                    "} // namespace out",
2334                    Style));
2335 }
2336 
2337 TEST_F(FormatTest, NamespaceMacros) {
2338   FormatStyle Style = getLLVMStyle();
2339   Style.NamespaceMacros.push_back("TESTSUITE");
2340 
2341   verifyFormat("TESTSUITE(A) {\n"
2342                "int foo();\n"
2343                "} // TESTSUITE(A)",
2344                Style);
2345 
2346   verifyFormat("TESTSUITE(A, B) {\n"
2347                "int foo();\n"
2348                "} // TESTSUITE(A)",
2349                Style);
2350 
2351   // Properly indent according to NamespaceIndentation style
2352   Style.NamespaceIndentation = FormatStyle::NI_All;
2353   verifyFormat("TESTSUITE(A) {\n"
2354                "  int foo();\n"
2355                "} // TESTSUITE(A)",
2356                Style);
2357   verifyFormat("TESTSUITE(A) {\n"
2358                "  namespace B {\n"
2359                "    int foo();\n"
2360                "  } // namespace B\n"
2361                "} // TESTSUITE(A)",
2362                Style);
2363   verifyFormat("namespace A {\n"
2364                "  TESTSUITE(B) {\n"
2365                "    int foo();\n"
2366                "  } // TESTSUITE(B)\n"
2367                "} // namespace A",
2368                Style);
2369 
2370   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2371   verifyFormat("TESTSUITE(A) {\n"
2372                "TESTSUITE(B) {\n"
2373                "  int foo();\n"
2374                "} // TESTSUITE(B)\n"
2375                "} // TESTSUITE(A)",
2376                Style);
2377   verifyFormat("TESTSUITE(A) {\n"
2378                "namespace B {\n"
2379                "  int foo();\n"
2380                "} // namespace B\n"
2381                "} // TESTSUITE(A)",
2382                Style);
2383   verifyFormat("namespace A {\n"
2384                "TESTSUITE(B) {\n"
2385                "  int foo();\n"
2386                "} // TESTSUITE(B)\n"
2387                "} // namespace A",
2388                Style);
2389 
2390   // Properly merge namespace-macros blocks in CompactNamespaces mode
2391   Style.NamespaceIndentation = FormatStyle::NI_None;
2392   Style.CompactNamespaces = true;
2393   verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
2394                "}} // TESTSUITE(A::B)",
2395                Style);
2396 
2397   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2398             "}} // TESTSUITE(out::in)",
2399             format("TESTSUITE(out) {\n"
2400                    "TESTSUITE(in) {\n"
2401                    "} // TESTSUITE(in)\n"
2402                    "} // TESTSUITE(out)",
2403                    Style));
2404 
2405   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2406             "}} // TESTSUITE(out::in)",
2407             format("TESTSUITE(out) {\n"
2408                    "TESTSUITE(in) {\n"
2409                    "} // TESTSUITE(in)\n"
2410                    "} // TESTSUITE(out)",
2411                    Style));
2412 
2413   // Do not merge different namespaces/macros
2414   EXPECT_EQ("namespace out {\n"
2415             "TESTSUITE(in) {\n"
2416             "} // TESTSUITE(in)\n"
2417             "} // namespace out",
2418             format("namespace out {\n"
2419                    "TESTSUITE(in) {\n"
2420                    "} // TESTSUITE(in)\n"
2421                    "} // namespace out",
2422                    Style));
2423   EXPECT_EQ("TESTSUITE(out) {\n"
2424             "namespace in {\n"
2425             "} // namespace in\n"
2426             "} // TESTSUITE(out)",
2427             format("TESTSUITE(out) {\n"
2428                    "namespace in {\n"
2429                    "} // namespace in\n"
2430                    "} // TESTSUITE(out)",
2431                    Style));
2432   Style.NamespaceMacros.push_back("FOOBAR");
2433   EXPECT_EQ("TESTSUITE(out) {\n"
2434             "FOOBAR(in) {\n"
2435             "} // FOOBAR(in)\n"
2436             "} // TESTSUITE(out)",
2437             format("TESTSUITE(out) {\n"
2438                    "FOOBAR(in) {\n"
2439                    "} // FOOBAR(in)\n"
2440                    "} // TESTSUITE(out)",
2441                    Style));
2442 }
2443 
2444 TEST_F(FormatTest, FormatsCompactNamespaces) {
2445   FormatStyle Style = getLLVMStyle();
2446   Style.CompactNamespaces = true;
2447   Style.NamespaceMacros.push_back("TESTSUITE");
2448 
2449   verifyFormat("namespace A { namespace B {\n"
2450                "}} // namespace A::B",
2451                Style);
2452 
2453   EXPECT_EQ("namespace out { namespace in {\n"
2454             "}} // namespace out::in",
2455             format("namespace out {\n"
2456                    "namespace in {\n"
2457                    "} // namespace in\n"
2458                    "} // namespace out",
2459                    Style));
2460 
2461   // Only namespaces which have both consecutive opening and end get compacted
2462   EXPECT_EQ("namespace out {\n"
2463             "namespace in1 {\n"
2464             "} // namespace in1\n"
2465             "namespace in2 {\n"
2466             "} // namespace in2\n"
2467             "} // namespace out",
2468             format("namespace out {\n"
2469                    "namespace in1 {\n"
2470                    "} // namespace in1\n"
2471                    "namespace in2 {\n"
2472                    "} // namespace in2\n"
2473                    "} // namespace out",
2474                    Style));
2475 
2476   EXPECT_EQ("namespace out {\n"
2477             "int i;\n"
2478             "namespace in {\n"
2479             "int j;\n"
2480             "} // namespace in\n"
2481             "int k;\n"
2482             "} // namespace out",
2483             format("namespace out { int i;\n"
2484                    "namespace in { int j; } // namespace in\n"
2485                    "int k; } // namespace out",
2486                    Style));
2487 
2488   EXPECT_EQ("namespace A { namespace B { namespace C {\n"
2489             "}}} // namespace A::B::C\n",
2490             format("namespace A { namespace B {\n"
2491                    "namespace C {\n"
2492                    "}} // namespace B::C\n"
2493                    "} // namespace A\n",
2494                    Style));
2495 
2496   Style.ColumnLimit = 40;
2497   EXPECT_EQ("namespace aaaaaaaaaa {\n"
2498             "namespace bbbbbbbbbb {\n"
2499             "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
2500             format("namespace aaaaaaaaaa {\n"
2501                    "namespace bbbbbbbbbb {\n"
2502                    "} // namespace bbbbbbbbbb\n"
2503                    "} // namespace aaaaaaaaaa",
2504                    Style));
2505 
2506   EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
2507             "namespace cccccc {\n"
2508             "}}} // namespace aaaaaa::bbbbbb::cccccc",
2509             format("namespace aaaaaa {\n"
2510                    "namespace bbbbbb {\n"
2511                    "namespace cccccc {\n"
2512                    "} // namespace cccccc\n"
2513                    "} // namespace bbbbbb\n"
2514                    "} // namespace aaaaaa",
2515                    Style));
2516   Style.ColumnLimit = 80;
2517 
2518   // Extra semicolon after 'inner' closing brace prevents merging
2519   EXPECT_EQ("namespace out { namespace in {\n"
2520             "}; } // namespace out::in",
2521             format("namespace out {\n"
2522                    "namespace in {\n"
2523                    "}; // namespace in\n"
2524                    "} // namespace out",
2525                    Style));
2526 
2527   // Extra semicolon after 'outer' closing brace is conserved
2528   EXPECT_EQ("namespace out { namespace in {\n"
2529             "}}; // namespace out::in",
2530             format("namespace out {\n"
2531                    "namespace in {\n"
2532                    "} // namespace in\n"
2533                    "}; // namespace out",
2534                    Style));
2535 
2536   Style.NamespaceIndentation = FormatStyle::NI_All;
2537   EXPECT_EQ("namespace out { namespace in {\n"
2538             "  int i;\n"
2539             "}} // namespace out::in",
2540             format("namespace out {\n"
2541                    "namespace in {\n"
2542                    "int i;\n"
2543                    "} // namespace in\n"
2544                    "} // namespace out",
2545                    Style));
2546   EXPECT_EQ("namespace out { namespace mid {\n"
2547             "  namespace in {\n"
2548             "    int j;\n"
2549             "  } // namespace in\n"
2550             "  int k;\n"
2551             "}} // namespace out::mid",
2552             format("namespace out { namespace mid {\n"
2553                    "namespace in { int j; } // namespace in\n"
2554                    "int k; }} // namespace out::mid",
2555                    Style));
2556 
2557   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2558   EXPECT_EQ("namespace out { namespace in {\n"
2559             "  int i;\n"
2560             "}} // namespace out::in",
2561             format("namespace out {\n"
2562                    "namespace in {\n"
2563                    "int i;\n"
2564                    "} // namespace in\n"
2565                    "} // namespace out",
2566                    Style));
2567   EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
2568             "  int i;\n"
2569             "}}} // namespace out::mid::in",
2570             format("namespace out {\n"
2571                    "namespace mid {\n"
2572                    "namespace in {\n"
2573                    "int i;\n"
2574                    "} // namespace in\n"
2575                    "} // namespace mid\n"
2576                    "} // namespace out",
2577                    Style));
2578 }
2579 
2580 TEST_F(FormatTest, FormatsExternC) {
2581   verifyFormat("extern \"C\" {\nint a;");
2582   verifyFormat("extern \"C\" {}");
2583   verifyFormat("extern \"C\" {\n"
2584                "int foo();\n"
2585                "}");
2586   verifyFormat("extern \"C\" int foo() {}");
2587   verifyFormat("extern \"C\" int foo();");
2588   verifyFormat("extern \"C\" int foo() {\n"
2589                "  int i = 42;\n"
2590                "  return i;\n"
2591                "}");
2592 
2593   FormatStyle Style = getLLVMStyle();
2594   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2595   Style.BraceWrapping.AfterFunction = true;
2596   verifyFormat("extern \"C\" int foo() {}", Style);
2597   verifyFormat("extern \"C\" int foo();", Style);
2598   verifyFormat("extern \"C\" int foo()\n"
2599                "{\n"
2600                "  int i = 42;\n"
2601                "  return i;\n"
2602                "}",
2603                Style);
2604 
2605   Style.BraceWrapping.AfterExternBlock = true;
2606   Style.BraceWrapping.SplitEmptyRecord = false;
2607   verifyFormat("extern \"C\"\n"
2608                "{}",
2609                Style);
2610   verifyFormat("extern \"C\"\n"
2611                "{\n"
2612                "  int foo();\n"
2613                "}",
2614                Style);
2615 }
2616 
2617 TEST_F(FormatTest, IndentExternBlockStyle) {
2618   FormatStyle Style = getLLVMStyle();
2619   Style.IndentWidth = 2;
2620 
2621   Style.IndentExternBlock = FormatStyle::IEBS_Indent;
2622   verifyFormat("extern \"C\" { /*9*/\n}", Style);
2623   verifyFormat("extern \"C\" {\n"
2624                "  int foo10();\n"
2625                "}",
2626                Style);
2627 
2628   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
2629   verifyFormat("extern \"C\" { /*11*/\n}", Style);
2630   verifyFormat("extern \"C\" {\n"
2631                "int foo12();\n"
2632                "}",
2633                Style);
2634 
2635   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2636   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2637   Style.BraceWrapping.AfterExternBlock = true;
2638   verifyFormat("extern \"C\"\n{ /*13*/\n}", Style);
2639   verifyFormat("extern \"C\"\n{\n"
2640                "  int foo14();\n"
2641                "}",
2642                Style);
2643 
2644   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2645   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2646   Style.BraceWrapping.AfterExternBlock = false;
2647   verifyFormat("extern \"C\" { /*15*/\n}", Style);
2648   verifyFormat("extern \"C\" {\n"
2649                "int foo16();\n"
2650                "}",
2651                Style);
2652 }
2653 
2654 TEST_F(FormatTest, FormatsInlineASM) {
2655   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
2656   verifyFormat("asm(\"nop\" ::: \"memory\");");
2657   verifyFormat(
2658       "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
2659       "    \"cpuid\\n\\t\"\n"
2660       "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
2661       "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
2662       "    : \"a\"(value));");
2663   EXPECT_EQ(
2664       "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
2665       "  __asm {\n"
2666       "        mov     edx,[that] // vtable in edx\n"
2667       "        mov     eax,methodIndex\n"
2668       "        call    [edx][eax*4] // stdcall\n"
2669       "  }\n"
2670       "}",
2671       format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
2672              "    __asm {\n"
2673              "        mov     edx,[that] // vtable in edx\n"
2674              "        mov     eax,methodIndex\n"
2675              "        call    [edx][eax*4] // stdcall\n"
2676              "    }\n"
2677              "}"));
2678   EXPECT_EQ("_asm {\n"
2679             "  xor eax, eax;\n"
2680             "  cpuid;\n"
2681             "}",
2682             format("_asm {\n"
2683                    "  xor eax, eax;\n"
2684                    "  cpuid;\n"
2685                    "}"));
2686   verifyFormat("void function() {\n"
2687                "  // comment\n"
2688                "  asm(\"\");\n"
2689                "}");
2690   EXPECT_EQ("__asm {\n"
2691             "}\n"
2692             "int i;",
2693             format("__asm   {\n"
2694                    "}\n"
2695                    "int   i;"));
2696 }
2697 
2698 TEST_F(FormatTest, FormatTryCatch) {
2699   verifyFormat("try {\n"
2700                "  throw a * b;\n"
2701                "} catch (int a) {\n"
2702                "  // Do nothing.\n"
2703                "} catch (...) {\n"
2704                "  exit(42);\n"
2705                "}");
2706 
2707   // Function-level try statements.
2708   verifyFormat("int f() try { return 4; } catch (...) {\n"
2709                "  return 5;\n"
2710                "}");
2711   verifyFormat("class A {\n"
2712                "  int a;\n"
2713                "  A() try : a(0) {\n"
2714                "  } catch (...) {\n"
2715                "    throw;\n"
2716                "  }\n"
2717                "};\n");
2718 
2719   // Incomplete try-catch blocks.
2720   verifyIncompleteFormat("try {} catch (");
2721 }
2722 
2723 TEST_F(FormatTest, FormatTryAsAVariable) {
2724   verifyFormat("int try;");
2725   verifyFormat("int try, size;");
2726   verifyFormat("try = foo();");
2727   verifyFormat("if (try < size) {\n  return true;\n}");
2728 
2729   verifyFormat("int catch;");
2730   verifyFormat("int catch, size;");
2731   verifyFormat("catch = foo();");
2732   verifyFormat("if (catch < size) {\n  return true;\n}");
2733 }
2734 
2735 TEST_F(FormatTest, FormatSEHTryCatch) {
2736   verifyFormat("__try {\n"
2737                "  int a = b * c;\n"
2738                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2739                "  // Do nothing.\n"
2740                "}");
2741 
2742   verifyFormat("__try {\n"
2743                "  int a = b * c;\n"
2744                "} __finally {\n"
2745                "  // Do nothing.\n"
2746                "}");
2747 
2748   verifyFormat("DEBUG({\n"
2749                "  __try {\n"
2750                "  } __finally {\n"
2751                "  }\n"
2752                "});\n");
2753 }
2754 
2755 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2756   verifyFormat("try {\n"
2757                "  f();\n"
2758                "} catch {\n"
2759                "  g();\n"
2760                "}");
2761   verifyFormat("try {\n"
2762                "  f();\n"
2763                "} catch (A a) MACRO(x) {\n"
2764                "  g();\n"
2765                "} catch (B b) MACRO(x) {\n"
2766                "  g();\n"
2767                "}");
2768 }
2769 
2770 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2771   FormatStyle Style = getLLVMStyle();
2772   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2773                           FormatStyle::BS_WebKit}) {
2774     Style.BreakBeforeBraces = BraceStyle;
2775     verifyFormat("try {\n"
2776                  "  // something\n"
2777                  "} catch (...) {\n"
2778                  "  // something\n"
2779                  "}",
2780                  Style);
2781   }
2782   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2783   verifyFormat("try {\n"
2784                "  // something\n"
2785                "}\n"
2786                "catch (...) {\n"
2787                "  // something\n"
2788                "}",
2789                Style);
2790   verifyFormat("__try {\n"
2791                "  // something\n"
2792                "}\n"
2793                "__finally {\n"
2794                "  // something\n"
2795                "}",
2796                Style);
2797   verifyFormat("@try {\n"
2798                "  // something\n"
2799                "}\n"
2800                "@finally {\n"
2801                "  // something\n"
2802                "}",
2803                Style);
2804   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2805   verifyFormat("try\n"
2806                "{\n"
2807                "  // something\n"
2808                "}\n"
2809                "catch (...)\n"
2810                "{\n"
2811                "  // something\n"
2812                "}",
2813                Style);
2814   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2815   verifyFormat("try\n"
2816                "  {\n"
2817                "  // something white\n"
2818                "  }\n"
2819                "catch (...)\n"
2820                "  {\n"
2821                "  // something white\n"
2822                "  }",
2823                Style);
2824   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2825   verifyFormat("try\n"
2826                "  {\n"
2827                "    // something\n"
2828                "  }\n"
2829                "catch (...)\n"
2830                "  {\n"
2831                "    // something\n"
2832                "  }",
2833                Style);
2834   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2835   Style.BraceWrapping.BeforeCatch = true;
2836   verifyFormat("try {\n"
2837                "  // something\n"
2838                "}\n"
2839                "catch (...) {\n"
2840                "  // something\n"
2841                "}",
2842                Style);
2843 }
2844 
2845 TEST_F(FormatTest, StaticInitializers) {
2846   verifyFormat("static SomeClass SC = {1, 'a'};");
2847 
2848   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2849                "    100000000, "
2850                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2851 
2852   // Here, everything other than the "}" would fit on a line.
2853   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2854                "    10000000000000000000000000};");
2855   EXPECT_EQ("S s = {a,\n"
2856             "\n"
2857             "       b};",
2858             format("S s = {\n"
2859                    "  a,\n"
2860                    "\n"
2861                    "  b\n"
2862                    "};"));
2863 
2864   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2865   // line. However, the formatting looks a bit off and this probably doesn't
2866   // happen often in practice.
2867   verifyFormat("static int Variable[1] = {\n"
2868                "    {1000000000000000000000000000000000000}};",
2869                getLLVMStyleWithColumns(40));
2870 }
2871 
2872 TEST_F(FormatTest, DesignatedInitializers) {
2873   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2874   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2875                "                    .bbbbbbbbbb = 2,\n"
2876                "                    .cccccccccc = 3,\n"
2877                "                    .dddddddddd = 4,\n"
2878                "                    .eeeeeeeeee = 5};");
2879   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2880                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2881                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2882                "    .ccccccccccccccccccccccccccc = 3,\n"
2883                "    .ddddddddddddddddddddddddddd = 4,\n"
2884                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2885 
2886   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2887 
2888   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2889   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2890                "                    [2] = bbbbbbbbbb,\n"
2891                "                    [3] = cccccccccc,\n"
2892                "                    [4] = dddddddddd,\n"
2893                "                    [5] = eeeeeeeeee};");
2894   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2895                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2896                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2897                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2898                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2899                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2900 }
2901 
2902 TEST_F(FormatTest, NestedStaticInitializers) {
2903   verifyFormat("static A x = {{{}}};\n");
2904   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2905                "               {init1, init2, init3, init4}}};",
2906                getLLVMStyleWithColumns(50));
2907 
2908   verifyFormat("somes Status::global_reps[3] = {\n"
2909                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2910                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2911                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2912                getLLVMStyleWithColumns(60));
2913   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2914                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2915                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2916                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2917   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2918                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
2919                "rect.fTop}};");
2920 
2921   verifyFormat(
2922       "SomeArrayOfSomeType a = {\n"
2923       "    {{1, 2, 3},\n"
2924       "     {1, 2, 3},\n"
2925       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
2926       "      333333333333333333333333333333},\n"
2927       "     {1, 2, 3},\n"
2928       "     {1, 2, 3}}};");
2929   verifyFormat(
2930       "SomeArrayOfSomeType a = {\n"
2931       "    {{1, 2, 3}},\n"
2932       "    {{1, 2, 3}},\n"
2933       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2934       "      333333333333333333333333333333}},\n"
2935       "    {{1, 2, 3}},\n"
2936       "    {{1, 2, 3}}};");
2937 
2938   verifyFormat("struct {\n"
2939                "  unsigned bit;\n"
2940                "  const char *const name;\n"
2941                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2942                "                 {kOsWin, \"Windows\"},\n"
2943                "                 {kOsLinux, \"Linux\"},\n"
2944                "                 {kOsCrOS, \"Chrome OS\"}};");
2945   verifyFormat("struct {\n"
2946                "  unsigned bit;\n"
2947                "  const char *const name;\n"
2948                "} kBitsToOs[] = {\n"
2949                "    {kOsMac, \"Mac\"},\n"
2950                "    {kOsWin, \"Windows\"},\n"
2951                "    {kOsLinux, \"Linux\"},\n"
2952                "    {kOsCrOS, \"Chrome OS\"},\n"
2953                "};");
2954 }
2955 
2956 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2957   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2958                "                      \\\n"
2959                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2960 }
2961 
2962 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
2963   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2964                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
2965 
2966   // Do break defaulted and deleted functions.
2967   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2968                "    default;",
2969                getLLVMStyleWithColumns(40));
2970   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2971                "    delete;",
2972                getLLVMStyleWithColumns(40));
2973 }
2974 
2975 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2976   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2977                getLLVMStyleWithColumns(40));
2978   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2979                getLLVMStyleWithColumns(40));
2980   EXPECT_EQ("#define Q                              \\\n"
2981             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
2982             "  \"aaaaaaaa.cpp\"",
2983             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2984                    getLLVMStyleWithColumns(40)));
2985 }
2986 
2987 TEST_F(FormatTest, UnderstandsLinePPDirective) {
2988   EXPECT_EQ("# 123 \"A string literal\"",
2989             format("   #     123    \"A string literal\""));
2990 }
2991 
2992 TEST_F(FormatTest, LayoutUnknownPPDirective) {
2993   EXPECT_EQ("#;", format("#;"));
2994   verifyFormat("#\n;\n;\n;");
2995 }
2996 
2997 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
2998   EXPECT_EQ("#line 42 \"test\"\n",
2999             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
3000   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
3001                                     getLLVMStyleWithColumns(12)));
3002 }
3003 
3004 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
3005   EXPECT_EQ("#line 42 \"test\"",
3006             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
3007   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
3008 }
3009 
3010 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
3011   verifyFormat("#define A \\x20");
3012   verifyFormat("#define A \\ x20");
3013   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
3014   verifyFormat("#define A ''");
3015   verifyFormat("#define A ''qqq");
3016   verifyFormat("#define A `qqq");
3017   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
3018   EXPECT_EQ("const char *c = STRINGIFY(\n"
3019             "\\na : b);",
3020             format("const char * c = STRINGIFY(\n"
3021                    "\\na : b);"));
3022 
3023   verifyFormat("a\r\\");
3024   verifyFormat("a\v\\");
3025   verifyFormat("a\f\\");
3026 }
3027 
3028 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
3029   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
3030   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
3031   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
3032   // FIXME: We never break before the macro name.
3033   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
3034 
3035   verifyFormat("#define A A\n#define A A");
3036   verifyFormat("#define A(X) A\n#define A A");
3037 
3038   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
3039   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
3040 }
3041 
3042 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
3043   EXPECT_EQ("// somecomment\n"
3044             "#include \"a.h\"\n"
3045             "#define A(  \\\n"
3046             "    A, B)\n"
3047             "#include \"b.h\"\n"
3048             "// somecomment\n",
3049             format("  // somecomment\n"
3050                    "  #include \"a.h\"\n"
3051                    "#define A(A,\\\n"
3052                    "    B)\n"
3053                    "    #include \"b.h\"\n"
3054                    " // somecomment\n",
3055                    getLLVMStyleWithColumns(13)));
3056 }
3057 
3058 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
3059 
3060 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
3061   EXPECT_EQ("#define A    \\\n"
3062             "  c;         \\\n"
3063             "  e;\n"
3064             "f;",
3065             format("#define A c; e;\n"
3066                    "f;",
3067                    getLLVMStyleWithColumns(14)));
3068 }
3069 
3070 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
3071 
3072 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
3073   EXPECT_EQ("int x,\n"
3074             "#define A\n"
3075             "    y;",
3076             format("int x,\n#define A\ny;"));
3077 }
3078 
3079 TEST_F(FormatTest, HashInMacroDefinition) {
3080   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
3081   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
3082   verifyFormat("#define A  \\\n"
3083                "  {        \\\n"
3084                "    f(#c); \\\n"
3085                "  }",
3086                getLLVMStyleWithColumns(11));
3087 
3088   verifyFormat("#define A(X)         \\\n"
3089                "  void function##X()",
3090                getLLVMStyleWithColumns(22));
3091 
3092   verifyFormat("#define A(a, b, c)   \\\n"
3093                "  void a##b##c()",
3094                getLLVMStyleWithColumns(22));
3095 
3096   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
3097 }
3098 
3099 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
3100   EXPECT_EQ("#define A (x)", format("#define A (x)"));
3101   EXPECT_EQ("#define A(x)", format("#define A(x)"));
3102 
3103   FormatStyle Style = getLLVMStyle();
3104   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
3105   verifyFormat("#define true ((foo)1)", Style);
3106   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
3107   verifyFormat("#define false((foo)0)", Style);
3108 }
3109 
3110 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
3111   EXPECT_EQ("#define A b;", format("#define A \\\n"
3112                                    "          \\\n"
3113                                    "  b;",
3114                                    getLLVMStyleWithColumns(25)));
3115   EXPECT_EQ("#define A \\\n"
3116             "          \\\n"
3117             "  a;      \\\n"
3118             "  b;",
3119             format("#define A \\\n"
3120                    "          \\\n"
3121                    "  a;      \\\n"
3122                    "  b;",
3123                    getLLVMStyleWithColumns(11)));
3124   EXPECT_EQ("#define A \\\n"
3125             "  a;      \\\n"
3126             "          \\\n"
3127             "  b;",
3128             format("#define A \\\n"
3129                    "  a;      \\\n"
3130                    "          \\\n"
3131                    "  b;",
3132                    getLLVMStyleWithColumns(11)));
3133 }
3134 
3135 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
3136   verifyIncompleteFormat("#define A :");
3137   verifyFormat("#define SOMECASES  \\\n"
3138                "  case 1:          \\\n"
3139                "  case 2\n",
3140                getLLVMStyleWithColumns(20));
3141   verifyFormat("#define MACRO(a) \\\n"
3142                "  if (a)         \\\n"
3143                "    f();         \\\n"
3144                "  else           \\\n"
3145                "    g()",
3146                getLLVMStyleWithColumns(18));
3147   verifyFormat("#define A template <typename T>");
3148   verifyIncompleteFormat("#define STR(x) #x\n"
3149                          "f(STR(this_is_a_string_literal{));");
3150   verifyFormat("#pragma omp threadprivate( \\\n"
3151                "    y)), // expected-warning",
3152                getLLVMStyleWithColumns(28));
3153   verifyFormat("#d, = };");
3154   verifyFormat("#if \"a");
3155   verifyIncompleteFormat("({\n"
3156                          "#define b     \\\n"
3157                          "  }           \\\n"
3158                          "  a\n"
3159                          "a",
3160                          getLLVMStyleWithColumns(15));
3161   verifyFormat("#define A     \\\n"
3162                "  {           \\\n"
3163                "    {\n"
3164                "#define B     \\\n"
3165                "  }           \\\n"
3166                "  }",
3167                getLLVMStyleWithColumns(15));
3168   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
3169   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
3170   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
3171   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
3172 }
3173 
3174 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
3175   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
3176   EXPECT_EQ("class A : public QObject {\n"
3177             "  Q_OBJECT\n"
3178             "\n"
3179             "  A() {}\n"
3180             "};",
3181             format("class A  :  public QObject {\n"
3182                    "     Q_OBJECT\n"
3183                    "\n"
3184                    "  A() {\n}\n"
3185                    "}  ;"));
3186   EXPECT_EQ("MACRO\n"
3187             "/*static*/ int i;",
3188             format("MACRO\n"
3189                    " /*static*/ int   i;"));
3190   EXPECT_EQ("SOME_MACRO\n"
3191             "namespace {\n"
3192             "void f();\n"
3193             "} // namespace",
3194             format("SOME_MACRO\n"
3195                    "  namespace    {\n"
3196                    "void   f(  );\n"
3197                    "} // namespace"));
3198   // Only if the identifier contains at least 5 characters.
3199   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
3200   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
3201   // Only if everything is upper case.
3202   EXPECT_EQ("class A : public QObject {\n"
3203             "  Q_Object A() {}\n"
3204             "};",
3205             format("class A  :  public QObject {\n"
3206                    "     Q_Object\n"
3207                    "  A() {\n}\n"
3208                    "}  ;"));
3209 
3210   // Only if the next line can actually start an unwrapped line.
3211   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
3212             format("SOME_WEIRD_LOG_MACRO\n"
3213                    "<< SomeThing;"));
3214 
3215   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3216                "(n, buffers))\n",
3217                getChromiumStyle(FormatStyle::LK_Cpp));
3218 
3219   // See PR41483
3220   EXPECT_EQ("/**/ FOO(a)\n"
3221             "FOO(b)",
3222             format("/**/ FOO(a)\n"
3223                    "FOO(b)"));
3224 }
3225 
3226 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
3227   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3228             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3229             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3230             "class X {};\n"
3231             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3232             "int *createScopDetectionPass() { return 0; }",
3233             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3234                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3235                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3236                    "  class X {};\n"
3237                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3238                    "  int *createScopDetectionPass() { return 0; }"));
3239   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
3240   // braces, so that inner block is indented one level more.
3241   EXPECT_EQ("int q() {\n"
3242             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3243             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3244             "  IPC_END_MESSAGE_MAP()\n"
3245             "}",
3246             format("int q() {\n"
3247                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3248                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3249                    "  IPC_END_MESSAGE_MAP()\n"
3250                    "}"));
3251 
3252   // Same inside macros.
3253   EXPECT_EQ("#define LIST(L) \\\n"
3254             "  L(A)          \\\n"
3255             "  L(B)          \\\n"
3256             "  L(C)",
3257             format("#define LIST(L) \\\n"
3258                    "  L(A) \\\n"
3259                    "  L(B) \\\n"
3260                    "  L(C)",
3261                    getGoogleStyle()));
3262 
3263   // These must not be recognized as macros.
3264   EXPECT_EQ("int q() {\n"
3265             "  f(x);\n"
3266             "  f(x) {}\n"
3267             "  f(x)->g();\n"
3268             "  f(x)->*g();\n"
3269             "  f(x).g();\n"
3270             "  f(x) = x;\n"
3271             "  f(x) += x;\n"
3272             "  f(x) -= x;\n"
3273             "  f(x) *= x;\n"
3274             "  f(x) /= x;\n"
3275             "  f(x) %= x;\n"
3276             "  f(x) &= x;\n"
3277             "  f(x) |= x;\n"
3278             "  f(x) ^= x;\n"
3279             "  f(x) >>= x;\n"
3280             "  f(x) <<= x;\n"
3281             "  f(x)[y].z();\n"
3282             "  LOG(INFO) << x;\n"
3283             "  ifstream(x) >> x;\n"
3284             "}\n",
3285             format("int q() {\n"
3286                    "  f(x)\n;\n"
3287                    "  f(x)\n {}\n"
3288                    "  f(x)\n->g();\n"
3289                    "  f(x)\n->*g();\n"
3290                    "  f(x)\n.g();\n"
3291                    "  f(x)\n = x;\n"
3292                    "  f(x)\n += x;\n"
3293                    "  f(x)\n -= x;\n"
3294                    "  f(x)\n *= x;\n"
3295                    "  f(x)\n /= x;\n"
3296                    "  f(x)\n %= x;\n"
3297                    "  f(x)\n &= x;\n"
3298                    "  f(x)\n |= x;\n"
3299                    "  f(x)\n ^= x;\n"
3300                    "  f(x)\n >>= x;\n"
3301                    "  f(x)\n <<= x;\n"
3302                    "  f(x)\n[y].z();\n"
3303                    "  LOG(INFO)\n << x;\n"
3304                    "  ifstream(x)\n >> x;\n"
3305                    "}\n"));
3306   EXPECT_EQ("int q() {\n"
3307             "  F(x)\n"
3308             "  if (1) {\n"
3309             "  }\n"
3310             "  F(x)\n"
3311             "  while (1) {\n"
3312             "  }\n"
3313             "  F(x)\n"
3314             "  G(x);\n"
3315             "  F(x)\n"
3316             "  try {\n"
3317             "    Q();\n"
3318             "  } catch (...) {\n"
3319             "  }\n"
3320             "}\n",
3321             format("int q() {\n"
3322                    "F(x)\n"
3323                    "if (1) {}\n"
3324                    "F(x)\n"
3325                    "while (1) {}\n"
3326                    "F(x)\n"
3327                    "G(x);\n"
3328                    "F(x)\n"
3329                    "try { Q(); } catch (...) {}\n"
3330                    "}\n"));
3331   EXPECT_EQ("class A {\n"
3332             "  A() : t(0) {}\n"
3333             "  A(int i) noexcept() : {}\n"
3334             "  A(X x)\n" // FIXME: function-level try blocks are broken.
3335             "  try : t(0) {\n"
3336             "  } catch (...) {\n"
3337             "  }\n"
3338             "};",
3339             format("class A {\n"
3340                    "  A()\n : t(0) {}\n"
3341                    "  A(int i)\n noexcept() : {}\n"
3342                    "  A(X x)\n"
3343                    "  try : t(0) {} catch (...) {}\n"
3344                    "};"));
3345   FormatStyle Style = getLLVMStyle();
3346   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3347   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3348   Style.BraceWrapping.AfterFunction = true;
3349   EXPECT_EQ("void f()\n"
3350             "try\n"
3351             "{\n"
3352             "}",
3353             format("void f() try {\n"
3354                    "}",
3355                    Style));
3356   EXPECT_EQ("class SomeClass {\n"
3357             "public:\n"
3358             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3359             "};",
3360             format("class SomeClass {\n"
3361                    "public:\n"
3362                    "  SomeClass()\n"
3363                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3364                    "};"));
3365   EXPECT_EQ("class SomeClass {\n"
3366             "public:\n"
3367             "  SomeClass()\n"
3368             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3369             "};",
3370             format("class SomeClass {\n"
3371                    "public:\n"
3372                    "  SomeClass()\n"
3373                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3374                    "};",
3375                    getLLVMStyleWithColumns(40)));
3376 
3377   verifyFormat("MACRO(>)");
3378 
3379   // Some macros contain an implicit semicolon.
3380   Style = getLLVMStyle();
3381   Style.StatementMacros.push_back("FOO");
3382   verifyFormat("FOO(a) int b = 0;");
3383   verifyFormat("FOO(a)\n"
3384                "int b = 0;",
3385                Style);
3386   verifyFormat("FOO(a);\n"
3387                "int b = 0;",
3388                Style);
3389   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3390                "int b = 0;",
3391                Style);
3392   verifyFormat("FOO()\n"
3393                "int b = 0;",
3394                Style);
3395   verifyFormat("FOO\n"
3396                "int b = 0;",
3397                Style);
3398   verifyFormat("void f() {\n"
3399                "  FOO(a)\n"
3400                "  return a;\n"
3401                "}",
3402                Style);
3403   verifyFormat("FOO(a)\n"
3404                "FOO(b)",
3405                Style);
3406   verifyFormat("int a = 0;\n"
3407                "FOO(b)\n"
3408                "int c = 0;",
3409                Style);
3410   verifyFormat("int a = 0;\n"
3411                "int x = FOO(a)\n"
3412                "int b = 0;",
3413                Style);
3414   verifyFormat("void foo(int a) { FOO(a) }\n"
3415                "uint32_t bar() {}",
3416                Style);
3417 }
3418 
3419 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3420   verifyFormat("#define A \\\n"
3421                "  f({     \\\n"
3422                "    g();  \\\n"
3423                "  });",
3424                getLLVMStyleWithColumns(11));
3425 }
3426 
3427 TEST_F(FormatTest, IndentPreprocessorDirectives) {
3428   FormatStyle Style = getLLVMStyle();
3429   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3430   Style.ColumnLimit = 40;
3431   verifyFormat("#ifdef _WIN32\n"
3432                "#define A 0\n"
3433                "#ifdef VAR2\n"
3434                "#define B 1\n"
3435                "#include <someheader.h>\n"
3436                "#define MACRO                          \\\n"
3437                "  some_very_long_func_aaaaaaaaaa();\n"
3438                "#endif\n"
3439                "#else\n"
3440                "#define A 1\n"
3441                "#endif",
3442                Style);
3443   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3444   verifyFormat("#ifdef _WIN32\n"
3445                "#  define A 0\n"
3446                "#  ifdef VAR2\n"
3447                "#    define B 1\n"
3448                "#    include <someheader.h>\n"
3449                "#    define MACRO                      \\\n"
3450                "      some_very_long_func_aaaaaaaaaa();\n"
3451                "#  endif\n"
3452                "#else\n"
3453                "#  define A 1\n"
3454                "#endif",
3455                Style);
3456   verifyFormat("#if A\n"
3457                "#  define MACRO                        \\\n"
3458                "    void a(int x) {                    \\\n"
3459                "      b();                             \\\n"
3460                "      c();                             \\\n"
3461                "      d();                             \\\n"
3462                "      e();                             \\\n"
3463                "      f();                             \\\n"
3464                "    }\n"
3465                "#endif",
3466                Style);
3467   // Comments before include guard.
3468   verifyFormat("// file comment\n"
3469                "// file comment\n"
3470                "#ifndef HEADER_H\n"
3471                "#define HEADER_H\n"
3472                "code();\n"
3473                "#endif",
3474                Style);
3475   // Test with include guards.
3476   verifyFormat("#ifndef HEADER_H\n"
3477                "#define HEADER_H\n"
3478                "code();\n"
3479                "#endif",
3480                Style);
3481   // Include guards must have a #define with the same variable immediately
3482   // after #ifndef.
3483   verifyFormat("#ifndef NOT_GUARD\n"
3484                "#  define FOO\n"
3485                "code();\n"
3486                "#endif",
3487                Style);
3488 
3489   // Include guards must cover the entire file.
3490   verifyFormat("code();\n"
3491                "code();\n"
3492                "#ifndef NOT_GUARD\n"
3493                "#  define NOT_GUARD\n"
3494                "code();\n"
3495                "#endif",
3496                Style);
3497   verifyFormat("#ifndef NOT_GUARD\n"
3498                "#  define NOT_GUARD\n"
3499                "code();\n"
3500                "#endif\n"
3501                "code();",
3502                Style);
3503   // Test with trailing blank lines.
3504   verifyFormat("#ifndef HEADER_H\n"
3505                "#define HEADER_H\n"
3506                "code();\n"
3507                "#endif\n",
3508                Style);
3509   // Include guards don't have #else.
3510   verifyFormat("#ifndef NOT_GUARD\n"
3511                "#  define NOT_GUARD\n"
3512                "code();\n"
3513                "#else\n"
3514                "#endif",
3515                Style);
3516   verifyFormat("#ifndef NOT_GUARD\n"
3517                "#  define NOT_GUARD\n"
3518                "code();\n"
3519                "#elif FOO\n"
3520                "#endif",
3521                Style);
3522   // Non-identifier #define after potential include guard.
3523   verifyFormat("#ifndef FOO\n"
3524                "#  define 1\n"
3525                "#endif\n",
3526                Style);
3527   // #if closes past last non-preprocessor line.
3528   verifyFormat("#ifndef FOO\n"
3529                "#define FOO\n"
3530                "#if 1\n"
3531                "int i;\n"
3532                "#  define A 0\n"
3533                "#endif\n"
3534                "#endif\n",
3535                Style);
3536   // Don't crash if there is an #elif directive without a condition.
3537   verifyFormat("#if 1\n"
3538                "int x;\n"
3539                "#elif\n"
3540                "int y;\n"
3541                "#else\n"
3542                "int z;\n"
3543                "#endif",
3544                Style);
3545   // FIXME: This doesn't handle the case where there's code between the
3546   // #ifndef and #define but all other conditions hold. This is because when
3547   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3548   // previous code line yet, so we can't detect it.
3549   EXPECT_EQ("#ifndef NOT_GUARD\n"
3550             "code();\n"
3551             "#define NOT_GUARD\n"
3552             "code();\n"
3553             "#endif",
3554             format("#ifndef NOT_GUARD\n"
3555                    "code();\n"
3556                    "#  define NOT_GUARD\n"
3557                    "code();\n"
3558                    "#endif",
3559                    Style));
3560   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3561   // be outside an include guard. Examples are #pragma once and
3562   // #pragma GCC diagnostic, or anything else that does not change the meaning
3563   // of the file if it's included multiple times.
3564   EXPECT_EQ("#ifdef WIN32\n"
3565             "#  pragma once\n"
3566             "#endif\n"
3567             "#ifndef HEADER_H\n"
3568             "#  define HEADER_H\n"
3569             "code();\n"
3570             "#endif",
3571             format("#ifdef WIN32\n"
3572                    "#  pragma once\n"
3573                    "#endif\n"
3574                    "#ifndef HEADER_H\n"
3575                    "#define HEADER_H\n"
3576                    "code();\n"
3577                    "#endif",
3578                    Style));
3579   // FIXME: This does not detect when there is a single non-preprocessor line
3580   // in front of an include-guard-like structure where other conditions hold
3581   // because ScopedLineState hides the line.
3582   EXPECT_EQ("code();\n"
3583             "#ifndef HEADER_H\n"
3584             "#define HEADER_H\n"
3585             "code();\n"
3586             "#endif",
3587             format("code();\n"
3588                    "#ifndef HEADER_H\n"
3589                    "#  define HEADER_H\n"
3590                    "code();\n"
3591                    "#endif",
3592                    Style));
3593   // Keep comments aligned with #, otherwise indent comments normally. These
3594   // tests cannot use verifyFormat because messUp manipulates leading
3595   // whitespace.
3596   {
3597     const char *Expected = ""
3598                            "void f() {\n"
3599                            "#if 1\n"
3600                            "// Preprocessor aligned.\n"
3601                            "#  define A 0\n"
3602                            "  // Code. Separated by blank line.\n"
3603                            "\n"
3604                            "#  define B 0\n"
3605                            "  // Code. Not aligned with #\n"
3606                            "#  define C 0\n"
3607                            "#endif";
3608     const char *ToFormat = ""
3609                            "void f() {\n"
3610                            "#if 1\n"
3611                            "// Preprocessor aligned.\n"
3612                            "#  define A 0\n"
3613                            "// Code. Separated by blank line.\n"
3614                            "\n"
3615                            "#  define B 0\n"
3616                            "   // Code. Not aligned with #\n"
3617                            "#  define C 0\n"
3618                            "#endif";
3619     EXPECT_EQ(Expected, format(ToFormat, Style));
3620     EXPECT_EQ(Expected, format(Expected, Style));
3621   }
3622   // Keep block quotes aligned.
3623   {
3624     const char *Expected = ""
3625                            "void f() {\n"
3626                            "#if 1\n"
3627                            "/* Preprocessor aligned. */\n"
3628                            "#  define A 0\n"
3629                            "  /* Code. Separated by blank line. */\n"
3630                            "\n"
3631                            "#  define B 0\n"
3632                            "  /* Code. Not aligned with # */\n"
3633                            "#  define C 0\n"
3634                            "#endif";
3635     const char *ToFormat = ""
3636                            "void f() {\n"
3637                            "#if 1\n"
3638                            "/* Preprocessor aligned. */\n"
3639                            "#  define A 0\n"
3640                            "/* Code. Separated by blank line. */\n"
3641                            "\n"
3642                            "#  define B 0\n"
3643                            "   /* Code. Not aligned with # */\n"
3644                            "#  define C 0\n"
3645                            "#endif";
3646     EXPECT_EQ(Expected, format(ToFormat, Style));
3647     EXPECT_EQ(Expected, format(Expected, Style));
3648   }
3649   // Keep comments aligned with un-indented directives.
3650   {
3651     const char *Expected = ""
3652                            "void f() {\n"
3653                            "// Preprocessor aligned.\n"
3654                            "#define A 0\n"
3655                            "  // Code. Separated by blank line.\n"
3656                            "\n"
3657                            "#define B 0\n"
3658                            "  // Code. Not aligned with #\n"
3659                            "#define C 0\n";
3660     const char *ToFormat = ""
3661                            "void f() {\n"
3662                            "// Preprocessor aligned.\n"
3663                            "#define A 0\n"
3664                            "// Code. Separated by blank line.\n"
3665                            "\n"
3666                            "#define B 0\n"
3667                            "   // Code. Not aligned with #\n"
3668                            "#define C 0\n";
3669     EXPECT_EQ(Expected, format(ToFormat, Style));
3670     EXPECT_EQ(Expected, format(Expected, Style));
3671   }
3672   // Test AfterHash with tabs.
3673   {
3674     FormatStyle Tabbed = Style;
3675     Tabbed.UseTab = FormatStyle::UT_Always;
3676     Tabbed.IndentWidth = 8;
3677     Tabbed.TabWidth = 8;
3678     verifyFormat("#ifdef _WIN32\n"
3679                  "#\tdefine A 0\n"
3680                  "#\tifdef VAR2\n"
3681                  "#\t\tdefine B 1\n"
3682                  "#\t\tinclude <someheader.h>\n"
3683                  "#\t\tdefine MACRO          \\\n"
3684                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3685                  "#\tendif\n"
3686                  "#else\n"
3687                  "#\tdefine A 1\n"
3688                  "#endif",
3689                  Tabbed);
3690   }
3691 
3692   // Regression test: Multiline-macro inside include guards.
3693   verifyFormat("#ifndef HEADER_H\n"
3694                "#define HEADER_H\n"
3695                "#define A()        \\\n"
3696                "  int i;           \\\n"
3697                "  int j;\n"
3698                "#endif // HEADER_H",
3699                getLLVMStyleWithColumns(20));
3700 
3701   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3702   // Basic before hash indent tests
3703   verifyFormat("#ifdef _WIN32\n"
3704                "  #define A 0\n"
3705                "  #ifdef VAR2\n"
3706                "    #define B 1\n"
3707                "    #include <someheader.h>\n"
3708                "    #define MACRO                      \\\n"
3709                "      some_very_long_func_aaaaaaaaaa();\n"
3710                "  #endif\n"
3711                "#else\n"
3712                "  #define A 1\n"
3713                "#endif",
3714                Style);
3715   verifyFormat("#if A\n"
3716                "  #define MACRO                        \\\n"
3717                "    void a(int x) {                    \\\n"
3718                "      b();                             \\\n"
3719                "      c();                             \\\n"
3720                "      d();                             \\\n"
3721                "      e();                             \\\n"
3722                "      f();                             \\\n"
3723                "    }\n"
3724                "#endif",
3725                Style);
3726   // Keep comments aligned with indented directives. These
3727   // tests cannot use verifyFormat because messUp manipulates leading
3728   // whitespace.
3729   {
3730     const char *Expected = "void f() {\n"
3731                            "// Aligned to preprocessor.\n"
3732                            "#if 1\n"
3733                            "  // Aligned to code.\n"
3734                            "  int a;\n"
3735                            "  #if 1\n"
3736                            "    // Aligned to preprocessor.\n"
3737                            "    #define A 0\n"
3738                            "  // Aligned to code.\n"
3739                            "  int b;\n"
3740                            "  #endif\n"
3741                            "#endif\n"
3742                            "}";
3743     const char *ToFormat = "void f() {\n"
3744                            "// Aligned to preprocessor.\n"
3745                            "#if 1\n"
3746                            "// Aligned to code.\n"
3747                            "int a;\n"
3748                            "#if 1\n"
3749                            "// Aligned to preprocessor.\n"
3750                            "#define A 0\n"
3751                            "// Aligned to code.\n"
3752                            "int b;\n"
3753                            "#endif\n"
3754                            "#endif\n"
3755                            "}";
3756     EXPECT_EQ(Expected, format(ToFormat, Style));
3757     EXPECT_EQ(Expected, format(Expected, Style));
3758   }
3759   {
3760     const char *Expected = "void f() {\n"
3761                            "/* Aligned to preprocessor. */\n"
3762                            "#if 1\n"
3763                            "  /* Aligned to code. */\n"
3764                            "  int a;\n"
3765                            "  #if 1\n"
3766                            "    /* Aligned to preprocessor. */\n"
3767                            "    #define A 0\n"
3768                            "  /* Aligned to code. */\n"
3769                            "  int b;\n"
3770                            "  #endif\n"
3771                            "#endif\n"
3772                            "}";
3773     const char *ToFormat = "void f() {\n"
3774                            "/* Aligned to preprocessor. */\n"
3775                            "#if 1\n"
3776                            "/* Aligned to code. */\n"
3777                            "int a;\n"
3778                            "#if 1\n"
3779                            "/* Aligned to preprocessor. */\n"
3780                            "#define A 0\n"
3781                            "/* Aligned to code. */\n"
3782                            "int b;\n"
3783                            "#endif\n"
3784                            "#endif\n"
3785                            "}";
3786     EXPECT_EQ(Expected, format(ToFormat, Style));
3787     EXPECT_EQ(Expected, format(Expected, Style));
3788   }
3789 
3790   // Test single comment before preprocessor
3791   verifyFormat("// Comment\n"
3792                "\n"
3793                "#if 1\n"
3794                "#endif",
3795                Style);
3796 }
3797 
3798 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3799   verifyFormat("{\n  { a #c; }\n}");
3800 }
3801 
3802 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3803   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
3804             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3805   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
3806             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3807 }
3808 
3809 TEST_F(FormatTest, EscapedNewlines) {
3810   FormatStyle Narrow = getLLVMStyleWithColumns(11);
3811   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
3812             format("#define A \\\nint i;\\\n  int j;", Narrow));
3813   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3814   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3815   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
3816   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3817 
3818   FormatStyle AlignLeft = getLLVMStyle();
3819   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3820   EXPECT_EQ("#define MACRO(x) \\\n"
3821             "private:         \\\n"
3822             "  int x(int a);\n",
3823             format("#define MACRO(x) \\\n"
3824                    "private:         \\\n"
3825                    "  int x(int a);\n",
3826                    AlignLeft));
3827 
3828   // CRLF line endings
3829   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
3830             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
3831   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3832   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3833   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
3834   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3835   EXPECT_EQ("#define MACRO(x) \\\r\n"
3836             "private:         \\\r\n"
3837             "  int x(int a);\r\n",
3838             format("#define MACRO(x) \\\r\n"
3839                    "private:         \\\r\n"
3840                    "  int x(int a);\r\n",
3841                    AlignLeft));
3842 
3843   FormatStyle DontAlign = getLLVMStyle();
3844   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3845   DontAlign.MaxEmptyLinesToKeep = 3;
3846   // FIXME: can't use verifyFormat here because the newline before
3847   // "public:" is not inserted the first time it's reformatted
3848   EXPECT_EQ("#define A \\\n"
3849             "  class Foo { \\\n"
3850             "    void bar(); \\\n"
3851             "\\\n"
3852             "\\\n"
3853             "\\\n"
3854             "  public: \\\n"
3855             "    void baz(); \\\n"
3856             "  };",
3857             format("#define A \\\n"
3858                    "  class Foo { \\\n"
3859                    "    void bar(); \\\n"
3860                    "\\\n"
3861                    "\\\n"
3862                    "\\\n"
3863                    "  public: \\\n"
3864                    "    void baz(); \\\n"
3865                    "  };",
3866                    DontAlign));
3867 }
3868 
3869 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3870   verifyFormat("#define A \\\n"
3871                "  int v(  \\\n"
3872                "      a); \\\n"
3873                "  int i;",
3874                getLLVMStyleWithColumns(11));
3875 }
3876 
3877 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3878   EXPECT_EQ(
3879       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3880       "                      \\\n"
3881       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3882       "\n"
3883       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3884       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3885       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
3886              "\\\n"
3887              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3888              "  \n"
3889              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3890              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3891 }
3892 
3893 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3894   EXPECT_EQ("int\n"
3895             "#define A\n"
3896             "    a;",
3897             format("int\n#define A\na;"));
3898   verifyFormat("functionCallTo(\n"
3899                "    someOtherFunction(\n"
3900                "        withSomeParameters, whichInSequence,\n"
3901                "        areLongerThanALine(andAnotherCall,\n"
3902                "#define A B\n"
3903                "                           withMoreParamters,\n"
3904                "                           whichStronglyInfluenceTheLayout),\n"
3905                "        andMoreParameters),\n"
3906                "    trailing);",
3907                getLLVMStyleWithColumns(69));
3908   verifyFormat("Foo::Foo()\n"
3909                "#ifdef BAR\n"
3910                "    : baz(0)\n"
3911                "#endif\n"
3912                "{\n"
3913                "}");
3914   verifyFormat("void f() {\n"
3915                "  if (true)\n"
3916                "#ifdef A\n"
3917                "    f(42);\n"
3918                "  x();\n"
3919                "#else\n"
3920                "    g();\n"
3921                "  x();\n"
3922                "#endif\n"
3923                "}");
3924   verifyFormat("void f(param1, param2,\n"
3925                "       param3,\n"
3926                "#ifdef A\n"
3927                "       param4(param5,\n"
3928                "#ifdef A1\n"
3929                "              param6,\n"
3930                "#ifdef A2\n"
3931                "              param7),\n"
3932                "#else\n"
3933                "              param8),\n"
3934                "       param9,\n"
3935                "#endif\n"
3936                "       param10,\n"
3937                "#endif\n"
3938                "       param11)\n"
3939                "#else\n"
3940                "       param12)\n"
3941                "#endif\n"
3942                "{\n"
3943                "  x();\n"
3944                "}",
3945                getLLVMStyleWithColumns(28));
3946   verifyFormat("#if 1\n"
3947                "int i;");
3948   verifyFormat("#if 1\n"
3949                "#endif\n"
3950                "#if 1\n"
3951                "#else\n"
3952                "#endif\n");
3953   verifyFormat("DEBUG({\n"
3954                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3955                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
3956                "});\n"
3957                "#if a\n"
3958                "#else\n"
3959                "#endif");
3960 
3961   verifyIncompleteFormat("void f(\n"
3962                          "#if A\n"
3963                          ");\n"
3964                          "#else\n"
3965                          "#endif");
3966 }
3967 
3968 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
3969   verifyFormat("#endif\n"
3970                "#if B");
3971 }
3972 
3973 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
3974   FormatStyle SingleLine = getLLVMStyle();
3975   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
3976   verifyFormat("#if 0\n"
3977                "#elif 1\n"
3978                "#endif\n"
3979                "void foo() {\n"
3980                "  if (test) foo2();\n"
3981                "}",
3982                SingleLine);
3983 }
3984 
3985 TEST_F(FormatTest, LayoutBlockInsideParens) {
3986   verifyFormat("functionCall({ int i; });");
3987   verifyFormat("functionCall({\n"
3988                "  int i;\n"
3989                "  int j;\n"
3990                "});");
3991   verifyFormat("functionCall(\n"
3992                "    {\n"
3993                "      int i;\n"
3994                "      int j;\n"
3995                "    },\n"
3996                "    aaaa, bbbb, cccc);");
3997   verifyFormat("functionA(functionB({\n"
3998                "            int i;\n"
3999                "            int j;\n"
4000                "          }),\n"
4001                "          aaaa, bbbb, cccc);");
4002   verifyFormat("functionCall(\n"
4003                "    {\n"
4004                "      int i;\n"
4005                "      int j;\n"
4006                "    },\n"
4007                "    aaaa, bbbb, // comment\n"
4008                "    cccc);");
4009   verifyFormat("functionA(functionB({\n"
4010                "            int i;\n"
4011                "            int j;\n"
4012                "          }),\n"
4013                "          aaaa, bbbb, // comment\n"
4014                "          cccc);");
4015   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
4016   verifyFormat("functionCall(aaaa, bbbb, {\n"
4017                "  int i;\n"
4018                "  int j;\n"
4019                "});");
4020   verifyFormat(
4021       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
4022       "    {\n"
4023       "      int i; // break\n"
4024       "    },\n"
4025       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
4026       "                                     ccccccccccccccccc));");
4027   verifyFormat("DEBUG({\n"
4028                "  if (a)\n"
4029                "    f();\n"
4030                "});");
4031 }
4032 
4033 TEST_F(FormatTest, LayoutBlockInsideStatement) {
4034   EXPECT_EQ("SOME_MACRO { int i; }\n"
4035             "int i;",
4036             format("  SOME_MACRO  {int i;}  int i;"));
4037 }
4038 
4039 TEST_F(FormatTest, LayoutNestedBlocks) {
4040   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
4041                "  struct s {\n"
4042                "    int i;\n"
4043                "  };\n"
4044                "  s kBitsToOs[] = {{10}};\n"
4045                "  for (int i = 0; i < 10; ++i)\n"
4046                "    return;\n"
4047                "}");
4048   verifyFormat("call(parameter, {\n"
4049                "  something();\n"
4050                "  // Comment using all columns.\n"
4051                "  somethingelse();\n"
4052                "});",
4053                getLLVMStyleWithColumns(40));
4054   verifyFormat("DEBUG( //\n"
4055                "    { f(); }, a);");
4056   verifyFormat("DEBUG( //\n"
4057                "    {\n"
4058                "      f(); //\n"
4059                "    },\n"
4060                "    a);");
4061 
4062   EXPECT_EQ("call(parameter, {\n"
4063             "  something();\n"
4064             "  // Comment too\n"
4065             "  // looooooooooong.\n"
4066             "  somethingElse();\n"
4067             "});",
4068             format("call(parameter, {\n"
4069                    "  something();\n"
4070                    "  // Comment too looooooooooong.\n"
4071                    "  somethingElse();\n"
4072                    "});",
4073                    getLLVMStyleWithColumns(29)));
4074   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
4075   EXPECT_EQ("DEBUG({ // comment\n"
4076             "  int i;\n"
4077             "});",
4078             format("DEBUG({ // comment\n"
4079                    "int  i;\n"
4080                    "});"));
4081   EXPECT_EQ("DEBUG({\n"
4082             "  int i;\n"
4083             "\n"
4084             "  // comment\n"
4085             "  int j;\n"
4086             "});",
4087             format("DEBUG({\n"
4088                    "  int  i;\n"
4089                    "\n"
4090                    "  // comment\n"
4091                    "  int  j;\n"
4092                    "});"));
4093 
4094   verifyFormat("DEBUG({\n"
4095                "  if (a)\n"
4096                "    return;\n"
4097                "});");
4098   verifyGoogleFormat("DEBUG({\n"
4099                      "  if (a) return;\n"
4100                      "});");
4101   FormatStyle Style = getGoogleStyle();
4102   Style.ColumnLimit = 45;
4103   verifyFormat("Debug(\n"
4104                "    aaaaa,\n"
4105                "    {\n"
4106                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
4107                "    },\n"
4108                "    a);",
4109                Style);
4110 
4111   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
4112 
4113   verifyNoCrash("^{v^{a}}");
4114 }
4115 
4116 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
4117   EXPECT_EQ("#define MACRO()                     \\\n"
4118             "  Debug(aaa, /* force line break */ \\\n"
4119             "        {                           \\\n"
4120             "          int i;                    \\\n"
4121             "          int j;                    \\\n"
4122             "        })",
4123             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
4124                    "          {  int   i;  int  j;   })",
4125                    getGoogleStyle()));
4126 
4127   EXPECT_EQ("#define A                                       \\\n"
4128             "  [] {                                          \\\n"
4129             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
4130             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
4131             "  }",
4132             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4133                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
4134                    getGoogleStyle()));
4135 }
4136 
4137 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
4138   EXPECT_EQ("{}", format("{}"));
4139   verifyFormat("enum E {};");
4140   verifyFormat("enum E {}");
4141   FormatStyle Style = getLLVMStyle();
4142   Style.SpaceInEmptyBlock = true;
4143   EXPECT_EQ("void f() { }", format("void f() {}", Style));
4144   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
4145   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4146 }
4147 
4148 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
4149   FormatStyle Style = getLLVMStyle();
4150   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
4151   Style.MacroBlockEnd = "^[A-Z_]+_END$";
4152   verifyFormat("FOO_BEGIN\n"
4153                "  FOO_ENTRY\n"
4154                "FOO_END",
4155                Style);
4156   verifyFormat("FOO_BEGIN\n"
4157                "  NESTED_FOO_BEGIN\n"
4158                "    NESTED_FOO_ENTRY\n"
4159                "  NESTED_FOO_END\n"
4160                "FOO_END",
4161                Style);
4162   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
4163                "  int x;\n"
4164                "  x = 1;\n"
4165                "FOO_END(Baz)",
4166                Style);
4167 }
4168 
4169 //===----------------------------------------------------------------------===//
4170 // Line break tests.
4171 //===----------------------------------------------------------------------===//
4172 
4173 TEST_F(FormatTest, PreventConfusingIndents) {
4174   verifyFormat(
4175       "void f() {\n"
4176       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
4177       "                         parameter, parameter, parameter)),\n"
4178       "                     SecondLongCall(parameter));\n"
4179       "}");
4180   verifyFormat(
4181       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4182       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4183       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4184       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
4185   verifyFormat(
4186       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4187       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
4188       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4189       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
4190   verifyFormat(
4191       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
4192       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
4193       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
4194       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
4195   verifyFormat("int a = bbbb && ccc &&\n"
4196                "        fffff(\n"
4197                "#define A Just forcing a new line\n"
4198                "            ddd);");
4199 }
4200 
4201 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
4202   verifyFormat(
4203       "bool aaaaaaa =\n"
4204       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
4205       "    bbbbbbbb();");
4206   verifyFormat(
4207       "bool aaaaaaa =\n"
4208       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
4209       "    bbbbbbbb();");
4210 
4211   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4212                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
4213                "    ccccccccc == ddddddddddd;");
4214   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4215                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
4216                "    ccccccccc == ddddddddddd;");
4217   verifyFormat(
4218       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
4219       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
4220       "    ccccccccc == ddddddddddd;");
4221 
4222   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4223                "                 aaaaaa) &&\n"
4224                "         bbbbbb && cccccc;");
4225   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4226                "                 aaaaaa) >>\n"
4227                "         bbbbbb;");
4228   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
4229                "    SourceMgr.getSpellingColumnNumber(\n"
4230                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
4231                "    1);");
4232 
4233   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4234                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
4235                "    cccccc) {\n}");
4236   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4237                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4238                "              cccccc) {\n}");
4239   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4240                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4241                "              cccccc) {\n}");
4242   verifyFormat("b = a &&\n"
4243                "    // Comment\n"
4244                "    b.c && d;");
4245 
4246   // If the LHS of a comparison is not a binary expression itself, the
4247   // additional linebreak confuses many people.
4248   verifyFormat(
4249       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4250       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
4251       "}");
4252   verifyFormat(
4253       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4254       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4255       "}");
4256   verifyFormat(
4257       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
4258       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4259       "}");
4260   verifyFormat(
4261       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4262       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
4263       "}");
4264   // Even explicit parentheses stress the precedence enough to make the
4265   // additional break unnecessary.
4266   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4267                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4268                "}");
4269   // This cases is borderline, but with the indentation it is still readable.
4270   verifyFormat(
4271       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4272       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4273       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4274       "}",
4275       getLLVMStyleWithColumns(75));
4276 
4277   // If the LHS is a binary expression, we should still use the additional break
4278   // as otherwise the formatting hides the operator precedence.
4279   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4280                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4281                "    5) {\n"
4282                "}");
4283   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4284                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4285                "    5) {\n"
4286                "}");
4287 
4288   FormatStyle OnePerLine = getLLVMStyle();
4289   OnePerLine.BinPackParameters = false;
4290   verifyFormat(
4291       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4292       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4293       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4294       OnePerLine);
4295 
4296   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4297                "                .aaa(aaaaaaaaaaaaa) *\n"
4298                "            aaaaaaa +\n"
4299                "        aaaaaaa;",
4300                getLLVMStyleWithColumns(40));
4301 }
4302 
4303 TEST_F(FormatTest, ExpressionIndentation) {
4304   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4305                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4306                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4307                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4308                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4309                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4310                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4311                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4312                "                 ccccccccccccccccccccccccccccccccccccccccc;");
4313   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4314                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4315                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4316                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4317   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4318                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4319                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4320                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4321   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4322                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4323                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4324                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4325   verifyFormat("if () {\n"
4326                "} else if (aaaaa && bbbbb > // break\n"
4327                "                        ccccc) {\n"
4328                "}");
4329   verifyFormat("if () {\n"
4330                "} else if constexpr (aaaaa && bbbbb > // break\n"
4331                "                                  ccccc) {\n"
4332                "}");
4333   verifyFormat("if () {\n"
4334                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4335                "                                  ccccc) {\n"
4336                "}");
4337   verifyFormat("if () {\n"
4338                "} else if (aaaaa &&\n"
4339                "           bbbbb > // break\n"
4340                "               ccccc &&\n"
4341                "           ddddd) {\n"
4342                "}");
4343 
4344   // Presence of a trailing comment used to change indentation of b.
4345   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4346                "       b;\n"
4347                "return aaaaaaaaaaaaaaaaaaa +\n"
4348                "       b; //",
4349                getLLVMStyleWithColumns(30));
4350 }
4351 
4352 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4353   // Not sure what the best system is here. Like this, the LHS can be found
4354   // immediately above an operator (everything with the same or a higher
4355   // indent). The RHS is aligned right of the operator and so compasses
4356   // everything until something with the same indent as the operator is found.
4357   // FIXME: Is this a good system?
4358   FormatStyle Style = getLLVMStyle();
4359   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4360   verifyFormat(
4361       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4362       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4363       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4364       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4365       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4366       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4367       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4368       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4369       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
4370       Style);
4371   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4372                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4373                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4374                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4375                Style);
4376   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4377                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4378                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4379                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4380                Style);
4381   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4382                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4383                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4384                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4385                Style);
4386   verifyFormat("if () {\n"
4387                "} else if (aaaaa\n"
4388                "           && bbbbb // break\n"
4389                "                  > ccccc) {\n"
4390                "}",
4391                Style);
4392   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4393                "       && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4394                Style);
4395   verifyFormat("return (a)\n"
4396                "       // comment\n"
4397                "       + b;",
4398                Style);
4399   verifyFormat(
4400       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4401       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4402       "             + cc;",
4403       Style);
4404 
4405   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4406                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4407                Style);
4408 
4409   // Forced by comments.
4410   verifyFormat(
4411       "unsigned ContentSize =\n"
4412       "    sizeof(int16_t)   // DWARF ARange version number\n"
4413       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4414       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4415       "    + sizeof(int8_t); // Segment Size (in bytes)");
4416 
4417   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4418                "       == boost::fusion::at_c<1>(iiii).second;",
4419                Style);
4420 
4421   Style.ColumnLimit = 60;
4422   verifyFormat("zzzzzzzzzz\n"
4423                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4424                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4425                Style);
4426 
4427   Style.ColumnLimit = 80;
4428   Style.IndentWidth = 4;
4429   Style.TabWidth = 4;
4430   Style.UseTab = FormatStyle::UT_Always;
4431   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4432   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4433   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4434             "\t&& (someOtherLongishConditionPart1\n"
4435             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4436             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4437                    "(someOtherLongishConditionPart1 || "
4438                    "someOtherEvenLongerNestedConditionPart2);",
4439                    Style));
4440 }
4441 
4442 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
4443   FormatStyle Style = getLLVMStyle();
4444   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4445   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
4446 
4447   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4448                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4449                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4450                "              == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4451                "                         * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4452                "                     + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4453                "          && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4454                "                     * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4455                "                 > ccccccccccccccccccccccccccccccccccccccccc;",
4456                Style);
4457   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4458                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4459                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4460                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4461                Style);
4462   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4463                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4464                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4465                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4466                Style);
4467   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4468                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4469                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4470                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4471                Style);
4472   verifyFormat("if () {\n"
4473                "} else if (aaaaa\n"
4474                "           && bbbbb // break\n"
4475                "                  > ccccc) {\n"
4476                "}",
4477                Style);
4478   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4479                "    && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4480                Style);
4481   verifyFormat("return (a)\n"
4482                "     // comment\n"
4483                "     + b;",
4484                Style);
4485   verifyFormat(
4486       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4487       "               * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4488       "           + cc;",
4489       Style);
4490   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
4491                "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4492                "                        : 3333333333333333;",
4493                Style);
4494   verifyFormat(
4495       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
4496       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
4497       "                                             : eeeeeeeeeeeeeeeeee)\n"
4498       "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4499       "                        : 3333333333333333;",
4500       Style);
4501   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4502                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4503                Style);
4504 
4505   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4506                "    == boost::fusion::at_c<1>(iiii).second;",
4507                Style);
4508 
4509   Style.ColumnLimit = 60;
4510   verifyFormat("zzzzzzzzzzzzz\n"
4511                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4512                "   >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4513                Style);
4514 
4515   // Forced by comments.
4516   Style.ColumnLimit = 80;
4517   verifyFormat(
4518       "unsigned ContentSize\n"
4519       "    = sizeof(int16_t) // DWARF ARange version number\n"
4520       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4521       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4522       "    + sizeof(int8_t); // Segment Size (in bytes)",
4523       Style);
4524 
4525   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4526   verifyFormat(
4527       "unsigned ContentSize =\n"
4528       "    sizeof(int16_t)   // DWARF ARange version number\n"
4529       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4530       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4531       "    + sizeof(int8_t); // Segment Size (in bytes)",
4532       Style);
4533 
4534   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4535   verifyFormat(
4536       "unsigned ContentSize =\n"
4537       "    sizeof(int16_t)   // DWARF ARange version number\n"
4538       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4539       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4540       "    + sizeof(int8_t); // Segment Size (in bytes)",
4541       Style);
4542 }
4543 
4544 TEST_F(FormatTest, EnforcedOperatorWraps) {
4545   // Here we'd like to wrap after the || operators, but a comment is forcing an
4546   // earlier wrap.
4547   verifyFormat("bool x = aaaaa //\n"
4548                "         || bbbbb\n"
4549                "         //\n"
4550                "         || cccc;");
4551 }
4552 
4553 TEST_F(FormatTest, NoOperandAlignment) {
4554   FormatStyle Style = getLLVMStyle();
4555   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4556   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4557                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4558                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4559                Style);
4560   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4561   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4562                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4563                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4564                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4565                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4566                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4567                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4568                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4569                "        > ccccccccccccccccccccccccccccccccccccccccc;",
4570                Style);
4571 
4572   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4573                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4574                "    + cc;",
4575                Style);
4576   verifyFormat("int a = aa\n"
4577                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4578                "        * cccccccccccccccccccccccccccccccccccc;\n",
4579                Style);
4580 
4581   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4582   verifyFormat("return (a > b\n"
4583                "    // comment1\n"
4584                "    // comment2\n"
4585                "    || c);",
4586                Style);
4587 }
4588 
4589 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4590   FormatStyle Style = getLLVMStyle();
4591   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4592   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4593                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4594                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4595                Style);
4596 }
4597 
4598 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4599   FormatStyle Style = getLLVMStyle();
4600   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4601   Style.BinPackArguments = false;
4602   Style.ColumnLimit = 40;
4603   verifyFormat("void test() {\n"
4604                "  someFunction(\n"
4605                "      this + argument + is + quite\n"
4606                "      + long + so + it + gets + wrapped\n"
4607                "      + but + remains + bin - packed);\n"
4608                "}",
4609                Style);
4610   verifyFormat("void test() {\n"
4611                "  someFunction(arg1,\n"
4612                "               this + argument + is\n"
4613                "                   + quite + long + so\n"
4614                "                   + it + gets + wrapped\n"
4615                "                   + but + remains + bin\n"
4616                "                   - packed,\n"
4617                "               arg3);\n"
4618                "}",
4619                Style);
4620   verifyFormat("void test() {\n"
4621                "  someFunction(\n"
4622                "      arg1,\n"
4623                "      this + argument + has\n"
4624                "          + anotherFunc(nested,\n"
4625                "                        calls + whose\n"
4626                "                            + arguments\n"
4627                "                            + are + also\n"
4628                "                            + wrapped,\n"
4629                "                        in + addition)\n"
4630                "          + to + being + bin - packed,\n"
4631                "      arg3);\n"
4632                "}",
4633                Style);
4634 
4635   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4636   verifyFormat("void test() {\n"
4637                "  someFunction(\n"
4638                "      arg1,\n"
4639                "      this + argument + has +\n"
4640                "          anotherFunc(nested,\n"
4641                "                      calls + whose +\n"
4642                "                          arguments +\n"
4643                "                          are + also +\n"
4644                "                          wrapped,\n"
4645                "                      in + addition) +\n"
4646                "          to + being + bin - packed,\n"
4647                "      arg3);\n"
4648                "}",
4649                Style);
4650 }
4651 
4652 TEST_F(FormatTest, ConstructorInitializers) {
4653   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4654   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4655                getLLVMStyleWithColumns(45));
4656   verifyFormat("Constructor()\n"
4657                "    : Inttializer(FitsOnTheLine) {}",
4658                getLLVMStyleWithColumns(44));
4659   verifyFormat("Constructor()\n"
4660                "    : Inttializer(FitsOnTheLine) {}",
4661                getLLVMStyleWithColumns(43));
4662 
4663   verifyFormat("template <typename T>\n"
4664                "Constructor() : Initializer(FitsOnTheLine) {}",
4665                getLLVMStyleWithColumns(45));
4666 
4667   verifyFormat(
4668       "SomeClass::Constructor()\n"
4669       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4670 
4671   verifyFormat(
4672       "SomeClass::Constructor()\n"
4673       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4674       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4675   verifyFormat(
4676       "SomeClass::Constructor()\n"
4677       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4678       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4679   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4680                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4681                "    : aaaaaaaaaa(aaaaaa) {}");
4682 
4683   verifyFormat("Constructor()\n"
4684                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4685                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4686                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4687                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
4688 
4689   verifyFormat("Constructor()\n"
4690                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4691                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4692 
4693   verifyFormat("Constructor(int Parameter = 0)\n"
4694                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4695                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4696   verifyFormat("Constructor()\n"
4697                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4698                "}",
4699                getLLVMStyleWithColumns(60));
4700   verifyFormat("Constructor()\n"
4701                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4702                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4703 
4704   // Here a line could be saved by splitting the second initializer onto two
4705   // lines, but that is not desirable.
4706   verifyFormat("Constructor()\n"
4707                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4708                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
4709                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4710 
4711   FormatStyle OnePerLine = getLLVMStyle();
4712   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4713   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4714   verifyFormat("SomeClass::Constructor()\n"
4715                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4716                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4717                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4718                OnePerLine);
4719   verifyFormat("SomeClass::Constructor()\n"
4720                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4721                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4722                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4723                OnePerLine);
4724   verifyFormat("MyClass::MyClass(int var)\n"
4725                "    : some_var_(var),            // 4 space indent\n"
4726                "      some_other_var_(var + 1) { // lined up\n"
4727                "}",
4728                OnePerLine);
4729   verifyFormat("Constructor()\n"
4730                "    : aaaaa(aaaaaa),\n"
4731                "      aaaaa(aaaaaa),\n"
4732                "      aaaaa(aaaaaa),\n"
4733                "      aaaaa(aaaaaa),\n"
4734                "      aaaaa(aaaaaa) {}",
4735                OnePerLine);
4736   verifyFormat("Constructor()\n"
4737                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4738                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
4739                OnePerLine);
4740   OnePerLine.BinPackParameters = false;
4741   verifyFormat(
4742       "Constructor()\n"
4743       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4744       "          aaaaaaaaaaa().aaa(),\n"
4745       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4746       OnePerLine);
4747   OnePerLine.ColumnLimit = 60;
4748   verifyFormat("Constructor()\n"
4749                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4750                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4751                OnePerLine);
4752 
4753   EXPECT_EQ("Constructor()\n"
4754             "    : // Comment forcing unwanted break.\n"
4755             "      aaaa(aaaa) {}",
4756             format("Constructor() :\n"
4757                    "    // Comment forcing unwanted break.\n"
4758                    "    aaaa(aaaa) {}"));
4759 }
4760 
4761 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4762   FormatStyle Style = getLLVMStyle();
4763   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4764   Style.ColumnLimit = 60;
4765   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4766   Style.AllowAllConstructorInitializersOnNextLine = true;
4767   Style.BinPackParameters = false;
4768 
4769   for (int i = 0; i < 4; ++i) {
4770     // Test all combinations of parameters that should not have an effect.
4771     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4772     Style.AllowAllArgumentsOnNextLine = i & 2;
4773 
4774     Style.AllowAllConstructorInitializersOnNextLine = true;
4775     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4776     verifyFormat("Constructor()\n"
4777                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4778                  Style);
4779     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4780 
4781     Style.AllowAllConstructorInitializersOnNextLine = false;
4782     verifyFormat("Constructor()\n"
4783                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4784                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4785                  Style);
4786     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4787 
4788     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4789     Style.AllowAllConstructorInitializersOnNextLine = true;
4790     verifyFormat("Constructor()\n"
4791                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4792                  Style);
4793 
4794     Style.AllowAllConstructorInitializersOnNextLine = false;
4795     verifyFormat("Constructor()\n"
4796                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4797                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4798                  Style);
4799 
4800     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4801     Style.AllowAllConstructorInitializersOnNextLine = true;
4802     verifyFormat("Constructor() :\n"
4803                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4804                  Style);
4805 
4806     Style.AllowAllConstructorInitializersOnNextLine = false;
4807     verifyFormat("Constructor() :\n"
4808                  "    aaaaaaaaaaaaaaaaaa(a),\n"
4809                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4810                  Style);
4811   }
4812 
4813   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4814   // AllowAllConstructorInitializersOnNextLine in all
4815   // BreakConstructorInitializers modes
4816   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4817   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4818   Style.AllowAllConstructorInitializersOnNextLine = false;
4819   verifyFormat("SomeClassWithALongName::Constructor(\n"
4820                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4821                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4822                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4823                Style);
4824 
4825   Style.AllowAllConstructorInitializersOnNextLine = true;
4826   verifyFormat("SomeClassWithALongName::Constructor(\n"
4827                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4828                "    int bbbbbbbbbbbbb,\n"
4829                "    int cccccccccccccccc)\n"
4830                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4831                Style);
4832 
4833   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4834   Style.AllowAllConstructorInitializersOnNextLine = false;
4835   verifyFormat("SomeClassWithALongName::Constructor(\n"
4836                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4837                "    int bbbbbbbbbbbbb)\n"
4838                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4839                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4840                Style);
4841 
4842   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4843 
4844   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4845   verifyFormat("SomeClassWithALongName::Constructor(\n"
4846                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4847                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4848                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4849                Style);
4850 
4851   Style.AllowAllConstructorInitializersOnNextLine = true;
4852   verifyFormat("SomeClassWithALongName::Constructor(\n"
4853                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4854                "    int bbbbbbbbbbbbb,\n"
4855                "    int cccccccccccccccc)\n"
4856                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4857                Style);
4858 
4859   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4860   Style.AllowAllConstructorInitializersOnNextLine = false;
4861   verifyFormat("SomeClassWithALongName::Constructor(\n"
4862                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4863                "    int bbbbbbbbbbbbb)\n"
4864                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4865                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4866                Style);
4867 
4868   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4869   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4870   verifyFormat("SomeClassWithALongName::Constructor(\n"
4871                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4872                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4873                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4874                Style);
4875 
4876   Style.AllowAllConstructorInitializersOnNextLine = true;
4877   verifyFormat("SomeClassWithALongName::Constructor(\n"
4878                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4879                "    int bbbbbbbbbbbbb,\n"
4880                "    int cccccccccccccccc) :\n"
4881                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4882                Style);
4883 
4884   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4885   Style.AllowAllConstructorInitializersOnNextLine = false;
4886   verifyFormat("SomeClassWithALongName::Constructor(\n"
4887                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4888                "    int bbbbbbbbbbbbb) :\n"
4889                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4890                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4891                Style);
4892 }
4893 
4894 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4895   FormatStyle Style = getLLVMStyle();
4896   Style.ColumnLimit = 60;
4897   Style.BinPackArguments = false;
4898   for (int i = 0; i < 4; ++i) {
4899     // Test all combinations of parameters that should not have an effect.
4900     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4901     Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4902 
4903     Style.AllowAllArgumentsOnNextLine = true;
4904     verifyFormat("void foo() {\n"
4905                  "  FunctionCallWithReallyLongName(\n"
4906                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4907                  "}",
4908                  Style);
4909     Style.AllowAllArgumentsOnNextLine = false;
4910     verifyFormat("void foo() {\n"
4911                  "  FunctionCallWithReallyLongName(\n"
4912                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4913                  "      bbbbbbbbbbbb);\n"
4914                  "}",
4915                  Style);
4916 
4917     Style.AllowAllArgumentsOnNextLine = true;
4918     verifyFormat("void foo() {\n"
4919                  "  auto VariableWithReallyLongName = {\n"
4920                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4921                  "}",
4922                  Style);
4923     Style.AllowAllArgumentsOnNextLine = false;
4924     verifyFormat("void foo() {\n"
4925                  "  auto VariableWithReallyLongName = {\n"
4926                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4927                  "      bbbbbbbbbbbb};\n"
4928                  "}",
4929                  Style);
4930   }
4931 
4932   // This parameter should not affect declarations.
4933   Style.BinPackParameters = false;
4934   Style.AllowAllArgumentsOnNextLine = false;
4935   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4936   verifyFormat("void FunctionCallWithReallyLongName(\n"
4937                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
4938                Style);
4939   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4940   verifyFormat("void FunctionCallWithReallyLongName(\n"
4941                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
4942                "    int bbbbbbbbbbbb);",
4943                Style);
4944 }
4945 
4946 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
4947   FormatStyle Style = getLLVMStyle();
4948   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4949 
4950   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4951   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
4952                getStyleWithColumns(Style, 45));
4953   verifyFormat("Constructor() :\n"
4954                "    Initializer(FitsOnTheLine) {}",
4955                getStyleWithColumns(Style, 44));
4956   verifyFormat("Constructor() :\n"
4957                "    Initializer(FitsOnTheLine) {}",
4958                getStyleWithColumns(Style, 43));
4959 
4960   verifyFormat("template <typename T>\n"
4961                "Constructor() : Initializer(FitsOnTheLine) {}",
4962                getStyleWithColumns(Style, 50));
4963   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4964   verifyFormat(
4965       "SomeClass::Constructor() :\n"
4966       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4967       Style);
4968 
4969   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
4970   verifyFormat(
4971       "SomeClass::Constructor() :\n"
4972       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4973       Style);
4974 
4975   verifyFormat(
4976       "SomeClass::Constructor() :\n"
4977       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4978       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4979       Style);
4980   verifyFormat(
4981       "SomeClass::Constructor() :\n"
4982       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4983       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4984       Style);
4985   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4986                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4987                "    aaaaaaaaaa(aaaaaa) {}",
4988                Style);
4989 
4990   verifyFormat("Constructor() :\n"
4991                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4992                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4993                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4994                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
4995                Style);
4996 
4997   verifyFormat("Constructor() :\n"
4998                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4999                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5000                Style);
5001 
5002   verifyFormat("Constructor(int Parameter = 0) :\n"
5003                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
5004                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
5005                Style);
5006   verifyFormat("Constructor() :\n"
5007                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
5008                "}",
5009                getStyleWithColumns(Style, 60));
5010   verifyFormat("Constructor() :\n"
5011                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5012                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
5013                Style);
5014 
5015   // Here a line could be saved by splitting the second initializer onto two
5016   // lines, but that is not desirable.
5017   verifyFormat("Constructor() :\n"
5018                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
5019                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
5020                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5021                Style);
5022 
5023   FormatStyle OnePerLine = Style;
5024   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5025   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
5026   verifyFormat("SomeClass::Constructor() :\n"
5027                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5028                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5029                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5030                OnePerLine);
5031   verifyFormat("SomeClass::Constructor() :\n"
5032                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
5033                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5034                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5035                OnePerLine);
5036   verifyFormat("MyClass::MyClass(int var) :\n"
5037                "    some_var_(var),            // 4 space indent\n"
5038                "    some_other_var_(var + 1) { // lined up\n"
5039                "}",
5040                OnePerLine);
5041   verifyFormat("Constructor() :\n"
5042                "    aaaaa(aaaaaa),\n"
5043                "    aaaaa(aaaaaa),\n"
5044                "    aaaaa(aaaaaa),\n"
5045                "    aaaaa(aaaaaa),\n"
5046                "    aaaaa(aaaaaa) {}",
5047                OnePerLine);
5048   verifyFormat("Constructor() :\n"
5049                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5050                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
5051                OnePerLine);
5052   OnePerLine.BinPackParameters = false;
5053   verifyFormat("Constructor() :\n"
5054                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5055                "        aaaaaaaaaaa().aaa(),\n"
5056                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5057                OnePerLine);
5058   OnePerLine.ColumnLimit = 60;
5059   verifyFormat("Constructor() :\n"
5060                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
5061                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
5062                OnePerLine);
5063 
5064   EXPECT_EQ("Constructor() :\n"
5065             "    // Comment forcing unwanted break.\n"
5066             "    aaaa(aaaa) {}",
5067             format("Constructor() :\n"
5068                    "    // Comment forcing unwanted break.\n"
5069                    "    aaaa(aaaa) {}",
5070                    Style));
5071 
5072   Style.ColumnLimit = 0;
5073   verifyFormat("SomeClass::Constructor() :\n"
5074                "    a(a) {}",
5075                Style);
5076   verifyFormat("SomeClass::Constructor() noexcept :\n"
5077                "    a(a) {}",
5078                Style);
5079   verifyFormat("SomeClass::Constructor() :\n"
5080                "    a(a), b(b), c(c) {}",
5081                Style);
5082   verifyFormat("SomeClass::Constructor() :\n"
5083                "    a(a) {\n"
5084                "  foo();\n"
5085                "  bar();\n"
5086                "}",
5087                Style);
5088 
5089   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5090   verifyFormat("SomeClass::Constructor() :\n"
5091                "    a(a), b(b), c(c) {\n"
5092                "}",
5093                Style);
5094   verifyFormat("SomeClass::Constructor() :\n"
5095                "    a(a) {\n"
5096                "}",
5097                Style);
5098 
5099   Style.ColumnLimit = 80;
5100   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5101   Style.ConstructorInitializerIndentWidth = 2;
5102   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5103   verifyFormat("SomeClass::Constructor() :\n"
5104                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5105                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5106                Style);
5107 
5108   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5109   // well
5110   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5111   verifyFormat(
5112       "class SomeClass\n"
5113       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5114       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5115       Style);
5116   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5117   verifyFormat(
5118       "class SomeClass\n"
5119       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5120       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5121       Style);
5122   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5123   verifyFormat(
5124       "class SomeClass :\n"
5125       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5126       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5127       Style);
5128 }
5129 
5130 #ifndef EXPENSIVE_CHECKS
5131 // Expensive checks enables libstdc++ checking which includes validating the
5132 // state of ranges used in std::priority_queue - this blows out the
5133 // runtime/scalability of the function and makes this test unacceptably slow.
5134 TEST_F(FormatTest, MemoizationTests) {
5135   // This breaks if the memoization lookup does not take \c Indent and
5136   // \c LastSpace into account.
5137   verifyFormat(
5138       "extern CFRunLoopTimerRef\n"
5139       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5140       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
5141       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
5142       "                     CFRunLoopTimerContext *context) {}");
5143 
5144   // Deep nesting somewhat works around our memoization.
5145   verifyFormat(
5146       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5147       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5148       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5149       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5150       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
5151       getLLVMStyleWithColumns(65));
5152   verifyFormat(
5153       "aaaaa(\n"
5154       "    aaaaa,\n"
5155       "    aaaaa(\n"
5156       "        aaaaa,\n"
5157       "        aaaaa(\n"
5158       "            aaaaa,\n"
5159       "            aaaaa(\n"
5160       "                aaaaa,\n"
5161       "                aaaaa(\n"
5162       "                    aaaaa,\n"
5163       "                    aaaaa(\n"
5164       "                        aaaaa,\n"
5165       "                        aaaaa(\n"
5166       "                            aaaaa,\n"
5167       "                            aaaaa(\n"
5168       "                                aaaaa,\n"
5169       "                                aaaaa(\n"
5170       "                                    aaaaa,\n"
5171       "                                    aaaaa(\n"
5172       "                                        aaaaa,\n"
5173       "                                        aaaaa(\n"
5174       "                                            aaaaa,\n"
5175       "                                            aaaaa(\n"
5176       "                                                aaaaa,\n"
5177       "                                                aaaaa))))))))))));",
5178       getLLVMStyleWithColumns(65));
5179   verifyFormat(
5180       "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"
5181       "                                  a),\n"
5182       "                                a),\n"
5183       "                              a),\n"
5184       "                            a),\n"
5185       "                          a),\n"
5186       "                        a),\n"
5187       "                      a),\n"
5188       "                    a),\n"
5189       "                  a),\n"
5190       "                a),\n"
5191       "              a),\n"
5192       "            a),\n"
5193       "          a),\n"
5194       "        a),\n"
5195       "      a),\n"
5196       "    a),\n"
5197       "  a)",
5198       getLLVMStyleWithColumns(65));
5199 
5200   // This test takes VERY long when memoization is broken.
5201   FormatStyle OnePerLine = getLLVMStyle();
5202   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5203   OnePerLine.BinPackParameters = false;
5204   std::string input = "Constructor()\n"
5205                       "    : aaaa(a,\n";
5206   for (unsigned i = 0, e = 80; i != e; ++i) {
5207     input += "           a,\n";
5208   }
5209   input += "           a) {}";
5210   verifyFormat(input, OnePerLine);
5211 }
5212 #endif
5213 
5214 TEST_F(FormatTest, BreaksAsHighAsPossible) {
5215   verifyFormat(
5216       "void f() {\n"
5217       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5218       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5219       "    f();\n"
5220       "}");
5221   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5222                "    Intervals[i - 1].getRange().getLast()) {\n}");
5223 }
5224 
5225 TEST_F(FormatTest, BreaksFunctionDeclarations) {
5226   // Principially, we break function declarations in a certain order:
5227   // 1) break amongst arguments.
5228   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5229                "                              Cccccccccccccc cccccccccccccc);");
5230   verifyFormat("template <class TemplateIt>\n"
5231                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5232                "                            TemplateIt *stop) {}");
5233 
5234   // 2) break after return type.
5235   verifyFormat(
5236       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5237       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5238       getGoogleStyle());
5239 
5240   // 3) break after (.
5241   verifyFormat(
5242       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5243       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5244       getGoogleStyle());
5245 
5246   // 4) break before after nested name specifiers.
5247   verifyFormat(
5248       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5249       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5250       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5251       getGoogleStyle());
5252 
5253   // However, there are exceptions, if a sufficient amount of lines can be
5254   // saved.
5255   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5256   // more adjusting.
5257   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5258                "                                  Cccccccccccccc cccccccccc,\n"
5259                "                                  Cccccccccccccc cccccccccc,\n"
5260                "                                  Cccccccccccccc cccccccccc,\n"
5261                "                                  Cccccccccccccc cccccccccc);");
5262   verifyFormat(
5263       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5264       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5265       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5266       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5267       getGoogleStyle());
5268   verifyFormat(
5269       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5270       "                                          Cccccccccccccc cccccccccc,\n"
5271       "                                          Cccccccccccccc cccccccccc,\n"
5272       "                                          Cccccccccccccc cccccccccc,\n"
5273       "                                          Cccccccccccccc cccccccccc,\n"
5274       "                                          Cccccccccccccc cccccccccc,\n"
5275       "                                          Cccccccccccccc cccccccccc);");
5276   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5277                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5278                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5279                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5280                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5281 
5282   // Break after multi-line parameters.
5283   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5284                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5285                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5286                "    bbbb bbbb);");
5287   verifyFormat("void SomeLoooooooooooongFunction(\n"
5288                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5289                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5290                "    int bbbbbbbbbbbbb);");
5291 
5292   // Treat overloaded operators like other functions.
5293   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5294                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5295   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5296                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5297   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5298                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5299   verifyGoogleFormat(
5300       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5301       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5302   verifyGoogleFormat(
5303       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5304       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5305   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5306                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5307   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5308                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5309   verifyGoogleFormat(
5310       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5311       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5312       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5313   verifyGoogleFormat("template <typename T>\n"
5314                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5315                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5316                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5317 
5318   FormatStyle Style = getLLVMStyle();
5319   Style.PointerAlignment = FormatStyle::PAS_Left;
5320   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5321                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5322                Style);
5323   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5324                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5325                Style);
5326 }
5327 
5328 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5329   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5330   // Prefer keeping `::` followed by `operator` together.
5331   EXPECT_EQ("const aaaa::bbbbbbb &\n"
5332             "ccccccccc::operator++() {\n"
5333             "  stuff();\n"
5334             "}",
5335             format("const aaaa::bbbbbbb\n"
5336                    "&ccccccccc::operator++() { stuff(); }",
5337                    getLLVMStyleWithColumns(40)));
5338 }
5339 
5340 TEST_F(FormatTest, TrailingReturnType) {
5341   verifyFormat("auto foo() -> int;\n");
5342   // correct trailing return type spacing
5343   verifyFormat("auto operator->() -> int;\n");
5344   verifyFormat("auto operator++(int) -> int;\n");
5345 
5346   verifyFormat("struct S {\n"
5347                "  auto bar() const -> int;\n"
5348                "};");
5349   verifyFormat("template <size_t Order, typename T>\n"
5350                "auto load_img(const std::string &filename)\n"
5351                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
5352   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5353                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5354   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5355   verifyFormat("template <typename T>\n"
5356                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5357                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5358 
5359   // Not trailing return types.
5360   verifyFormat("void f() { auto a = b->c(); }");
5361 }
5362 
5363 TEST_F(FormatTest, DeductionGuides) {
5364   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5365   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5366   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5367   verifyFormat(
5368       "template <class... T>\n"
5369       "array(T &&...t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5370   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5371   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5372   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5373   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5374   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5375   verifyFormat("template <class T> x() -> x<1>;");
5376   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5377 
5378   // Ensure not deduction guides.
5379   verifyFormat("c()->f<int>();");
5380   verifyFormat("x()->foo<1>;");
5381   verifyFormat("x = p->foo<3>();");
5382   verifyFormat("x()->x<1>();");
5383   verifyFormat("x()->x<1>;");
5384 }
5385 
5386 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5387   // Avoid breaking before trailing 'const' or other trailing annotations, if
5388   // they are not function-like.
5389   FormatStyle Style = getGoogleStyle();
5390   Style.ColumnLimit = 47;
5391   verifyFormat("void someLongFunction(\n"
5392                "    int someLoooooooooooooongParameter) const {\n}",
5393                getLLVMStyleWithColumns(47));
5394   verifyFormat("LoooooongReturnType\n"
5395                "someLoooooooongFunction() const {}",
5396                getLLVMStyleWithColumns(47));
5397   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5398                "    const {}",
5399                Style);
5400   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5401                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5402   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5403                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5404   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5405                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5406   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5407                "                   aaaaaaaaaaa aaaaa) const override;");
5408   verifyGoogleFormat(
5409       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5410       "    const override;");
5411 
5412   // Even if the first parameter has to be wrapped.
5413   verifyFormat("void someLongFunction(\n"
5414                "    int someLongParameter) const {}",
5415                getLLVMStyleWithColumns(46));
5416   verifyFormat("void someLongFunction(\n"
5417                "    int someLongParameter) const {}",
5418                Style);
5419   verifyFormat("void someLongFunction(\n"
5420                "    int someLongParameter) override {}",
5421                Style);
5422   verifyFormat("void someLongFunction(\n"
5423                "    int someLongParameter) OVERRIDE {}",
5424                Style);
5425   verifyFormat("void someLongFunction(\n"
5426                "    int someLongParameter) final {}",
5427                Style);
5428   verifyFormat("void someLongFunction(\n"
5429                "    int someLongParameter) FINAL {}",
5430                Style);
5431   verifyFormat("void someLongFunction(\n"
5432                "    int parameter) const override {}",
5433                Style);
5434 
5435   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5436   verifyFormat("void someLongFunction(\n"
5437                "    int someLongParameter) const\n"
5438                "{\n"
5439                "}",
5440                Style);
5441 
5442   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5443   verifyFormat("void someLongFunction(\n"
5444                "    int someLongParameter) const\n"
5445                "  {\n"
5446                "  }",
5447                Style);
5448 
5449   // Unless these are unknown annotations.
5450   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5451                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5452                "    LONG_AND_UGLY_ANNOTATION;");
5453 
5454   // Breaking before function-like trailing annotations is fine to keep them
5455   // close to their arguments.
5456   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5457                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5458   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5459                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5460   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5461                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5462   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5463                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5464   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5465 
5466   verifyFormat(
5467       "void aaaaaaaaaaaaaaaaaa()\n"
5468       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5469       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5470   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5471                "    __attribute__((unused));");
5472   verifyGoogleFormat(
5473       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5474       "    GUARDED_BY(aaaaaaaaaaaa);");
5475   verifyGoogleFormat(
5476       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5477       "    GUARDED_BY(aaaaaaaaaaaa);");
5478   verifyGoogleFormat(
5479       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5480       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5481   verifyGoogleFormat(
5482       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5483       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5484 }
5485 
5486 TEST_F(FormatTest, FunctionAnnotations) {
5487   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5488                "int OldFunction(const string &parameter) {}");
5489   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5490                "string OldFunction(const string &parameter) {}");
5491   verifyFormat("template <typename T>\n"
5492                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5493                "string OldFunction(const string &parameter) {}");
5494 
5495   // Not function annotations.
5496   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5497                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5498   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5499                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5500   verifyFormat("MACRO(abc).function() // wrap\n"
5501                "    << abc;");
5502   verifyFormat("MACRO(abc)->function() // wrap\n"
5503                "    << abc;");
5504   verifyFormat("MACRO(abc)::function() // wrap\n"
5505                "    << abc;");
5506 }
5507 
5508 TEST_F(FormatTest, BreaksDesireably) {
5509   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5510                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5511                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5512   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5513                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5514                "}");
5515 
5516   verifyFormat(
5517       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5518       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5519 
5520   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5521                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5522                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5523 
5524   verifyFormat(
5525       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5526       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5527       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5528       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5529       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5530 
5531   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5532                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5533 
5534   verifyFormat(
5535       "void f() {\n"
5536       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5537       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5538       "}");
5539   verifyFormat(
5540       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5541       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5542   verifyFormat(
5543       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5544       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5545   verifyFormat(
5546       "aaaaaa(aaa,\n"
5547       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5548       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5549       "       aaaa);");
5550   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5551                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5552                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5553 
5554   // Indent consistently independent of call expression and unary operator.
5555   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5556                "    dddddddddddddddddddddddddddddd));");
5557   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5558                "    dddddddddddddddddddddddddddddd));");
5559   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5560                "    dddddddddddddddddddddddddddddd));");
5561 
5562   // This test case breaks on an incorrect memoization, i.e. an optimization not
5563   // taking into account the StopAt value.
5564   verifyFormat(
5565       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5566       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5567       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5568       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5569 
5570   verifyFormat("{\n  {\n    {\n"
5571                "      Annotation.SpaceRequiredBefore =\n"
5572                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5573                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5574                "    }\n  }\n}");
5575 
5576   // Break on an outer level if there was a break on an inner level.
5577   EXPECT_EQ("f(g(h(a, // comment\n"
5578             "      b, c),\n"
5579             "    d, e),\n"
5580             "  x, y);",
5581             format("f(g(h(a, // comment\n"
5582                    "    b, c), d, e), x, y);"));
5583 
5584   // Prefer breaking similar line breaks.
5585   verifyFormat(
5586       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5587       "                             NSTrackingMouseEnteredAndExited |\n"
5588       "                             NSTrackingActiveAlways;");
5589 }
5590 
5591 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5592   FormatStyle NoBinPacking = getGoogleStyle();
5593   NoBinPacking.BinPackParameters = false;
5594   NoBinPacking.BinPackArguments = true;
5595   verifyFormat("void f() {\n"
5596                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5597                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5598                "}",
5599                NoBinPacking);
5600   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5601                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5602                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5603                NoBinPacking);
5604 
5605   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5606   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5607                "                        vector<int> bbbbbbbbbbbbbbb);",
5608                NoBinPacking);
5609   // FIXME: This behavior difference is probably not wanted. However, currently
5610   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5611   // template arguments from BreakBeforeParameter being set because of the
5612   // one-per-line formatting.
5613   verifyFormat(
5614       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5615       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5616       NoBinPacking);
5617   verifyFormat(
5618       "void fffffffffff(\n"
5619       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5620       "        aaaaaaaaaa);");
5621 }
5622 
5623 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5624   FormatStyle NoBinPacking = getGoogleStyle();
5625   NoBinPacking.BinPackParameters = false;
5626   NoBinPacking.BinPackArguments = false;
5627   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5628                "  aaaaaaaaaaaaaaaaaaaa,\n"
5629                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5630                NoBinPacking);
5631   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5632                "        aaaaaaaaaaaaa,\n"
5633                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5634                NoBinPacking);
5635   verifyFormat(
5636       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5637       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5638       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5639       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5640       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5641       NoBinPacking);
5642   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5643                "    .aaaaaaaaaaaaaaaaaa();",
5644                NoBinPacking);
5645   verifyFormat("void f() {\n"
5646                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5647                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5648                "}",
5649                NoBinPacking);
5650 
5651   verifyFormat(
5652       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5653       "             aaaaaaaaaaaa,\n"
5654       "             aaaaaaaaaaaa);",
5655       NoBinPacking);
5656   verifyFormat(
5657       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5658       "                               ddddddddddddddddddddddddddddd),\n"
5659       "             test);",
5660       NoBinPacking);
5661 
5662   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5663                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5664                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5665                "    aaaaaaaaaaaaaaaaaa;",
5666                NoBinPacking);
5667   verifyFormat("a(\"a\"\n"
5668                "  \"a\",\n"
5669                "  a);");
5670 
5671   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5672   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5673                "                aaaaaaaaa,\n"
5674                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5675                NoBinPacking);
5676   verifyFormat(
5677       "void f() {\n"
5678       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5679       "      .aaaaaaa();\n"
5680       "}",
5681       NoBinPacking);
5682   verifyFormat(
5683       "template <class SomeType, class SomeOtherType>\n"
5684       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5685       NoBinPacking);
5686 }
5687 
5688 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5689   FormatStyle Style = getLLVMStyleWithColumns(15);
5690   Style.ExperimentalAutoDetectBinPacking = true;
5691   EXPECT_EQ("aaa(aaaa,\n"
5692             "    aaaa,\n"
5693             "    aaaa);\n"
5694             "aaa(aaaa,\n"
5695             "    aaaa,\n"
5696             "    aaaa);",
5697             format("aaa(aaaa,\n" // one-per-line
5698                    "  aaaa,\n"
5699                    "    aaaa  );\n"
5700                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5701                    Style));
5702   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5703             "    aaaa);\n"
5704             "aaa(aaaa, aaaa,\n"
5705             "    aaaa);",
5706             format("aaa(aaaa,  aaaa,\n" // bin-packed
5707                    "    aaaa  );\n"
5708                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5709                    Style));
5710 }
5711 
5712 TEST_F(FormatTest, FormatsBuilderPattern) {
5713   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5714                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5715                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5716                "    .StartsWith(\".init\", ORDER_INIT)\n"
5717                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5718                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5719                "    .Default(ORDER_TEXT);\n");
5720 
5721   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5722                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5723   verifyFormat("aaaaaaa->aaaaaaa\n"
5724                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5725                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5726                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5727   verifyFormat(
5728       "aaaaaaa->aaaaaaa\n"
5729       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5730       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5731   verifyFormat(
5732       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5733       "    aaaaaaaaaaaaaa);");
5734   verifyFormat(
5735       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5736       "    aaaaaa->aaaaaaaaaaaa()\n"
5737       "        ->aaaaaaaaaaaaaaaa(\n"
5738       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5739       "        ->aaaaaaaaaaaaaaaaa();");
5740   verifyGoogleFormat(
5741       "void f() {\n"
5742       "  someo->Add((new util::filetools::Handler(dir))\n"
5743       "                 ->OnEvent1(NewPermanentCallback(\n"
5744       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5745       "                 ->OnEvent2(NewPermanentCallback(\n"
5746       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5747       "                 ->OnEvent3(NewPermanentCallback(\n"
5748       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5749       "                 ->OnEvent5(NewPermanentCallback(\n"
5750       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5751       "                 ->OnEvent6(NewPermanentCallback(\n"
5752       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5753       "}");
5754 
5755   verifyFormat(
5756       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5757   verifyFormat("aaaaaaaaaaaaaaa()\n"
5758                "    .aaaaaaaaaaaaaaa()\n"
5759                "    .aaaaaaaaaaaaaaa()\n"
5760                "    .aaaaaaaaaaaaaaa()\n"
5761                "    .aaaaaaaaaaaaaaa();");
5762   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5763                "    .aaaaaaaaaaaaaaa()\n"
5764                "    .aaaaaaaaaaaaaaa()\n"
5765                "    .aaaaaaaaaaaaaaa();");
5766   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5767                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5768                "    .aaaaaaaaaaaaaaa();");
5769   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5770                "    ->aaaaaaaaaaaaaae(0)\n"
5771                "    ->aaaaaaaaaaaaaaa();");
5772 
5773   // Don't linewrap after very short segments.
5774   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5775                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5776                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5777   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5778                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5779                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5780   verifyFormat("aaa()\n"
5781                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5782                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5783                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5784 
5785   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5786                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5787                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5788   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5789                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5790                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5791 
5792   // Prefer not to break after empty parentheses.
5793   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5794                "    First->LastNewlineOffset);");
5795 
5796   // Prefer not to create "hanging" indents.
5797   verifyFormat(
5798       "return !soooooooooooooome_map\n"
5799       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5800       "            .second;");
5801   verifyFormat(
5802       "return aaaaaaaaaaaaaaaa\n"
5803       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5804       "    .aaaa(aaaaaaaaaaaaaa);");
5805   // No hanging indent here.
5806   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5807                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5808   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5809                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5810   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5811                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5812                getLLVMStyleWithColumns(60));
5813   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5814                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5815                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5816                getLLVMStyleWithColumns(59));
5817   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5818                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5819                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5820 
5821   // Dont break if only closing statements before member call
5822   verifyFormat("test() {\n"
5823                "  ([]() -> {\n"
5824                "    int b = 32;\n"
5825                "    return 3;\n"
5826                "  }).foo();\n"
5827                "}");
5828   verifyFormat("test() {\n"
5829                "  (\n"
5830                "      []() -> {\n"
5831                "        int b = 32;\n"
5832                "        return 3;\n"
5833                "      },\n"
5834                "      foo, bar)\n"
5835                "      .foo();\n"
5836                "}");
5837   verifyFormat("test() {\n"
5838                "  ([]() -> {\n"
5839                "    int b = 32;\n"
5840                "    return 3;\n"
5841                "  })\n"
5842                "      .foo()\n"
5843                "      .bar();\n"
5844                "}");
5845   verifyFormat("test() {\n"
5846                "  ([]() -> {\n"
5847                "    int b = 32;\n"
5848                "    return 3;\n"
5849                "  })\n"
5850                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5851                "           \"bbbb\");\n"
5852                "}",
5853                getLLVMStyleWithColumns(30));
5854 }
5855 
5856 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5857   verifyFormat(
5858       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5859       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5860   verifyFormat(
5861       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5862       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5863 
5864   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5865                "    ccccccccccccccccccccccccc) {\n}");
5866   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5867                "    ccccccccccccccccccccccccc) {\n}");
5868 
5869   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5870                "    ccccccccccccccccccccccccc) {\n}");
5871   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5872                "    ccccccccccccccccccccccccc) {\n}");
5873 
5874   verifyFormat(
5875       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
5876       "    ccccccccccccccccccccccccc) {\n}");
5877   verifyFormat(
5878       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
5879       "    ccccccccccccccccccccccccc) {\n}");
5880 
5881   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5882                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
5883                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
5884                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5885   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5886                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
5887                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
5888                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5889 
5890   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5891                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
5892                "    aaaaaaaaaaaaaaa != aa) {\n}");
5893   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5894                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
5895                "    aaaaaaaaaaaaaaa != aa) {\n}");
5896 }
5897 
5898 TEST_F(FormatTest, BreaksAfterAssignments) {
5899   verifyFormat(
5900       "unsigned Cost =\n"
5901       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
5902       "                        SI->getPointerAddressSpaceee());\n");
5903   verifyFormat(
5904       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
5905       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
5906 
5907   verifyFormat(
5908       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
5909       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
5910   verifyFormat("unsigned OriginalStartColumn =\n"
5911                "    SourceMgr.getSpellingColumnNumber(\n"
5912                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
5913                "    1;");
5914 }
5915 
5916 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
5917   FormatStyle Style = getLLVMStyle();
5918   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5919                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
5920                Style);
5921 
5922   Style.PenaltyBreakAssignment = 20;
5923   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5924                "                                 cccccccccccccccccccccccccc;",
5925                Style);
5926 }
5927 
5928 TEST_F(FormatTest, AlignsAfterAssignments) {
5929   verifyFormat(
5930       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5931       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
5932   verifyFormat(
5933       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5934       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
5935   verifyFormat(
5936       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5937       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
5938   verifyFormat(
5939       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5940       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
5941   verifyFormat(
5942       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5943       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5944       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
5945 }
5946 
5947 TEST_F(FormatTest, AlignsAfterReturn) {
5948   verifyFormat(
5949       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5950       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
5951   verifyFormat(
5952       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5953       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
5954   verifyFormat(
5955       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5956       "       aaaaaaaaaaaaaaaaaaaaaa();");
5957   verifyFormat(
5958       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5959       "        aaaaaaaaaaaaaaaaaaaaaa());");
5960   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5961                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5962   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5963                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
5964                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5965   verifyFormat("return\n"
5966                "    // true if code is one of a or b.\n"
5967                "    code == a || code == b;");
5968 }
5969 
5970 TEST_F(FormatTest, AlignsAfterOpenBracket) {
5971   verifyFormat(
5972       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5973       "                                                aaaaaaaaa aaaaaaa) {}");
5974   verifyFormat(
5975       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5976       "                                               aaaaaaaaaaa aaaaaaaaa);");
5977   verifyFormat(
5978       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5979       "                                             aaaaaaaaaaaaaaaaaaaaa));");
5980   FormatStyle Style = getLLVMStyle();
5981   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5982   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5983                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
5984                Style);
5985   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5986                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
5987                Style);
5988   verifyFormat("SomeLongVariableName->someFunction(\n"
5989                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
5990                Style);
5991   verifyFormat(
5992       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5993       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5994       Style);
5995   verifyFormat(
5996       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5997       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5998       Style);
5999   verifyFormat(
6000       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6001       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6002       Style);
6003 
6004   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
6005                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
6006                "        b));",
6007                Style);
6008 
6009   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6010   Style.BinPackArguments = false;
6011   Style.BinPackParameters = false;
6012   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6013                "    aaaaaaaaaaa aaaaaaaa,\n"
6014                "    aaaaaaaaa aaaaaaa,\n"
6015                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6016                Style);
6017   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6018                "    aaaaaaaaaaa aaaaaaaaa,\n"
6019                "    aaaaaaaaaaa aaaaaaaaa,\n"
6020                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6021                Style);
6022   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
6023                "    aaaaaaaaaaaaaaa,\n"
6024                "    aaaaaaaaaaaaaaaaaaaaa,\n"
6025                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6026                Style);
6027   verifyFormat(
6028       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
6029       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6030       Style);
6031   verifyFormat(
6032       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
6033       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6034       Style);
6035   verifyFormat(
6036       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6037       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6038       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
6039       "    aaaaaaaaaaaaaaaa);",
6040       Style);
6041   verifyFormat(
6042       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6043       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6044       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
6045       "    aaaaaaaaaaaaaaaa);",
6046       Style);
6047 }
6048 
6049 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
6050   FormatStyle Style = getLLVMStyleWithColumns(40);
6051   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6052                "          bbbbbbbbbbbbbbbbbbbbbb);",
6053                Style);
6054   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6055   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6056   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6057                "          bbbbbbbbbbbbbbbbbbbbbb);",
6058                Style);
6059   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6060   Style.AlignOperands = FormatStyle::OAS_Align;
6061   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6062                "          bbbbbbbbbbbbbbbbbbbbbb);",
6063                Style);
6064   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6065   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6066   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6067                "    bbbbbbbbbbbbbbbbbbbbbb);",
6068                Style);
6069 }
6070 
6071 TEST_F(FormatTest, BreaksConditionalExpressions) {
6072   verifyFormat(
6073       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6074       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6075       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6076   verifyFormat(
6077       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6078       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6079       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6080   verifyFormat(
6081       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6082       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6083   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6084                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6085                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6086   verifyFormat(
6087       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6088       "                                                    : aaaaaaaaaaaaa);");
6089   verifyFormat(
6090       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6091       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6092       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6093       "                   aaaaaaaaaaaaa);");
6094   verifyFormat(
6095       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6096       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6097       "                   aaaaaaaaaaaaa);");
6098   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6099                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6100                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6101                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6102                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6103   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6104                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6105                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6106                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6107                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6108                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6109                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6110   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6111                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6112                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6113                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6114                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6115   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6116                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6117                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6118   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6119                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6120                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6121                "        : aaaaaaaaaaaaaaaa;");
6122   verifyFormat(
6123       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6124       "    ? aaaaaaaaaaaaaaa\n"
6125       "    : aaaaaaaaaaaaaaa;");
6126   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6127                "          aaaaaaaaa\n"
6128                "      ? b\n"
6129                "      : c);");
6130   verifyFormat("return aaaa == bbbb\n"
6131                "           // comment\n"
6132                "           ? aaaa\n"
6133                "           : bbbb;");
6134   verifyFormat("unsigned Indent =\n"
6135                "    format(TheLine.First,\n"
6136                "           IndentForLevel[TheLine.Level] >= 0\n"
6137                "               ? IndentForLevel[TheLine.Level]\n"
6138                "               : TheLine * 2,\n"
6139                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6140                getLLVMStyleWithColumns(60));
6141   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6142                "                  ? aaaaaaaaaaaaaaa\n"
6143                "                  : bbbbbbbbbbbbbbb //\n"
6144                "                        ? ccccccccccccccc\n"
6145                "                        : ddddddddddddddd;");
6146   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6147                "                  ? aaaaaaaaaaaaaaa\n"
6148                "                  : (bbbbbbbbbbbbbbb //\n"
6149                "                         ? ccccccccccccccc\n"
6150                "                         : ddddddddddddddd);");
6151   verifyFormat(
6152       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6153       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6154       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
6155       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
6156       "                                      : aaaaaaaaaa;");
6157   verifyFormat(
6158       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6159       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
6160       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6161 
6162   FormatStyle NoBinPacking = getLLVMStyle();
6163   NoBinPacking.BinPackArguments = false;
6164   verifyFormat(
6165       "void f() {\n"
6166       "  g(aaa,\n"
6167       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6168       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6169       "        ? aaaaaaaaaaaaaaa\n"
6170       "        : aaaaaaaaaaaaaaa);\n"
6171       "}",
6172       NoBinPacking);
6173   verifyFormat(
6174       "void f() {\n"
6175       "  g(aaa,\n"
6176       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6177       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6178       "        ?: aaaaaaaaaaaaaaa);\n"
6179       "}",
6180       NoBinPacking);
6181 
6182   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6183                "             // comment.\n"
6184                "             ccccccccccccccccccccccccccccccccccccccc\n"
6185                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6186                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6187 
6188   // Assignments in conditional expressions. Apparently not uncommon :-(.
6189   verifyFormat("return a != b\n"
6190                "           // comment\n"
6191                "           ? a = b\n"
6192                "           : a = b;");
6193   verifyFormat("return a != b\n"
6194                "           // comment\n"
6195                "           ? a = a != b\n"
6196                "                     // comment\n"
6197                "                     ? a = b\n"
6198                "                     : a\n"
6199                "           : a;\n");
6200   verifyFormat("return a != b\n"
6201                "           // comment\n"
6202                "           ? a\n"
6203                "           : a = a != b\n"
6204                "                     // comment\n"
6205                "                     ? a = b\n"
6206                "                     : a;");
6207 
6208   // Chained conditionals
6209   FormatStyle Style = getLLVMStyle();
6210   Style.ColumnLimit = 70;
6211   Style.AlignOperands = FormatStyle::OAS_Align;
6212   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6213                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6214                "                        : 3333333333333333;",
6215                Style);
6216   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6217                "       : bbbbbbbbbb     ? 2222222222222222\n"
6218                "                        : 3333333333333333;",
6219                Style);
6220   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
6221                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6222                "                          : 3333333333333333;",
6223                Style);
6224   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6225                "       : bbbbbbbbbbbbbb ? 222222\n"
6226                "                        : 333333;",
6227                Style);
6228   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6229                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6230                "       : cccccccccccccc ? 3333333333333333\n"
6231                "                        : 4444444444444444;",
6232                Style);
6233   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6234                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6235                "                        : 3333333333333333;",
6236                Style);
6237   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6238                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6239                "                        : (aaa ? bbb : ccc);",
6240                Style);
6241   verifyFormat(
6242       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6243       "                                             : cccccccccccccccccc)\n"
6244       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6245       "                        : 3333333333333333;",
6246       Style);
6247   verifyFormat(
6248       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6249       "                                             : cccccccccccccccccc)\n"
6250       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6251       "                        : 3333333333333333;",
6252       Style);
6253   verifyFormat(
6254       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6255       "                                             : dddddddddddddddddd)\n"
6256       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6257       "                        : 3333333333333333;",
6258       Style);
6259   verifyFormat(
6260       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6261       "                                             : dddddddddddddddddd)\n"
6262       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6263       "                        : 3333333333333333;",
6264       Style);
6265   verifyFormat(
6266       "return aaaaaaaaa        ? 1111111111111111\n"
6267       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6268       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6269       "                                             : dddddddddddddddddd)\n",
6270       Style);
6271   verifyFormat(
6272       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6273       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6274       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6275       "                                             : cccccccccccccccccc);",
6276       Style);
6277   verifyFormat(
6278       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6279       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6280       "                                             : eeeeeeeeeeeeeeeeee)\n"
6281       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6282       "                        : 3333333333333333;",
6283       Style);
6284   verifyFormat(
6285       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
6286       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6287       "                                             : eeeeeeeeeeeeeeeeee)\n"
6288       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6289       "                        : 3333333333333333;",
6290       Style);
6291   verifyFormat(
6292       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6293       "                           : cccccccccccc    ? dddddddddddddddddd\n"
6294       "                                             : eeeeeeeeeeeeeeeeee)\n"
6295       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6296       "                        : 3333333333333333;",
6297       Style);
6298   verifyFormat(
6299       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6300       "                                             : cccccccccccccccccc\n"
6301       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6302       "                        : 3333333333333333;",
6303       Style);
6304   verifyFormat(
6305       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6306       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
6307       "                                             : eeeeeeeeeeeeeeeeee\n"
6308       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6309       "                        : 3333333333333333;",
6310       Style);
6311   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6312                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
6313                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
6314                "                                   : eeeeeeeeeeeeeeeeee)\n"
6315                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6316                "                             : 3333333333333333;",
6317                Style);
6318   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6319                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6320                "             : cccccccccccccccc ? dddddddddddddddddd\n"
6321                "                                : eeeeeeeeeeeeeeeeee\n"
6322                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6323                "                                 : 3333333333333333;",
6324                Style);
6325 
6326   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6327   Style.BreakBeforeTernaryOperators = false;
6328   // FIXME: Aligning the question marks is weird given DontAlign.
6329   // Consider disabling this alignment in this case. Also check whether this
6330   // will render the adjustment from https://reviews.llvm.org/D82199
6331   // unnecessary.
6332   verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
6333                "    bbbb                ? cccccccccccccccccc :\n"
6334                "                          ddddd;\n",
6335                Style);
6336 }
6337 
6338 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6339   FormatStyle Style = getLLVMStyle();
6340   Style.BreakBeforeTernaryOperators = false;
6341   Style.ColumnLimit = 70;
6342   verifyFormat(
6343       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6344       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6345       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6346       Style);
6347   verifyFormat(
6348       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6349       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6350       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6351       Style);
6352   verifyFormat(
6353       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6354       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6355       Style);
6356   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6357                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6358                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6359                Style);
6360   verifyFormat(
6361       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6362       "                                                      aaaaaaaaaaaaa);",
6363       Style);
6364   verifyFormat(
6365       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6366       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6367       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6368       "                   aaaaaaaaaaaaa);",
6369       Style);
6370   verifyFormat(
6371       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6372       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6373       "                   aaaaaaaaaaaaa);",
6374       Style);
6375   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6376                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6377                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6378                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6379                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6380                Style);
6381   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6382                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6383                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6384                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6385                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6386                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6387                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6388                Style);
6389   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6390                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6391                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6392                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6393                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6394                Style);
6395   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6396                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6397                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6398                Style);
6399   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6400                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6401                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6402                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6403                Style);
6404   verifyFormat(
6405       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6406       "    aaaaaaaaaaaaaaa :\n"
6407       "    aaaaaaaaaaaaaaa;",
6408       Style);
6409   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6410                "          aaaaaaaaa ?\n"
6411                "      b :\n"
6412                "      c);",
6413                Style);
6414   verifyFormat("unsigned Indent =\n"
6415                "    format(TheLine.First,\n"
6416                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
6417                "               IndentForLevel[TheLine.Level] :\n"
6418                "               TheLine * 2,\n"
6419                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6420                Style);
6421   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6422                "                  aaaaaaaaaaaaaaa :\n"
6423                "                  bbbbbbbbbbbbbbb ? //\n"
6424                "                      ccccccccccccccc :\n"
6425                "                      ddddddddddddddd;",
6426                Style);
6427   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6428                "                  aaaaaaaaaaaaaaa :\n"
6429                "                  (bbbbbbbbbbbbbbb ? //\n"
6430                "                       ccccccccccccccc :\n"
6431                "                       ddddddddddddddd);",
6432                Style);
6433   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6434                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6435                "            ccccccccccccccccccccccccccc;",
6436                Style);
6437   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6438                "           aaaaa :\n"
6439                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
6440                Style);
6441 
6442   // Chained conditionals
6443   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6444                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6445                "                          3333333333333333;",
6446                Style);
6447   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6448                "       bbbbbbbbbb       ? 2222222222222222 :\n"
6449                "                          3333333333333333;",
6450                Style);
6451   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
6452                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6453                "                          3333333333333333;",
6454                Style);
6455   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6456                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
6457                "                          333333;",
6458                Style);
6459   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6460                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6461                "       cccccccccccccccc ? 3333333333333333 :\n"
6462                "                          4444444444444444;",
6463                Style);
6464   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6465                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6466                "                          3333333333333333;",
6467                Style);
6468   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6469                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6470                "                          (aaa ? bbb : ccc);",
6471                Style);
6472   verifyFormat(
6473       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6474       "                                               cccccccccccccccccc) :\n"
6475       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6476       "                          3333333333333333;",
6477       Style);
6478   verifyFormat(
6479       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6480       "                                               cccccccccccccccccc) :\n"
6481       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6482       "                          3333333333333333;",
6483       Style);
6484   verifyFormat(
6485       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6486       "                                               dddddddddddddddddd) :\n"
6487       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6488       "                          3333333333333333;",
6489       Style);
6490   verifyFormat(
6491       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6492       "                                               dddddddddddddddddd) :\n"
6493       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6494       "                          3333333333333333;",
6495       Style);
6496   verifyFormat(
6497       "return aaaaaaaaa        ? 1111111111111111 :\n"
6498       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6499       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6500       "                                               dddddddddddddddddd)\n",
6501       Style);
6502   verifyFormat(
6503       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6504       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6505       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6506       "                                               cccccccccccccccccc);",
6507       Style);
6508   verifyFormat(
6509       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6510       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6511       "                                               eeeeeeeeeeeeeeeeee) :\n"
6512       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6513       "                          3333333333333333;",
6514       Style);
6515   verifyFormat(
6516       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6517       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
6518       "                                               eeeeeeeeeeeeeeeeee) :\n"
6519       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6520       "                          3333333333333333;",
6521       Style);
6522   verifyFormat(
6523       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
6524       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6525       "                                               eeeeeeeeeeeeeeeeee) :\n"
6526       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6527       "                          3333333333333333;",
6528       Style);
6529   verifyFormat(
6530       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6531       "                                               cccccccccccccccccc :\n"
6532       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6533       "                          3333333333333333;",
6534       Style);
6535   verifyFormat(
6536       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6537       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
6538       "                                               eeeeeeeeeeeeeeeeee :\n"
6539       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6540       "                          3333333333333333;",
6541       Style);
6542   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6543                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6544                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
6545                "                                 eeeeeeeeeeeeeeeeee) :\n"
6546                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6547                "                               3333333333333333;",
6548                Style);
6549   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6550                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6551                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
6552                "                                  eeeeeeeeeeeeeeeeee :\n"
6553                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6554                "                               3333333333333333;",
6555                Style);
6556 }
6557 
6558 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6559   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6560                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6561   verifyFormat("bool a = true, b = false;");
6562 
6563   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6564                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6565                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6566                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6567   verifyFormat(
6568       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6569       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6570       "     d = e && f;");
6571   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6572                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6573   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6574                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6575   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6576                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6577 
6578   FormatStyle Style = getGoogleStyle();
6579   Style.PointerAlignment = FormatStyle::PAS_Left;
6580   Style.DerivePointerAlignment = false;
6581   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6582                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6583                "    *b = bbbbbbbbbbbbbbbbbbb;",
6584                Style);
6585   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6586                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6587                Style);
6588   verifyFormat("vector<int*> a, b;", Style);
6589   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6590 }
6591 
6592 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6593   verifyFormat("arr[foo ? bar : baz];");
6594   verifyFormat("f()[foo ? bar : baz];");
6595   verifyFormat("(a + b)[foo ? bar : baz];");
6596   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6597 }
6598 
6599 TEST_F(FormatTest, AlignsStringLiterals) {
6600   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6601                "                                      \"short literal\");");
6602   verifyFormat(
6603       "looooooooooooooooooooooooongFunction(\n"
6604       "    \"short literal\"\n"
6605       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6606   verifyFormat("someFunction(\"Always break between multi-line\"\n"
6607                "             \" string literals\",\n"
6608                "             and, other, parameters);");
6609   EXPECT_EQ("fun + \"1243\" /* comment */\n"
6610             "      \"5678\";",
6611             format("fun + \"1243\" /* comment */\n"
6612                    "    \"5678\";",
6613                    getLLVMStyleWithColumns(28)));
6614   EXPECT_EQ(
6615       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6616       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6617       "         \"aaaaaaaaaaaaaaaa\";",
6618       format("aaaaaa ="
6619              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6620              "aaaaaaaaaaaaaaaaaaaaa\" "
6621              "\"aaaaaaaaaaaaaaaa\";"));
6622   verifyFormat("a = a + \"a\"\n"
6623                "        \"a\"\n"
6624                "        \"a\";");
6625   verifyFormat("f(\"a\", \"b\"\n"
6626                "       \"c\");");
6627 
6628   verifyFormat(
6629       "#define LL_FORMAT \"ll\"\n"
6630       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6631       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6632 
6633   verifyFormat("#define A(X)          \\\n"
6634                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
6635                "  \"ccccc\"",
6636                getLLVMStyleWithColumns(23));
6637   verifyFormat("#define A \"def\"\n"
6638                "f(\"abc\" A \"ghi\"\n"
6639                "  \"jkl\");");
6640 
6641   verifyFormat("f(L\"a\"\n"
6642                "  L\"b\");");
6643   verifyFormat("#define A(X)            \\\n"
6644                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6645                "  L\"ccccc\"",
6646                getLLVMStyleWithColumns(25));
6647 
6648   verifyFormat("f(@\"a\"\n"
6649                "  @\"b\");");
6650   verifyFormat("NSString s = @\"a\"\n"
6651                "             @\"b\"\n"
6652                "             @\"c\";");
6653   verifyFormat("NSString s = @\"a\"\n"
6654                "              \"b\"\n"
6655                "              \"c\";");
6656 }
6657 
6658 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6659   FormatStyle Style = getLLVMStyle();
6660   // No declarations or definitions should be moved to own line.
6661   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6662   verifyFormat("class A {\n"
6663                "  int f() { return 1; }\n"
6664                "  int g();\n"
6665                "};\n"
6666                "int f() { return 1; }\n"
6667                "int g();\n",
6668                Style);
6669 
6670   // All declarations and definitions should have the return type moved to its
6671   // own
6672   // line.
6673   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6674   verifyFormat("class E {\n"
6675                "  int\n"
6676                "  f() {\n"
6677                "    return 1;\n"
6678                "  }\n"
6679                "  int\n"
6680                "  g();\n"
6681                "};\n"
6682                "int\n"
6683                "f() {\n"
6684                "  return 1;\n"
6685                "}\n"
6686                "int\n"
6687                "g();\n",
6688                Style);
6689 
6690   // Top-level definitions, and no kinds of declarations should have the
6691   // return type moved to its own line.
6692   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6693   verifyFormat("class B {\n"
6694                "  int f() { return 1; }\n"
6695                "  int g();\n"
6696                "};\n"
6697                "int\n"
6698                "f() {\n"
6699                "  return 1;\n"
6700                "}\n"
6701                "int g();\n",
6702                Style);
6703 
6704   // Top-level definitions and declarations should have the return type moved
6705   // to its own line.
6706   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6707   verifyFormat("class C {\n"
6708                "  int f() { return 1; }\n"
6709                "  int g();\n"
6710                "};\n"
6711                "int\n"
6712                "f() {\n"
6713                "  return 1;\n"
6714                "}\n"
6715                "int\n"
6716                "g();\n",
6717                Style);
6718 
6719   // All definitions should have the return type moved to its own line, but no
6720   // kinds of declarations.
6721   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6722   verifyFormat("class D {\n"
6723                "  int\n"
6724                "  f() {\n"
6725                "    return 1;\n"
6726                "  }\n"
6727                "  int g();\n"
6728                "};\n"
6729                "int\n"
6730                "f() {\n"
6731                "  return 1;\n"
6732                "}\n"
6733                "int g();\n",
6734                Style);
6735   verifyFormat("const char *\n"
6736                "f(void) {\n" // Break here.
6737                "  return \"\";\n"
6738                "}\n"
6739                "const char *bar(void);\n", // No break here.
6740                Style);
6741   verifyFormat("template <class T>\n"
6742                "T *\n"
6743                "f(T &c) {\n" // Break here.
6744                "  return NULL;\n"
6745                "}\n"
6746                "template <class T> T *f(T &c);\n", // No break here.
6747                Style);
6748   verifyFormat("class C {\n"
6749                "  int\n"
6750                "  operator+() {\n"
6751                "    return 1;\n"
6752                "  }\n"
6753                "  int\n"
6754                "  operator()() {\n"
6755                "    return 1;\n"
6756                "  }\n"
6757                "};\n",
6758                Style);
6759   verifyFormat("void\n"
6760                "A::operator()() {}\n"
6761                "void\n"
6762                "A::operator>>() {}\n"
6763                "void\n"
6764                "A::operator+() {}\n"
6765                "void\n"
6766                "A::operator*() {}\n"
6767                "void\n"
6768                "A::operator->() {}\n"
6769                "void\n"
6770                "A::operator void *() {}\n"
6771                "void\n"
6772                "A::operator void &() {}\n"
6773                "void\n"
6774                "A::operator void &&() {}\n"
6775                "void\n"
6776                "A::operator char *() {}\n"
6777                "void\n"
6778                "A::operator[]() {}\n"
6779                "void\n"
6780                "A::operator!() {}\n"
6781                "void\n"
6782                "A::operator**() {}\n"
6783                "void\n"
6784                "A::operator<Foo> *() {}\n"
6785                "void\n"
6786                "A::operator<Foo> **() {}\n"
6787                "void\n"
6788                "A::operator<Foo> &() {}\n"
6789                "void\n"
6790                "A::operator void **() {}\n",
6791                Style);
6792   verifyFormat("constexpr auto\n"
6793                "operator()() const -> reference {}\n"
6794                "constexpr auto\n"
6795                "operator>>() const -> reference {}\n"
6796                "constexpr auto\n"
6797                "operator+() const -> reference {}\n"
6798                "constexpr auto\n"
6799                "operator*() const -> reference {}\n"
6800                "constexpr auto\n"
6801                "operator->() const -> reference {}\n"
6802                "constexpr auto\n"
6803                "operator++() const -> reference {}\n"
6804                "constexpr auto\n"
6805                "operator void *() const -> reference {}\n"
6806                "constexpr auto\n"
6807                "operator void **() const -> reference {}\n"
6808                "constexpr auto\n"
6809                "operator void *() const -> reference {}\n"
6810                "constexpr auto\n"
6811                "operator void &() const -> reference {}\n"
6812                "constexpr auto\n"
6813                "operator void &&() const -> reference {}\n"
6814                "constexpr auto\n"
6815                "operator char *() const -> reference {}\n"
6816                "constexpr auto\n"
6817                "operator!() const -> reference {}\n"
6818                "constexpr auto\n"
6819                "operator[]() const -> reference {}\n",
6820                Style);
6821   verifyFormat("void *operator new(std::size_t s);", // No break here.
6822                Style);
6823   verifyFormat("void *\n"
6824                "operator new(std::size_t s) {}",
6825                Style);
6826   verifyFormat("void *\n"
6827                "operator delete[](void *ptr) {}",
6828                Style);
6829   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6830   verifyFormat("const char *\n"
6831                "f(void)\n" // Break here.
6832                "{\n"
6833                "  return \"\";\n"
6834                "}\n"
6835                "const char *bar(void);\n", // No break here.
6836                Style);
6837   verifyFormat("template <class T>\n"
6838                "T *\n"     // Problem here: no line break
6839                "f(T &c)\n" // Break here.
6840                "{\n"
6841                "  return NULL;\n"
6842                "}\n"
6843                "template <class T> T *f(T &c);\n", // No break here.
6844                Style);
6845   verifyFormat("int\n"
6846                "foo(A<bool> a)\n"
6847                "{\n"
6848                "  return a;\n"
6849                "}\n",
6850                Style);
6851   verifyFormat("int\n"
6852                "foo(A<8> a)\n"
6853                "{\n"
6854                "  return a;\n"
6855                "}\n",
6856                Style);
6857   verifyFormat("int\n"
6858                "foo(A<B<bool>, 8> a)\n"
6859                "{\n"
6860                "  return a;\n"
6861                "}\n",
6862                Style);
6863   verifyFormat("int\n"
6864                "foo(A<B<8>, bool> a)\n"
6865                "{\n"
6866                "  return a;\n"
6867                "}\n",
6868                Style);
6869   verifyFormat("int\n"
6870                "foo(A<B<bool>, bool> a)\n"
6871                "{\n"
6872                "  return a;\n"
6873                "}\n",
6874                Style);
6875   verifyFormat("int\n"
6876                "foo(A<B<8>, 8> a)\n"
6877                "{\n"
6878                "  return a;\n"
6879                "}\n",
6880                Style);
6881 
6882   Style = getGNUStyle();
6883 
6884   // Test for comments at the end of function declarations.
6885   verifyFormat("void\n"
6886                "foo (int a, /*abc*/ int b) // def\n"
6887                "{\n"
6888                "}\n",
6889                Style);
6890 
6891   verifyFormat("void\n"
6892                "foo (int a, /* abc */ int b) /* def */\n"
6893                "{\n"
6894                "}\n",
6895                Style);
6896 
6897   // Definitions that should not break after return type
6898   verifyFormat("void foo (int a, int b); // def\n", Style);
6899   verifyFormat("void foo (int a, int b); /* def */\n", Style);
6900   verifyFormat("void foo (int a, int b);\n", Style);
6901 }
6902 
6903 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
6904   FormatStyle NoBreak = getLLVMStyle();
6905   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
6906   FormatStyle Break = getLLVMStyle();
6907   Break.AlwaysBreakBeforeMultilineStrings = true;
6908   verifyFormat("aaaa = \"bbbb\"\n"
6909                "       \"cccc\";",
6910                NoBreak);
6911   verifyFormat("aaaa =\n"
6912                "    \"bbbb\"\n"
6913                "    \"cccc\";",
6914                Break);
6915   verifyFormat("aaaa(\"bbbb\"\n"
6916                "     \"cccc\");",
6917                NoBreak);
6918   verifyFormat("aaaa(\n"
6919                "    \"bbbb\"\n"
6920                "    \"cccc\");",
6921                Break);
6922   verifyFormat("aaaa(qqq, \"bbbb\"\n"
6923                "          \"cccc\");",
6924                NoBreak);
6925   verifyFormat("aaaa(qqq,\n"
6926                "     \"bbbb\"\n"
6927                "     \"cccc\");",
6928                Break);
6929   verifyFormat("aaaa(qqq,\n"
6930                "     L\"bbbb\"\n"
6931                "     L\"cccc\");",
6932                Break);
6933   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
6934                "                      \"bbbb\"));",
6935                Break);
6936   verifyFormat("string s = someFunction(\n"
6937                "    \"abc\"\n"
6938                "    \"abc\");",
6939                Break);
6940 
6941   // As we break before unary operators, breaking right after them is bad.
6942   verifyFormat("string foo = abc ? \"x\"\n"
6943                "                   \"blah blah blah blah blah blah\"\n"
6944                "                 : \"y\";",
6945                Break);
6946 
6947   // Don't break if there is no column gain.
6948   verifyFormat("f(\"aaaa\"\n"
6949                "  \"bbbb\");",
6950                Break);
6951 
6952   // Treat literals with escaped newlines like multi-line string literals.
6953   EXPECT_EQ("x = \"a\\\n"
6954             "b\\\n"
6955             "c\";",
6956             format("x = \"a\\\n"
6957                    "b\\\n"
6958                    "c\";",
6959                    NoBreak));
6960   EXPECT_EQ("xxxx =\n"
6961             "    \"a\\\n"
6962             "b\\\n"
6963             "c\";",
6964             format("xxxx = \"a\\\n"
6965                    "b\\\n"
6966                    "c\";",
6967                    Break));
6968 
6969   EXPECT_EQ("NSString *const kString =\n"
6970             "    @\"aaaa\"\n"
6971             "    @\"bbbb\";",
6972             format("NSString *const kString = @\"aaaa\"\n"
6973                    "@\"bbbb\";",
6974                    Break));
6975 
6976   Break.ColumnLimit = 0;
6977   verifyFormat("const char *hello = \"hello llvm\";", Break);
6978 }
6979 
6980 TEST_F(FormatTest, AlignsPipes) {
6981   verifyFormat(
6982       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6983       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6984       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6985   verifyFormat(
6986       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
6987       "                     << aaaaaaaaaaaaaaaaaaaa;");
6988   verifyFormat(
6989       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6990       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6991   verifyFormat(
6992       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
6993       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6994   verifyFormat(
6995       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
6996       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
6997       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
6998   verifyFormat(
6999       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7000       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7001       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7002   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7003                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7004                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7005                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7006   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
7007                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
7008   verifyFormat(
7009       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7010       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7011   verifyFormat(
7012       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
7013       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
7014 
7015   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
7016                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
7017   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7018                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7019                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
7020                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
7021   verifyFormat("LOG_IF(aaa == //\n"
7022                "       bbb)\n"
7023                "    << a << b;");
7024 
7025   // But sometimes, breaking before the first "<<" is desirable.
7026   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7027                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
7028   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
7029                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7030                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7031   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
7032                "    << BEF << IsTemplate << Description << E->getType();");
7033   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7034                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7035                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7036   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7037                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7038                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7039                "    << aaa;");
7040 
7041   verifyFormat(
7042       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7043       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7044 
7045   // Incomplete string literal.
7046   EXPECT_EQ("llvm::errs() << \"\n"
7047             "             << a;",
7048             format("llvm::errs() << \"\n<<a;"));
7049 
7050   verifyFormat("void f() {\n"
7051                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
7052                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
7053                "}");
7054 
7055   // Handle 'endl'.
7056   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
7057                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7058   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7059 
7060   // Handle '\n'.
7061   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
7062                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7063   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
7064                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
7065   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
7066                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
7067   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7068 }
7069 
7070 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
7071   verifyFormat("return out << \"somepacket = {\\n\"\n"
7072                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
7073                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
7074                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
7075                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
7076                "           << \"}\";");
7077 
7078   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7079                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7080                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7081   verifyFormat(
7082       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7083       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7084       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7085       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7086       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7087   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7088                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7089   verifyFormat(
7090       "void f() {\n"
7091       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7092       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7093       "}");
7094 
7095   // Breaking before the first "<<" is generally not desirable.
7096   verifyFormat(
7097       "llvm::errs()\n"
7098       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7099       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7100       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7101       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7102       getLLVMStyleWithColumns(70));
7103   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7104                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7105                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7106                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7107                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7108                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7109                getLLVMStyleWithColumns(70));
7110 
7111   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7112                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7113                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7114   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7115                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7116                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7117   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7118                "           (aaaa + aaaa);",
7119                getLLVMStyleWithColumns(40));
7120   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7121                "                  (aaaaaaa + aaaaa));",
7122                getLLVMStyleWithColumns(40));
7123   verifyFormat(
7124       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7125       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7126       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
7127 }
7128 
7129 TEST_F(FormatTest, UnderstandsEquals) {
7130   verifyFormat(
7131       "aaaaaaaaaaaaaaaaa =\n"
7132       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7133   verifyFormat(
7134       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7135       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7136   verifyFormat(
7137       "if (a) {\n"
7138       "  f();\n"
7139       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7140       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7141       "}");
7142 
7143   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7144                "        100000000 + 10000000) {\n}");
7145 }
7146 
7147 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7148   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7149                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
7150 
7151   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7152                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
7153 
7154   verifyFormat(
7155       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7156       "                                                          Parameter2);");
7157 
7158   verifyFormat(
7159       "ShortObject->shortFunction(\n"
7160       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7161       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7162 
7163   verifyFormat("loooooooooooooongFunction(\n"
7164                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
7165 
7166   verifyFormat(
7167       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7168       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7169 
7170   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7171                "    .WillRepeatedly(Return(SomeValue));");
7172   verifyFormat("void f() {\n"
7173                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7174                "      .Times(2)\n"
7175                "      .WillRepeatedly(Return(SomeValue));\n"
7176                "}");
7177   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7178                "    ccccccccccccccccccccccc);");
7179   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7180                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7181                "          .aaaaa(aaaaa),\n"
7182                "      aaaaaaaaaaaaaaaaaaaaa);");
7183   verifyFormat("void f() {\n"
7184                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7185                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7186                "}");
7187   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7188                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7189                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7190                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7191                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7192   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7193                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7194                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7195                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7196                "}");
7197 
7198   // Here, it is not necessary to wrap at "." or "->".
7199   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7200                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7201   verifyFormat(
7202       "aaaaaaaaaaa->aaaaaaaaa(\n"
7203       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7204       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7205 
7206   verifyFormat(
7207       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7208       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7209   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7210                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7211   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7212                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7213 
7214   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7215                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7216                "    .a();");
7217 
7218   FormatStyle NoBinPacking = getLLVMStyle();
7219   NoBinPacking.BinPackParameters = false;
7220   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7221                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7222                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7223                "                         aaaaaaaaaaaaaaaaaaa,\n"
7224                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7225                NoBinPacking);
7226 
7227   // If there is a subsequent call, change to hanging indentation.
7228   verifyFormat(
7229       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7230       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7231       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7232   verifyFormat(
7233       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7234       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7235   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7236                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7237                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7238   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7239                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7240                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7241 }
7242 
7243 TEST_F(FormatTest, WrapsTemplateDeclarations) {
7244   verifyFormat("template <typename T>\n"
7245                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7246   verifyFormat("template <typename T>\n"
7247                "// T should be one of {A, B}.\n"
7248                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7249   verifyFormat(
7250       "template <typename T>\n"
7251       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7252   verifyFormat("template <typename T>\n"
7253                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7254                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7255   verifyFormat(
7256       "template <typename T>\n"
7257       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7258       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
7259   verifyFormat(
7260       "template <typename T>\n"
7261       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7262       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7263       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7264   verifyFormat("template <typename T>\n"
7265                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7266                "    int aaaaaaaaaaaaaaaaaaaaaa);");
7267   verifyFormat(
7268       "template <typename T1, typename T2 = char, typename T3 = char,\n"
7269       "          typename T4 = char>\n"
7270       "void f();");
7271   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7272                "          template <typename> class cccccccccccccccccccccc,\n"
7273                "          typename ddddddddddddd>\n"
7274                "class C {};");
7275   verifyFormat(
7276       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7277       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7278 
7279   verifyFormat("void f() {\n"
7280                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7281                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7282                "}");
7283 
7284   verifyFormat("template <typename T> class C {};");
7285   verifyFormat("template <typename T> void f();");
7286   verifyFormat("template <typename T> void f() {}");
7287   verifyFormat(
7288       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7289       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7290       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7291       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7292       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7293       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7294       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
7295       getLLVMStyleWithColumns(72));
7296   EXPECT_EQ("static_cast<A< //\n"
7297             "    B> *>(\n"
7298             "\n"
7299             ");",
7300             format("static_cast<A<//\n"
7301                    "    B>*>(\n"
7302                    "\n"
7303                    "    );"));
7304   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7305                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7306 
7307   FormatStyle AlwaysBreak = getLLVMStyle();
7308   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7309   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7310   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7311   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7312   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7313                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7314                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
7315   verifyFormat("template <template <typename> class Fooooooo,\n"
7316                "          template <typename> class Baaaaaaar>\n"
7317                "struct C {};",
7318                AlwaysBreak);
7319   verifyFormat("template <typename T> // T can be A, B or C.\n"
7320                "struct C {};",
7321                AlwaysBreak);
7322   verifyFormat("template <enum E> class A {\n"
7323                "public:\n"
7324                "  E *f();\n"
7325                "};");
7326 
7327   FormatStyle NeverBreak = getLLVMStyle();
7328   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7329   verifyFormat("template <typename T> class C {};", NeverBreak);
7330   verifyFormat("template <typename T> void f();", NeverBreak);
7331   verifyFormat("template <typename T> void f() {}", NeverBreak);
7332   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7333                "bbbbbbbbbbbbbbbbbbbb) {}",
7334                NeverBreak);
7335   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7336                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7337                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
7338                NeverBreak);
7339   verifyFormat("template <template <typename> class Fooooooo,\n"
7340                "          template <typename> class Baaaaaaar>\n"
7341                "struct C {};",
7342                NeverBreak);
7343   verifyFormat("template <typename T> // T can be A, B or C.\n"
7344                "struct C {};",
7345                NeverBreak);
7346   verifyFormat("template <enum E> class A {\n"
7347                "public:\n"
7348                "  E *f();\n"
7349                "};",
7350                NeverBreak);
7351   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7352   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7353                "bbbbbbbbbbbbbbbbbbbb) {}",
7354                NeverBreak);
7355 }
7356 
7357 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7358   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7359   Style.ColumnLimit = 60;
7360   EXPECT_EQ("// Baseline - no comments.\n"
7361             "template <\n"
7362             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7363             "void f() {}",
7364             format("// Baseline - no comments.\n"
7365                    "template <\n"
7366                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7367                    "void f() {}",
7368                    Style));
7369 
7370   EXPECT_EQ("template <\n"
7371             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7372             "void f() {}",
7373             format("template <\n"
7374                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7375                    "void f() {}",
7376                    Style));
7377 
7378   EXPECT_EQ(
7379       "template <\n"
7380       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7381       "void f() {}",
7382       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
7383              "void f() {}",
7384              Style));
7385 
7386   EXPECT_EQ(
7387       "template <\n"
7388       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7389       "                                               // multiline\n"
7390       "void f() {}",
7391       format("template <\n"
7392              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7393              "                                              // multiline\n"
7394              "void f() {}",
7395              Style));
7396 
7397   EXPECT_EQ(
7398       "template <typename aaaaaaaaaa<\n"
7399       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
7400       "void f() {}",
7401       format(
7402           "template <\n"
7403           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7404           "void f() {}",
7405           Style));
7406 }
7407 
7408 TEST_F(FormatTest, WrapsTemplateParameters) {
7409   FormatStyle Style = getLLVMStyle();
7410   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7411   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7412   verifyFormat(
7413       "template <typename... a> struct q {};\n"
7414       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7415       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7416       "    y;",
7417       Style);
7418   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7419   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7420   verifyFormat(
7421       "template <typename... a> struct r {};\n"
7422       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7423       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7424       "    y;",
7425       Style);
7426   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7427   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7428   verifyFormat("template <typename... a> struct s {};\n"
7429                "extern s<\n"
7430                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7431                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7432                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7433                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7434                "    y;",
7435                Style);
7436   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7437   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7438   verifyFormat("template <typename... a> struct t {};\n"
7439                "extern t<\n"
7440                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7441                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7442                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7443                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7444                "    y;",
7445                Style);
7446 }
7447 
7448 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7449   verifyFormat(
7450       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7451       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7452   verifyFormat(
7453       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7454       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7455       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7456 
7457   // FIXME: Should we have the extra indent after the second break?
7458   verifyFormat(
7459       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7460       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7461       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7462 
7463   verifyFormat(
7464       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7465       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
7466 
7467   // Breaking at nested name specifiers is generally not desirable.
7468   verifyFormat(
7469       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7470       "    aaaaaaaaaaaaaaaaaaaaaaa);");
7471 
7472   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7473                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7474                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7475                "                   aaaaaaaaaaaaaaaaaaaaa);",
7476                getLLVMStyleWithColumns(74));
7477 
7478   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7479                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7480                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7481 }
7482 
7483 TEST_F(FormatTest, UnderstandsTemplateParameters) {
7484   verifyFormat("A<int> a;");
7485   verifyFormat("A<A<A<int>>> a;");
7486   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7487   verifyFormat("bool x = a < 1 || 2 > a;");
7488   verifyFormat("bool x = 5 < f<int>();");
7489   verifyFormat("bool x = f<int>() > 5;");
7490   verifyFormat("bool x = 5 < a<int>::x;");
7491   verifyFormat("bool x = a < 4 ? a > 2 : false;");
7492   verifyFormat("bool x = f() ? a < 2 : a > 2;");
7493 
7494   verifyGoogleFormat("A<A<int>> a;");
7495   verifyGoogleFormat("A<A<A<int>>> a;");
7496   verifyGoogleFormat("A<A<A<A<int>>>> a;");
7497   verifyGoogleFormat("A<A<int> > a;");
7498   verifyGoogleFormat("A<A<A<int> > > a;");
7499   verifyGoogleFormat("A<A<A<A<int> > > > a;");
7500   verifyGoogleFormat("A<::A<int>> a;");
7501   verifyGoogleFormat("A<::A> a;");
7502   verifyGoogleFormat("A< ::A> a;");
7503   verifyGoogleFormat("A< ::A<int> > a;");
7504   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7505   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7506   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7507   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7508   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7509             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7510 
7511   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7512 
7513   // template closer followed by a token that starts with > or =
7514   verifyFormat("bool b = a<1> > 1;");
7515   verifyFormat("bool b = a<1> >= 1;");
7516   verifyFormat("int i = a<1> >> 1;");
7517   FormatStyle Style = getLLVMStyle();
7518   Style.SpaceBeforeAssignmentOperators = false;
7519   verifyFormat("bool b= a<1> == 1;", Style);
7520   verifyFormat("a<int> = 1;", Style);
7521   verifyFormat("a<int> >>= 1;", Style);
7522 
7523   verifyFormat("test >> a >> b;");
7524   verifyFormat("test << a >> b;");
7525 
7526   verifyFormat("f<int>();");
7527   verifyFormat("template <typename T> void f() {}");
7528   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7529   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7530                "sizeof(char)>::type>;");
7531   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7532   verifyFormat("f(a.operator()<A>());");
7533   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7534                "      .template operator()<A>());",
7535                getLLVMStyleWithColumns(35));
7536 
7537   // Not template parameters.
7538   verifyFormat("return a < b && c > d;");
7539   verifyFormat("void f() {\n"
7540                "  while (a < b && c > d) {\n"
7541                "  }\n"
7542                "}");
7543   verifyFormat("template <typename... Types>\n"
7544                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7545 
7546   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7547                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7548                getLLVMStyleWithColumns(60));
7549   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7550   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7551   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7552 }
7553 
7554 TEST_F(FormatTest, BitshiftOperatorWidth) {
7555   EXPECT_EQ("int a = 1 << 2; /* foo\n"
7556             "                   bar */",
7557             format("int    a=1<<2;  /* foo\n"
7558                    "                   bar */"));
7559 
7560   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7561             "                     bar */",
7562             format("int  b  =256>>1 ;  /* foo\n"
7563                    "                      bar */"));
7564 }
7565 
7566 TEST_F(FormatTest, UnderstandsBinaryOperators) {
7567   verifyFormat("COMPARE(a, ==, b);");
7568   verifyFormat("auto s = sizeof...(Ts) - 1;");
7569 }
7570 
7571 TEST_F(FormatTest, UnderstandsPointersToMembers) {
7572   verifyFormat("int A::*x;");
7573   verifyFormat("int (S::*func)(void *);");
7574   verifyFormat("void f() { int (S::*func)(void *); }");
7575   verifyFormat("typedef bool *(Class::*Member)() const;");
7576   verifyFormat("void f() {\n"
7577                "  (a->*f)();\n"
7578                "  a->*x;\n"
7579                "  (a.*f)();\n"
7580                "  ((*a).*f)();\n"
7581                "  a.*x;\n"
7582                "}");
7583   verifyFormat("void f() {\n"
7584                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7585                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7586                "}");
7587   verifyFormat(
7588       "(aaaaaaaaaa->*bbbbbbb)(\n"
7589       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7590   FormatStyle Style = getLLVMStyle();
7591   Style.PointerAlignment = FormatStyle::PAS_Left;
7592   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7593 }
7594 
7595 TEST_F(FormatTest, UnderstandsUnaryOperators) {
7596   verifyFormat("int a = -2;");
7597   verifyFormat("f(-1, -2, -3);");
7598   verifyFormat("a[-1] = 5;");
7599   verifyFormat("int a = 5 + -2;");
7600   verifyFormat("if (i == -1) {\n}");
7601   verifyFormat("if (i != -1) {\n}");
7602   verifyFormat("if (i > -1) {\n}");
7603   verifyFormat("if (i < -1) {\n}");
7604   verifyFormat("++(a->f());");
7605   verifyFormat("--(a->f());");
7606   verifyFormat("(a->f())++;");
7607   verifyFormat("a[42]++;");
7608   verifyFormat("if (!(a->f())) {\n}");
7609   verifyFormat("if (!+i) {\n}");
7610   verifyFormat("~&a;");
7611 
7612   verifyFormat("a-- > b;");
7613   verifyFormat("b ? -a : c;");
7614   verifyFormat("n * sizeof char16;");
7615   verifyFormat("n * alignof char16;", getGoogleStyle());
7616   verifyFormat("sizeof(char);");
7617   verifyFormat("alignof(char);", getGoogleStyle());
7618 
7619   verifyFormat("return -1;");
7620   verifyFormat("throw -1;");
7621   verifyFormat("switch (a) {\n"
7622                "case -1:\n"
7623                "  break;\n"
7624                "}");
7625   verifyFormat("#define X -1");
7626   verifyFormat("#define X -kConstant");
7627 
7628   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7629   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7630 
7631   verifyFormat("int a = /* confusing comment */ -1;");
7632   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7633   verifyFormat("int a = i /* confusing comment */++;");
7634 
7635   verifyFormat("co_yield -1;");
7636   verifyFormat("co_return -1;");
7637 }
7638 
7639 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7640   verifyFormat("if (!aaaaaaaaaa( // break\n"
7641                "        aaaaa)) {\n"
7642                "}");
7643   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7644                "    aaaaa));");
7645   verifyFormat("*aaa = aaaaaaa( // break\n"
7646                "    bbbbbb);");
7647 }
7648 
7649 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7650   verifyFormat("bool operator<();");
7651   verifyFormat("bool operator>();");
7652   verifyFormat("bool operator=();");
7653   verifyFormat("bool operator==();");
7654   verifyFormat("bool operator!=();");
7655   verifyFormat("int operator+();");
7656   verifyFormat("int operator++();");
7657   verifyFormat("int operator++(int) volatile noexcept;");
7658   verifyFormat("bool operator,();");
7659   verifyFormat("bool operator();");
7660   verifyFormat("bool operator()();");
7661   verifyFormat("bool operator[]();");
7662   verifyFormat("operator bool();");
7663   verifyFormat("operator int();");
7664   verifyFormat("operator void *();");
7665   verifyFormat("operator SomeType<int>();");
7666   verifyFormat("operator SomeType<int, int>();");
7667   verifyFormat("operator SomeType<SomeType<int>>();");
7668   verifyFormat("void *operator new(std::size_t size);");
7669   verifyFormat("void *operator new[](std::size_t size);");
7670   verifyFormat("void operator delete(void *ptr);");
7671   verifyFormat("void operator delete[](void *ptr);");
7672   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7673                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7674   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7675                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7676 
7677   verifyFormat(
7678       "ostream &operator<<(ostream &OutputStream,\n"
7679       "                    SomeReallyLongType WithSomeReallyLongValue);");
7680   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7681                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7682                "  return left.group < right.group;\n"
7683                "}");
7684   verifyFormat("SomeType &operator=(const SomeType &S);");
7685   verifyFormat("f.template operator()<int>();");
7686 
7687   verifyGoogleFormat("operator void*();");
7688   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7689   verifyGoogleFormat("operator ::A();");
7690 
7691   verifyFormat("using A::operator+;");
7692   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7693                "int i;");
7694 }
7695 
7696 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7697   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7698   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7699   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7700   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7701   verifyFormat("Deleted &operator=(const Deleted &) &;");
7702   verifyFormat("Deleted &operator=(const Deleted &) &&;");
7703   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7704   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7705   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7706   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7707   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7708   verifyFormat("void Fn(T const &) const &;");
7709   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7710   verifyFormat("template <typename T>\n"
7711                "void F(T) && = delete;",
7712                getGoogleStyle());
7713 
7714   FormatStyle AlignLeft = getLLVMStyle();
7715   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7716   verifyFormat("void A::b() && {}", AlignLeft);
7717   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7718   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7719                AlignLeft);
7720   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7721   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7722   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7723   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7724   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7725   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7726   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7727   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7728 
7729   FormatStyle Spaces = getLLVMStyle();
7730   Spaces.SpacesInCStyleCastParentheses = true;
7731   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7732   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7733   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7734   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7735 
7736   Spaces.SpacesInCStyleCastParentheses = false;
7737   Spaces.SpacesInParentheses = true;
7738   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7739   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7740                Spaces);
7741   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7742   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7743 
7744   FormatStyle BreakTemplate = getLLVMStyle();
7745   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7746 
7747   verifyFormat("struct f {\n"
7748                "  template <class T>\n"
7749                "  int &foo(const std::string &str) &noexcept {}\n"
7750                "};",
7751                BreakTemplate);
7752 
7753   verifyFormat("struct f {\n"
7754                "  template <class T>\n"
7755                "  int &foo(const std::string &str) &&noexcept {}\n"
7756                "};",
7757                BreakTemplate);
7758 
7759   verifyFormat("struct f {\n"
7760                "  template <class T>\n"
7761                "  int &foo(const std::string &str) const &noexcept {}\n"
7762                "};",
7763                BreakTemplate);
7764 
7765   verifyFormat("struct f {\n"
7766                "  template <class T>\n"
7767                "  int &foo(const std::string &str) const &noexcept {}\n"
7768                "};",
7769                BreakTemplate);
7770 
7771   verifyFormat("struct f {\n"
7772                "  template <class T>\n"
7773                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
7774                "};",
7775                BreakTemplate);
7776 
7777   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7778   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7779       FormatStyle::BTDS_Yes;
7780   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7781 
7782   verifyFormat("struct f {\n"
7783                "  template <class T>\n"
7784                "  int& foo(const std::string& str) & noexcept {}\n"
7785                "};",
7786                AlignLeftBreakTemplate);
7787 
7788   verifyFormat("struct f {\n"
7789                "  template <class T>\n"
7790                "  int& foo(const std::string& str) && noexcept {}\n"
7791                "};",
7792                AlignLeftBreakTemplate);
7793 
7794   verifyFormat("struct f {\n"
7795                "  template <class T>\n"
7796                "  int& foo(const std::string& str) const& noexcept {}\n"
7797                "};",
7798                AlignLeftBreakTemplate);
7799 
7800   verifyFormat("struct f {\n"
7801                "  template <class T>\n"
7802                "  int& foo(const std::string& str) const&& noexcept {}\n"
7803                "};",
7804                AlignLeftBreakTemplate);
7805 
7806   verifyFormat("struct f {\n"
7807                "  template <class T>\n"
7808                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7809                "};",
7810                AlignLeftBreakTemplate);
7811 
7812   // The `&` in `Type&` should not be confused with a trailing `&` of
7813   // DEPRECATED(reason) member function.
7814   verifyFormat("struct f {\n"
7815                "  template <class T>\n"
7816                "  DEPRECATED(reason)\n"
7817                "  Type &foo(arguments) {}\n"
7818                "};",
7819                BreakTemplate);
7820 
7821   verifyFormat("struct f {\n"
7822                "  template <class T>\n"
7823                "  DEPRECATED(reason)\n"
7824                "  Type& foo(arguments) {}\n"
7825                "};",
7826                AlignLeftBreakTemplate);
7827 
7828   verifyFormat("void (*foopt)(int) = &func;");
7829 }
7830 
7831 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7832   verifyFormat("void f() {\n"
7833                "  A *a = new A;\n"
7834                "  A *a = new (placement) A;\n"
7835                "  delete a;\n"
7836                "  delete (A *)a;\n"
7837                "}");
7838   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7839                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7840   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7841                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7842                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7843   verifyFormat("delete[] h->p;");
7844 }
7845 
7846 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
7847   verifyFormat("int *f(int *a) {}");
7848   verifyFormat("int main(int argc, char **argv) {}");
7849   verifyFormat("Test::Test(int b) : a(b * b) {}");
7850   verifyIndependentOfContext("f(a, *a);");
7851   verifyFormat("void g() { f(*a); }");
7852   verifyIndependentOfContext("int a = b * 10;");
7853   verifyIndependentOfContext("int a = 10 * b;");
7854   verifyIndependentOfContext("int a = b * c;");
7855   verifyIndependentOfContext("int a += b * c;");
7856   verifyIndependentOfContext("int a -= b * c;");
7857   verifyIndependentOfContext("int a *= b * c;");
7858   verifyIndependentOfContext("int a /= b * c;");
7859   verifyIndependentOfContext("int a = *b;");
7860   verifyIndependentOfContext("int a = *b * c;");
7861   verifyIndependentOfContext("int a = b * *c;");
7862   verifyIndependentOfContext("int a = b * (10);");
7863   verifyIndependentOfContext("S << b * (10);");
7864   verifyIndependentOfContext("return 10 * b;");
7865   verifyIndependentOfContext("return *b * *c;");
7866   verifyIndependentOfContext("return a & ~b;");
7867   verifyIndependentOfContext("f(b ? *c : *d);");
7868   verifyIndependentOfContext("int a = b ? *c : *d;");
7869   verifyIndependentOfContext("*b = a;");
7870   verifyIndependentOfContext("a * ~b;");
7871   verifyIndependentOfContext("a * !b;");
7872   verifyIndependentOfContext("a * +b;");
7873   verifyIndependentOfContext("a * -b;");
7874   verifyIndependentOfContext("a * ++b;");
7875   verifyIndependentOfContext("a * --b;");
7876   verifyIndependentOfContext("a[4] * b;");
7877   verifyIndependentOfContext("a[a * a] = 1;");
7878   verifyIndependentOfContext("f() * b;");
7879   verifyIndependentOfContext("a * [self dostuff];");
7880   verifyIndependentOfContext("int x = a * (a + b);");
7881   verifyIndependentOfContext("(a *)(a + b);");
7882   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
7883   verifyIndependentOfContext("int *pa = (int *)&a;");
7884   verifyIndependentOfContext("return sizeof(int **);");
7885   verifyIndependentOfContext("return sizeof(int ******);");
7886   verifyIndependentOfContext("return (int **&)a;");
7887   verifyIndependentOfContext("f((*PointerToArray)[10]);");
7888   verifyFormat("void f(Type (*parameter)[10]) {}");
7889   verifyFormat("void f(Type (&parameter)[10]) {}");
7890   verifyGoogleFormat("return sizeof(int**);");
7891   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
7892   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
7893   verifyFormat("auto a = [](int **&, int ***) {};");
7894   verifyFormat("auto PointerBinding = [](const char *S) {};");
7895   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
7896   verifyFormat("[](const decltype(*a) &value) {}");
7897   verifyFormat("decltype(a * b) F();");
7898   verifyFormat("#define MACRO() [](A *a) { return 1; }");
7899   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
7900   verifyIndependentOfContext("typedef void (*f)(int *a);");
7901   verifyIndependentOfContext("int i{a * b};");
7902   verifyIndependentOfContext("aaa && aaa->f();");
7903   verifyIndependentOfContext("int x = ~*p;");
7904   verifyFormat("Constructor() : a(a), area(width * height) {}");
7905   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
7906   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
7907   verifyFormat("void f() { f(a, c * d); }");
7908   verifyFormat("void f() { f(new a(), c * d); }");
7909   verifyFormat("void f(const MyOverride &override);");
7910   verifyFormat("void f(const MyFinal &final);");
7911   verifyIndependentOfContext("bool a = f() && override.f();");
7912   verifyIndependentOfContext("bool a = f() && final.f();");
7913 
7914   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
7915 
7916   verifyIndependentOfContext("A<int *> a;");
7917   verifyIndependentOfContext("A<int **> a;");
7918   verifyIndependentOfContext("A<int *, int *> a;");
7919   verifyIndependentOfContext("A<int *[]> a;");
7920   verifyIndependentOfContext(
7921       "const char *const p = reinterpret_cast<const char *const>(q);");
7922   verifyIndependentOfContext("A<int **, int **> a;");
7923   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
7924   verifyFormat("for (char **a = b; *a; ++a) {\n}");
7925   verifyFormat("for (; a && b;) {\n}");
7926   verifyFormat("bool foo = true && [] { return false; }();");
7927 
7928   verifyFormat(
7929       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7930       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7931 
7932   verifyGoogleFormat("int const* a = &b;");
7933   verifyGoogleFormat("**outparam = 1;");
7934   verifyGoogleFormat("*outparam = a * b;");
7935   verifyGoogleFormat("int main(int argc, char** argv) {}");
7936   verifyGoogleFormat("A<int*> a;");
7937   verifyGoogleFormat("A<int**> a;");
7938   verifyGoogleFormat("A<int*, int*> a;");
7939   verifyGoogleFormat("A<int**, int**> a;");
7940   verifyGoogleFormat("f(b ? *c : *d);");
7941   verifyGoogleFormat("int a = b ? *c : *d;");
7942   verifyGoogleFormat("Type* t = **x;");
7943   verifyGoogleFormat("Type* t = *++*x;");
7944   verifyGoogleFormat("*++*x;");
7945   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
7946   verifyGoogleFormat("Type* t = x++ * y;");
7947   verifyGoogleFormat(
7948       "const char* const p = reinterpret_cast<const char* const>(q);");
7949   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
7950   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
7951   verifyGoogleFormat("template <typename T>\n"
7952                      "void f(int i = 0, SomeType** temps = NULL);");
7953 
7954   FormatStyle Left = getLLVMStyle();
7955   Left.PointerAlignment = FormatStyle::PAS_Left;
7956   verifyFormat("x = *a(x) = *a(y);", Left);
7957   verifyFormat("for (;; *a = b) {\n}", Left);
7958   verifyFormat("return *this += 1;", Left);
7959   verifyFormat("throw *x;", Left);
7960   verifyFormat("delete *x;", Left);
7961   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
7962   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
7963   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
7964   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
7965   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
7966   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
7967 
7968   verifyIndependentOfContext("a = *(x + y);");
7969   verifyIndependentOfContext("a = &(x + y);");
7970   verifyIndependentOfContext("*(x + y).call();");
7971   verifyIndependentOfContext("&(x + y)->call();");
7972   verifyFormat("void f() { &(*I).first; }");
7973 
7974   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
7975   verifyFormat(
7976       "int *MyValues = {\n"
7977       "    *A, // Operator detection might be confused by the '{'\n"
7978       "    *BB // Operator detection might be confused by previous comment\n"
7979       "};");
7980 
7981   verifyIndependentOfContext("if (int *a = &b)");
7982   verifyIndependentOfContext("if (int &a = *b)");
7983   verifyIndependentOfContext("if (a & b[i])");
7984   verifyIndependentOfContext("if constexpr (a & b[i])");
7985   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
7986   verifyIndependentOfContext("if (a * (b * c))");
7987   verifyIndependentOfContext("if constexpr (a * (b * c))");
7988   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
7989   verifyIndependentOfContext("if (a::b::c::d & b[i])");
7990   verifyIndependentOfContext("if (*b[i])");
7991   verifyIndependentOfContext("if (int *a = (&b))");
7992   verifyIndependentOfContext("while (int *a = &b)");
7993   verifyIndependentOfContext("while (a * (b * c))");
7994   verifyIndependentOfContext("size = sizeof *a;");
7995   verifyIndependentOfContext("if (a && (b = c))");
7996   verifyFormat("void f() {\n"
7997                "  for (const int &v : Values) {\n"
7998                "  }\n"
7999                "}");
8000   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
8001   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
8002   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
8003 
8004   verifyFormat("#define A (!a * b)");
8005   verifyFormat("#define MACRO     \\\n"
8006                "  int *i = a * b; \\\n"
8007                "  void f(a *b);",
8008                getLLVMStyleWithColumns(19));
8009 
8010   verifyIndependentOfContext("A = new SomeType *[Length];");
8011   verifyIndependentOfContext("A = new SomeType *[Length]();");
8012   verifyIndependentOfContext("T **t = new T *;");
8013   verifyIndependentOfContext("T **t = new T *();");
8014   verifyGoogleFormat("A = new SomeType*[Length]();");
8015   verifyGoogleFormat("A = new SomeType*[Length];");
8016   verifyGoogleFormat("T** t = new T*;");
8017   verifyGoogleFormat("T** t = new T*();");
8018 
8019   verifyFormat("STATIC_ASSERT((a & b) == 0);");
8020   verifyFormat("STATIC_ASSERT(0 == (a & b));");
8021   verifyFormat("template <bool a, bool b> "
8022                "typename t::if<x && y>::type f() {}");
8023   verifyFormat("template <int *y> f() {}");
8024   verifyFormat("vector<int *> v;");
8025   verifyFormat("vector<int *const> v;");
8026   verifyFormat("vector<int *const **const *> v;");
8027   verifyFormat("vector<int *volatile> v;");
8028   verifyFormat("vector<a * b> v;");
8029   verifyFormat("foo<b && false>();");
8030   verifyFormat("foo<b & 1>();");
8031   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
8032   verifyFormat(
8033       "template <class T, class = typename std::enable_if<\n"
8034       "                       std::is_integral<T>::value &&\n"
8035       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
8036       "void F();",
8037       getLLVMStyleWithColumns(70));
8038   verifyFormat("template <class T,\n"
8039                "          class = typename std::enable_if<\n"
8040                "              std::is_integral<T>::value &&\n"
8041                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
8042                "          class U>\n"
8043                "void F();",
8044                getLLVMStyleWithColumns(70));
8045   verifyFormat(
8046       "template <class T,\n"
8047       "          class = typename ::std::enable_if<\n"
8048       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
8049       "void F();",
8050       getGoogleStyleWithColumns(68));
8051 
8052   verifyIndependentOfContext("MACRO(int *i);");
8053   verifyIndependentOfContext("MACRO(auto *a);");
8054   verifyIndependentOfContext("MACRO(const A *a);");
8055   verifyIndependentOfContext("MACRO(A *const a);");
8056   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
8057   verifyFormat("void f() { f(float{1}, a * a); }");
8058   // FIXME: Is there a way to make this work?
8059   // verifyIndependentOfContext("MACRO(A *a);");
8060 
8061   verifyFormat("DatumHandle const *operator->() const { return input_; }");
8062   verifyFormat("return options != nullptr && operator==(*options);");
8063 
8064   EXPECT_EQ("#define OP(x)                                    \\\n"
8065             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
8066             "    return s << a.DebugString();                 \\\n"
8067             "  }",
8068             format("#define OP(x) \\\n"
8069                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
8070                    "    return s << a.DebugString(); \\\n"
8071                    "  }",
8072                    getLLVMStyleWithColumns(50)));
8073 
8074   // FIXME: We cannot handle this case yet; we might be able to figure out that
8075   // foo<x> d > v; doesn't make sense.
8076   verifyFormat("foo<a<b && c> d> v;");
8077 
8078   FormatStyle PointerMiddle = getLLVMStyle();
8079   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8080   verifyFormat("delete *x;", PointerMiddle);
8081   verifyFormat("int * x;", PointerMiddle);
8082   verifyFormat("int *[] x;", PointerMiddle);
8083   verifyFormat("template <int * y> f() {}", PointerMiddle);
8084   verifyFormat("int * f(int * a) {}", PointerMiddle);
8085   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8086   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8087   verifyFormat("A<int *> a;", PointerMiddle);
8088   verifyFormat("A<int **> a;", PointerMiddle);
8089   verifyFormat("A<int *, int *> a;", PointerMiddle);
8090   verifyFormat("A<int *[]> a;", PointerMiddle);
8091   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8092   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8093   verifyFormat("T ** t = new T *;", PointerMiddle);
8094 
8095   // Member function reference qualifiers aren't binary operators.
8096   verifyFormat("string // break\n"
8097                "operator()() & {}");
8098   verifyFormat("string // break\n"
8099                "operator()() && {}");
8100   verifyGoogleFormat("template <typename T>\n"
8101                      "auto x() & -> int {}");
8102 }
8103 
8104 TEST_F(FormatTest, UnderstandsAttributes) {
8105   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8106   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8107                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8108   FormatStyle AfterType = getLLVMStyle();
8109   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
8110   verifyFormat("__attribute__((nodebug)) void\n"
8111                "foo() {}\n",
8112                AfterType);
8113 }
8114 
8115 TEST_F(FormatTest, UnderstandsSquareAttributes) {
8116   verifyFormat("SomeType s [[unused]] (InitValue);");
8117   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8118   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8119   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8120   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8121   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8122                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8123   verifyFormat("[[nodiscard]] bool f() { return false; }");
8124   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
8125   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
8126   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
8127 
8128   // Make sure we do not mistake attributes for array subscripts.
8129   verifyFormat("int a() {}\n"
8130                "[[unused]] int b() {}\n");
8131   verifyFormat("NSArray *arr;\n"
8132                "arr[[Foo() bar]];");
8133 
8134   // On the other hand, we still need to correctly find array subscripts.
8135   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8136 
8137   // Make sure that we do not mistake Objective-C method inside array literals
8138   // as attributes, even if those method names are also keywords.
8139   verifyFormat("@[ [foo bar] ];");
8140   verifyFormat("@[ [NSArray class] ];");
8141   verifyFormat("@[ [foo enum] ];");
8142 
8143   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8144 
8145   // Make sure we do not parse attributes as lambda introducers.
8146   FormatStyle MultiLineFunctions = getLLVMStyle();
8147   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8148   verifyFormat("[[unused]] int b() {\n"
8149                "  return 42;\n"
8150                "}\n",
8151                MultiLineFunctions);
8152 }
8153 
8154 TEST_F(FormatTest, AttributeClass) {
8155   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8156   verifyFormat("class S {\n"
8157                "  S(S&&) = default;\n"
8158                "};",
8159                Style);
8160   verifyFormat("class [[nodiscard]] S {\n"
8161                "  S(S&&) = default;\n"
8162                "};",
8163                Style);
8164   verifyFormat("class __attribute((maybeunused)) S {\n"
8165                "  S(S&&) = default;\n"
8166                "};",
8167                Style);
8168   verifyFormat("struct S {\n"
8169                "  S(S&&) = default;\n"
8170                "};",
8171                Style);
8172   verifyFormat("struct [[nodiscard]] S {\n"
8173                "  S(S&&) = default;\n"
8174                "};",
8175                Style);
8176 }
8177 
8178 TEST_F(FormatTest, AttributesAfterMacro) {
8179   FormatStyle Style = getLLVMStyle();
8180   verifyFormat("MACRO;\n"
8181                "__attribute__((maybe_unused)) int foo() {\n"
8182                "  //...\n"
8183                "}");
8184 
8185   verifyFormat("MACRO;\n"
8186                "[[nodiscard]] int foo() {\n"
8187                "  //...\n"
8188                "}");
8189 
8190   EXPECT_EQ("MACRO\n\n"
8191             "__attribute__((maybe_unused)) int foo() {\n"
8192             "  //...\n"
8193             "}",
8194             format("MACRO\n\n"
8195                    "__attribute__((maybe_unused)) int foo() {\n"
8196                    "  //...\n"
8197                    "}"));
8198 
8199   EXPECT_EQ("MACRO\n\n"
8200             "[[nodiscard]] int foo() {\n"
8201             "  //...\n"
8202             "}",
8203             format("MACRO\n\n"
8204                    "[[nodiscard]] int foo() {\n"
8205                    "  //...\n"
8206                    "}"));
8207 }
8208 
8209 TEST_F(FormatTest, AttributePenaltyBreaking) {
8210   FormatStyle Style = getLLVMStyle();
8211   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8212                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8213                Style);
8214   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8215                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8216                Style);
8217   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8218                "shared_ptr<ALongTypeName> &C d) {\n}",
8219                Style);
8220 }
8221 
8222 TEST_F(FormatTest, UnderstandsEllipsis) {
8223   FormatStyle Style = getLLVMStyle();
8224   verifyFormat("int printf(const char *fmt, ...);");
8225   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8226   verifyFormat("template <class... Ts> void Foo(Ts *...ts) {}");
8227 
8228   verifyFormat("template <int *...PP> a;", Style);
8229 
8230   Style.PointerAlignment = FormatStyle::PAS_Left;
8231   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", Style);
8232 
8233   verifyFormat("template <int*... PP> a;", Style);
8234 
8235   Style.PointerAlignment = FormatStyle::PAS_Middle;
8236   verifyFormat("template <int *... PP> a;", Style);
8237 }
8238 
8239 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8240   EXPECT_EQ("int *a;\n"
8241             "int *a;\n"
8242             "int *a;",
8243             format("int *a;\n"
8244                    "int* a;\n"
8245                    "int *a;",
8246                    getGoogleStyle()));
8247   EXPECT_EQ("int* a;\n"
8248             "int* a;\n"
8249             "int* a;",
8250             format("int* a;\n"
8251                    "int* a;\n"
8252                    "int *a;",
8253                    getGoogleStyle()));
8254   EXPECT_EQ("int *a;\n"
8255             "int *a;\n"
8256             "int *a;",
8257             format("int *a;\n"
8258                    "int * a;\n"
8259                    "int *  a;",
8260                    getGoogleStyle()));
8261   EXPECT_EQ("auto x = [] {\n"
8262             "  int *a;\n"
8263             "  int *a;\n"
8264             "  int *a;\n"
8265             "};",
8266             format("auto x=[]{int *a;\n"
8267                    "int * a;\n"
8268                    "int *  a;};",
8269                    getGoogleStyle()));
8270 }
8271 
8272 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8273   verifyFormat("int f(int &&a) {}");
8274   verifyFormat("int f(int a, char &&b) {}");
8275   verifyFormat("void f() { int &&a = b; }");
8276   verifyGoogleFormat("int f(int a, char&& b) {}");
8277   verifyGoogleFormat("void f() { int&& a = b; }");
8278 
8279   verifyIndependentOfContext("A<int &&> a;");
8280   verifyIndependentOfContext("A<int &&, int &&> a;");
8281   verifyGoogleFormat("A<int&&> a;");
8282   verifyGoogleFormat("A<int&&, int&&> a;");
8283 
8284   // Not rvalue references:
8285   verifyFormat("template <bool B, bool C> class A {\n"
8286                "  static_assert(B && C, \"Something is wrong\");\n"
8287                "};");
8288   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8289   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8290   verifyFormat("#define A(a, b) (a && b)");
8291 }
8292 
8293 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8294   verifyFormat("void f() {\n"
8295                "  x[aaaaaaaaa -\n"
8296                "    b] = 23;\n"
8297                "}",
8298                getLLVMStyleWithColumns(15));
8299 }
8300 
8301 TEST_F(FormatTest, FormatsCasts) {
8302   verifyFormat("Type *A = static_cast<Type *>(P);");
8303   verifyFormat("Type *A = (Type *)P;");
8304   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8305   verifyFormat("int a = (int)(2.0f);");
8306   verifyFormat("int a = (int)2.0f;");
8307   verifyFormat("x[(int32)y];");
8308   verifyFormat("x = (int32)y;");
8309   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8310   verifyFormat("int a = (int)*b;");
8311   verifyFormat("int a = (int)2.0f;");
8312   verifyFormat("int a = (int)~0;");
8313   verifyFormat("int a = (int)++a;");
8314   verifyFormat("int a = (int)sizeof(int);");
8315   verifyFormat("int a = (int)+2;");
8316   verifyFormat("my_int a = (my_int)2.0f;");
8317   verifyFormat("my_int a = (my_int)sizeof(int);");
8318   verifyFormat("return (my_int)aaa;");
8319   verifyFormat("#define x ((int)-1)");
8320   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8321   verifyFormat("#define p(q) ((int *)&q)");
8322   verifyFormat("fn(a)(b) + 1;");
8323 
8324   verifyFormat("void f() { my_int a = (my_int)*b; }");
8325   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8326   verifyFormat("my_int a = (my_int)~0;");
8327   verifyFormat("my_int a = (my_int)++a;");
8328   verifyFormat("my_int a = (my_int)-2;");
8329   verifyFormat("my_int a = (my_int)1;");
8330   verifyFormat("my_int a = (my_int *)1;");
8331   verifyFormat("my_int a = (const my_int)-1;");
8332   verifyFormat("my_int a = (const my_int *)-1;");
8333   verifyFormat("my_int a = (my_int)(my_int)-1;");
8334   verifyFormat("my_int a = (ns::my_int)-2;");
8335   verifyFormat("case (my_int)ONE:");
8336   verifyFormat("auto x = (X)this;");
8337   // Casts in Obj-C style calls used to not be recognized as such.
8338   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8339 
8340   // FIXME: single value wrapped with paren will be treated as cast.
8341   verifyFormat("void f(int i = (kValue)*kMask) {}");
8342 
8343   verifyFormat("{ (void)F; }");
8344 
8345   // Don't break after a cast's
8346   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8347                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8348                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8349 
8350   // These are not casts.
8351   verifyFormat("void f(int *) {}");
8352   verifyFormat("f(foo)->b;");
8353   verifyFormat("f(foo).b;");
8354   verifyFormat("f(foo)(b);");
8355   verifyFormat("f(foo)[b];");
8356   verifyFormat("[](foo) { return 4; }(bar);");
8357   verifyFormat("(*funptr)(foo)[4];");
8358   verifyFormat("funptrs[4](foo)[4];");
8359   verifyFormat("void f(int *);");
8360   verifyFormat("void f(int *) = 0;");
8361   verifyFormat("void f(SmallVector<int>) {}");
8362   verifyFormat("void f(SmallVector<int>);");
8363   verifyFormat("void f(SmallVector<int>) = 0;");
8364   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8365   verifyFormat("int a = sizeof(int) * b;");
8366   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8367   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8368   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8369   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8370 
8371   // These are not casts, but at some point were confused with casts.
8372   verifyFormat("virtual void foo(int *) override;");
8373   verifyFormat("virtual void foo(char &) const;");
8374   verifyFormat("virtual void foo(int *a, char *) const;");
8375   verifyFormat("int a = sizeof(int *) + b;");
8376   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8377   verifyFormat("bool b = f(g<int>) && c;");
8378   verifyFormat("typedef void (*f)(int i) func;");
8379   verifyFormat("void operator++(int) noexcept;");
8380   verifyFormat("void operator++(int &) noexcept;");
8381   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8382                "&) noexcept;");
8383   verifyFormat(
8384       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8385   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8386   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8387   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8388   verifyFormat("void operator delete(foo &) noexcept;");
8389   verifyFormat("void operator delete(foo) noexcept;");
8390   verifyFormat("void operator delete(int) noexcept;");
8391   verifyFormat("void operator delete(int &) noexcept;");
8392   verifyFormat("void operator delete(int &) volatile noexcept;");
8393   verifyFormat("void operator delete(int &) const");
8394   verifyFormat("void operator delete(int &) = default");
8395   verifyFormat("void operator delete(int &) = delete");
8396   verifyFormat("void operator delete(int &) [[noreturn]]");
8397   verifyFormat("void operator delete(int &) throw();");
8398   verifyFormat("void operator delete(int &) throw(int);");
8399   verifyFormat("auto operator delete(int &) -> int;");
8400   verifyFormat("auto operator delete(int &) override");
8401   verifyFormat("auto operator delete(int &) final");
8402 
8403   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8404                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8405   // FIXME: The indentation here is not ideal.
8406   verifyFormat(
8407       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8408       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8409       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8410 }
8411 
8412 TEST_F(FormatTest, FormatsFunctionTypes) {
8413   verifyFormat("A<bool()> a;");
8414   verifyFormat("A<SomeType()> a;");
8415   verifyFormat("A<void (*)(int, std::string)> a;");
8416   verifyFormat("A<void *(int)>;");
8417   verifyFormat("void *(*a)(int *, SomeType *);");
8418   verifyFormat("int (*func)(void *);");
8419   verifyFormat("void f() { int (*func)(void *); }");
8420   verifyFormat("template <class CallbackClass>\n"
8421                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8422 
8423   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8424   verifyGoogleFormat("void* (*a)(int);");
8425   verifyGoogleFormat(
8426       "template <class CallbackClass>\n"
8427       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8428 
8429   // Other constructs can look somewhat like function types:
8430   verifyFormat("A<sizeof(*x)> a;");
8431   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8432   verifyFormat("some_var = function(*some_pointer_var)[0];");
8433   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8434   verifyFormat("int x = f(&h)();");
8435   verifyFormat("returnsFunction(&param1, &param2)(param);");
8436   verifyFormat("std::function<\n"
8437                "    LooooooooooongTemplatedType<\n"
8438                "        SomeType>*(\n"
8439                "        LooooooooooooooooongType type)>\n"
8440                "    function;",
8441                getGoogleStyleWithColumns(40));
8442 }
8443 
8444 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8445   verifyFormat("A (*foo_)[6];");
8446   verifyFormat("vector<int> (*foo_)[6];");
8447 }
8448 
8449 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8450   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8451                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8452   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8453                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8454   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8455                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8456 
8457   // Different ways of ()-initializiation.
8458   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8459                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8460   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8461                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8462   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8463                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8464   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8465                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8466 
8467   // Lambdas should not confuse the variable declaration heuristic.
8468   verifyFormat("LooooooooooooooooongType\n"
8469                "    variable(nullptr, [](A *a) {});",
8470                getLLVMStyleWithColumns(40));
8471 }
8472 
8473 TEST_F(FormatTest, BreaksLongDeclarations) {
8474   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8475                "    AnotherNameForTheLongType;");
8476   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8477                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8478   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8479                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8480   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8481                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8482   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8483                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8484   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8485                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8486   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8487                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8488   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8489                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8490   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8491                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8492   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8493                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8494   FormatStyle Indented = getLLVMStyle();
8495   Indented.IndentWrappedFunctionNames = true;
8496   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8497                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8498                Indented);
8499   verifyFormat(
8500       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8501       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8502       Indented);
8503   verifyFormat(
8504       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8505       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8506       Indented);
8507   verifyFormat(
8508       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8509       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8510       Indented);
8511 
8512   // FIXME: Without the comment, this breaks after "(".
8513   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8514                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8515                getGoogleStyle());
8516 
8517   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8518                "                  int LoooooooooooooooooooongParam2) {}");
8519   verifyFormat(
8520       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8521       "                                   SourceLocation L, IdentifierIn *II,\n"
8522       "                                   Type *T) {}");
8523   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8524                "ReallyReaaallyLongFunctionName(\n"
8525                "    const std::string &SomeParameter,\n"
8526                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8527                "        &ReallyReallyLongParameterName,\n"
8528                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8529                "        &AnotherLongParameterName) {}");
8530   verifyFormat("template <typename A>\n"
8531                "SomeLoooooooooooooooooooooongType<\n"
8532                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8533                "Function() {}");
8534 
8535   verifyGoogleFormat(
8536       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8537       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8538   verifyGoogleFormat(
8539       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8540       "                                   SourceLocation L) {}");
8541   verifyGoogleFormat(
8542       "some_namespace::LongReturnType\n"
8543       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8544       "    int first_long_parameter, int second_parameter) {}");
8545 
8546   verifyGoogleFormat("template <typename T>\n"
8547                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8548                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8549   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8550                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8551 
8552   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8553                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8554                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8555   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8556                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8557                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8558   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8559                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8560                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8561                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8562 
8563   verifyFormat("template <typename T> // Templates on own line.\n"
8564                "static int            // Some comment.\n"
8565                "MyFunction(int a);",
8566                getLLVMStyle());
8567 }
8568 
8569 TEST_F(FormatTest, FormatsArrays) {
8570   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8571                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8572   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8573                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8574   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8575                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8576   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8577                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8578   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8579                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8580   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8581                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8582                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8583   verifyFormat(
8584       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8585       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8586       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8587   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8588                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8589 
8590   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8591                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8592   verifyFormat(
8593       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8594       "                                  .aaaaaaa[0]\n"
8595       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8596   verifyFormat("a[::b::c];");
8597 
8598   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8599 
8600   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8601   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8602 }
8603 
8604 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8605   verifyFormat("(a)->b();");
8606   verifyFormat("--a;");
8607 }
8608 
8609 TEST_F(FormatTest, HandlesIncludeDirectives) {
8610   verifyFormat("#include <string>\n"
8611                "#include <a/b/c.h>\n"
8612                "#include \"a/b/string\"\n"
8613                "#include \"string.h\"\n"
8614                "#include \"string.h\"\n"
8615                "#include <a-a>\n"
8616                "#include < path with space >\n"
8617                "#include_next <test.h>"
8618                "#include \"abc.h\" // this is included for ABC\n"
8619                "#include \"some long include\" // with a comment\n"
8620                "#include \"some very long include path\"\n"
8621                "#include <some/very/long/include/path>\n",
8622                getLLVMStyleWithColumns(35));
8623   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8624   EXPECT_EQ("#include <a>", format("#include<a>"));
8625 
8626   verifyFormat("#import <string>");
8627   verifyFormat("#import <a/b/c.h>");
8628   verifyFormat("#import \"a/b/string\"");
8629   verifyFormat("#import \"string.h\"");
8630   verifyFormat("#import \"string.h\"");
8631   verifyFormat("#if __has_include(<strstream>)\n"
8632                "#include <strstream>\n"
8633                "#endif");
8634 
8635   verifyFormat("#define MY_IMPORT <a/b>");
8636 
8637   verifyFormat("#if __has_include(<a/b>)");
8638   verifyFormat("#if __has_include_next(<a/b>)");
8639   verifyFormat("#define F __has_include(<a/b>)");
8640   verifyFormat("#define F __has_include_next(<a/b>)");
8641 
8642   // Protocol buffer definition or missing "#".
8643   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8644                getLLVMStyleWithColumns(30));
8645 
8646   FormatStyle Style = getLLVMStyle();
8647   Style.AlwaysBreakBeforeMultilineStrings = true;
8648   Style.ColumnLimit = 0;
8649   verifyFormat("#import \"abc.h\"", Style);
8650 
8651   // But 'import' might also be a regular C++ namespace.
8652   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8653                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8654 }
8655 
8656 //===----------------------------------------------------------------------===//
8657 // Error recovery tests.
8658 //===----------------------------------------------------------------------===//
8659 
8660 TEST_F(FormatTest, IncompleteParameterLists) {
8661   FormatStyle NoBinPacking = getLLVMStyle();
8662   NoBinPacking.BinPackParameters = false;
8663   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8664                "                        double *min_x,\n"
8665                "                        double *max_x,\n"
8666                "                        double *min_y,\n"
8667                "                        double *max_y,\n"
8668                "                        double *min_z,\n"
8669                "                        double *max_z, ) {}",
8670                NoBinPacking);
8671 }
8672 
8673 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8674   verifyFormat("void f() { return; }\n42");
8675   verifyFormat("void f() {\n"
8676                "  if (0)\n"
8677                "    return;\n"
8678                "}\n"
8679                "42");
8680   verifyFormat("void f() { return }\n42");
8681   verifyFormat("void f() {\n"
8682                "  if (0)\n"
8683                "    return\n"
8684                "}\n"
8685                "42");
8686 }
8687 
8688 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
8689   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
8690   EXPECT_EQ("void f() {\n"
8691             "  if (a)\n"
8692             "    return\n"
8693             "}",
8694             format("void  f  (  )  {  if  ( a )  return  }"));
8695   EXPECT_EQ("namespace N {\n"
8696             "void f()\n"
8697             "}",
8698             format("namespace  N  {  void f()  }"));
8699   EXPECT_EQ("namespace N {\n"
8700             "void f() {}\n"
8701             "void g()\n"
8702             "} // namespace N",
8703             format("namespace N  { void f( ) { } void g( ) }"));
8704 }
8705 
8706 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
8707   verifyFormat("int aaaaaaaa =\n"
8708                "    // Overlylongcomment\n"
8709                "    b;",
8710                getLLVMStyleWithColumns(20));
8711   verifyFormat("function(\n"
8712                "    ShortArgument,\n"
8713                "    LoooooooooooongArgument);\n",
8714                getLLVMStyleWithColumns(20));
8715 }
8716 
8717 TEST_F(FormatTest, IncorrectAccessSpecifier) {
8718   verifyFormat("public:");
8719   verifyFormat("class A {\n"
8720                "public\n"
8721                "  void f() {}\n"
8722                "};");
8723   verifyFormat("public\n"
8724                "int qwerty;");
8725   verifyFormat("public\n"
8726                "B {}");
8727   verifyFormat("public\n"
8728                "{}");
8729   verifyFormat("public\n"
8730                "B { int x; }");
8731 }
8732 
8733 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
8734   verifyFormat("{");
8735   verifyFormat("#})");
8736   verifyNoCrash("(/**/[:!] ?[).");
8737 }
8738 
8739 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
8740   // Found by oss-fuzz:
8741   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
8742   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
8743   Style.ColumnLimit = 60;
8744   verifyNoCrash(
8745       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
8746       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
8747       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
8748       Style);
8749 }
8750 
8751 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
8752   verifyFormat("do {\n}");
8753   verifyFormat("do {\n}\n"
8754                "f();");
8755   verifyFormat("do {\n}\n"
8756                "wheeee(fun);");
8757   verifyFormat("do {\n"
8758                "  f();\n"
8759                "}");
8760 }
8761 
8762 TEST_F(FormatTest, IncorrectCodeMissingParens) {
8763   verifyFormat("if {\n  foo;\n  foo();\n}");
8764   verifyFormat("switch {\n  foo;\n  foo();\n}");
8765   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
8766   verifyFormat("while {\n  foo;\n  foo();\n}");
8767   verifyFormat("do {\n  foo;\n  foo();\n} while;");
8768 }
8769 
8770 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
8771   verifyIncompleteFormat("namespace {\n"
8772                          "class Foo { Foo (\n"
8773                          "};\n"
8774                          "} // namespace");
8775 }
8776 
8777 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
8778   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
8779   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
8780   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
8781   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
8782 
8783   EXPECT_EQ("{\n"
8784             "  {\n"
8785             "    breakme(\n"
8786             "        qwe);\n"
8787             "  }\n",
8788             format("{\n"
8789                    "    {\n"
8790                    " breakme(qwe);\n"
8791                    "}\n",
8792                    getLLVMStyleWithColumns(10)));
8793 }
8794 
8795 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
8796   verifyFormat("int x = {\n"
8797                "    avariable,\n"
8798                "    b(alongervariable)};",
8799                getLLVMStyleWithColumns(25));
8800 }
8801 
8802 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
8803   verifyFormat("return (a)(b){1, 2, 3};");
8804 }
8805 
8806 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
8807   verifyFormat("vector<int> x{1, 2, 3, 4};");
8808   verifyFormat("vector<int> x{\n"
8809                "    1,\n"
8810                "    2,\n"
8811                "    3,\n"
8812                "    4,\n"
8813                "};");
8814   verifyFormat("vector<T> x{{}, {}, {}, {}};");
8815   verifyFormat("f({1, 2});");
8816   verifyFormat("auto v = Foo{-1};");
8817   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
8818   verifyFormat("Class::Class : member{1, 2, 3} {}");
8819   verifyFormat("new vector<int>{1, 2, 3};");
8820   verifyFormat("new int[3]{1, 2, 3};");
8821   verifyFormat("new int{1};");
8822   verifyFormat("return {arg1, arg2};");
8823   verifyFormat("return {arg1, SomeType{parameter}};");
8824   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
8825   verifyFormat("new T{arg1, arg2};");
8826   verifyFormat("f(MyMap[{composite, key}]);");
8827   verifyFormat("class Class {\n"
8828                "  T member = {arg1, arg2};\n"
8829                "};");
8830   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
8831   verifyFormat("const struct A a = {.a = 1, .b = 2};");
8832   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
8833   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
8834   verifyFormat("int a = std::is_integral<int>{} + 0;");
8835 
8836   verifyFormat("int foo(int i) { return fo1{}(i); }");
8837   verifyFormat("int foo(int i) { return fo1{}(i); }");
8838   verifyFormat("auto i = decltype(x){};");
8839   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
8840   verifyFormat("Node n{1, Node{1000}, //\n"
8841                "       2};");
8842   verifyFormat("Aaaa aaaaaaa{\n"
8843                "    {\n"
8844                "        aaaa,\n"
8845                "    },\n"
8846                "};");
8847   verifyFormat("class C : public D {\n"
8848                "  SomeClass SC{2};\n"
8849                "};");
8850   verifyFormat("class C : public A {\n"
8851                "  class D : public B {\n"
8852                "    void f() { int i{2}; }\n"
8853                "  };\n"
8854                "};");
8855   verifyFormat("#define A {a, a},");
8856 
8857   // Avoid breaking between equal sign and opening brace
8858   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
8859   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
8860   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
8861                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
8862                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
8863                "     {\"ccccccccccccccccccccc\", 2}};",
8864                AvoidBreakingFirstArgument);
8865 
8866   // Binpacking only if there is no trailing comma
8867   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
8868                "                      cccccccccc, dddddddddd};",
8869                getLLVMStyleWithColumns(50));
8870   verifyFormat("const Aaaaaa aaaaa = {\n"
8871                "    aaaaaaaaaaa,\n"
8872                "    bbbbbbbbbbb,\n"
8873                "    ccccccccccc,\n"
8874                "    ddddddddddd,\n"
8875                "};",
8876                getLLVMStyleWithColumns(50));
8877 
8878   // Cases where distinguising braced lists and blocks is hard.
8879   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
8880   verifyFormat("void f() {\n"
8881                "  return; // comment\n"
8882                "}\n"
8883                "SomeType t;");
8884   verifyFormat("void f() {\n"
8885                "  if (a) {\n"
8886                "    f();\n"
8887                "  }\n"
8888                "}\n"
8889                "SomeType t;");
8890 
8891   // In combination with BinPackArguments = false.
8892   FormatStyle NoBinPacking = getLLVMStyle();
8893   NoBinPacking.BinPackArguments = false;
8894   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
8895                "                      bbbbb,\n"
8896                "                      ccccc,\n"
8897                "                      ddddd,\n"
8898                "                      eeeee,\n"
8899                "                      ffffff,\n"
8900                "                      ggggg,\n"
8901                "                      hhhhhh,\n"
8902                "                      iiiiii,\n"
8903                "                      jjjjjj,\n"
8904                "                      kkkkkk};",
8905                NoBinPacking);
8906   verifyFormat("const Aaaaaa aaaaa = {\n"
8907                "    aaaaa,\n"
8908                "    bbbbb,\n"
8909                "    ccccc,\n"
8910                "    ddddd,\n"
8911                "    eeeee,\n"
8912                "    ffffff,\n"
8913                "    ggggg,\n"
8914                "    hhhhhh,\n"
8915                "    iiiiii,\n"
8916                "    jjjjjj,\n"
8917                "    kkkkkk,\n"
8918                "};",
8919                NoBinPacking);
8920   verifyFormat(
8921       "const Aaaaaa aaaaa = {\n"
8922       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
8923       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
8924       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
8925       "};",
8926       NoBinPacking);
8927 
8928   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
8929   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
8930             "    CDDDP83848_BMCR_REGISTER,\n"
8931             "    CDDDP83848_BMSR_REGISTER,\n"
8932             "    CDDDP83848_RBR_REGISTER};",
8933             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
8934                    "                                CDDDP83848_BMSR_REGISTER,\n"
8935                    "                                CDDDP83848_RBR_REGISTER};",
8936                    NoBinPacking));
8937 
8938   // FIXME: The alignment of these trailing comments might be bad. Then again,
8939   // this might be utterly useless in real code.
8940   verifyFormat("Constructor::Constructor()\n"
8941                "    : some_value{         //\n"
8942                "                 aaaaaaa, //\n"
8943                "                 bbbbbbb} {}");
8944 
8945   // In braced lists, the first comment is always assumed to belong to the
8946   // first element. Thus, it can be moved to the next or previous line as
8947   // appropriate.
8948   EXPECT_EQ("function({// First element:\n"
8949             "          1,\n"
8950             "          // Second element:\n"
8951             "          2});",
8952             format("function({\n"
8953                    "    // First element:\n"
8954                    "    1,\n"
8955                    "    // Second element:\n"
8956                    "    2});"));
8957   EXPECT_EQ("std::vector<int> MyNumbers{\n"
8958             "    // First element:\n"
8959             "    1,\n"
8960             "    // Second element:\n"
8961             "    2};",
8962             format("std::vector<int> MyNumbers{// First element:\n"
8963                    "                           1,\n"
8964                    "                           // Second element:\n"
8965                    "                           2};",
8966                    getLLVMStyleWithColumns(30)));
8967   // A trailing comma should still lead to an enforced line break and no
8968   // binpacking.
8969   EXPECT_EQ("vector<int> SomeVector = {\n"
8970             "    // aaa\n"
8971             "    1,\n"
8972             "    2,\n"
8973             "};",
8974             format("vector<int> SomeVector = { // aaa\n"
8975                    "    1, 2, };"));
8976 
8977   // C++11 brace initializer list l-braces should not be treated any differently
8978   // when breaking before lambda bodies is enabled
8979   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
8980   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
8981   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
8982   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
8983   verifyFormat(
8984       "std::runtime_error{\n"
8985       "    \"Long string which will force a break onto the next line...\"};",
8986       BreakBeforeLambdaBody);
8987 
8988   FormatStyle ExtraSpaces = getLLVMStyle();
8989   ExtraSpaces.Cpp11BracedListStyle = false;
8990   ExtraSpaces.ColumnLimit = 75;
8991   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
8992   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
8993   verifyFormat("f({ 1, 2 });", ExtraSpaces);
8994   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
8995   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
8996   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
8997   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
8998   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
8999   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
9000   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
9001   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
9002   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
9003   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
9004   verifyFormat("class Class {\n"
9005                "  T member = { arg1, arg2 };\n"
9006                "};",
9007                ExtraSpaces);
9008   verifyFormat(
9009       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9010       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
9011       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
9012       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
9013       ExtraSpaces);
9014   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
9015   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
9016                ExtraSpaces);
9017   verifyFormat(
9018       "someFunction(OtherParam,\n"
9019       "             BracedList{ // comment 1 (Forcing interesting break)\n"
9020       "                         param1, param2,\n"
9021       "                         // comment 2\n"
9022       "                         param3, param4 });",
9023       ExtraSpaces);
9024   verifyFormat(
9025       "std::this_thread::sleep_for(\n"
9026       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
9027       ExtraSpaces);
9028   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
9029                "    aaaaaaa,\n"
9030                "    aaaaaaaaaa,\n"
9031                "    aaaaa,\n"
9032                "    aaaaaaaaaaaaaaa,\n"
9033                "    aaa,\n"
9034                "    aaaaaaaaaa,\n"
9035                "    a,\n"
9036                "    aaaaaaaaaaaaaaaaaaaaa,\n"
9037                "    aaaaaaaaaaaa,\n"
9038                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
9039                "    aaaaaaa,\n"
9040                "    a};");
9041   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
9042   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
9043   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
9044 
9045   // Avoid breaking between initializer/equal sign and opening brace
9046   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
9047   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
9048                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9049                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9050                "  { \"ccccccccccccccccccccc\", 2 }\n"
9051                "};",
9052                ExtraSpaces);
9053   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
9054                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9055                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9056                "  { \"ccccccccccccccccccccc\", 2 }\n"
9057                "};",
9058                ExtraSpaces);
9059 
9060   FormatStyle SpaceBeforeBrace = getLLVMStyle();
9061   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9062   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9063   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9064 
9065   FormatStyle SpaceBetweenBraces = getLLVMStyle();
9066   SpaceBetweenBraces.SpacesInAngles = true;
9067   SpaceBetweenBraces.SpacesInParentheses = true;
9068   SpaceBetweenBraces.SpacesInSquareBrackets = true;
9069   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9070   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9071   verifyFormat("vector< int > x{ // comment 1\n"
9072                "                 1, 2, 3, 4 };",
9073                SpaceBetweenBraces);
9074   SpaceBetweenBraces.ColumnLimit = 20;
9075   EXPECT_EQ("vector< int > x{\n"
9076             "    1, 2, 3, 4 };",
9077             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9078   SpaceBetweenBraces.ColumnLimit = 24;
9079   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9080             "                 3, 4 };",
9081             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9082   EXPECT_EQ("vector< int > x{\n"
9083             "    1,\n"
9084             "    2,\n"
9085             "    3,\n"
9086             "    4,\n"
9087             "};",
9088             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9089   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9090   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9091   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9092 }
9093 
9094 TEST_F(FormatTest, FormatSpacesInAngles) {
9095   FormatStyle SpaceInAngles = getLLVMStyle();
9096   SpaceInAngles.SpacesInAngles = true;
9097   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9098   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9099   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9100 
9101   SpaceInAngles.SpacesInAngles = false;
9102   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9103   verifyFormat("vector<int> x5;", SpaceInAngles);
9104   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9105   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9106 }
9107 
9108 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9109   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9110                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9111                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9112                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9113                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9114                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9115   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9116                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9117                "                 1, 22, 333, 4444, 55555, //\n"
9118                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9119                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9120   verifyFormat(
9121       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9122       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9123       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9124       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9125       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9126       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9127       "                 7777777};");
9128   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9129                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9130                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9131   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9132                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9133                "    // Separating comment.\n"
9134                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9135   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9136                "    // Leading comment\n"
9137                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9138                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9139   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9140                "                 1, 1, 1, 1};",
9141                getLLVMStyleWithColumns(39));
9142   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9143                "                 1, 1, 1, 1};",
9144                getLLVMStyleWithColumns(38));
9145   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9146                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9147                getLLVMStyleWithColumns(43));
9148   verifyFormat(
9149       "static unsigned SomeValues[10][3] = {\n"
9150       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9151       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9152   verifyFormat("static auto fields = new vector<string>{\n"
9153                "    \"aaaaaaaaaaaaa\",\n"
9154                "    \"aaaaaaaaaaaaa\",\n"
9155                "    \"aaaaaaaaaaaa\",\n"
9156                "    \"aaaaaaaaaaaaaa\",\n"
9157                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9158                "    \"aaaaaaaaaaaa\",\n"
9159                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9160                "};");
9161   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9162   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9163                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9164                "                 3, cccccccccccccccccccccc};",
9165                getLLVMStyleWithColumns(60));
9166 
9167   // Trailing commas.
9168   verifyFormat("vector<int> x = {\n"
9169                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9170                "};",
9171                getLLVMStyleWithColumns(39));
9172   verifyFormat("vector<int> x = {\n"
9173                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9174                "};",
9175                getLLVMStyleWithColumns(39));
9176   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9177                "                 1, 1, 1, 1,\n"
9178                "                 /**/ /**/};",
9179                getLLVMStyleWithColumns(39));
9180 
9181   // Trailing comment in the first line.
9182   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9183                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9184                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9185                "    11111111,   22222222,   333333333,   44444444};");
9186   // Trailing comment in the last line.
9187   verifyFormat("int aaaaa[] = {\n"
9188                "    1, 2, 3, // comment\n"
9189                "    4, 5, 6  // comment\n"
9190                "};");
9191 
9192   // With nested lists, we should either format one item per line or all nested
9193   // lists one on line.
9194   // FIXME: For some nested lists, we can do better.
9195   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9196                "        {aaaaaaaaaaaaaaaaaaa},\n"
9197                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9198                "        {aaaaaaaaaaaaaaaaa}};",
9199                getLLVMStyleWithColumns(60));
9200   verifyFormat(
9201       "SomeStruct my_struct_array = {\n"
9202       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9203       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9204       "    {aaa, aaa},\n"
9205       "    {aaa, aaa},\n"
9206       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9207       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9208       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9209 
9210   // No column layout should be used here.
9211   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9212                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9213 
9214   verifyNoCrash("a<,");
9215 
9216   // No braced initializer here.
9217   verifyFormat("void f() {\n"
9218                "  struct Dummy {};\n"
9219                "  f(v);\n"
9220                "}");
9221 
9222   // Long lists should be formatted in columns even if they are nested.
9223   verifyFormat(
9224       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9225       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9226       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9227       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9228       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9229       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9230 
9231   // Allow "single-column" layout even if that violates the column limit. There
9232   // isn't going to be a better way.
9233   verifyFormat("std::vector<int> a = {\n"
9234                "    aaaaaaaa,\n"
9235                "    aaaaaaaa,\n"
9236                "    aaaaaaaa,\n"
9237                "    aaaaaaaa,\n"
9238                "    aaaaaaaaaa,\n"
9239                "    aaaaaaaa,\n"
9240                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9241                getLLVMStyleWithColumns(30));
9242   verifyFormat("vector<int> aaaa = {\n"
9243                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9244                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9245                "    aaaaaa.aaaaaaa,\n"
9246                "    aaaaaa.aaaaaaa,\n"
9247                "    aaaaaa.aaaaaaa,\n"
9248                "    aaaaaa.aaaaaaa,\n"
9249                "};");
9250 
9251   // Don't create hanging lists.
9252   verifyFormat("someFunction(Param, {List1, List2,\n"
9253                "                     List3});",
9254                getLLVMStyleWithColumns(35));
9255   verifyFormat("someFunction(Param, Param,\n"
9256                "             {List1, List2,\n"
9257                "              List3});",
9258                getLLVMStyleWithColumns(35));
9259   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9260                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9261 }
9262 
9263 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9264   FormatStyle DoNotMerge = getLLVMStyle();
9265   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9266 
9267   verifyFormat("void f() { return 42; }");
9268   verifyFormat("void f() {\n"
9269                "  return 42;\n"
9270                "}",
9271                DoNotMerge);
9272   verifyFormat("void f() {\n"
9273                "  // Comment\n"
9274                "}");
9275   verifyFormat("{\n"
9276                "#error {\n"
9277                "  int a;\n"
9278                "}");
9279   verifyFormat("{\n"
9280                "  int a;\n"
9281                "#error {\n"
9282                "}");
9283   verifyFormat("void f() {} // comment");
9284   verifyFormat("void f() { int a; } // comment");
9285   verifyFormat("void f() {\n"
9286                "} // comment",
9287                DoNotMerge);
9288   verifyFormat("void f() {\n"
9289                "  int a;\n"
9290                "} // comment",
9291                DoNotMerge);
9292   verifyFormat("void f() {\n"
9293                "} // comment",
9294                getLLVMStyleWithColumns(15));
9295 
9296   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9297   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9298 
9299   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9300   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9301   verifyFormat("class C {\n"
9302                "  C()\n"
9303                "      : iiiiiiii(nullptr),\n"
9304                "        kkkkkkk(nullptr),\n"
9305                "        mmmmmmm(nullptr),\n"
9306                "        nnnnnnn(nullptr) {}\n"
9307                "};",
9308                getGoogleStyle());
9309 
9310   FormatStyle NoColumnLimit = getLLVMStyle();
9311   NoColumnLimit.ColumnLimit = 0;
9312   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9313   EXPECT_EQ("class C {\n"
9314             "  A() : b(0) {}\n"
9315             "};",
9316             format("class C{A():b(0){}};", NoColumnLimit));
9317   EXPECT_EQ("A()\n"
9318             "    : b(0) {\n"
9319             "}",
9320             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9321 
9322   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9323   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9324       FormatStyle::SFS_None;
9325   EXPECT_EQ("A()\n"
9326             "    : b(0) {\n"
9327             "}",
9328             format("A():b(0){}", DoNotMergeNoColumnLimit));
9329   EXPECT_EQ("A()\n"
9330             "    : b(0) {\n"
9331             "}",
9332             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9333 
9334   verifyFormat("#define A          \\\n"
9335                "  void f() {       \\\n"
9336                "    int i;         \\\n"
9337                "  }",
9338                getLLVMStyleWithColumns(20));
9339   verifyFormat("#define A           \\\n"
9340                "  void f() { int i; }",
9341                getLLVMStyleWithColumns(21));
9342   verifyFormat("#define A            \\\n"
9343                "  void f() {         \\\n"
9344                "    int i;           \\\n"
9345                "  }                  \\\n"
9346                "  int j;",
9347                getLLVMStyleWithColumns(22));
9348   verifyFormat("#define A             \\\n"
9349                "  void f() { int i; } \\\n"
9350                "  int j;",
9351                getLLVMStyleWithColumns(23));
9352 }
9353 
9354 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9355   FormatStyle MergeEmptyOnly = getLLVMStyle();
9356   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9357   verifyFormat("class C {\n"
9358                "  int f() {}\n"
9359                "};",
9360                MergeEmptyOnly);
9361   verifyFormat("class C {\n"
9362                "  int f() {\n"
9363                "    return 42;\n"
9364                "  }\n"
9365                "};",
9366                MergeEmptyOnly);
9367   verifyFormat("int f() {}", MergeEmptyOnly);
9368   verifyFormat("int f() {\n"
9369                "  return 42;\n"
9370                "}",
9371                MergeEmptyOnly);
9372 
9373   // Also verify behavior when BraceWrapping.AfterFunction = true
9374   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9375   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9376   verifyFormat("int f() {}", MergeEmptyOnly);
9377   verifyFormat("class C {\n"
9378                "  int f() {}\n"
9379                "};",
9380                MergeEmptyOnly);
9381 }
9382 
9383 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9384   FormatStyle MergeInlineOnly = getLLVMStyle();
9385   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9386   verifyFormat("class C {\n"
9387                "  int f() { return 42; }\n"
9388                "};",
9389                MergeInlineOnly);
9390   verifyFormat("int f() {\n"
9391                "  return 42;\n"
9392                "}",
9393                MergeInlineOnly);
9394 
9395   // SFS_Inline implies SFS_Empty
9396   verifyFormat("class C {\n"
9397                "  int f() {}\n"
9398                "};",
9399                MergeInlineOnly);
9400   verifyFormat("int f() {}", MergeInlineOnly);
9401 
9402   // Also verify behavior when BraceWrapping.AfterFunction = true
9403   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9404   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9405   verifyFormat("class C {\n"
9406                "  int f() { return 42; }\n"
9407                "};",
9408                MergeInlineOnly);
9409   verifyFormat("int f()\n"
9410                "{\n"
9411                "  return 42;\n"
9412                "}",
9413                MergeInlineOnly);
9414 
9415   // SFS_Inline implies SFS_Empty
9416   verifyFormat("int f() {}", MergeInlineOnly);
9417   verifyFormat("class C {\n"
9418                "  int f() {}\n"
9419                "};",
9420                MergeInlineOnly);
9421 }
9422 
9423 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9424   FormatStyle MergeInlineOnly = getLLVMStyle();
9425   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9426       FormatStyle::SFS_InlineOnly;
9427   verifyFormat("class C {\n"
9428                "  int f() { return 42; }\n"
9429                "};",
9430                MergeInlineOnly);
9431   verifyFormat("int f() {\n"
9432                "  return 42;\n"
9433                "}",
9434                MergeInlineOnly);
9435 
9436   // SFS_InlineOnly does not imply SFS_Empty
9437   verifyFormat("class C {\n"
9438                "  int f() {}\n"
9439                "};",
9440                MergeInlineOnly);
9441   verifyFormat("int f() {\n"
9442                "}",
9443                MergeInlineOnly);
9444 
9445   // Also verify behavior when BraceWrapping.AfterFunction = true
9446   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9447   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9448   verifyFormat("class C {\n"
9449                "  int f() { return 42; }\n"
9450                "};",
9451                MergeInlineOnly);
9452   verifyFormat("int f()\n"
9453                "{\n"
9454                "  return 42;\n"
9455                "}",
9456                MergeInlineOnly);
9457 
9458   // SFS_InlineOnly does not imply SFS_Empty
9459   verifyFormat("int f()\n"
9460                "{\n"
9461                "}",
9462                MergeInlineOnly);
9463   verifyFormat("class C {\n"
9464                "  int f() {}\n"
9465                "};",
9466                MergeInlineOnly);
9467 }
9468 
9469 TEST_F(FormatTest, SplitEmptyFunction) {
9470   FormatStyle Style = getLLVMStyle();
9471   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9472   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9473   Style.BraceWrapping.AfterFunction = true;
9474   Style.BraceWrapping.SplitEmptyFunction = false;
9475   Style.ColumnLimit = 40;
9476 
9477   verifyFormat("int f()\n"
9478                "{}",
9479                Style);
9480   verifyFormat("int f()\n"
9481                "{\n"
9482                "  return 42;\n"
9483                "}",
9484                Style);
9485   verifyFormat("int f()\n"
9486                "{\n"
9487                "  // some comment\n"
9488                "}",
9489                Style);
9490 
9491   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9492   verifyFormat("int f() {}", Style);
9493   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9494                "{}",
9495                Style);
9496   verifyFormat("int f()\n"
9497                "{\n"
9498                "  return 0;\n"
9499                "}",
9500                Style);
9501 
9502   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9503   verifyFormat("class Foo {\n"
9504                "  int f() {}\n"
9505                "};\n",
9506                Style);
9507   verifyFormat("class Foo {\n"
9508                "  int f() { return 0; }\n"
9509                "};\n",
9510                Style);
9511   verifyFormat("class Foo {\n"
9512                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9513                "  {}\n"
9514                "};\n",
9515                Style);
9516   verifyFormat("class Foo {\n"
9517                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9518                "  {\n"
9519                "    return 0;\n"
9520                "  }\n"
9521                "};\n",
9522                Style);
9523 
9524   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9525   verifyFormat("int f() {}", Style);
9526   verifyFormat("int f() { return 0; }", Style);
9527   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9528                "{}",
9529                Style);
9530   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9531                "{\n"
9532                "  return 0;\n"
9533                "}",
9534                Style);
9535 }
9536 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9537   FormatStyle Style = getLLVMStyle();
9538   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9539   verifyFormat("#ifdef A\n"
9540                "int f() {}\n"
9541                "#else\n"
9542                "int g() {}\n"
9543                "#endif",
9544                Style);
9545 }
9546 
9547 TEST_F(FormatTest, SplitEmptyClass) {
9548   FormatStyle Style = getLLVMStyle();
9549   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9550   Style.BraceWrapping.AfterClass = true;
9551   Style.BraceWrapping.SplitEmptyRecord = false;
9552 
9553   verifyFormat("class Foo\n"
9554                "{};",
9555                Style);
9556   verifyFormat("/* something */ class Foo\n"
9557                "{};",
9558                Style);
9559   verifyFormat("template <typename X> class Foo\n"
9560                "{};",
9561                Style);
9562   verifyFormat("class Foo\n"
9563                "{\n"
9564                "  Foo();\n"
9565                "};",
9566                Style);
9567   verifyFormat("typedef class Foo\n"
9568                "{\n"
9569                "} Foo_t;",
9570                Style);
9571 }
9572 
9573 TEST_F(FormatTest, SplitEmptyStruct) {
9574   FormatStyle Style = getLLVMStyle();
9575   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9576   Style.BraceWrapping.AfterStruct = true;
9577   Style.BraceWrapping.SplitEmptyRecord = false;
9578 
9579   verifyFormat("struct Foo\n"
9580                "{};",
9581                Style);
9582   verifyFormat("/* something */ struct Foo\n"
9583                "{};",
9584                Style);
9585   verifyFormat("template <typename X> struct Foo\n"
9586                "{};",
9587                Style);
9588   verifyFormat("struct Foo\n"
9589                "{\n"
9590                "  Foo();\n"
9591                "};",
9592                Style);
9593   verifyFormat("typedef struct Foo\n"
9594                "{\n"
9595                "} Foo_t;",
9596                Style);
9597   // typedef struct Bar {} Bar_t;
9598 }
9599 
9600 TEST_F(FormatTest, SplitEmptyUnion) {
9601   FormatStyle Style = getLLVMStyle();
9602   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9603   Style.BraceWrapping.AfterUnion = true;
9604   Style.BraceWrapping.SplitEmptyRecord = false;
9605 
9606   verifyFormat("union Foo\n"
9607                "{};",
9608                Style);
9609   verifyFormat("/* something */ union Foo\n"
9610                "{};",
9611                Style);
9612   verifyFormat("union Foo\n"
9613                "{\n"
9614                "  A,\n"
9615                "};",
9616                Style);
9617   verifyFormat("typedef union Foo\n"
9618                "{\n"
9619                "} Foo_t;",
9620                Style);
9621 }
9622 
9623 TEST_F(FormatTest, SplitEmptyNamespace) {
9624   FormatStyle Style = getLLVMStyle();
9625   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9626   Style.BraceWrapping.AfterNamespace = true;
9627   Style.BraceWrapping.SplitEmptyNamespace = false;
9628 
9629   verifyFormat("namespace Foo\n"
9630                "{};",
9631                Style);
9632   verifyFormat("/* something */ namespace Foo\n"
9633                "{};",
9634                Style);
9635   verifyFormat("inline namespace Foo\n"
9636                "{};",
9637                Style);
9638   verifyFormat("/* something */ inline namespace Foo\n"
9639                "{};",
9640                Style);
9641   verifyFormat("export namespace Foo\n"
9642                "{};",
9643                Style);
9644   verifyFormat("namespace Foo\n"
9645                "{\n"
9646                "void Bar();\n"
9647                "};",
9648                Style);
9649 }
9650 
9651 TEST_F(FormatTest, NeverMergeShortRecords) {
9652   FormatStyle Style = getLLVMStyle();
9653 
9654   verifyFormat("class Foo {\n"
9655                "  Foo();\n"
9656                "};",
9657                Style);
9658   verifyFormat("typedef class Foo {\n"
9659                "  Foo();\n"
9660                "} Foo_t;",
9661                Style);
9662   verifyFormat("struct Foo {\n"
9663                "  Foo();\n"
9664                "};",
9665                Style);
9666   verifyFormat("typedef struct Foo {\n"
9667                "  Foo();\n"
9668                "} Foo_t;",
9669                Style);
9670   verifyFormat("union Foo {\n"
9671                "  A,\n"
9672                "};",
9673                Style);
9674   verifyFormat("typedef union Foo {\n"
9675                "  A,\n"
9676                "} Foo_t;",
9677                Style);
9678   verifyFormat("namespace Foo {\n"
9679                "void Bar();\n"
9680                "};",
9681                Style);
9682 
9683   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9684   Style.BraceWrapping.AfterClass = true;
9685   Style.BraceWrapping.AfterStruct = true;
9686   Style.BraceWrapping.AfterUnion = true;
9687   Style.BraceWrapping.AfterNamespace = true;
9688   verifyFormat("class Foo\n"
9689                "{\n"
9690                "  Foo();\n"
9691                "};",
9692                Style);
9693   verifyFormat("typedef class Foo\n"
9694                "{\n"
9695                "  Foo();\n"
9696                "} Foo_t;",
9697                Style);
9698   verifyFormat("struct Foo\n"
9699                "{\n"
9700                "  Foo();\n"
9701                "};",
9702                Style);
9703   verifyFormat("typedef struct Foo\n"
9704                "{\n"
9705                "  Foo();\n"
9706                "} Foo_t;",
9707                Style);
9708   verifyFormat("union Foo\n"
9709                "{\n"
9710                "  A,\n"
9711                "};",
9712                Style);
9713   verifyFormat("typedef union Foo\n"
9714                "{\n"
9715                "  A,\n"
9716                "} Foo_t;",
9717                Style);
9718   verifyFormat("namespace Foo\n"
9719                "{\n"
9720                "void Bar();\n"
9721                "};",
9722                Style);
9723 }
9724 
9725 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
9726   // Elaborate type variable declarations.
9727   verifyFormat("struct foo a = {bar};\nint n;");
9728   verifyFormat("class foo a = {bar};\nint n;");
9729   verifyFormat("union foo a = {bar};\nint n;");
9730 
9731   // Elaborate types inside function definitions.
9732   verifyFormat("struct foo f() {}\nint n;");
9733   verifyFormat("class foo f() {}\nint n;");
9734   verifyFormat("union foo f() {}\nint n;");
9735 
9736   // Templates.
9737   verifyFormat("template <class X> void f() {}\nint n;");
9738   verifyFormat("template <struct X> void f() {}\nint n;");
9739   verifyFormat("template <union X> void f() {}\nint n;");
9740 
9741   // Actual definitions...
9742   verifyFormat("struct {\n} n;");
9743   verifyFormat(
9744       "template <template <class T, class Y>, class Z> class X {\n} n;");
9745   verifyFormat("union Z {\n  int n;\n} x;");
9746   verifyFormat("class MACRO Z {\n} n;");
9747   verifyFormat("class MACRO(X) Z {\n} n;");
9748   verifyFormat("class __attribute__(X) Z {\n} n;");
9749   verifyFormat("class __declspec(X) Z {\n} n;");
9750   verifyFormat("class A##B##C {\n} n;");
9751   verifyFormat("class alignas(16) Z {\n} n;");
9752   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
9753   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
9754 
9755   // Redefinition from nested context:
9756   verifyFormat("class A::B::C {\n} n;");
9757 
9758   // Template definitions.
9759   verifyFormat(
9760       "template <typename F>\n"
9761       "Matcher(const Matcher<F> &Other,\n"
9762       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
9763       "                             !is_same<F, T>::value>::type * = 0)\n"
9764       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
9765 
9766   // FIXME: This is still incorrectly handled at the formatter side.
9767   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
9768   verifyFormat("int i = SomeFunction(a<b, a> b);");
9769 
9770   // FIXME:
9771   // This now gets parsed incorrectly as class definition.
9772   // verifyFormat("class A<int> f() {\n}\nint n;");
9773 
9774   // Elaborate types where incorrectly parsing the structural element would
9775   // break the indent.
9776   verifyFormat("if (true)\n"
9777                "  class X x;\n"
9778                "else\n"
9779                "  f();\n");
9780 
9781   // This is simply incomplete. Formatting is not important, but must not crash.
9782   verifyFormat("class A:");
9783 }
9784 
9785 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
9786   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
9787             format("#error Leave     all         white!!!!! space* alone!\n"));
9788   EXPECT_EQ(
9789       "#warning Leave     all         white!!!!! space* alone!\n",
9790       format("#warning Leave     all         white!!!!! space* alone!\n"));
9791   EXPECT_EQ("#error 1", format("  #  error   1"));
9792   EXPECT_EQ("#warning 1", format("  #  warning 1"));
9793 }
9794 
9795 TEST_F(FormatTest, FormatHashIfExpressions) {
9796   verifyFormat("#if AAAA && BBBB");
9797   verifyFormat("#if (AAAA && BBBB)");
9798   verifyFormat("#elif (AAAA && BBBB)");
9799   // FIXME: Come up with a better indentation for #elif.
9800   verifyFormat(
9801       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
9802       "    defined(BBBBBBBB)\n"
9803       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
9804       "    defined(BBBBBBBB)\n"
9805       "#endif",
9806       getLLVMStyleWithColumns(65));
9807 }
9808 
9809 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
9810   FormatStyle AllowsMergedIf = getGoogleStyle();
9811   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
9812       FormatStyle::SIS_WithoutElse;
9813   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
9814   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
9815   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
9816   EXPECT_EQ("if (true) return 42;",
9817             format("if (true)\nreturn 42;", AllowsMergedIf));
9818   FormatStyle ShortMergedIf = AllowsMergedIf;
9819   ShortMergedIf.ColumnLimit = 25;
9820   verifyFormat("#define A \\\n"
9821                "  if (true) return 42;",
9822                ShortMergedIf);
9823   verifyFormat("#define A \\\n"
9824                "  f();    \\\n"
9825                "  if (true)\n"
9826                "#define B",
9827                ShortMergedIf);
9828   verifyFormat("#define A \\\n"
9829                "  f();    \\\n"
9830                "  if (true)\n"
9831                "g();",
9832                ShortMergedIf);
9833   verifyFormat("{\n"
9834                "#ifdef A\n"
9835                "  // Comment\n"
9836                "  if (true) continue;\n"
9837                "#endif\n"
9838                "  // Comment\n"
9839                "  if (true) continue;\n"
9840                "}",
9841                ShortMergedIf);
9842   ShortMergedIf.ColumnLimit = 33;
9843   verifyFormat("#define A \\\n"
9844                "  if constexpr (true) return 42;",
9845                ShortMergedIf);
9846   verifyFormat("#define A \\\n"
9847                "  if CONSTEXPR (true) return 42;",
9848                ShortMergedIf);
9849   ShortMergedIf.ColumnLimit = 29;
9850   verifyFormat("#define A                   \\\n"
9851                "  if (aaaaaaaaaa) return 1; \\\n"
9852                "  return 2;",
9853                ShortMergedIf);
9854   ShortMergedIf.ColumnLimit = 28;
9855   verifyFormat("#define A         \\\n"
9856                "  if (aaaaaaaaaa) \\\n"
9857                "    return 1;     \\\n"
9858                "  return 2;",
9859                ShortMergedIf);
9860   verifyFormat("#define A                \\\n"
9861                "  if constexpr (aaaaaaa) \\\n"
9862                "    return 1;            \\\n"
9863                "  return 2;",
9864                ShortMergedIf);
9865   verifyFormat("#define A                \\\n"
9866                "  if CONSTEXPR (aaaaaaa) \\\n"
9867                "    return 1;            \\\n"
9868                "  return 2;",
9869                ShortMergedIf);
9870 }
9871 
9872 TEST_F(FormatTest, FormatStarDependingOnContext) {
9873   verifyFormat("void f(int *a);");
9874   verifyFormat("void f() { f(fint * b); }");
9875   verifyFormat("class A {\n  void f(int *a);\n};");
9876   verifyFormat("class A {\n  int *a;\n};");
9877   verifyFormat("namespace a {\n"
9878                "namespace b {\n"
9879                "class A {\n"
9880                "  void f() {}\n"
9881                "  int *a;\n"
9882                "};\n"
9883                "} // namespace b\n"
9884                "} // namespace a");
9885 }
9886 
9887 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
9888   verifyFormat("while");
9889   verifyFormat("operator");
9890 }
9891 
9892 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
9893   // This code would be painfully slow to format if we didn't skip it.
9894   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
9895                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9896                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9897                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9898                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9899                    "A(1, 1)\n"
9900                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
9901                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9902                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9903                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9904                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9905                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9906                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9907                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9908                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9909                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
9910   // Deeply nested part is untouched, rest is formatted.
9911   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
9912             format(std::string("int    i;\n") + Code + "int    j;\n",
9913                    getLLVMStyle(), SC_ExpectIncomplete));
9914 }
9915 
9916 //===----------------------------------------------------------------------===//
9917 // Objective-C tests.
9918 //===----------------------------------------------------------------------===//
9919 
9920 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
9921   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
9922   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
9923             format("-(NSUInteger)indexOfObject:(id)anObject;"));
9924   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
9925   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
9926   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
9927             format("-(NSInteger)Method3:(id)anObject;"));
9928   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
9929             format("-(NSInteger)Method4:(id)anObject;"));
9930   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
9931             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
9932   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
9933             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
9934   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9935             "forAllCells:(BOOL)flag;",
9936             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9937                    "forAllCells:(BOOL)flag;"));
9938 
9939   // Very long objectiveC method declaration.
9940   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
9941                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
9942   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
9943                "                    inRange:(NSRange)range\n"
9944                "                   outRange:(NSRange)out_range\n"
9945                "                  outRange1:(NSRange)out_range1\n"
9946                "                  outRange2:(NSRange)out_range2\n"
9947                "                  outRange3:(NSRange)out_range3\n"
9948                "                  outRange4:(NSRange)out_range4\n"
9949                "                  outRange5:(NSRange)out_range5\n"
9950                "                  outRange6:(NSRange)out_range6\n"
9951                "                  outRange7:(NSRange)out_range7\n"
9952                "                  outRange8:(NSRange)out_range8\n"
9953                "                  outRange9:(NSRange)out_range9;");
9954 
9955   // When the function name has to be wrapped.
9956   FormatStyle Style = getLLVMStyle();
9957   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
9958   // and always indents instead.
9959   Style.IndentWrappedFunctionNames = false;
9960   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9961                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
9962                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
9963                "}",
9964                Style);
9965   Style.IndentWrappedFunctionNames = true;
9966   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9967                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
9968                "               anotherName:(NSString)dddddddddddddd {\n"
9969                "}",
9970                Style);
9971 
9972   verifyFormat("- (int)sum:(vector<int>)numbers;");
9973   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
9974   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
9975   // protocol lists (but not for template classes):
9976   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
9977 
9978   verifyFormat("- (int (*)())foo:(int (*)())f;");
9979   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
9980 
9981   // If there's no return type (very rare in practice!), LLVM and Google style
9982   // agree.
9983   verifyFormat("- foo;");
9984   verifyFormat("- foo:(int)f;");
9985   verifyGoogleFormat("- foo:(int)foo;");
9986 }
9987 
9988 TEST_F(FormatTest, BreaksStringLiterals) {
9989   EXPECT_EQ("\"some text \"\n"
9990             "\"other\";",
9991             format("\"some text other\";", getLLVMStyleWithColumns(12)));
9992   EXPECT_EQ("\"some text \"\n"
9993             "\"other\";",
9994             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
9995   EXPECT_EQ(
9996       "#define A  \\\n"
9997       "  \"some \"  \\\n"
9998       "  \"text \"  \\\n"
9999       "  \"other\";",
10000       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
10001   EXPECT_EQ(
10002       "#define A  \\\n"
10003       "  \"so \"    \\\n"
10004       "  \"text \"  \\\n"
10005       "  \"other\";",
10006       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
10007 
10008   EXPECT_EQ("\"some text\"",
10009             format("\"some text\"", getLLVMStyleWithColumns(1)));
10010   EXPECT_EQ("\"some text\"",
10011             format("\"some text\"", getLLVMStyleWithColumns(11)));
10012   EXPECT_EQ("\"some \"\n"
10013             "\"text\"",
10014             format("\"some text\"", getLLVMStyleWithColumns(10)));
10015   EXPECT_EQ("\"some \"\n"
10016             "\"text\"",
10017             format("\"some text\"", getLLVMStyleWithColumns(7)));
10018   EXPECT_EQ("\"some\"\n"
10019             "\" tex\"\n"
10020             "\"t\"",
10021             format("\"some text\"", getLLVMStyleWithColumns(6)));
10022   EXPECT_EQ("\"some\"\n"
10023             "\" tex\"\n"
10024             "\" and\"",
10025             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
10026   EXPECT_EQ("\"some\"\n"
10027             "\"/tex\"\n"
10028             "\"/and\"",
10029             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
10030 
10031   EXPECT_EQ("variable =\n"
10032             "    \"long string \"\n"
10033             "    \"literal\";",
10034             format("variable = \"long string literal\";",
10035                    getLLVMStyleWithColumns(20)));
10036 
10037   EXPECT_EQ("variable = f(\n"
10038             "    \"long string \"\n"
10039             "    \"literal\",\n"
10040             "    short,\n"
10041             "    loooooooooooooooooooong);",
10042             format("variable = f(\"long string literal\", short, "
10043                    "loooooooooooooooooooong);",
10044                    getLLVMStyleWithColumns(20)));
10045 
10046   EXPECT_EQ(
10047       "f(g(\"long string \"\n"
10048       "    \"literal\"),\n"
10049       "  b);",
10050       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
10051   EXPECT_EQ("f(g(\"long string \"\n"
10052             "    \"literal\",\n"
10053             "    a),\n"
10054             "  b);",
10055             format("f(g(\"long string literal\", a), b);",
10056                    getLLVMStyleWithColumns(20)));
10057   EXPECT_EQ(
10058       "f(\"one two\".split(\n"
10059       "    variable));",
10060       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10061   EXPECT_EQ("f(\"one two three four five six \"\n"
10062             "  \"seven\".split(\n"
10063             "      really_looooong_variable));",
10064             format("f(\"one two three four five six seven\"."
10065                    "split(really_looooong_variable));",
10066                    getLLVMStyleWithColumns(33)));
10067 
10068   EXPECT_EQ("f(\"some \"\n"
10069             "  \"text\",\n"
10070             "  other);",
10071             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10072 
10073   // Only break as a last resort.
10074   verifyFormat(
10075       "aaaaaaaaaaaaaaaaaaaa(\n"
10076       "    aaaaaaaaaaaaaaaaaaaa,\n"
10077       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10078 
10079   EXPECT_EQ("\"splitmea\"\n"
10080             "\"trandomp\"\n"
10081             "\"oint\"",
10082             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10083 
10084   EXPECT_EQ("\"split/\"\n"
10085             "\"pathat/\"\n"
10086             "\"slashes\"",
10087             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10088 
10089   EXPECT_EQ("\"split/\"\n"
10090             "\"pathat/\"\n"
10091             "\"slashes\"",
10092             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10093   EXPECT_EQ("\"split at \"\n"
10094             "\"spaces/at/\"\n"
10095             "\"slashes.at.any$\"\n"
10096             "\"non-alphanumeric%\"\n"
10097             "\"1111111111characte\"\n"
10098             "\"rs\"",
10099             format("\"split at "
10100                    "spaces/at/"
10101                    "slashes.at."
10102                    "any$non-"
10103                    "alphanumeric%"
10104                    "1111111111characte"
10105                    "rs\"",
10106                    getLLVMStyleWithColumns(20)));
10107 
10108   // Verify that splitting the strings understands
10109   // Style::AlwaysBreakBeforeMultilineStrings.
10110   EXPECT_EQ("aaaaaaaaaaaa(\n"
10111             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10112             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10113             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10114                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10115                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10116                    getGoogleStyle()));
10117   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10118             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10119             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10120                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10121                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10122                    getGoogleStyle()));
10123   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10124             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10125             format("llvm::outs() << "
10126                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10127                    "aaaaaaaaaaaaaaaaaaa\";"));
10128   EXPECT_EQ("ffff(\n"
10129             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10130             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10131             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10132                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10133                    getGoogleStyle()));
10134 
10135   FormatStyle Style = getLLVMStyleWithColumns(12);
10136   Style.BreakStringLiterals = false;
10137   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10138 
10139   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10140   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10141   EXPECT_EQ("#define A \\\n"
10142             "  \"some \" \\\n"
10143             "  \"text \" \\\n"
10144             "  \"other\";",
10145             format("#define A \"some text other\";", AlignLeft));
10146 }
10147 
10148 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10149   EXPECT_EQ("C a = \"some more \"\n"
10150             "      \"text\";",
10151             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10152 }
10153 
10154 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10155   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10156   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10157   EXPECT_EQ("int i = a(b());",
10158             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10159 }
10160 
10161 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10162   EXPECT_EQ(
10163       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10164       "(\n"
10165       "    \"x\t\");",
10166       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10167              "aaaaaaa("
10168              "\"x\t\");"));
10169 }
10170 
10171 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10172   EXPECT_EQ(
10173       "u8\"utf8 string \"\n"
10174       "u8\"literal\";",
10175       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10176   EXPECT_EQ(
10177       "u\"utf16 string \"\n"
10178       "u\"literal\";",
10179       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10180   EXPECT_EQ(
10181       "U\"utf32 string \"\n"
10182       "U\"literal\";",
10183       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10184   EXPECT_EQ("L\"wide string \"\n"
10185             "L\"literal\";",
10186             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10187   EXPECT_EQ("@\"NSString \"\n"
10188             "@\"literal\";",
10189             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10190   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10191 
10192   // This input makes clang-format try to split the incomplete unicode escape
10193   // sequence, which used to lead to a crasher.
10194   verifyNoCrash(
10195       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10196       getLLVMStyleWithColumns(60));
10197 }
10198 
10199 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10200   FormatStyle Style = getGoogleStyleWithColumns(15);
10201   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10202   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10203   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10204   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10205   EXPECT_EQ("u8R\"x(raw literal)x\";",
10206             format("u8R\"x(raw literal)x\";", Style));
10207 }
10208 
10209 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10210   FormatStyle Style = getLLVMStyleWithColumns(20);
10211   EXPECT_EQ(
10212       "_T(\"aaaaaaaaaaaaaa\")\n"
10213       "_T(\"aaaaaaaaaaaaaa\")\n"
10214       "_T(\"aaaaaaaaaaaa\")",
10215       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10216   EXPECT_EQ("f(x,\n"
10217             "  _T(\"aaaaaaaaaaaa\")\n"
10218             "  _T(\"aaa\"),\n"
10219             "  z);",
10220             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10221 
10222   // FIXME: Handle embedded spaces in one iteration.
10223   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10224   //            "_T(\"aaaaaaaaaaaaa\")\n"
10225   //            "_T(\"aaaaaaaaaaaaa\")\n"
10226   //            "_T(\"a\")",
10227   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10228   //                   getLLVMStyleWithColumns(20)));
10229   EXPECT_EQ(
10230       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10231       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10232   EXPECT_EQ("f(\n"
10233             "#if !TEST\n"
10234             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10235             "#endif\n"
10236             ");",
10237             format("f(\n"
10238                    "#if !TEST\n"
10239                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10240                    "#endif\n"
10241                    ");"));
10242   EXPECT_EQ("f(\n"
10243             "\n"
10244             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10245             format("f(\n"
10246                    "\n"
10247                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10248 }
10249 
10250 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10251   // In a function call with two operands, the second can be broken with no line
10252   // break before it.
10253   EXPECT_EQ(
10254       "func(a, \"long long \"\n"
10255       "        \"long long\");",
10256       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10257   // In a function call with three operands, the second must be broken with a
10258   // line break before it.
10259   EXPECT_EQ("func(a,\n"
10260             "     \"long long long \"\n"
10261             "     \"long\",\n"
10262             "     c);",
10263             format("func(a, \"long long long long\", c);",
10264                    getLLVMStyleWithColumns(24)));
10265   // In a function call with three operands, the third must be broken with a
10266   // line break before it.
10267   EXPECT_EQ("func(a, b,\n"
10268             "     \"long long long \"\n"
10269             "     \"long\");",
10270             format("func(a, b, \"long long long long\");",
10271                    getLLVMStyleWithColumns(24)));
10272   // In a function call with three operands, both the second and the third must
10273   // be broken with a line break before them.
10274   EXPECT_EQ("func(a,\n"
10275             "     \"long long long \"\n"
10276             "     \"long\",\n"
10277             "     \"long long long \"\n"
10278             "     \"long\");",
10279             format("func(a, \"long long long long\", \"long long long long\");",
10280                    getLLVMStyleWithColumns(24)));
10281   // In a chain of << with two operands, the second can be broken with no line
10282   // break before it.
10283   EXPECT_EQ("a << \"line line \"\n"
10284             "     \"line\";",
10285             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10286   // In a chain of << with three operands, the second can be broken with no line
10287   // break before it.
10288   EXPECT_EQ(
10289       "abcde << \"line \"\n"
10290       "         \"line line\"\n"
10291       "      << c;",
10292       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10293   // In a chain of << with three operands, the third must be broken with a line
10294   // break before it.
10295   EXPECT_EQ(
10296       "a << b\n"
10297       "  << \"line line \"\n"
10298       "     \"line\";",
10299       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10300   // In a chain of << with three operands, the second can be broken with no line
10301   // break before it and the third must be broken with a line break before it.
10302   EXPECT_EQ("abcd << \"line line \"\n"
10303             "        \"line\"\n"
10304             "     << \"line line \"\n"
10305             "        \"line\";",
10306             format("abcd << \"line line line\" << \"line line line\";",
10307                    getLLVMStyleWithColumns(20)));
10308   // In a chain of binary operators with two operands, the second can be broken
10309   // with no line break before it.
10310   EXPECT_EQ(
10311       "abcd + \"line line \"\n"
10312       "       \"line line\";",
10313       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10314   // In a chain of binary operators with three operands, the second must be
10315   // broken with a line break before it.
10316   EXPECT_EQ("abcd +\n"
10317             "    \"line line \"\n"
10318             "    \"line line\" +\n"
10319             "    e;",
10320             format("abcd + \"line line line line\" + e;",
10321                    getLLVMStyleWithColumns(20)));
10322   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10323   // the first must be broken with a line break before it.
10324   FormatStyle Style = getLLVMStyleWithColumns(25);
10325   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10326   EXPECT_EQ("someFunction(\n"
10327             "    \"long long long \"\n"
10328             "    \"long\",\n"
10329             "    a);",
10330             format("someFunction(\"long long long long\", a);", Style));
10331 }
10332 
10333 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10334   EXPECT_EQ(
10335       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10336       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10337       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10338       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10339              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10340              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10341 }
10342 
10343 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10344   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10345             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10346   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10347             "multiline raw string literal xxxxxxxxxxxxxx\n"
10348             ")x\",\n"
10349             "              a),\n"
10350             "            b);",
10351             format("fffffffffff(g(R\"x(\n"
10352                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10353                    ")x\", a), b);",
10354                    getGoogleStyleWithColumns(20)));
10355   EXPECT_EQ("fffffffffff(\n"
10356             "    g(R\"x(qqq\n"
10357             "multiline raw string literal xxxxxxxxxxxxxx\n"
10358             ")x\",\n"
10359             "      a),\n"
10360             "    b);",
10361             format("fffffffffff(g(R\"x(qqq\n"
10362                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10363                    ")x\", a), b);",
10364                    getGoogleStyleWithColumns(20)));
10365 
10366   EXPECT_EQ("fffffffffff(R\"x(\n"
10367             "multiline raw string literal xxxxxxxxxxxxxx\n"
10368             ")x\");",
10369             format("fffffffffff(R\"x(\n"
10370                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10371                    ")x\");",
10372                    getGoogleStyleWithColumns(20)));
10373   EXPECT_EQ("fffffffffff(R\"x(\n"
10374             "multiline raw string literal xxxxxxxxxxxxxx\n"
10375             ")x\" + bbbbbb);",
10376             format("fffffffffff(R\"x(\n"
10377                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10378                    ")x\" +   bbbbbb);",
10379                    getGoogleStyleWithColumns(20)));
10380   EXPECT_EQ("fffffffffff(\n"
10381             "    R\"x(\n"
10382             "multiline raw string literal xxxxxxxxxxxxxx\n"
10383             ")x\" +\n"
10384             "    bbbbbb);",
10385             format("fffffffffff(\n"
10386                    " R\"x(\n"
10387                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10388                    ")x\" + bbbbbb);",
10389                    getGoogleStyleWithColumns(20)));
10390   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10391             format("fffffffffff(\n"
10392                    " R\"(single line raw string)\" + bbbbbb);"));
10393 }
10394 
10395 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10396   verifyFormat("string a = \"unterminated;");
10397   EXPECT_EQ("function(\"unterminated,\n"
10398             "         OtherParameter);",
10399             format("function(  \"unterminated,\n"
10400                    "    OtherParameter);"));
10401 }
10402 
10403 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10404   FormatStyle Style = getLLVMStyle();
10405   Style.Standard = FormatStyle::LS_Cpp03;
10406   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10407             format("#define x(_a) printf(\"foo\"_a);", Style));
10408 }
10409 
10410 TEST_F(FormatTest, CppLexVersion) {
10411   FormatStyle Style = getLLVMStyle();
10412   // Formatting of x * y differs if x is a type.
10413   verifyFormat("void foo() { MACRO(a * b); }", Style);
10414   verifyFormat("void foo() { MACRO(int *b); }", Style);
10415 
10416   // LLVM style uses latest lexer.
10417   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10418   Style.Standard = FormatStyle::LS_Cpp17;
10419   // But in c++17, char8_t isn't a keyword.
10420   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10421 }
10422 
10423 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10424 
10425 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10426   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10427             "             \"ddeeefff\");",
10428             format("someFunction(\"aaabbbcccdddeeefff\");",
10429                    getLLVMStyleWithColumns(25)));
10430   EXPECT_EQ("someFunction1234567890(\n"
10431             "    \"aaabbbcccdddeeefff\");",
10432             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10433                    getLLVMStyleWithColumns(26)));
10434   EXPECT_EQ("someFunction1234567890(\n"
10435             "    \"aaabbbcccdddeeeff\"\n"
10436             "    \"f\");",
10437             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10438                    getLLVMStyleWithColumns(25)));
10439   EXPECT_EQ("someFunction1234567890(\n"
10440             "    \"aaabbbcccdddeeeff\"\n"
10441             "    \"f\");",
10442             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10443                    getLLVMStyleWithColumns(24)));
10444   EXPECT_EQ("someFunction(\n"
10445             "    \"aaabbbcc ddde \"\n"
10446             "    \"efff\");",
10447             format("someFunction(\"aaabbbcc ddde efff\");",
10448                    getLLVMStyleWithColumns(25)));
10449   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10450             "             \"ddeeefff\");",
10451             format("someFunction(\"aaabbbccc ddeeefff\");",
10452                    getLLVMStyleWithColumns(25)));
10453   EXPECT_EQ("someFunction1234567890(\n"
10454             "    \"aaabb \"\n"
10455             "    \"cccdddeeefff\");",
10456             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10457                    getLLVMStyleWithColumns(25)));
10458   EXPECT_EQ("#define A          \\\n"
10459             "  string s =       \\\n"
10460             "      \"123456789\"  \\\n"
10461             "      \"0\";         \\\n"
10462             "  int i;",
10463             format("#define A string s = \"1234567890\"; int i;",
10464                    getLLVMStyleWithColumns(20)));
10465   EXPECT_EQ("someFunction(\n"
10466             "    \"aaabbbcc \"\n"
10467             "    \"dddeeefff\");",
10468             format("someFunction(\"aaabbbcc dddeeefff\");",
10469                    getLLVMStyleWithColumns(25)));
10470 }
10471 
10472 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10473   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10474   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10475   EXPECT_EQ("\"test\"\n"
10476             "\"\\n\"",
10477             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10478   EXPECT_EQ("\"tes\\\\\"\n"
10479             "\"n\"",
10480             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10481   EXPECT_EQ("\"\\\\\\\\\"\n"
10482             "\"\\n\"",
10483             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10484   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10485   EXPECT_EQ("\"\\uff01\"\n"
10486             "\"test\"",
10487             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10488   EXPECT_EQ("\"\\Uff01ff02\"",
10489             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10490   EXPECT_EQ("\"\\x000000000001\"\n"
10491             "\"next\"",
10492             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10493   EXPECT_EQ("\"\\x000000000001next\"",
10494             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10495   EXPECT_EQ("\"\\x000000000001\"",
10496             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10497   EXPECT_EQ("\"test\"\n"
10498             "\"\\000000\"\n"
10499             "\"000001\"",
10500             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10501   EXPECT_EQ("\"test\\000\"\n"
10502             "\"00000000\"\n"
10503             "\"1\"",
10504             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10505 }
10506 
10507 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10508   verifyFormat("void f() {\n"
10509                "  return g() {}\n"
10510                "  void h() {}");
10511   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10512                "g();\n"
10513                "}");
10514 }
10515 
10516 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10517   verifyFormat(
10518       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10519 }
10520 
10521 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10522   verifyFormat("class X {\n"
10523                "  void f() {\n"
10524                "  }\n"
10525                "};",
10526                getLLVMStyleWithColumns(12));
10527 }
10528 
10529 TEST_F(FormatTest, ConfigurableIndentWidth) {
10530   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10531   EightIndent.IndentWidth = 8;
10532   EightIndent.ContinuationIndentWidth = 8;
10533   verifyFormat("void f() {\n"
10534                "        someFunction();\n"
10535                "        if (true) {\n"
10536                "                f();\n"
10537                "        }\n"
10538                "}",
10539                EightIndent);
10540   verifyFormat("class X {\n"
10541                "        void f() {\n"
10542                "        }\n"
10543                "};",
10544                EightIndent);
10545   verifyFormat("int x[] = {\n"
10546                "        call(),\n"
10547                "        call()};",
10548                EightIndent);
10549 }
10550 
10551 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10552   verifyFormat("double\n"
10553                "f();",
10554                getLLVMStyleWithColumns(8));
10555 }
10556 
10557 TEST_F(FormatTest, ConfigurableUseOfTab) {
10558   FormatStyle Tab = getLLVMStyleWithColumns(42);
10559   Tab.IndentWidth = 8;
10560   Tab.UseTab = FormatStyle::UT_Always;
10561   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10562 
10563   EXPECT_EQ("if (aaaaaaaa && // q\n"
10564             "    bb)\t\t// w\n"
10565             "\t;",
10566             format("if (aaaaaaaa &&// q\n"
10567                    "bb)// w\n"
10568                    ";",
10569                    Tab));
10570   EXPECT_EQ("if (aaa && bbb) // w\n"
10571             "\t;",
10572             format("if(aaa&&bbb)// w\n"
10573                    ";",
10574                    Tab));
10575 
10576   verifyFormat("class X {\n"
10577                "\tvoid f() {\n"
10578                "\t\tsomeFunction(parameter1,\n"
10579                "\t\t\t     parameter2);\n"
10580                "\t}\n"
10581                "};",
10582                Tab);
10583   verifyFormat("#define A                        \\\n"
10584                "\tvoid f() {               \\\n"
10585                "\t\tsomeFunction(    \\\n"
10586                "\t\t    parameter1,  \\\n"
10587                "\t\t    parameter2); \\\n"
10588                "\t}",
10589                Tab);
10590   verifyFormat("int a;\t      // x\n"
10591                "int bbbbbbbb; // x\n",
10592                Tab);
10593 
10594   Tab.TabWidth = 4;
10595   Tab.IndentWidth = 8;
10596   verifyFormat("class TabWidth4Indent8 {\n"
10597                "\t\tvoid f() {\n"
10598                "\t\t\t\tsomeFunction(parameter1,\n"
10599                "\t\t\t\t\t\t\t parameter2);\n"
10600                "\t\t}\n"
10601                "};",
10602                Tab);
10603 
10604   Tab.TabWidth = 4;
10605   Tab.IndentWidth = 4;
10606   verifyFormat("class TabWidth4Indent4 {\n"
10607                "\tvoid f() {\n"
10608                "\t\tsomeFunction(parameter1,\n"
10609                "\t\t\t\t\t parameter2);\n"
10610                "\t}\n"
10611                "};",
10612                Tab);
10613 
10614   Tab.TabWidth = 8;
10615   Tab.IndentWidth = 4;
10616   verifyFormat("class TabWidth8Indent4 {\n"
10617                "    void f() {\n"
10618                "\tsomeFunction(parameter1,\n"
10619                "\t\t     parameter2);\n"
10620                "    }\n"
10621                "};",
10622                Tab);
10623 
10624   Tab.TabWidth = 8;
10625   Tab.IndentWidth = 8;
10626   EXPECT_EQ("/*\n"
10627             "\t      a\t\tcomment\n"
10628             "\t      in multiple lines\n"
10629             "       */",
10630             format("   /*\t \t \n"
10631                    " \t \t a\t\tcomment\t \t\n"
10632                    " \t \t in multiple lines\t\n"
10633                    " \t  */",
10634                    Tab));
10635 
10636   Tab.UseTab = FormatStyle::UT_ForIndentation;
10637   verifyFormat("{\n"
10638                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10639                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10640                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10641                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10642                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10643                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10644                "};",
10645                Tab);
10646   verifyFormat("enum AA {\n"
10647                "\ta1, // Force multiple lines\n"
10648                "\ta2,\n"
10649                "\ta3\n"
10650                "};",
10651                Tab);
10652   EXPECT_EQ("if (aaaaaaaa && // q\n"
10653             "    bb)         // w\n"
10654             "\t;",
10655             format("if (aaaaaaaa &&// q\n"
10656                    "bb)// w\n"
10657                    ";",
10658                    Tab));
10659   verifyFormat("class X {\n"
10660                "\tvoid f() {\n"
10661                "\t\tsomeFunction(parameter1,\n"
10662                "\t\t             parameter2);\n"
10663                "\t}\n"
10664                "};",
10665                Tab);
10666   verifyFormat("{\n"
10667                "\tQ(\n"
10668                "\t    {\n"
10669                "\t\t    int a;\n"
10670                "\t\t    someFunction(aaaaaaaa,\n"
10671                "\t\t                 bbbbbbb);\n"
10672                "\t    },\n"
10673                "\t    p);\n"
10674                "}",
10675                Tab);
10676   EXPECT_EQ("{\n"
10677             "\t/* aaaa\n"
10678             "\t   bbbb */\n"
10679             "}",
10680             format("{\n"
10681                    "/* aaaa\n"
10682                    "   bbbb */\n"
10683                    "}",
10684                    Tab));
10685   EXPECT_EQ("{\n"
10686             "\t/*\n"
10687             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10688             "\t  bbbbbbbbbbbbb\n"
10689             "\t*/\n"
10690             "}",
10691             format("{\n"
10692                    "/*\n"
10693                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10694                    "*/\n"
10695                    "}",
10696                    Tab));
10697   EXPECT_EQ("{\n"
10698             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10699             "\t// bbbbbbbbbbbbb\n"
10700             "}",
10701             format("{\n"
10702                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10703                    "}",
10704                    Tab));
10705   EXPECT_EQ("{\n"
10706             "\t/*\n"
10707             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10708             "\t  bbbbbbbbbbbbb\n"
10709             "\t*/\n"
10710             "}",
10711             format("{\n"
10712                    "\t/*\n"
10713                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10714                    "\t*/\n"
10715                    "}",
10716                    Tab));
10717   EXPECT_EQ("{\n"
10718             "\t/*\n"
10719             "\n"
10720             "\t*/\n"
10721             "}",
10722             format("{\n"
10723                    "\t/*\n"
10724                    "\n"
10725                    "\t*/\n"
10726                    "}",
10727                    Tab));
10728   EXPECT_EQ("{\n"
10729             "\t/*\n"
10730             " asdf\n"
10731             "\t*/\n"
10732             "}",
10733             format("{\n"
10734                    "\t/*\n"
10735                    " asdf\n"
10736                    "\t*/\n"
10737                    "}",
10738                    Tab));
10739 
10740   Tab.UseTab = FormatStyle::UT_Never;
10741   EXPECT_EQ("/*\n"
10742             "              a\t\tcomment\n"
10743             "              in multiple lines\n"
10744             "       */",
10745             format("   /*\t \t \n"
10746                    " \t \t a\t\tcomment\t \t\n"
10747                    " \t \t in multiple lines\t\n"
10748                    " \t  */",
10749                    Tab));
10750   EXPECT_EQ("/* some\n"
10751             "   comment */",
10752             format(" \t \t /* some\n"
10753                    " \t \t    comment */",
10754                    Tab));
10755   EXPECT_EQ("int a; /* some\n"
10756             "   comment */",
10757             format(" \t \t int a; /* some\n"
10758                    " \t \t    comment */",
10759                    Tab));
10760 
10761   EXPECT_EQ("int a; /* some\n"
10762             "comment */",
10763             format(" \t \t int\ta; /* some\n"
10764                    " \t \t    comment */",
10765                    Tab));
10766   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10767             "    comment */",
10768             format(" \t \t f(\"\t\t\"); /* some\n"
10769                    " \t \t    comment */",
10770                    Tab));
10771   EXPECT_EQ("{\n"
10772             "        /*\n"
10773             "         * Comment\n"
10774             "         */\n"
10775             "        int i;\n"
10776             "}",
10777             format("{\n"
10778                    "\t/*\n"
10779                    "\t * Comment\n"
10780                    "\t */\n"
10781                    "\t int i;\n"
10782                    "}",
10783                    Tab));
10784 
10785   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
10786   Tab.TabWidth = 8;
10787   Tab.IndentWidth = 8;
10788   EXPECT_EQ("if (aaaaaaaa && // q\n"
10789             "    bb)         // w\n"
10790             "\t;",
10791             format("if (aaaaaaaa &&// q\n"
10792                    "bb)// w\n"
10793                    ";",
10794                    Tab));
10795   EXPECT_EQ("if (aaa && bbb) // w\n"
10796             "\t;",
10797             format("if(aaa&&bbb)// w\n"
10798                    ";",
10799                    Tab));
10800   verifyFormat("class X {\n"
10801                "\tvoid f() {\n"
10802                "\t\tsomeFunction(parameter1,\n"
10803                "\t\t\t     parameter2);\n"
10804                "\t}\n"
10805                "};",
10806                Tab);
10807   verifyFormat("#define A                        \\\n"
10808                "\tvoid f() {               \\\n"
10809                "\t\tsomeFunction(    \\\n"
10810                "\t\t    parameter1,  \\\n"
10811                "\t\t    parameter2); \\\n"
10812                "\t}",
10813                Tab);
10814   Tab.TabWidth = 4;
10815   Tab.IndentWidth = 8;
10816   verifyFormat("class TabWidth4Indent8 {\n"
10817                "\t\tvoid f() {\n"
10818                "\t\t\t\tsomeFunction(parameter1,\n"
10819                "\t\t\t\t\t\t\t parameter2);\n"
10820                "\t\t}\n"
10821                "};",
10822                Tab);
10823   Tab.TabWidth = 4;
10824   Tab.IndentWidth = 4;
10825   verifyFormat("class TabWidth4Indent4 {\n"
10826                "\tvoid f() {\n"
10827                "\t\tsomeFunction(parameter1,\n"
10828                "\t\t\t\t\t parameter2);\n"
10829                "\t}\n"
10830                "};",
10831                Tab);
10832   Tab.TabWidth = 8;
10833   Tab.IndentWidth = 4;
10834   verifyFormat("class TabWidth8Indent4 {\n"
10835                "    void f() {\n"
10836                "\tsomeFunction(parameter1,\n"
10837                "\t\t     parameter2);\n"
10838                "    }\n"
10839                "};",
10840                Tab);
10841   Tab.TabWidth = 8;
10842   Tab.IndentWidth = 8;
10843   EXPECT_EQ("/*\n"
10844             "\t      a\t\tcomment\n"
10845             "\t      in multiple lines\n"
10846             "       */",
10847             format("   /*\t \t \n"
10848                    " \t \t a\t\tcomment\t \t\n"
10849                    " \t \t in multiple lines\t\n"
10850                    " \t  */",
10851                    Tab));
10852   verifyFormat("{\n"
10853                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10854                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10855                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10856                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10857                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10858                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10859                "};",
10860                Tab);
10861   verifyFormat("enum AA {\n"
10862                "\ta1, // Force multiple lines\n"
10863                "\ta2,\n"
10864                "\ta3\n"
10865                "};",
10866                Tab);
10867   EXPECT_EQ("if (aaaaaaaa && // q\n"
10868             "    bb)         // w\n"
10869             "\t;",
10870             format("if (aaaaaaaa &&// q\n"
10871                    "bb)// w\n"
10872                    ";",
10873                    Tab));
10874   verifyFormat("class X {\n"
10875                "\tvoid f() {\n"
10876                "\t\tsomeFunction(parameter1,\n"
10877                "\t\t\t     parameter2);\n"
10878                "\t}\n"
10879                "};",
10880                Tab);
10881   verifyFormat("{\n"
10882                "\tQ(\n"
10883                "\t    {\n"
10884                "\t\t    int a;\n"
10885                "\t\t    someFunction(aaaaaaaa,\n"
10886                "\t\t\t\t bbbbbbb);\n"
10887                "\t    },\n"
10888                "\t    p);\n"
10889                "}",
10890                Tab);
10891   EXPECT_EQ("{\n"
10892             "\t/* aaaa\n"
10893             "\t   bbbb */\n"
10894             "}",
10895             format("{\n"
10896                    "/* aaaa\n"
10897                    "   bbbb */\n"
10898                    "}",
10899                    Tab));
10900   EXPECT_EQ("{\n"
10901             "\t/*\n"
10902             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10903             "\t  bbbbbbbbbbbbb\n"
10904             "\t*/\n"
10905             "}",
10906             format("{\n"
10907                    "/*\n"
10908                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10909                    "*/\n"
10910                    "}",
10911                    Tab));
10912   EXPECT_EQ("{\n"
10913             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10914             "\t// bbbbbbbbbbbbb\n"
10915             "}",
10916             format("{\n"
10917                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10918                    "}",
10919                    Tab));
10920   EXPECT_EQ("{\n"
10921             "\t/*\n"
10922             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10923             "\t  bbbbbbbbbbbbb\n"
10924             "\t*/\n"
10925             "}",
10926             format("{\n"
10927                    "\t/*\n"
10928                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10929                    "\t*/\n"
10930                    "}",
10931                    Tab));
10932   EXPECT_EQ("{\n"
10933             "\t/*\n"
10934             "\n"
10935             "\t*/\n"
10936             "}",
10937             format("{\n"
10938                    "\t/*\n"
10939                    "\n"
10940                    "\t*/\n"
10941                    "}",
10942                    Tab));
10943   EXPECT_EQ("{\n"
10944             "\t/*\n"
10945             " asdf\n"
10946             "\t*/\n"
10947             "}",
10948             format("{\n"
10949                    "\t/*\n"
10950                    " asdf\n"
10951                    "\t*/\n"
10952                    "}",
10953                    Tab));
10954   EXPECT_EQ("/* some\n"
10955             "   comment */",
10956             format(" \t \t /* some\n"
10957                    " \t \t    comment */",
10958                    Tab));
10959   EXPECT_EQ("int a; /* some\n"
10960             "   comment */",
10961             format(" \t \t int a; /* some\n"
10962                    " \t \t    comment */",
10963                    Tab));
10964   EXPECT_EQ("int a; /* some\n"
10965             "comment */",
10966             format(" \t \t int\ta; /* some\n"
10967                    " \t \t    comment */",
10968                    Tab));
10969   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10970             "    comment */",
10971             format(" \t \t f(\"\t\t\"); /* some\n"
10972                    " \t \t    comment */",
10973                    Tab));
10974   EXPECT_EQ("{\n"
10975             "\t/*\n"
10976             "\t * Comment\n"
10977             "\t */\n"
10978             "\tint i;\n"
10979             "}",
10980             format("{\n"
10981                    "\t/*\n"
10982                    "\t * Comment\n"
10983                    "\t */\n"
10984                    "\t int i;\n"
10985                    "}",
10986                    Tab));
10987   Tab.TabWidth = 2;
10988   Tab.IndentWidth = 2;
10989   EXPECT_EQ("{\n"
10990             "\t/* aaaa\n"
10991             "\t\t bbbb */\n"
10992             "}",
10993             format("{\n"
10994                    "/* aaaa\n"
10995                    "\t bbbb */\n"
10996                    "}",
10997                    Tab));
10998   EXPECT_EQ("{\n"
10999             "\t/*\n"
11000             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11001             "\t\tbbbbbbbbbbbbb\n"
11002             "\t*/\n"
11003             "}",
11004             format("{\n"
11005                    "/*\n"
11006                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11007                    "*/\n"
11008                    "}",
11009                    Tab));
11010   Tab.AlignConsecutiveAssignments = true;
11011   Tab.AlignConsecutiveDeclarations = true;
11012   Tab.TabWidth = 4;
11013   Tab.IndentWidth = 4;
11014   verifyFormat("class Assign {\n"
11015                "\tvoid f() {\n"
11016                "\t\tint         x      = 123;\n"
11017                "\t\tint         random = 4;\n"
11018                "\t\tstd::string alphabet =\n"
11019                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11020                "\t}\n"
11021                "};",
11022                Tab);
11023 
11024   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11025   Tab.TabWidth = 8;
11026   Tab.IndentWidth = 8;
11027   EXPECT_EQ("if (aaaaaaaa && // q\n"
11028             "    bb)         // w\n"
11029             "\t;",
11030             format("if (aaaaaaaa &&// q\n"
11031                    "bb)// w\n"
11032                    ";",
11033                    Tab));
11034   EXPECT_EQ("if (aaa && bbb) // w\n"
11035             "\t;",
11036             format("if(aaa&&bbb)// w\n"
11037                    ";",
11038                    Tab));
11039   verifyFormat("class X {\n"
11040                "\tvoid f() {\n"
11041                "\t\tsomeFunction(parameter1,\n"
11042                "\t\t             parameter2);\n"
11043                "\t}\n"
11044                "};",
11045                Tab);
11046   verifyFormat("#define A                        \\\n"
11047                "\tvoid f() {               \\\n"
11048                "\t\tsomeFunction(    \\\n"
11049                "\t\t    parameter1,  \\\n"
11050                "\t\t    parameter2); \\\n"
11051                "\t}",
11052                Tab);
11053   Tab.TabWidth = 4;
11054   Tab.IndentWidth = 8;
11055   verifyFormat("class TabWidth4Indent8 {\n"
11056                "\t\tvoid f() {\n"
11057                "\t\t\t\tsomeFunction(parameter1,\n"
11058                "\t\t\t\t             parameter2);\n"
11059                "\t\t}\n"
11060                "};",
11061                Tab);
11062   Tab.TabWidth = 4;
11063   Tab.IndentWidth = 4;
11064   verifyFormat("class TabWidth4Indent4 {\n"
11065                "\tvoid f() {\n"
11066                "\t\tsomeFunction(parameter1,\n"
11067                "\t\t             parameter2);\n"
11068                "\t}\n"
11069                "};",
11070                Tab);
11071   Tab.TabWidth = 8;
11072   Tab.IndentWidth = 4;
11073   verifyFormat("class TabWidth8Indent4 {\n"
11074                "    void f() {\n"
11075                "\tsomeFunction(parameter1,\n"
11076                "\t             parameter2);\n"
11077                "    }\n"
11078                "};",
11079                Tab);
11080   Tab.TabWidth = 8;
11081   Tab.IndentWidth = 8;
11082   EXPECT_EQ("/*\n"
11083             "              a\t\tcomment\n"
11084             "              in multiple lines\n"
11085             "       */",
11086             format("   /*\t \t \n"
11087                    " \t \t a\t\tcomment\t \t\n"
11088                    " \t \t in multiple lines\t\n"
11089                    " \t  */",
11090                    Tab));
11091   verifyFormat("{\n"
11092                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11093                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11094                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11095                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11096                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11097                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11098                "};",
11099                Tab);
11100   verifyFormat("enum AA {\n"
11101                "\ta1, // Force multiple lines\n"
11102                "\ta2,\n"
11103                "\ta3\n"
11104                "};",
11105                Tab);
11106   EXPECT_EQ("if (aaaaaaaa && // q\n"
11107             "    bb)         // w\n"
11108             "\t;",
11109             format("if (aaaaaaaa &&// q\n"
11110                    "bb)// w\n"
11111                    ";",
11112                    Tab));
11113   verifyFormat("class X {\n"
11114                "\tvoid f() {\n"
11115                "\t\tsomeFunction(parameter1,\n"
11116                "\t\t             parameter2);\n"
11117                "\t}\n"
11118                "};",
11119                Tab);
11120   verifyFormat("{\n"
11121                "\tQ(\n"
11122                "\t    {\n"
11123                "\t\t    int a;\n"
11124                "\t\t    someFunction(aaaaaaaa,\n"
11125                "\t\t                 bbbbbbb);\n"
11126                "\t    },\n"
11127                "\t    p);\n"
11128                "}",
11129                Tab);
11130   EXPECT_EQ("{\n"
11131             "\t/* aaaa\n"
11132             "\t   bbbb */\n"
11133             "}",
11134             format("{\n"
11135                    "/* aaaa\n"
11136                    "   bbbb */\n"
11137                    "}",
11138                    Tab));
11139   EXPECT_EQ("{\n"
11140             "\t/*\n"
11141             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11142             "\t  bbbbbbbbbbbbb\n"
11143             "\t*/\n"
11144             "}",
11145             format("{\n"
11146                    "/*\n"
11147                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11148                    "*/\n"
11149                    "}",
11150                    Tab));
11151   EXPECT_EQ("{\n"
11152             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11153             "\t// bbbbbbbbbbbbb\n"
11154             "}",
11155             format("{\n"
11156                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11157                    "}",
11158                    Tab));
11159   EXPECT_EQ("{\n"
11160             "\t/*\n"
11161             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11162             "\t  bbbbbbbbbbbbb\n"
11163             "\t*/\n"
11164             "}",
11165             format("{\n"
11166                    "\t/*\n"
11167                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11168                    "\t*/\n"
11169                    "}",
11170                    Tab));
11171   EXPECT_EQ("{\n"
11172             "\t/*\n"
11173             "\n"
11174             "\t*/\n"
11175             "}",
11176             format("{\n"
11177                    "\t/*\n"
11178                    "\n"
11179                    "\t*/\n"
11180                    "}",
11181                    Tab));
11182   EXPECT_EQ("{\n"
11183             "\t/*\n"
11184             " asdf\n"
11185             "\t*/\n"
11186             "}",
11187             format("{\n"
11188                    "\t/*\n"
11189                    " asdf\n"
11190                    "\t*/\n"
11191                    "}",
11192                    Tab));
11193   EXPECT_EQ("/* some\n"
11194             "   comment */",
11195             format(" \t \t /* some\n"
11196                    " \t \t    comment */",
11197                    Tab));
11198   EXPECT_EQ("int a; /* some\n"
11199             "   comment */",
11200             format(" \t \t int a; /* some\n"
11201                    " \t \t    comment */",
11202                    Tab));
11203   EXPECT_EQ("int a; /* some\n"
11204             "comment */",
11205             format(" \t \t int\ta; /* some\n"
11206                    " \t \t    comment */",
11207                    Tab));
11208   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11209             "    comment */",
11210             format(" \t \t f(\"\t\t\"); /* some\n"
11211                    " \t \t    comment */",
11212                    Tab));
11213   EXPECT_EQ("{\n"
11214             "\t/*\n"
11215             "\t * Comment\n"
11216             "\t */\n"
11217             "\tint i;\n"
11218             "}",
11219             format("{\n"
11220                    "\t/*\n"
11221                    "\t * Comment\n"
11222                    "\t */\n"
11223                    "\t int i;\n"
11224                    "}",
11225                    Tab));
11226   Tab.TabWidth = 2;
11227   Tab.IndentWidth = 2;
11228   EXPECT_EQ("{\n"
11229             "\t/* aaaa\n"
11230             "\t   bbbb */\n"
11231             "}",
11232             format("{\n"
11233                    "/* aaaa\n"
11234                    "   bbbb */\n"
11235                    "}",
11236                    Tab));
11237   EXPECT_EQ("{\n"
11238             "\t/*\n"
11239             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11240             "\t  bbbbbbbbbbbbb\n"
11241             "\t*/\n"
11242             "}",
11243             format("{\n"
11244                    "/*\n"
11245                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11246                    "*/\n"
11247                    "}",
11248                    Tab));
11249   Tab.AlignConsecutiveAssignments = true;
11250   Tab.AlignConsecutiveDeclarations = true;
11251   Tab.TabWidth = 4;
11252   Tab.IndentWidth = 4;
11253   verifyFormat("class Assign {\n"
11254                "\tvoid f() {\n"
11255                "\t\tint         x      = 123;\n"
11256                "\t\tint         random = 4;\n"
11257                "\t\tstd::string alphabet =\n"
11258                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11259                "\t}\n"
11260                "};",
11261                Tab);
11262   Tab.AlignOperands = FormatStyle::OAS_Align;
11263   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb +\n"
11264                "                 cccccccccccccccccccc;",
11265                Tab);
11266   // no alignment
11267   verifyFormat("int aaaaaaaaaa =\n"
11268                "\tbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
11269                Tab);
11270   verifyFormat("return aaaaaaaaaaaaaaaa ? 111111111111111\n"
11271                "       : bbbbbbbbbbbbbb ? 222222222222222\n"
11272                "                        : 333333333333333;",
11273                Tab);
11274   Tab.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
11275   Tab.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
11276   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb\n"
11277                "               + cccccccccccccccccccc;",
11278                Tab);
11279 }
11280 
11281 TEST_F(FormatTest, ZeroTabWidth) {
11282   FormatStyle Tab = getLLVMStyleWithColumns(42);
11283   Tab.IndentWidth = 8;
11284   Tab.UseTab = FormatStyle::UT_Never;
11285   Tab.TabWidth = 0;
11286   EXPECT_EQ("void a(){\n"
11287             "    // line starts with '\t'\n"
11288             "};",
11289             format("void a(){\n"
11290                    "\t// line starts with '\t'\n"
11291                    "};",
11292                    Tab));
11293 
11294   EXPECT_EQ("void a(){\n"
11295             "    // line starts with '\t'\n"
11296             "};",
11297             format("void a(){\n"
11298                    "\t\t// line starts with '\t'\n"
11299                    "};",
11300                    Tab));
11301 
11302   Tab.UseTab = FormatStyle::UT_ForIndentation;
11303   EXPECT_EQ("void a(){\n"
11304             "    // line starts with '\t'\n"
11305             "};",
11306             format("void a(){\n"
11307                    "\t// line starts with '\t'\n"
11308                    "};",
11309                    Tab));
11310 
11311   EXPECT_EQ("void a(){\n"
11312             "    // line starts with '\t'\n"
11313             "};",
11314             format("void a(){\n"
11315                    "\t\t// line starts with '\t'\n"
11316                    "};",
11317                    Tab));
11318 
11319   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11320   EXPECT_EQ("void a(){\n"
11321             "    // line starts with '\t'\n"
11322             "};",
11323             format("void a(){\n"
11324                    "\t// line starts with '\t'\n"
11325                    "};",
11326                    Tab));
11327 
11328   EXPECT_EQ("void a(){\n"
11329             "    // line starts with '\t'\n"
11330             "};",
11331             format("void a(){\n"
11332                    "\t\t// line starts with '\t'\n"
11333                    "};",
11334                    Tab));
11335 
11336   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11337   EXPECT_EQ("void a(){\n"
11338             "    // line starts with '\t'\n"
11339             "};",
11340             format("void a(){\n"
11341                    "\t// line starts with '\t'\n"
11342                    "};",
11343                    Tab));
11344 
11345   EXPECT_EQ("void a(){\n"
11346             "    // line starts with '\t'\n"
11347             "};",
11348             format("void a(){\n"
11349                    "\t\t// line starts with '\t'\n"
11350                    "};",
11351                    Tab));
11352 
11353   Tab.UseTab = FormatStyle::UT_Always;
11354   EXPECT_EQ("void a(){\n"
11355             "// line starts with '\t'\n"
11356             "};",
11357             format("void a(){\n"
11358                    "\t// line starts with '\t'\n"
11359                    "};",
11360                    Tab));
11361 
11362   EXPECT_EQ("void a(){\n"
11363             "// line starts with '\t'\n"
11364             "};",
11365             format("void a(){\n"
11366                    "\t\t// line starts with '\t'\n"
11367                    "};",
11368                    Tab));
11369 }
11370 
11371 TEST_F(FormatTest, CalculatesOriginalColumn) {
11372   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11373             "q\"; /* some\n"
11374             "       comment */",
11375             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11376                    "q\"; /* some\n"
11377                    "       comment */",
11378                    getLLVMStyle()));
11379   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11380             "/* some\n"
11381             "   comment */",
11382             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11383                    " /* some\n"
11384                    "    comment */",
11385                    getLLVMStyle()));
11386   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11387             "qqq\n"
11388             "/* some\n"
11389             "   comment */",
11390             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11391                    "qqq\n"
11392                    " /* some\n"
11393                    "    comment */",
11394                    getLLVMStyle()));
11395   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11396             "wwww; /* some\n"
11397             "         comment */",
11398             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11399                    "wwww; /* some\n"
11400                    "         comment */",
11401                    getLLVMStyle()));
11402 }
11403 
11404 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11405   FormatStyle NoSpace = getLLVMStyle();
11406   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11407 
11408   verifyFormat("while(true)\n"
11409                "  continue;",
11410                NoSpace);
11411   verifyFormat("for(;;)\n"
11412                "  continue;",
11413                NoSpace);
11414   verifyFormat("if(true)\n"
11415                "  f();\n"
11416                "else if(true)\n"
11417                "  f();",
11418                NoSpace);
11419   verifyFormat("do {\n"
11420                "  do_something();\n"
11421                "} while(something());",
11422                NoSpace);
11423   verifyFormat("switch(x) {\n"
11424                "default:\n"
11425                "  break;\n"
11426                "}",
11427                NoSpace);
11428   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11429   verifyFormat("size_t x = sizeof(x);", NoSpace);
11430   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11431   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11432   verifyFormat("alignas(128) char a[128];", NoSpace);
11433   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11434   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11435   verifyFormat("int f() throw(Deprecated);", NoSpace);
11436   verifyFormat("typedef void (*cb)(int);", NoSpace);
11437   verifyFormat("T A::operator()();", NoSpace);
11438   verifyFormat("X A::operator++(T);", NoSpace);
11439   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11440 
11441   FormatStyle Space = getLLVMStyle();
11442   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11443 
11444   verifyFormat("int f ();", Space);
11445   verifyFormat("void f (int a, T b) {\n"
11446                "  while (true)\n"
11447                "    continue;\n"
11448                "}",
11449                Space);
11450   verifyFormat("if (true)\n"
11451                "  f ();\n"
11452                "else if (true)\n"
11453                "  f ();",
11454                Space);
11455   verifyFormat("do {\n"
11456                "  do_something ();\n"
11457                "} while (something ());",
11458                Space);
11459   verifyFormat("switch (x) {\n"
11460                "default:\n"
11461                "  break;\n"
11462                "}",
11463                Space);
11464   verifyFormat("A::A () : a (1) {}", Space);
11465   verifyFormat("void f () __attribute__ ((asdf));", Space);
11466   verifyFormat("*(&a + 1);\n"
11467                "&((&a)[1]);\n"
11468                "a[(b + c) * d];\n"
11469                "(((a + 1) * 2) + 3) * 4;",
11470                Space);
11471   verifyFormat("#define A(x) x", Space);
11472   verifyFormat("#define A (x) x", Space);
11473   verifyFormat("#if defined(x)\n"
11474                "#endif",
11475                Space);
11476   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11477   verifyFormat("size_t x = sizeof (x);", Space);
11478   verifyFormat("auto f (int x) -> decltype (x);", Space);
11479   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11480   verifyFormat("alignas (128) char a[128];", Space);
11481   verifyFormat("size_t x = alignof (MyType);", Space);
11482   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11483   verifyFormat("int f () throw (Deprecated);", Space);
11484   verifyFormat("typedef void (*cb) (int);", Space);
11485   verifyFormat("T A::operator() ();", Space);
11486   verifyFormat("X A::operator++ (T);", Space);
11487   verifyFormat("auto lambda = [] () { return 0; };", Space);
11488   verifyFormat("int x = int (y);", Space);
11489 
11490   FormatStyle SomeSpace = getLLVMStyle();
11491   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11492 
11493   verifyFormat("[]() -> float {}", SomeSpace);
11494   verifyFormat("[] (auto foo) {}", SomeSpace);
11495   verifyFormat("[foo]() -> int {}", SomeSpace);
11496   verifyFormat("int f();", SomeSpace);
11497   verifyFormat("void f (int a, T b) {\n"
11498                "  while (true)\n"
11499                "    continue;\n"
11500                "}",
11501                SomeSpace);
11502   verifyFormat("if (true)\n"
11503                "  f();\n"
11504                "else if (true)\n"
11505                "  f();",
11506                SomeSpace);
11507   verifyFormat("do {\n"
11508                "  do_something();\n"
11509                "} while (something());",
11510                SomeSpace);
11511   verifyFormat("switch (x) {\n"
11512                "default:\n"
11513                "  break;\n"
11514                "}",
11515                SomeSpace);
11516   verifyFormat("A::A() : a (1) {}", SomeSpace);
11517   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11518   verifyFormat("*(&a + 1);\n"
11519                "&((&a)[1]);\n"
11520                "a[(b + c) * d];\n"
11521                "(((a + 1) * 2) + 3) * 4;",
11522                SomeSpace);
11523   verifyFormat("#define A(x) x", SomeSpace);
11524   verifyFormat("#define A (x) x", SomeSpace);
11525   verifyFormat("#if defined(x)\n"
11526                "#endif",
11527                SomeSpace);
11528   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11529   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11530   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11531   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11532   verifyFormat("alignas (128) char a[128];", SomeSpace);
11533   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11534   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11535                SomeSpace);
11536   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11537   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11538   verifyFormat("T A::operator()();", SomeSpace);
11539   verifyFormat("X A::operator++ (T);", SomeSpace);
11540   verifyFormat("int x = int (y);", SomeSpace);
11541   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11542 }
11543 
11544 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11545   FormatStyle Spaces = getLLVMStyle();
11546   Spaces.SpaceAfterLogicalNot = true;
11547 
11548   verifyFormat("bool x = ! y", Spaces);
11549   verifyFormat("if (! isFailure())", Spaces);
11550   verifyFormat("if (! (a && b))", Spaces);
11551   verifyFormat("\"Error!\"", Spaces);
11552   verifyFormat("! ! x", Spaces);
11553 }
11554 
11555 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11556   FormatStyle Spaces = getLLVMStyle();
11557 
11558   Spaces.SpacesInParentheses = true;
11559   verifyFormat("do_something( ::globalVar );", Spaces);
11560   verifyFormat("call( x, y, z );", Spaces);
11561   verifyFormat("call();", Spaces);
11562   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11563   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11564                Spaces);
11565   verifyFormat("while ( (bool)1 )\n"
11566                "  continue;",
11567                Spaces);
11568   verifyFormat("for ( ;; )\n"
11569                "  continue;",
11570                Spaces);
11571   verifyFormat("if ( true )\n"
11572                "  f();\n"
11573                "else if ( true )\n"
11574                "  f();",
11575                Spaces);
11576   verifyFormat("do {\n"
11577                "  do_something( (int)i );\n"
11578                "} while ( something() );",
11579                Spaces);
11580   verifyFormat("switch ( x ) {\n"
11581                "default:\n"
11582                "  break;\n"
11583                "}",
11584                Spaces);
11585 
11586   Spaces.SpacesInParentheses = false;
11587   Spaces.SpacesInCStyleCastParentheses = true;
11588   verifyFormat("Type *A = ( Type * )P;", Spaces);
11589   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11590   verifyFormat("x = ( int32 )y;", Spaces);
11591   verifyFormat("int a = ( int )(2.0f);", Spaces);
11592   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11593   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11594   verifyFormat("#define x (( int )-1)", Spaces);
11595 
11596   // Run the first set of tests again with:
11597   Spaces.SpacesInParentheses = false;
11598   Spaces.SpaceInEmptyParentheses = true;
11599   Spaces.SpacesInCStyleCastParentheses = true;
11600   verifyFormat("call(x, y, z);", Spaces);
11601   verifyFormat("call( );", Spaces);
11602   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11603   verifyFormat("while (( bool )1)\n"
11604                "  continue;",
11605                Spaces);
11606   verifyFormat("for (;;)\n"
11607                "  continue;",
11608                Spaces);
11609   verifyFormat("if (true)\n"
11610                "  f( );\n"
11611                "else if (true)\n"
11612                "  f( );",
11613                Spaces);
11614   verifyFormat("do {\n"
11615                "  do_something(( int )i);\n"
11616                "} while (something( ));",
11617                Spaces);
11618   verifyFormat("switch (x) {\n"
11619                "default:\n"
11620                "  break;\n"
11621                "}",
11622                Spaces);
11623 
11624   // Run the first set of tests again with:
11625   Spaces.SpaceAfterCStyleCast = true;
11626   verifyFormat("call(x, y, z);", Spaces);
11627   verifyFormat("call( );", Spaces);
11628   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11629   verifyFormat("while (( bool ) 1)\n"
11630                "  continue;",
11631                Spaces);
11632   verifyFormat("for (;;)\n"
11633                "  continue;",
11634                Spaces);
11635   verifyFormat("if (true)\n"
11636                "  f( );\n"
11637                "else if (true)\n"
11638                "  f( );",
11639                Spaces);
11640   verifyFormat("do {\n"
11641                "  do_something(( int ) i);\n"
11642                "} while (something( ));",
11643                Spaces);
11644   verifyFormat("switch (x) {\n"
11645                "default:\n"
11646                "  break;\n"
11647                "}",
11648                Spaces);
11649 
11650   // Run subset of tests again with:
11651   Spaces.SpacesInCStyleCastParentheses = false;
11652   Spaces.SpaceAfterCStyleCast = true;
11653   verifyFormat("while ((bool) 1)\n"
11654                "  continue;",
11655                Spaces);
11656   verifyFormat("do {\n"
11657                "  do_something((int) i);\n"
11658                "} while (something( ));",
11659                Spaces);
11660 }
11661 
11662 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
11663   verifyFormat("int a[5];");
11664   verifyFormat("a[3] += 42;");
11665 
11666   FormatStyle Spaces = getLLVMStyle();
11667   Spaces.SpacesInSquareBrackets = true;
11668   // Not lambdas.
11669   verifyFormat("int a[ 5 ];", Spaces);
11670   verifyFormat("a[ 3 ] += 42;", Spaces);
11671   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
11672   verifyFormat("double &operator[](int i) { return 0; }\n"
11673                "int i;",
11674                Spaces);
11675   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
11676   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
11677   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
11678   // Lambdas.
11679   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
11680   verifyFormat("return [ i, args... ] {};", Spaces);
11681   verifyFormat("int foo = [ &bar ]() {};", Spaces);
11682   verifyFormat("int foo = [ = ]() {};", Spaces);
11683   verifyFormat("int foo = [ & ]() {};", Spaces);
11684   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
11685   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
11686 }
11687 
11688 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
11689   FormatStyle NoSpaceStyle = getLLVMStyle();
11690   verifyFormat("int a[5];", NoSpaceStyle);
11691   verifyFormat("a[3] += 42;", NoSpaceStyle);
11692 
11693   verifyFormat("int a[1];", NoSpaceStyle);
11694   verifyFormat("int 1 [a];", NoSpaceStyle);
11695   verifyFormat("int a[1][2];", NoSpaceStyle);
11696   verifyFormat("a[7] = 5;", NoSpaceStyle);
11697   verifyFormat("int a = (f())[23];", NoSpaceStyle);
11698   verifyFormat("f([] {})", NoSpaceStyle);
11699 
11700   FormatStyle Space = getLLVMStyle();
11701   Space.SpaceBeforeSquareBrackets = true;
11702   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
11703   verifyFormat("return [i, args...] {};", Space);
11704 
11705   verifyFormat("int a [5];", Space);
11706   verifyFormat("a [3] += 42;", Space);
11707   verifyFormat("constexpr char hello []{\"hello\"};", Space);
11708   verifyFormat("double &operator[](int i) { return 0; }\n"
11709                "int i;",
11710                Space);
11711   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
11712   verifyFormat("int i = a [a][a]->f();", Space);
11713   verifyFormat("int i = (*b) [a]->f();", Space);
11714 
11715   verifyFormat("int a [1];", Space);
11716   verifyFormat("int 1 [a];", Space);
11717   verifyFormat("int a [1][2];", Space);
11718   verifyFormat("a [7] = 5;", Space);
11719   verifyFormat("int a = (f()) [23];", Space);
11720   verifyFormat("f([] {})", Space);
11721 }
11722 
11723 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
11724   verifyFormat("int a = 5;");
11725   verifyFormat("a += 42;");
11726   verifyFormat("a or_eq 8;");
11727 
11728   FormatStyle Spaces = getLLVMStyle();
11729   Spaces.SpaceBeforeAssignmentOperators = false;
11730   verifyFormat("int a= 5;", Spaces);
11731   verifyFormat("a+= 42;", Spaces);
11732   verifyFormat("a or_eq 8;", Spaces);
11733 }
11734 
11735 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
11736   verifyFormat("class Foo : public Bar {};");
11737   verifyFormat("Foo::Foo() : foo(1) {}");
11738   verifyFormat("for (auto a : b) {\n}");
11739   verifyFormat("int x = a ? b : c;");
11740   verifyFormat("{\n"
11741                "label0:\n"
11742                "  int x = 0;\n"
11743                "}");
11744   verifyFormat("switch (x) {\n"
11745                "case 1:\n"
11746                "default:\n"
11747                "}");
11748 
11749   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
11750   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
11751   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
11752   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
11753   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
11754   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
11755   verifyFormat("{\n"
11756                "label1:\n"
11757                "  int x = 0;\n"
11758                "}",
11759                CtorInitializerStyle);
11760   verifyFormat("switch (x) {\n"
11761                "case 1:\n"
11762                "default:\n"
11763                "}",
11764                CtorInitializerStyle);
11765   CtorInitializerStyle.BreakConstructorInitializers =
11766       FormatStyle::BCIS_AfterColon;
11767   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
11768                "    aaaaaaaaaaaaaaaa(1),\n"
11769                "    bbbbbbbbbbbbbbbb(2) {}",
11770                CtorInitializerStyle);
11771   CtorInitializerStyle.BreakConstructorInitializers =
11772       FormatStyle::BCIS_BeforeComma;
11773   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11774                "    : aaaaaaaaaaaaaaaa(1)\n"
11775                "    , bbbbbbbbbbbbbbbb(2) {}",
11776                CtorInitializerStyle);
11777   CtorInitializerStyle.BreakConstructorInitializers =
11778       FormatStyle::BCIS_BeforeColon;
11779   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11780                "    : aaaaaaaaaaaaaaaa(1),\n"
11781                "      bbbbbbbbbbbbbbbb(2) {}",
11782                CtorInitializerStyle);
11783   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
11784   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11785                ": aaaaaaaaaaaaaaaa(1),\n"
11786                "  bbbbbbbbbbbbbbbb(2) {}",
11787                CtorInitializerStyle);
11788 
11789   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
11790   InheritanceStyle.SpaceBeforeInheritanceColon = false;
11791   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
11792   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
11793   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
11794   verifyFormat("int x = a ? b : c;", InheritanceStyle);
11795   verifyFormat("{\n"
11796                "label2:\n"
11797                "  int x = 0;\n"
11798                "}",
11799                InheritanceStyle);
11800   verifyFormat("switch (x) {\n"
11801                "case 1:\n"
11802                "default:\n"
11803                "}",
11804                InheritanceStyle);
11805   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
11806   verifyFormat("class Foooooooooooooooooooooo:\n"
11807                "    public aaaaaaaaaaaaaaaaaa,\n"
11808                "    public bbbbbbbbbbbbbbbbbb {\n"
11809                "}",
11810                InheritanceStyle);
11811   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
11812   verifyFormat("class Foooooooooooooooooooooo\n"
11813                "    : public aaaaaaaaaaaaaaaaaa\n"
11814                "    , public bbbbbbbbbbbbbbbbbb {\n"
11815                "}",
11816                InheritanceStyle);
11817   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
11818   verifyFormat("class Foooooooooooooooooooooo\n"
11819                "    : public aaaaaaaaaaaaaaaaaa,\n"
11820                "      public bbbbbbbbbbbbbbbbbb {\n"
11821                "}",
11822                InheritanceStyle);
11823   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
11824   verifyFormat("class Foooooooooooooooooooooo\n"
11825                ": public aaaaaaaaaaaaaaaaaa,\n"
11826                "  public bbbbbbbbbbbbbbbbbb {}",
11827                InheritanceStyle);
11828 
11829   FormatStyle ForLoopStyle = getLLVMStyle();
11830   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
11831   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
11832   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
11833   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
11834   verifyFormat("int x = a ? b : c;", ForLoopStyle);
11835   verifyFormat("{\n"
11836                "label2:\n"
11837                "  int x = 0;\n"
11838                "}",
11839                ForLoopStyle);
11840   verifyFormat("switch (x) {\n"
11841                "case 1:\n"
11842                "default:\n"
11843                "}",
11844                ForLoopStyle);
11845 
11846   FormatStyle NoSpaceStyle = getLLVMStyle();
11847   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
11848   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
11849   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
11850   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
11851   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
11852   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
11853   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
11854   verifyFormat("{\n"
11855                "label3:\n"
11856                "  int x = 0;\n"
11857                "}",
11858                NoSpaceStyle);
11859   verifyFormat("switch (x) {\n"
11860                "case 1:\n"
11861                "default:\n"
11862                "}",
11863                NoSpaceStyle);
11864 }
11865 
11866 TEST_F(FormatTest, AlignConsecutiveMacros) {
11867   FormatStyle Style = getLLVMStyle();
11868   Style.AlignConsecutiveAssignments = true;
11869   Style.AlignConsecutiveDeclarations = true;
11870   Style.AlignConsecutiveMacros = false;
11871 
11872   verifyFormat("#define a 3\n"
11873                "#define bbbb 4\n"
11874                "#define ccc (5)",
11875                Style);
11876 
11877   verifyFormat("#define f(x) (x * x)\n"
11878                "#define fff(x, y, z) (x * y + z)\n"
11879                "#define ffff(x, y) (x - y)",
11880                Style);
11881 
11882   verifyFormat("#define foo(x, y) (x + y)\n"
11883                "#define bar (5, 6)(2 + 2)",
11884                Style);
11885 
11886   verifyFormat("#define a 3\n"
11887                "#define bbbb 4\n"
11888                "#define ccc (5)\n"
11889                "#define f(x) (x * x)\n"
11890                "#define fff(x, y, z) (x * y + z)\n"
11891                "#define ffff(x, y) (x - y)",
11892                Style);
11893 
11894   Style.AlignConsecutiveMacros = true;
11895   verifyFormat("#define a    3\n"
11896                "#define bbbb 4\n"
11897                "#define ccc  (5)",
11898                Style);
11899 
11900   verifyFormat("#define f(x)         (x * x)\n"
11901                "#define fff(x, y, z) (x * y + z)\n"
11902                "#define ffff(x, y)   (x - y)",
11903                Style);
11904 
11905   verifyFormat("#define foo(x, y) (x + y)\n"
11906                "#define bar       (5, 6)(2 + 2)",
11907                Style);
11908 
11909   verifyFormat("#define a            3\n"
11910                "#define bbbb         4\n"
11911                "#define ccc          (5)\n"
11912                "#define f(x)         (x * x)\n"
11913                "#define fff(x, y, z) (x * y + z)\n"
11914                "#define ffff(x, y)   (x - y)",
11915                Style);
11916 
11917   verifyFormat("#define a         5\n"
11918                "#define foo(x, y) (x + y)\n"
11919                "#define CCC       (6)\n"
11920                "auto lambda = []() {\n"
11921                "  auto  ii = 0;\n"
11922                "  float j  = 0;\n"
11923                "  return 0;\n"
11924                "};\n"
11925                "int   i  = 0;\n"
11926                "float i2 = 0;\n"
11927                "auto  v  = type{\n"
11928                "    i = 1,   //\n"
11929                "    (i = 2), //\n"
11930                "    i = 3    //\n"
11931                "};",
11932                Style);
11933 
11934   Style.AlignConsecutiveMacros = false;
11935   Style.ColumnLimit = 20;
11936 
11937   verifyFormat("#define a          \\\n"
11938                "  \"aabbbbbbbbbbbb\"\n"
11939                "#define D          \\\n"
11940                "  \"aabbbbbbbbbbbb\" \\\n"
11941                "  \"ccddeeeeeeeee\"\n"
11942                "#define B          \\\n"
11943                "  \"QQQQQQQQQQQQQ\"  \\\n"
11944                "  \"FFFFFFFFFFFFF\"  \\\n"
11945                "  \"LLLLLLLL\"\n",
11946                Style);
11947 
11948   Style.AlignConsecutiveMacros = true;
11949   verifyFormat("#define a          \\\n"
11950                "  \"aabbbbbbbbbbbb\"\n"
11951                "#define D          \\\n"
11952                "  \"aabbbbbbbbbbbb\" \\\n"
11953                "  \"ccddeeeeeeeee\"\n"
11954                "#define B          \\\n"
11955                "  \"QQQQQQQQQQQQQ\"  \\\n"
11956                "  \"FFFFFFFFFFFFF\"  \\\n"
11957                "  \"LLLLLLLL\"\n",
11958                Style);
11959 }
11960 
11961 TEST_F(FormatTest, AlignConsecutiveAssignments) {
11962   FormatStyle Alignment = getLLVMStyle();
11963   Alignment.AlignConsecutiveMacros = true;
11964   Alignment.AlignConsecutiveAssignments = false;
11965   verifyFormat("int a = 5;\n"
11966                "int oneTwoThree = 123;",
11967                Alignment);
11968   verifyFormat("int a = 5;\n"
11969                "int oneTwoThree = 123;",
11970                Alignment);
11971 
11972   Alignment.AlignConsecutiveAssignments = true;
11973   verifyFormat("int a           = 5;\n"
11974                "int oneTwoThree = 123;",
11975                Alignment);
11976   verifyFormat("int a           = method();\n"
11977                "int oneTwoThree = 133;",
11978                Alignment);
11979   verifyFormat("a &= 5;\n"
11980                "bcd *= 5;\n"
11981                "ghtyf += 5;\n"
11982                "dvfvdb -= 5;\n"
11983                "a /= 5;\n"
11984                "vdsvsv %= 5;\n"
11985                "sfdbddfbdfbb ^= 5;\n"
11986                "dvsdsv |= 5;\n"
11987                "int dsvvdvsdvvv = 123;",
11988                Alignment);
11989   verifyFormat("int i = 1, j = 10;\n"
11990                "something = 2000;",
11991                Alignment);
11992   verifyFormat("something = 2000;\n"
11993                "int i = 1, j = 10;\n",
11994                Alignment);
11995   verifyFormat("something = 2000;\n"
11996                "another   = 911;\n"
11997                "int i = 1, j = 10;\n"
11998                "oneMore = 1;\n"
11999                "i       = 2;",
12000                Alignment);
12001   verifyFormat("int a   = 5;\n"
12002                "int one = 1;\n"
12003                "method();\n"
12004                "int oneTwoThree = 123;\n"
12005                "int oneTwo      = 12;",
12006                Alignment);
12007   verifyFormat("int oneTwoThree = 123;\n"
12008                "int oneTwo      = 12;\n"
12009                "method();\n",
12010                Alignment);
12011   verifyFormat("int oneTwoThree = 123; // comment\n"
12012                "int oneTwo      = 12;  // comment",
12013                Alignment);
12014 
12015   // Bug 25167
12016   verifyFormat("#if A\n"
12017                "#else\n"
12018                "int aaaaaaaa = 12;\n"
12019                "#endif\n"
12020                "#if B\n"
12021                "#else\n"
12022                "int a = 12;\n"
12023                "#endif\n",
12024                Alignment);
12025   verifyFormat("enum foo {\n"
12026                "#if A\n"
12027                "#else\n"
12028                "  aaaaaaaa = 12;\n"
12029                "#endif\n"
12030                "#if B\n"
12031                "#else\n"
12032                "  a = 12;\n"
12033                "#endif\n"
12034                "};\n",
12035                Alignment);
12036 
12037   EXPECT_EQ("int a = 5;\n"
12038             "\n"
12039             "int oneTwoThree = 123;",
12040             format("int a       = 5;\n"
12041                    "\n"
12042                    "int oneTwoThree= 123;",
12043                    Alignment));
12044   EXPECT_EQ("int a   = 5;\n"
12045             "int one = 1;\n"
12046             "\n"
12047             "int oneTwoThree = 123;",
12048             format("int a = 5;\n"
12049                    "int one = 1;\n"
12050                    "\n"
12051                    "int oneTwoThree = 123;",
12052                    Alignment));
12053   EXPECT_EQ("int a   = 5;\n"
12054             "int one = 1;\n"
12055             "\n"
12056             "int oneTwoThree = 123;\n"
12057             "int oneTwo      = 12;",
12058             format("int a = 5;\n"
12059                    "int one = 1;\n"
12060                    "\n"
12061                    "int oneTwoThree = 123;\n"
12062                    "int oneTwo = 12;",
12063                    Alignment));
12064   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12065   verifyFormat("#define A \\\n"
12066                "  int aaaa       = 12; \\\n"
12067                "  int b          = 23; \\\n"
12068                "  int ccc        = 234; \\\n"
12069                "  int dddddddddd = 2345;",
12070                Alignment);
12071   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12072   verifyFormat("#define A               \\\n"
12073                "  int aaaa       = 12;  \\\n"
12074                "  int b          = 23;  \\\n"
12075                "  int ccc        = 234; \\\n"
12076                "  int dddddddddd = 2345;",
12077                Alignment);
12078   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12079   verifyFormat("#define A                                                      "
12080                "                \\\n"
12081                "  int aaaa       = 12;                                         "
12082                "                \\\n"
12083                "  int b          = 23;                                         "
12084                "                \\\n"
12085                "  int ccc        = 234;                                        "
12086                "                \\\n"
12087                "  int dddddddddd = 2345;",
12088                Alignment);
12089   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12090                "k = 4, int l = 5,\n"
12091                "                  int m = 6) {\n"
12092                "  int j      = 10;\n"
12093                "  otherThing = 1;\n"
12094                "}",
12095                Alignment);
12096   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12097                "  int i   = 1;\n"
12098                "  int j   = 2;\n"
12099                "  int big = 10000;\n"
12100                "}",
12101                Alignment);
12102   verifyFormat("class C {\n"
12103                "public:\n"
12104                "  int i            = 1;\n"
12105                "  virtual void f() = 0;\n"
12106                "};",
12107                Alignment);
12108   verifyFormat("int i = 1;\n"
12109                "if (SomeType t = getSomething()) {\n"
12110                "}\n"
12111                "int j   = 2;\n"
12112                "int big = 10000;",
12113                Alignment);
12114   verifyFormat("int j = 7;\n"
12115                "for (int k = 0; k < N; ++k) {\n"
12116                "}\n"
12117                "int j   = 2;\n"
12118                "int big = 10000;\n"
12119                "}",
12120                Alignment);
12121   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12122   verifyFormat("int i = 1;\n"
12123                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12124                "    = someLooooooooooooooooongFunction();\n"
12125                "int j = 2;",
12126                Alignment);
12127   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12128   verifyFormat("int i = 1;\n"
12129                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12130                "    someLooooooooooooooooongFunction();\n"
12131                "int j = 2;",
12132                Alignment);
12133 
12134   verifyFormat("auto lambda = []() {\n"
12135                "  auto i = 0;\n"
12136                "  return 0;\n"
12137                "};\n"
12138                "int i  = 0;\n"
12139                "auto v = type{\n"
12140                "    i = 1,   //\n"
12141                "    (i = 2), //\n"
12142                "    i = 3    //\n"
12143                "};",
12144                Alignment);
12145 
12146   verifyFormat(
12147       "int i      = 1;\n"
12148       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12149       "                          loooooooooooooooooooooongParameterB);\n"
12150       "int j      = 2;",
12151       Alignment);
12152 
12153   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12154                "          typename B   = very_long_type_name_1,\n"
12155                "          typename T_2 = very_long_type_name_2>\n"
12156                "auto foo() {}\n",
12157                Alignment);
12158   verifyFormat("int a, b = 1;\n"
12159                "int c  = 2;\n"
12160                "int dd = 3;\n",
12161                Alignment);
12162   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12163                "float b[1][] = {{3.f}};\n",
12164                Alignment);
12165   verifyFormat("for (int i = 0; i < 1; i++)\n"
12166                "  int x = 1;\n",
12167                Alignment);
12168   verifyFormat("for (i = 0; i < 1; i++)\n"
12169                "  x = 1;\n"
12170                "y = 1;\n",
12171                Alignment);
12172 
12173   Alignment.ReflowComments = true;
12174   Alignment.ColumnLimit = 50;
12175   EXPECT_EQ("int x   = 0;\n"
12176             "int yy  = 1; /// specificlennospace\n"
12177             "int zzz = 2;\n",
12178             format("int x   = 0;\n"
12179                    "int yy  = 1; ///specificlennospace\n"
12180                    "int zzz = 2;\n",
12181                    Alignment));
12182 }
12183 
12184 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12185   FormatStyle Alignment = getLLVMStyle();
12186   Alignment.AlignConsecutiveBitFields = true;
12187   verifyFormat("int const a     : 5;\n"
12188                "int oneTwoThree : 23;",
12189                Alignment);
12190 
12191   // Initializers are allowed starting with c++2a
12192   verifyFormat("int const a     : 5 = 1;\n"
12193                "int oneTwoThree : 23 = 0;",
12194                Alignment);
12195 
12196   Alignment.AlignConsecutiveDeclarations = true;
12197   verifyFormat("int const a           : 5;\n"
12198                "int       oneTwoThree : 23;",
12199                Alignment);
12200 
12201   verifyFormat("int const a           : 5;  // comment\n"
12202                "int       oneTwoThree : 23; // comment",
12203                Alignment);
12204 
12205   verifyFormat("int const a           : 5 = 1;\n"
12206                "int       oneTwoThree : 23 = 0;",
12207                Alignment);
12208 
12209   Alignment.AlignConsecutiveAssignments = true;
12210   verifyFormat("int const a           : 5  = 1;\n"
12211                "int       oneTwoThree : 23 = 0;",
12212                Alignment);
12213   verifyFormat("int const a           : 5  = {1};\n"
12214                "int       oneTwoThree : 23 = 0;",
12215                Alignment);
12216 
12217   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_None;
12218   verifyFormat("int const a          :5;\n"
12219                "int       oneTwoThree:23;",
12220                Alignment);
12221 
12222   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_Before;
12223   verifyFormat("int const a           :5;\n"
12224                "int       oneTwoThree :23;",
12225                Alignment);
12226 
12227   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_After;
12228   verifyFormat("int const a          : 5;\n"
12229                "int       oneTwoThree: 23;",
12230                Alignment);
12231 
12232   // Known limitations: ':' is only recognized as a bitfield colon when
12233   // followed by a number.
12234   /*
12235   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12236                "int a           : 5;",
12237                Alignment);
12238   */
12239 }
12240 
12241 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12242   FormatStyle Alignment = getLLVMStyle();
12243   Alignment.AlignConsecutiveMacros = true;
12244   Alignment.AlignConsecutiveDeclarations = false;
12245   verifyFormat("float const a = 5;\n"
12246                "int oneTwoThree = 123;",
12247                Alignment);
12248   verifyFormat("int a = 5;\n"
12249                "float const oneTwoThree = 123;",
12250                Alignment);
12251 
12252   Alignment.AlignConsecutiveDeclarations = true;
12253   verifyFormat("float const a = 5;\n"
12254                "int         oneTwoThree = 123;",
12255                Alignment);
12256   verifyFormat("int         a = method();\n"
12257                "float const oneTwoThree = 133;",
12258                Alignment);
12259   verifyFormat("int i = 1, j = 10;\n"
12260                "something = 2000;",
12261                Alignment);
12262   verifyFormat("something = 2000;\n"
12263                "int i = 1, j = 10;\n",
12264                Alignment);
12265   verifyFormat("float      something = 2000;\n"
12266                "double     another = 911;\n"
12267                "int        i = 1, j = 10;\n"
12268                "const int *oneMore = 1;\n"
12269                "unsigned   i = 2;",
12270                Alignment);
12271   verifyFormat("float a = 5;\n"
12272                "int   one = 1;\n"
12273                "method();\n"
12274                "const double       oneTwoThree = 123;\n"
12275                "const unsigned int oneTwo = 12;",
12276                Alignment);
12277   verifyFormat("int      oneTwoThree{0}; // comment\n"
12278                "unsigned oneTwo;         // comment",
12279                Alignment);
12280   EXPECT_EQ("float const a = 5;\n"
12281             "\n"
12282             "int oneTwoThree = 123;",
12283             format("float const   a = 5;\n"
12284                    "\n"
12285                    "int           oneTwoThree= 123;",
12286                    Alignment));
12287   EXPECT_EQ("float a = 5;\n"
12288             "int   one = 1;\n"
12289             "\n"
12290             "unsigned oneTwoThree = 123;",
12291             format("float    a = 5;\n"
12292                    "int      one = 1;\n"
12293                    "\n"
12294                    "unsigned oneTwoThree = 123;",
12295                    Alignment));
12296   EXPECT_EQ("float a = 5;\n"
12297             "int   one = 1;\n"
12298             "\n"
12299             "unsigned oneTwoThree = 123;\n"
12300             "int      oneTwo = 12;",
12301             format("float    a = 5;\n"
12302                    "int one = 1;\n"
12303                    "\n"
12304                    "unsigned oneTwoThree = 123;\n"
12305                    "int oneTwo = 12;",
12306                    Alignment));
12307   // Function prototype alignment
12308   verifyFormat("int    a();\n"
12309                "double b();",
12310                Alignment);
12311   verifyFormat("int    a(int x);\n"
12312                "double b();",
12313                Alignment);
12314   unsigned OldColumnLimit = Alignment.ColumnLimit;
12315   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12316   // otherwise the function parameters will be re-flowed onto a single line.
12317   Alignment.ColumnLimit = 0;
12318   EXPECT_EQ("int    a(int   x,\n"
12319             "         float y);\n"
12320             "double b(int    x,\n"
12321             "         double y);",
12322             format("int a(int x,\n"
12323                    " float y);\n"
12324                    "double b(int x,\n"
12325                    " double y);",
12326                    Alignment));
12327   // This ensures that function parameters of function declarations are
12328   // correctly indented when their owning functions are indented.
12329   // The failure case here is for 'double y' to not be indented enough.
12330   EXPECT_EQ("double a(int x);\n"
12331             "int    b(int    y,\n"
12332             "         double z);",
12333             format("double a(int x);\n"
12334                    "int b(int y,\n"
12335                    " double z);",
12336                    Alignment));
12337   // Set ColumnLimit low so that we induce wrapping immediately after
12338   // the function name and opening paren.
12339   Alignment.ColumnLimit = 13;
12340   verifyFormat("int function(\n"
12341                "    int  x,\n"
12342                "    bool y);",
12343                Alignment);
12344   Alignment.ColumnLimit = OldColumnLimit;
12345   // Ensure function pointers don't screw up recursive alignment
12346   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12347                "double b();",
12348                Alignment);
12349   Alignment.AlignConsecutiveAssignments = true;
12350   // Ensure recursive alignment is broken by function braces, so that the
12351   // "a = 1" does not align with subsequent assignments inside the function
12352   // body.
12353   verifyFormat("int func(int a = 1) {\n"
12354                "  int b  = 2;\n"
12355                "  int cc = 3;\n"
12356                "}",
12357                Alignment);
12358   verifyFormat("float      something = 2000;\n"
12359                "double     another   = 911;\n"
12360                "int        i = 1, j = 10;\n"
12361                "const int *oneMore = 1;\n"
12362                "unsigned   i       = 2;",
12363                Alignment);
12364   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12365                "unsigned oneTwo      = 0;   // comment",
12366                Alignment);
12367   // Make sure that scope is correctly tracked, in the absence of braces
12368   verifyFormat("for (int i = 0; i < n; i++)\n"
12369                "  j = i;\n"
12370                "double x = 1;\n",
12371                Alignment);
12372   verifyFormat("if (int i = 0)\n"
12373                "  j = i;\n"
12374                "double x = 1;\n",
12375                Alignment);
12376   // Ensure operator[] and operator() are comprehended
12377   verifyFormat("struct test {\n"
12378                "  long long int foo();\n"
12379                "  int           operator[](int a);\n"
12380                "  double        bar();\n"
12381                "};\n",
12382                Alignment);
12383   verifyFormat("struct test {\n"
12384                "  long long int foo();\n"
12385                "  int           operator()(int a);\n"
12386                "  double        bar();\n"
12387                "};\n",
12388                Alignment);
12389   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12390             "  int const i   = 1;\n"
12391             "  int *     j   = 2;\n"
12392             "  int       big = 10000;\n"
12393             "\n"
12394             "  unsigned oneTwoThree = 123;\n"
12395             "  int      oneTwo      = 12;\n"
12396             "  method();\n"
12397             "  float k  = 2;\n"
12398             "  int   ll = 10000;\n"
12399             "}",
12400             format("void SomeFunction(int parameter= 0) {\n"
12401                    " int const  i= 1;\n"
12402                    "  int *j=2;\n"
12403                    " int big  =  10000;\n"
12404                    "\n"
12405                    "unsigned oneTwoThree  =123;\n"
12406                    "int oneTwo = 12;\n"
12407                    "  method();\n"
12408                    "float k= 2;\n"
12409                    "int ll=10000;\n"
12410                    "}",
12411                    Alignment));
12412   Alignment.AlignConsecutiveAssignments = false;
12413   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12414   verifyFormat("#define A \\\n"
12415                "  int       aaaa = 12; \\\n"
12416                "  float     b = 23; \\\n"
12417                "  const int ccc = 234; \\\n"
12418                "  unsigned  dddddddddd = 2345;",
12419                Alignment);
12420   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12421   verifyFormat("#define A              \\\n"
12422                "  int       aaaa = 12; \\\n"
12423                "  float     b = 23;    \\\n"
12424                "  const int ccc = 234; \\\n"
12425                "  unsigned  dddddddddd = 2345;",
12426                Alignment);
12427   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12428   Alignment.ColumnLimit = 30;
12429   verifyFormat("#define A                    \\\n"
12430                "  int       aaaa = 12;       \\\n"
12431                "  float     b = 23;          \\\n"
12432                "  const int ccc = 234;       \\\n"
12433                "  int       dddddddddd = 2345;",
12434                Alignment);
12435   Alignment.ColumnLimit = 80;
12436   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12437                "k = 4, int l = 5,\n"
12438                "                  int m = 6) {\n"
12439                "  const int j = 10;\n"
12440                "  otherThing = 1;\n"
12441                "}",
12442                Alignment);
12443   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12444                "  int const i = 1;\n"
12445                "  int *     j = 2;\n"
12446                "  int       big = 10000;\n"
12447                "}",
12448                Alignment);
12449   verifyFormat("class C {\n"
12450                "public:\n"
12451                "  int          i = 1;\n"
12452                "  virtual void f() = 0;\n"
12453                "};",
12454                Alignment);
12455   verifyFormat("float i = 1;\n"
12456                "if (SomeType t = getSomething()) {\n"
12457                "}\n"
12458                "const unsigned j = 2;\n"
12459                "int            big = 10000;",
12460                Alignment);
12461   verifyFormat("float j = 7;\n"
12462                "for (int k = 0; k < N; ++k) {\n"
12463                "}\n"
12464                "unsigned j = 2;\n"
12465                "int      big = 10000;\n"
12466                "}",
12467                Alignment);
12468   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12469   verifyFormat("float              i = 1;\n"
12470                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12471                "    = someLooooooooooooooooongFunction();\n"
12472                "int j = 2;",
12473                Alignment);
12474   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12475   verifyFormat("int                i = 1;\n"
12476                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12477                "    someLooooooooooooooooongFunction();\n"
12478                "int j = 2;",
12479                Alignment);
12480 
12481   Alignment.AlignConsecutiveAssignments = true;
12482   verifyFormat("auto lambda = []() {\n"
12483                "  auto  ii = 0;\n"
12484                "  float j  = 0;\n"
12485                "  return 0;\n"
12486                "};\n"
12487                "int   i  = 0;\n"
12488                "float i2 = 0;\n"
12489                "auto  v  = type{\n"
12490                "    i = 1,   //\n"
12491                "    (i = 2), //\n"
12492                "    i = 3    //\n"
12493                "};",
12494                Alignment);
12495   Alignment.AlignConsecutiveAssignments = false;
12496 
12497   verifyFormat(
12498       "int      i = 1;\n"
12499       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12500       "                          loooooooooooooooooooooongParameterB);\n"
12501       "int      j = 2;",
12502       Alignment);
12503 
12504   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12505   // We expect declarations and assignments to align, as long as it doesn't
12506   // exceed the column limit, starting a new alignment sequence whenever it
12507   // happens.
12508   Alignment.AlignConsecutiveAssignments = true;
12509   Alignment.ColumnLimit = 30;
12510   verifyFormat("float    ii              = 1;\n"
12511                "unsigned j               = 2;\n"
12512                "int someVerylongVariable = 1;\n"
12513                "AnotherLongType  ll = 123456;\n"
12514                "VeryVeryLongType k  = 2;\n"
12515                "int              myvar = 1;",
12516                Alignment);
12517   Alignment.ColumnLimit = 80;
12518   Alignment.AlignConsecutiveAssignments = false;
12519 
12520   verifyFormat(
12521       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12522       "          typename LongType, typename B>\n"
12523       "auto foo() {}\n",
12524       Alignment);
12525   verifyFormat("float a, b = 1;\n"
12526                "int   c = 2;\n"
12527                "int   dd = 3;\n",
12528                Alignment);
12529   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12530                "float b[1][] = {{3.f}};\n",
12531                Alignment);
12532   Alignment.AlignConsecutiveAssignments = true;
12533   verifyFormat("float a, b = 1;\n"
12534                "int   c  = 2;\n"
12535                "int   dd = 3;\n",
12536                Alignment);
12537   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12538                "float b[1][] = {{3.f}};\n",
12539                Alignment);
12540   Alignment.AlignConsecutiveAssignments = false;
12541 
12542   Alignment.ColumnLimit = 30;
12543   Alignment.BinPackParameters = false;
12544   verifyFormat("void foo(float     a,\n"
12545                "         float     b,\n"
12546                "         int       c,\n"
12547                "         uint32_t *d) {\n"
12548                "  int *  e = 0;\n"
12549                "  float  f = 0;\n"
12550                "  double g = 0;\n"
12551                "}\n"
12552                "void bar(ino_t     a,\n"
12553                "         int       b,\n"
12554                "         uint32_t *c,\n"
12555                "         bool      d) {}\n",
12556                Alignment);
12557   Alignment.BinPackParameters = true;
12558   Alignment.ColumnLimit = 80;
12559 
12560   // Bug 33507
12561   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12562   verifyFormat(
12563       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12564       "  static const Version verVs2017;\n"
12565       "  return true;\n"
12566       "});\n",
12567       Alignment);
12568   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12569 
12570   // See llvm.org/PR35641
12571   Alignment.AlignConsecutiveDeclarations = true;
12572   verifyFormat("int func() { //\n"
12573                "  int      b;\n"
12574                "  unsigned c;\n"
12575                "}",
12576                Alignment);
12577 
12578   // See PR37175
12579   FormatStyle Style = getMozillaStyle();
12580   Style.AlignConsecutiveDeclarations = true;
12581   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12582             "foo(int a);",
12583             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12584 }
12585 
12586 TEST_F(FormatTest, LinuxBraceBreaking) {
12587   FormatStyle LinuxBraceStyle = getLLVMStyle();
12588   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12589   verifyFormat("namespace a\n"
12590                "{\n"
12591                "class A\n"
12592                "{\n"
12593                "  void f()\n"
12594                "  {\n"
12595                "    if (true) {\n"
12596                "      a();\n"
12597                "      b();\n"
12598                "    } else {\n"
12599                "      a();\n"
12600                "    }\n"
12601                "  }\n"
12602                "  void g() { return; }\n"
12603                "};\n"
12604                "struct B {\n"
12605                "  int x;\n"
12606                "};\n"
12607                "} // namespace a\n",
12608                LinuxBraceStyle);
12609   verifyFormat("enum X {\n"
12610                "  Y = 0,\n"
12611                "}\n",
12612                LinuxBraceStyle);
12613   verifyFormat("struct S {\n"
12614                "  int Type;\n"
12615                "  union {\n"
12616                "    int x;\n"
12617                "    double y;\n"
12618                "  } Value;\n"
12619                "  class C\n"
12620                "  {\n"
12621                "    MyFavoriteType Value;\n"
12622                "  } Class;\n"
12623                "}\n",
12624                LinuxBraceStyle);
12625 }
12626 
12627 TEST_F(FormatTest, MozillaBraceBreaking) {
12628   FormatStyle MozillaBraceStyle = getLLVMStyle();
12629   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
12630   MozillaBraceStyle.FixNamespaceComments = false;
12631   verifyFormat("namespace a {\n"
12632                "class A\n"
12633                "{\n"
12634                "  void f()\n"
12635                "  {\n"
12636                "    if (true) {\n"
12637                "      a();\n"
12638                "      b();\n"
12639                "    }\n"
12640                "  }\n"
12641                "  void g() { return; }\n"
12642                "};\n"
12643                "enum E\n"
12644                "{\n"
12645                "  A,\n"
12646                "  // foo\n"
12647                "  B,\n"
12648                "  C\n"
12649                "};\n"
12650                "struct B\n"
12651                "{\n"
12652                "  int x;\n"
12653                "};\n"
12654                "}\n",
12655                MozillaBraceStyle);
12656   verifyFormat("struct S\n"
12657                "{\n"
12658                "  int Type;\n"
12659                "  union\n"
12660                "  {\n"
12661                "    int x;\n"
12662                "    double y;\n"
12663                "  } Value;\n"
12664                "  class C\n"
12665                "  {\n"
12666                "    MyFavoriteType Value;\n"
12667                "  } Class;\n"
12668                "}\n",
12669                MozillaBraceStyle);
12670 }
12671 
12672 TEST_F(FormatTest, StroustrupBraceBreaking) {
12673   FormatStyle StroustrupBraceStyle = getLLVMStyle();
12674   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12675   verifyFormat("namespace a {\n"
12676                "class A {\n"
12677                "  void f()\n"
12678                "  {\n"
12679                "    if (true) {\n"
12680                "      a();\n"
12681                "      b();\n"
12682                "    }\n"
12683                "  }\n"
12684                "  void g() { return; }\n"
12685                "};\n"
12686                "struct B {\n"
12687                "  int x;\n"
12688                "};\n"
12689                "} // namespace a\n",
12690                StroustrupBraceStyle);
12691 
12692   verifyFormat("void foo()\n"
12693                "{\n"
12694                "  if (a) {\n"
12695                "    a();\n"
12696                "  }\n"
12697                "  else {\n"
12698                "    b();\n"
12699                "  }\n"
12700                "}\n",
12701                StroustrupBraceStyle);
12702 
12703   verifyFormat("#ifdef _DEBUG\n"
12704                "int foo(int i = 0)\n"
12705                "#else\n"
12706                "int foo(int i = 5)\n"
12707                "#endif\n"
12708                "{\n"
12709                "  return i;\n"
12710                "}",
12711                StroustrupBraceStyle);
12712 
12713   verifyFormat("void foo() {}\n"
12714                "void bar()\n"
12715                "#ifdef _DEBUG\n"
12716                "{\n"
12717                "  foo();\n"
12718                "}\n"
12719                "#else\n"
12720                "{\n"
12721                "}\n"
12722                "#endif",
12723                StroustrupBraceStyle);
12724 
12725   verifyFormat("void foobar() { int i = 5; }\n"
12726                "#ifdef _DEBUG\n"
12727                "void bar() {}\n"
12728                "#else\n"
12729                "void bar() { foobar(); }\n"
12730                "#endif",
12731                StroustrupBraceStyle);
12732 }
12733 
12734 TEST_F(FormatTest, AllmanBraceBreaking) {
12735   FormatStyle AllmanBraceStyle = getLLVMStyle();
12736   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
12737 
12738   EXPECT_EQ("namespace a\n"
12739             "{\n"
12740             "void f();\n"
12741             "void g();\n"
12742             "} // namespace a\n",
12743             format("namespace a\n"
12744                    "{\n"
12745                    "void f();\n"
12746                    "void g();\n"
12747                    "}\n",
12748                    AllmanBraceStyle));
12749 
12750   verifyFormat("namespace a\n"
12751                "{\n"
12752                "class A\n"
12753                "{\n"
12754                "  void f()\n"
12755                "  {\n"
12756                "    if (true)\n"
12757                "    {\n"
12758                "      a();\n"
12759                "      b();\n"
12760                "    }\n"
12761                "  }\n"
12762                "  void g() { return; }\n"
12763                "};\n"
12764                "struct B\n"
12765                "{\n"
12766                "  int x;\n"
12767                "};\n"
12768                "union C\n"
12769                "{\n"
12770                "};\n"
12771                "} // namespace a",
12772                AllmanBraceStyle);
12773 
12774   verifyFormat("void f()\n"
12775                "{\n"
12776                "  if (true)\n"
12777                "  {\n"
12778                "    a();\n"
12779                "  }\n"
12780                "  else if (false)\n"
12781                "  {\n"
12782                "    b();\n"
12783                "  }\n"
12784                "  else\n"
12785                "  {\n"
12786                "    c();\n"
12787                "  }\n"
12788                "}\n",
12789                AllmanBraceStyle);
12790 
12791   verifyFormat("void f()\n"
12792                "{\n"
12793                "  for (int i = 0; i < 10; ++i)\n"
12794                "  {\n"
12795                "    a();\n"
12796                "  }\n"
12797                "  while (false)\n"
12798                "  {\n"
12799                "    b();\n"
12800                "  }\n"
12801                "  do\n"
12802                "  {\n"
12803                "    c();\n"
12804                "  } while (false)\n"
12805                "}\n",
12806                AllmanBraceStyle);
12807 
12808   verifyFormat("void f(int a)\n"
12809                "{\n"
12810                "  switch (a)\n"
12811                "  {\n"
12812                "  case 0:\n"
12813                "    break;\n"
12814                "  case 1:\n"
12815                "  {\n"
12816                "    break;\n"
12817                "  }\n"
12818                "  case 2:\n"
12819                "  {\n"
12820                "  }\n"
12821                "  break;\n"
12822                "  default:\n"
12823                "    break;\n"
12824                "  }\n"
12825                "}\n",
12826                AllmanBraceStyle);
12827 
12828   verifyFormat("enum X\n"
12829                "{\n"
12830                "  Y = 0,\n"
12831                "}\n",
12832                AllmanBraceStyle);
12833   verifyFormat("enum X\n"
12834                "{\n"
12835                "  Y = 0\n"
12836                "}\n",
12837                AllmanBraceStyle);
12838 
12839   verifyFormat("@interface BSApplicationController ()\n"
12840                "{\n"
12841                "@private\n"
12842                "  id _extraIvar;\n"
12843                "}\n"
12844                "@end\n",
12845                AllmanBraceStyle);
12846 
12847   verifyFormat("#ifdef _DEBUG\n"
12848                "int foo(int i = 0)\n"
12849                "#else\n"
12850                "int foo(int i = 5)\n"
12851                "#endif\n"
12852                "{\n"
12853                "  return i;\n"
12854                "}",
12855                AllmanBraceStyle);
12856 
12857   verifyFormat("void foo() {}\n"
12858                "void bar()\n"
12859                "#ifdef _DEBUG\n"
12860                "{\n"
12861                "  foo();\n"
12862                "}\n"
12863                "#else\n"
12864                "{\n"
12865                "}\n"
12866                "#endif",
12867                AllmanBraceStyle);
12868 
12869   verifyFormat("void foobar() { int i = 5; }\n"
12870                "#ifdef _DEBUG\n"
12871                "void bar() {}\n"
12872                "#else\n"
12873                "void bar() { foobar(); }\n"
12874                "#endif",
12875                AllmanBraceStyle);
12876 
12877   // This shouldn't affect ObjC blocks..
12878   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
12879                "  // ...\n"
12880                "  int i;\n"
12881                "}];",
12882                AllmanBraceStyle);
12883   verifyFormat("void (^block)(void) = ^{\n"
12884                "  // ...\n"
12885                "  int i;\n"
12886                "};",
12887                AllmanBraceStyle);
12888   // .. or dict literals.
12889   verifyFormat("void f()\n"
12890                "{\n"
12891                "  // ...\n"
12892                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
12893                "}",
12894                AllmanBraceStyle);
12895   verifyFormat("void f()\n"
12896                "{\n"
12897                "  // ...\n"
12898                "  [object someMethod:@{a : @\"b\"}];\n"
12899                "}",
12900                AllmanBraceStyle);
12901   verifyFormat("int f()\n"
12902                "{ // comment\n"
12903                "  return 42;\n"
12904                "}",
12905                AllmanBraceStyle);
12906 
12907   AllmanBraceStyle.ColumnLimit = 19;
12908   verifyFormat("void f() { int i; }", AllmanBraceStyle);
12909   AllmanBraceStyle.ColumnLimit = 18;
12910   verifyFormat("void f()\n"
12911                "{\n"
12912                "  int i;\n"
12913                "}",
12914                AllmanBraceStyle);
12915   AllmanBraceStyle.ColumnLimit = 80;
12916 
12917   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
12918   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
12919       FormatStyle::SIS_WithoutElse;
12920   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
12921   verifyFormat("void f(bool b)\n"
12922                "{\n"
12923                "  if (b)\n"
12924                "  {\n"
12925                "    return;\n"
12926                "  }\n"
12927                "}\n",
12928                BreakBeforeBraceShortIfs);
12929   verifyFormat("void f(bool b)\n"
12930                "{\n"
12931                "  if constexpr (b)\n"
12932                "  {\n"
12933                "    return;\n"
12934                "  }\n"
12935                "}\n",
12936                BreakBeforeBraceShortIfs);
12937   verifyFormat("void f(bool b)\n"
12938                "{\n"
12939                "  if CONSTEXPR (b)\n"
12940                "  {\n"
12941                "    return;\n"
12942                "  }\n"
12943                "}\n",
12944                BreakBeforeBraceShortIfs);
12945   verifyFormat("void f(bool b)\n"
12946                "{\n"
12947                "  if (b) return;\n"
12948                "}\n",
12949                BreakBeforeBraceShortIfs);
12950   verifyFormat("void f(bool b)\n"
12951                "{\n"
12952                "  if constexpr (b) return;\n"
12953                "}\n",
12954                BreakBeforeBraceShortIfs);
12955   verifyFormat("void f(bool b)\n"
12956                "{\n"
12957                "  if CONSTEXPR (b) return;\n"
12958                "}\n",
12959                BreakBeforeBraceShortIfs);
12960   verifyFormat("void f(bool b)\n"
12961                "{\n"
12962                "  while (b)\n"
12963                "  {\n"
12964                "    return;\n"
12965                "  }\n"
12966                "}\n",
12967                BreakBeforeBraceShortIfs);
12968 }
12969 
12970 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
12971   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
12972   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
12973 
12974   // Make a few changes to the style for testing purposes
12975   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
12976       FormatStyle::SFS_Empty;
12977   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
12978   WhitesmithsBraceStyle.ColumnLimit = 0;
12979 
12980   // FIXME: this test case can't decide whether there should be a blank line
12981   // after the ~D() line or not. It adds one if one doesn't exist in the test
12982   // and it removes the line if one exists.
12983   /*
12984   verifyFormat("class A;\n"
12985                "namespace B\n"
12986                "  {\n"
12987                "class C;\n"
12988                "// Comment\n"
12989                "class D\n"
12990                "  {\n"
12991                "public:\n"
12992                "  D();\n"
12993                "  ~D() {}\n"
12994                "private:\n"
12995                "  enum E\n"
12996                "    {\n"
12997                "    F\n"
12998                "    }\n"
12999                "  };\n"
13000                "  } // namespace B\n",
13001                WhitesmithsBraceStyle);
13002   */
13003 
13004   verifyFormat("namespace a\n"
13005                "  {\n"
13006                "class A\n"
13007                "  {\n"
13008                "  void f()\n"
13009                "    {\n"
13010                "    if (true)\n"
13011                "      {\n"
13012                "      a();\n"
13013                "      b();\n"
13014                "      }\n"
13015                "    }\n"
13016                "  void g()\n"
13017                "    {\n"
13018                "    return;\n"
13019                "    }\n"
13020                "  };\n"
13021                "struct B\n"
13022                "  {\n"
13023                "  int x;\n"
13024                "  };\n"
13025                "  } // namespace a",
13026                WhitesmithsBraceStyle);
13027 
13028   verifyFormat("void f()\n"
13029                "  {\n"
13030                "  if (true)\n"
13031                "    {\n"
13032                "    a();\n"
13033                "    }\n"
13034                "  else if (false)\n"
13035                "    {\n"
13036                "    b();\n"
13037                "    }\n"
13038                "  else\n"
13039                "    {\n"
13040                "    c();\n"
13041                "    }\n"
13042                "  }\n",
13043                WhitesmithsBraceStyle);
13044 
13045   verifyFormat("void f()\n"
13046                "  {\n"
13047                "  for (int i = 0; i < 10; ++i)\n"
13048                "    {\n"
13049                "    a();\n"
13050                "    }\n"
13051                "  while (false)\n"
13052                "    {\n"
13053                "    b();\n"
13054                "    }\n"
13055                "  do\n"
13056                "    {\n"
13057                "    c();\n"
13058                "    } while (false)\n"
13059                "  }\n",
13060                WhitesmithsBraceStyle);
13061 
13062   WhitesmithsBraceStyle.IndentCaseBlocks = true;
13063   verifyFormat("void switchTest1(int a)\n"
13064                "  {\n"
13065                "  switch (a)\n"
13066                "    {\n"
13067                "    case 2:\n"
13068                "      {\n"
13069                "      }\n"
13070                "    break;\n"
13071                "    }\n"
13072                "  }\n",
13073                WhitesmithsBraceStyle);
13074 
13075   verifyFormat("void switchTest2(int a)\n"
13076                "  {\n"
13077                "  switch (a)\n"
13078                "    {\n"
13079                "    case 0:\n"
13080                "    break;\n"
13081                "    case 1:\n"
13082                "      {\n"
13083                "      break;\n"
13084                "      }\n"
13085                "    case 2:\n"
13086                "      {\n"
13087                "      }\n"
13088                "    break;\n"
13089                "    default:\n"
13090                "    break;\n"
13091                "    }\n"
13092                "  }\n",
13093                WhitesmithsBraceStyle);
13094 
13095   verifyFormat("void switchTest3(int a)\n"
13096                "  {\n"
13097                "  switch (a)\n"
13098                "    {\n"
13099                "    case 0:\n"
13100                "      {\n"
13101                "      foo(x);\n"
13102                "      }\n"
13103                "    break;\n"
13104                "    default:\n"
13105                "      {\n"
13106                "      foo(1);\n"
13107                "      }\n"
13108                "    break;\n"
13109                "    }\n"
13110                "  }\n",
13111                WhitesmithsBraceStyle);
13112 
13113   WhitesmithsBraceStyle.IndentCaseBlocks = false;
13114 
13115   verifyFormat("void switchTest4(int a)\n"
13116                "  {\n"
13117                "  switch (a)\n"
13118                "    {\n"
13119                "    case 2:\n"
13120                "    {\n"
13121                "    }\n"
13122                "    break;\n"
13123                "    }\n"
13124                "  }\n",
13125                WhitesmithsBraceStyle);
13126 
13127   verifyFormat("void switchTest5(int a)\n"
13128                "  {\n"
13129                "  switch (a)\n"
13130                "    {\n"
13131                "    case 0:\n"
13132                "    break;\n"
13133                "    case 1:\n"
13134                "    {\n"
13135                "    foo();\n"
13136                "    break;\n"
13137                "    }\n"
13138                "    case 2:\n"
13139                "    {\n"
13140                "    }\n"
13141                "    break;\n"
13142                "    default:\n"
13143                "    break;\n"
13144                "    }\n"
13145                "  }\n",
13146                WhitesmithsBraceStyle);
13147 
13148   verifyFormat("void switchTest6(int a)\n"
13149                "  {\n"
13150                "  switch (a)\n"
13151                "    {\n"
13152                "    case 0:\n"
13153                "    {\n"
13154                "    foo(x);\n"
13155                "    }\n"
13156                "    break;\n"
13157                "    default:\n"
13158                "    {\n"
13159                "    foo(1);\n"
13160                "    }\n"
13161                "    break;\n"
13162                "    }\n"
13163                "  }\n",
13164                WhitesmithsBraceStyle);
13165 
13166   verifyFormat("enum X\n"
13167                "  {\n"
13168                "  Y = 0, // testing\n"
13169                "  }\n",
13170                WhitesmithsBraceStyle);
13171 
13172   verifyFormat("enum X\n"
13173                "  {\n"
13174                "  Y = 0\n"
13175                "  }\n",
13176                WhitesmithsBraceStyle);
13177   verifyFormat("enum X\n"
13178                "  {\n"
13179                "  Y = 0,\n"
13180                "  Z = 1\n"
13181                "  };\n",
13182                WhitesmithsBraceStyle);
13183 
13184   verifyFormat("@interface BSApplicationController ()\n"
13185                "  {\n"
13186                "@private\n"
13187                "  id _extraIvar;\n"
13188                "  }\n"
13189                "@end\n",
13190                WhitesmithsBraceStyle);
13191 
13192   verifyFormat("#ifdef _DEBUG\n"
13193                "int foo(int i = 0)\n"
13194                "#else\n"
13195                "int foo(int i = 5)\n"
13196                "#endif\n"
13197                "  {\n"
13198                "  return i;\n"
13199                "  }",
13200                WhitesmithsBraceStyle);
13201 
13202   verifyFormat("void foo() {}\n"
13203                "void bar()\n"
13204                "#ifdef _DEBUG\n"
13205                "  {\n"
13206                "  foo();\n"
13207                "  }\n"
13208                "#else\n"
13209                "  {\n"
13210                "  }\n"
13211                "#endif",
13212                WhitesmithsBraceStyle);
13213 
13214   verifyFormat("void foobar()\n"
13215                "  {\n"
13216                "  int i = 5;\n"
13217                "  }\n"
13218                "#ifdef _DEBUG\n"
13219                "void bar()\n"
13220                "  {\n"
13221                "  }\n"
13222                "#else\n"
13223                "void bar()\n"
13224                "  {\n"
13225                "  foobar();\n"
13226                "  }\n"
13227                "#endif",
13228                WhitesmithsBraceStyle);
13229 
13230   // This shouldn't affect ObjC blocks..
13231   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13232                "  // ...\n"
13233                "  int i;\n"
13234                "}];",
13235                WhitesmithsBraceStyle);
13236   verifyFormat("void (^block)(void) = ^{\n"
13237                "  // ...\n"
13238                "  int i;\n"
13239                "};",
13240                WhitesmithsBraceStyle);
13241   // .. or dict literals.
13242   verifyFormat("void f()\n"
13243                "  {\n"
13244                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13245                "  }",
13246                WhitesmithsBraceStyle);
13247 
13248   verifyFormat("int f()\n"
13249                "  { // comment\n"
13250                "  return 42;\n"
13251                "  }",
13252                WhitesmithsBraceStyle);
13253 
13254   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13255   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13256       FormatStyle::SIS_Always;
13257   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13258   verifyFormat("void f(bool b)\n"
13259                "  {\n"
13260                "  if (b)\n"
13261                "    {\n"
13262                "    return;\n"
13263                "    }\n"
13264                "  }\n",
13265                BreakBeforeBraceShortIfs);
13266   verifyFormat("void f(bool b)\n"
13267                "  {\n"
13268                "  if (b) return;\n"
13269                "  }\n",
13270                BreakBeforeBraceShortIfs);
13271   verifyFormat("void f(bool b)\n"
13272                "  {\n"
13273                "  while (b)\n"
13274                "    {\n"
13275                "    return;\n"
13276                "    }\n"
13277                "  }\n",
13278                BreakBeforeBraceShortIfs);
13279 }
13280 
13281 TEST_F(FormatTest, GNUBraceBreaking) {
13282   FormatStyle GNUBraceStyle = getLLVMStyle();
13283   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13284   verifyFormat("namespace a\n"
13285                "{\n"
13286                "class A\n"
13287                "{\n"
13288                "  void f()\n"
13289                "  {\n"
13290                "    int a;\n"
13291                "    {\n"
13292                "      int b;\n"
13293                "    }\n"
13294                "    if (true)\n"
13295                "      {\n"
13296                "        a();\n"
13297                "        b();\n"
13298                "      }\n"
13299                "  }\n"
13300                "  void g() { return; }\n"
13301                "}\n"
13302                "} // namespace a",
13303                GNUBraceStyle);
13304 
13305   verifyFormat("void f()\n"
13306                "{\n"
13307                "  if (true)\n"
13308                "    {\n"
13309                "      a();\n"
13310                "    }\n"
13311                "  else if (false)\n"
13312                "    {\n"
13313                "      b();\n"
13314                "    }\n"
13315                "  else\n"
13316                "    {\n"
13317                "      c();\n"
13318                "    }\n"
13319                "}\n",
13320                GNUBraceStyle);
13321 
13322   verifyFormat("void f()\n"
13323                "{\n"
13324                "  for (int i = 0; i < 10; ++i)\n"
13325                "    {\n"
13326                "      a();\n"
13327                "    }\n"
13328                "  while (false)\n"
13329                "    {\n"
13330                "      b();\n"
13331                "    }\n"
13332                "  do\n"
13333                "    {\n"
13334                "      c();\n"
13335                "    }\n"
13336                "  while (false);\n"
13337                "}\n",
13338                GNUBraceStyle);
13339 
13340   verifyFormat("void f(int a)\n"
13341                "{\n"
13342                "  switch (a)\n"
13343                "    {\n"
13344                "    case 0:\n"
13345                "      break;\n"
13346                "    case 1:\n"
13347                "      {\n"
13348                "        break;\n"
13349                "      }\n"
13350                "    case 2:\n"
13351                "      {\n"
13352                "      }\n"
13353                "      break;\n"
13354                "    default:\n"
13355                "      break;\n"
13356                "    }\n"
13357                "}\n",
13358                GNUBraceStyle);
13359 
13360   verifyFormat("enum X\n"
13361                "{\n"
13362                "  Y = 0,\n"
13363                "}\n",
13364                GNUBraceStyle);
13365 
13366   verifyFormat("@interface BSApplicationController ()\n"
13367                "{\n"
13368                "@private\n"
13369                "  id _extraIvar;\n"
13370                "}\n"
13371                "@end\n",
13372                GNUBraceStyle);
13373 
13374   verifyFormat("#ifdef _DEBUG\n"
13375                "int foo(int i = 0)\n"
13376                "#else\n"
13377                "int foo(int i = 5)\n"
13378                "#endif\n"
13379                "{\n"
13380                "  return i;\n"
13381                "}",
13382                GNUBraceStyle);
13383 
13384   verifyFormat("void foo() {}\n"
13385                "void bar()\n"
13386                "#ifdef _DEBUG\n"
13387                "{\n"
13388                "  foo();\n"
13389                "}\n"
13390                "#else\n"
13391                "{\n"
13392                "}\n"
13393                "#endif",
13394                GNUBraceStyle);
13395 
13396   verifyFormat("void foobar() { int i = 5; }\n"
13397                "#ifdef _DEBUG\n"
13398                "void bar() {}\n"
13399                "#else\n"
13400                "void bar() { foobar(); }\n"
13401                "#endif",
13402                GNUBraceStyle);
13403 }
13404 
13405 TEST_F(FormatTest, WebKitBraceBreaking) {
13406   FormatStyle WebKitBraceStyle = getLLVMStyle();
13407   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13408   WebKitBraceStyle.FixNamespaceComments = false;
13409   verifyFormat("namespace a {\n"
13410                "class A {\n"
13411                "  void f()\n"
13412                "  {\n"
13413                "    if (true) {\n"
13414                "      a();\n"
13415                "      b();\n"
13416                "    }\n"
13417                "  }\n"
13418                "  void g() { return; }\n"
13419                "};\n"
13420                "enum E {\n"
13421                "  A,\n"
13422                "  // foo\n"
13423                "  B,\n"
13424                "  C\n"
13425                "};\n"
13426                "struct B {\n"
13427                "  int x;\n"
13428                "};\n"
13429                "}\n",
13430                WebKitBraceStyle);
13431   verifyFormat("struct S {\n"
13432                "  int Type;\n"
13433                "  union {\n"
13434                "    int x;\n"
13435                "    double y;\n"
13436                "  } Value;\n"
13437                "  class C {\n"
13438                "    MyFavoriteType Value;\n"
13439                "  } Class;\n"
13440                "};\n",
13441                WebKitBraceStyle);
13442 }
13443 
13444 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13445   verifyFormat("void f() {\n"
13446                "  try {\n"
13447                "  } catch (const Exception &e) {\n"
13448                "  }\n"
13449                "}\n",
13450                getLLVMStyle());
13451 }
13452 
13453 TEST_F(FormatTest, UnderstandsPragmas) {
13454   verifyFormat("#pragma omp reduction(| : var)");
13455   verifyFormat("#pragma omp reduction(+ : var)");
13456 
13457   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13458             "(including parentheses).",
13459             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13460                    "(including parentheses)."));
13461 }
13462 
13463 TEST_F(FormatTest, UnderstandPragmaOption) {
13464   verifyFormat("#pragma option -C -A");
13465 
13466   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13467 }
13468 
13469 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13470   FormatStyle Style = getLLVMStyle();
13471   Style.ColumnLimit = 20;
13472 
13473   // See PR41213
13474   EXPECT_EQ("/*\n"
13475             " *\t9012345\n"
13476             " * /8901\n"
13477             " */",
13478             format("/*\n"
13479                    " *\t9012345 /8901\n"
13480                    " */",
13481                    Style));
13482   EXPECT_EQ("/*\n"
13483             " *345678\n"
13484             " *\t/8901\n"
13485             " */",
13486             format("/*\n"
13487                    " *345678\t/8901\n"
13488                    " */",
13489                    Style));
13490 
13491   verifyFormat("int a; // the\n"
13492                "       // comment",
13493                Style);
13494   EXPECT_EQ("int a; /* first line\n"
13495             "        * second\n"
13496             "        * line third\n"
13497             "        * line\n"
13498             "        */",
13499             format("int a; /* first line\n"
13500                    "        * second\n"
13501                    "        * line third\n"
13502                    "        * line\n"
13503                    "        */",
13504                    Style));
13505   EXPECT_EQ("int a; // first line\n"
13506             "       // second\n"
13507             "       // line third\n"
13508             "       // line",
13509             format("int a; // first line\n"
13510                    "       // second line\n"
13511                    "       // third line",
13512                    Style));
13513 
13514   Style.PenaltyExcessCharacter = 90;
13515   verifyFormat("int a; // the comment", Style);
13516   EXPECT_EQ("int a; // the comment\n"
13517             "       // aaa",
13518             format("int a; // the comment aaa", Style));
13519   EXPECT_EQ("int a; /* first line\n"
13520             "        * second line\n"
13521             "        * third line\n"
13522             "        */",
13523             format("int a; /* first line\n"
13524                    "        * second line\n"
13525                    "        * third line\n"
13526                    "        */",
13527                    Style));
13528   EXPECT_EQ("int a; // first line\n"
13529             "       // second line\n"
13530             "       // third line",
13531             format("int a; // first line\n"
13532                    "       // second line\n"
13533                    "       // third line",
13534                    Style));
13535   // FIXME: Investigate why this is not getting the same layout as the test
13536   // above.
13537   EXPECT_EQ("int a; /* first line\n"
13538             "        * second line\n"
13539             "        * third line\n"
13540             "        */",
13541             format("int a; /* first line second line third line"
13542                    "\n*/",
13543                    Style));
13544 
13545   EXPECT_EQ("// foo bar baz bazfoo\n"
13546             "// foo bar foo bar\n",
13547             format("// foo bar baz bazfoo\n"
13548                    "// foo bar foo           bar\n",
13549                    Style));
13550   EXPECT_EQ("// foo bar baz bazfoo\n"
13551             "// foo bar foo bar\n",
13552             format("// foo bar baz      bazfoo\n"
13553                    "// foo            bar foo bar\n",
13554                    Style));
13555 
13556   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13557   // next one.
13558   EXPECT_EQ("// foo bar baz bazfoo\n"
13559             "// bar foo bar\n",
13560             format("// foo bar baz      bazfoo bar\n"
13561                    "// foo            bar\n",
13562                    Style));
13563 
13564   EXPECT_EQ("// foo bar baz bazfoo\n"
13565             "// foo bar baz bazfoo\n"
13566             "// bar foo bar\n",
13567             format("// foo bar baz      bazfoo\n"
13568                    "// foo bar baz      bazfoo bar\n"
13569                    "// foo bar\n",
13570                    Style));
13571 
13572   EXPECT_EQ("// foo bar baz bazfoo\n"
13573             "// foo bar baz bazfoo\n"
13574             "// bar foo bar\n",
13575             format("// foo bar baz      bazfoo\n"
13576                    "// foo bar baz      bazfoo bar\n"
13577                    "// foo           bar\n",
13578                    Style));
13579 
13580   // Make sure we do not keep protruding characters if strict mode reflow is
13581   // cheaper than keeping protruding characters.
13582   Style.ColumnLimit = 21;
13583   EXPECT_EQ(
13584       "// foo foo foo foo\n"
13585       "// foo foo foo foo\n"
13586       "// foo foo foo foo\n",
13587       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13588 
13589   EXPECT_EQ("int a = /* long block\n"
13590             "           comment */\n"
13591             "    42;",
13592             format("int a = /* long block comment */ 42;", Style));
13593 }
13594 
13595 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13596   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13597   EXPECT_EQ(Styles[0], Styles[i])                                              \
13598       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13599 
13600 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13601   SmallVector<FormatStyle, 3> Styles;
13602   Styles.resize(3);
13603 
13604   Styles[0] = getLLVMStyle();
13605   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13606   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13607   EXPECT_ALL_STYLES_EQUAL(Styles);
13608 
13609   Styles[0] = getGoogleStyle();
13610   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13611   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13612   EXPECT_ALL_STYLES_EQUAL(Styles);
13613 
13614   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13615   EXPECT_TRUE(
13616       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13617   EXPECT_TRUE(
13618       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13619   EXPECT_ALL_STYLES_EQUAL(Styles);
13620 
13621   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13622   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13623   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
13624   EXPECT_ALL_STYLES_EQUAL(Styles);
13625 
13626   Styles[0] = getMozillaStyle();
13627   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
13628   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
13629   EXPECT_ALL_STYLES_EQUAL(Styles);
13630 
13631   Styles[0] = getWebKitStyle();
13632   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
13633   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
13634   EXPECT_ALL_STYLES_EQUAL(Styles);
13635 
13636   Styles[0] = getGNUStyle();
13637   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
13638   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
13639   EXPECT_ALL_STYLES_EQUAL(Styles);
13640 
13641   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
13642 }
13643 
13644 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
13645   SmallVector<FormatStyle, 8> Styles;
13646   Styles.resize(2);
13647 
13648   Styles[0] = getGoogleStyle();
13649   Styles[1] = getLLVMStyle();
13650   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13651   EXPECT_ALL_STYLES_EQUAL(Styles);
13652 
13653   Styles.resize(5);
13654   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13655   Styles[1] = getLLVMStyle();
13656   Styles[1].Language = FormatStyle::LK_JavaScript;
13657   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13658 
13659   Styles[2] = getLLVMStyle();
13660   Styles[2].Language = FormatStyle::LK_JavaScript;
13661   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
13662                                   "BasedOnStyle: Google",
13663                                   &Styles[2])
13664                    .value());
13665 
13666   Styles[3] = getLLVMStyle();
13667   Styles[3].Language = FormatStyle::LK_JavaScript;
13668   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
13669                                   "Language: JavaScript",
13670                                   &Styles[3])
13671                    .value());
13672 
13673   Styles[4] = getLLVMStyle();
13674   Styles[4].Language = FormatStyle::LK_JavaScript;
13675   EXPECT_EQ(0, parseConfiguration("---\n"
13676                                   "BasedOnStyle: LLVM\n"
13677                                   "IndentWidth: 123\n"
13678                                   "---\n"
13679                                   "BasedOnStyle: Google\n"
13680                                   "Language: JavaScript",
13681                                   &Styles[4])
13682                    .value());
13683   EXPECT_ALL_STYLES_EQUAL(Styles);
13684 }
13685 
13686 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
13687   Style.FIELD = false;                                                         \
13688   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
13689   EXPECT_TRUE(Style.FIELD);                                                    \
13690   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
13691   EXPECT_FALSE(Style.FIELD);
13692 
13693 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
13694 
13695 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
13696   Style.STRUCT.FIELD = false;                                                  \
13697   EXPECT_EQ(0,                                                                 \
13698             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
13699                 .value());                                                     \
13700   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
13701   EXPECT_EQ(0,                                                                 \
13702             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
13703                 .value());                                                     \
13704   EXPECT_FALSE(Style.STRUCT.FIELD);
13705 
13706 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
13707   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
13708 
13709 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
13710   EXPECT_NE(VALUE, Style.FIELD);                                               \
13711   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
13712   EXPECT_EQ(VALUE, Style.FIELD)
13713 
13714 TEST_F(FormatTest, ParsesConfigurationBools) {
13715   FormatStyle Style = {};
13716   Style.Language = FormatStyle::LK_Cpp;
13717   CHECK_PARSE_BOOL(AlignTrailingComments);
13718   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
13719   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
13720   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
13721   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
13722   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
13723   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
13724   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
13725   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
13726   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
13727   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
13728   CHECK_PARSE_BOOL(BinPackArguments);
13729   CHECK_PARSE_BOOL(BinPackParameters);
13730   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
13731   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
13732   CHECK_PARSE_BOOL(BreakStringLiterals);
13733   CHECK_PARSE_BOOL(CompactNamespaces);
13734   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
13735   CHECK_PARSE_BOOL(DeriveLineEnding);
13736   CHECK_PARSE_BOOL(DerivePointerAlignment);
13737   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
13738   CHECK_PARSE_BOOL(DisableFormat);
13739   CHECK_PARSE_BOOL(IndentCaseLabels);
13740   CHECK_PARSE_BOOL(IndentCaseBlocks);
13741   CHECK_PARSE_BOOL(IndentGotoLabels);
13742   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
13743   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
13744   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
13745   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
13746   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
13747   CHECK_PARSE_BOOL(ReflowComments);
13748   CHECK_PARSE_BOOL(SortIncludes);
13749   CHECK_PARSE_BOOL(SortUsingDeclarations);
13750   CHECK_PARSE_BOOL(SpacesInParentheses);
13751   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
13752   CHECK_PARSE_BOOL(SpacesInAngles);
13753   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
13754   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
13755   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
13756   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
13757   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
13758   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
13759   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
13760   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
13761   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
13762   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
13763   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
13764   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
13765   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
13766   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
13767   CHECK_PARSE_BOOL(UseCRLF);
13768 
13769   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
13770   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
13771   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
13772   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
13773   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
13774   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
13775   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
13776   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
13777   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
13778   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
13779   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
13780   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
13781   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
13782   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
13783   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
13784   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
13785   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
13786 }
13787 
13788 #undef CHECK_PARSE_BOOL
13789 
13790 TEST_F(FormatTest, ParsesConfiguration) {
13791   FormatStyle Style = {};
13792   Style.Language = FormatStyle::LK_Cpp;
13793   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
13794   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
13795               ConstructorInitializerIndentWidth, 1234u);
13796   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
13797   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
13798   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
13799   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
13800   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
13801               PenaltyBreakBeforeFirstCallParameter, 1234u);
13802   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
13803               PenaltyBreakTemplateDeclaration, 1234u);
13804   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
13805   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
13806               PenaltyReturnTypeOnItsOwnLine, 1234u);
13807   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
13808               SpacesBeforeTrailingComments, 1234u);
13809   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
13810   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
13811   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
13812 
13813   Style.PointerAlignment = FormatStyle::PAS_Middle;
13814   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
13815               FormatStyle::PAS_Left);
13816   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
13817               FormatStyle::PAS_Right);
13818   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
13819               FormatStyle::PAS_Middle);
13820   // For backward compatibility:
13821   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
13822               FormatStyle::PAS_Left);
13823   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
13824               FormatStyle::PAS_Right);
13825   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
13826               FormatStyle::PAS_Middle);
13827 
13828   Style.Standard = FormatStyle::LS_Auto;
13829   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
13830   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
13831   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
13832   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
13833   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
13834   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
13835   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
13836   // Legacy aliases:
13837   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
13838   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
13839   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
13840   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
13841 
13842   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13843   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
13844               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
13845   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
13846               FormatStyle::BOS_None);
13847   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
13848               FormatStyle::BOS_All);
13849   // For backward compatibility:
13850   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
13851               FormatStyle::BOS_None);
13852   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
13853               FormatStyle::BOS_All);
13854 
13855   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
13856   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
13857               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13858   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
13859               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
13860   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
13861               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
13862   // For backward compatibility:
13863   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
13864               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13865 
13866   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
13867   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
13868               FormatStyle::BILS_BeforeComma);
13869   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
13870               FormatStyle::BILS_AfterColon);
13871   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
13872               FormatStyle::BILS_BeforeColon);
13873   // For backward compatibility:
13874   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
13875               FormatStyle::BILS_BeforeComma);
13876 
13877   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
13878   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
13879               FormatStyle::BAS_Align);
13880   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
13881               FormatStyle::BAS_DontAlign);
13882   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
13883               FormatStyle::BAS_AlwaysBreak);
13884   // For backward compatibility:
13885   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
13886               FormatStyle::BAS_DontAlign);
13887   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
13888               FormatStyle::BAS_Align);
13889 
13890   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13891   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
13892               FormatStyle::ENAS_DontAlign);
13893   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
13894               FormatStyle::ENAS_Left);
13895   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
13896               FormatStyle::ENAS_Right);
13897   // For backward compatibility:
13898   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
13899               FormatStyle::ENAS_Left);
13900   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
13901               FormatStyle::ENAS_Right);
13902 
13903   Style.AlignOperands = FormatStyle::OAS_Align;
13904   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
13905               FormatStyle::OAS_DontAlign);
13906   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
13907   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
13908               FormatStyle::OAS_AlignAfterOperator);
13909   // For backward compatibility:
13910   CHECK_PARSE("AlignOperands: false", AlignOperands,
13911               FormatStyle::OAS_DontAlign);
13912   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
13913 
13914   Style.UseTab = FormatStyle::UT_ForIndentation;
13915   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
13916   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
13917   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
13918   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
13919               FormatStyle::UT_ForContinuationAndIndentation);
13920   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
13921               FormatStyle::UT_AlignWithSpaces);
13922   // For backward compatibility:
13923   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
13924   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
13925 
13926   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
13927   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
13928               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13929   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
13930               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
13931   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
13932               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13933   // For backward compatibility:
13934   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
13935               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13936   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
13937               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13938 
13939   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
13940   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
13941               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13942   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
13943               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
13944   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
13945               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
13946   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
13947               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13948   // For backward compatibility:
13949   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
13950               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13951   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
13952               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13953 
13954   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
13955   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
13956               FormatStyle::SBPO_Never);
13957   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
13958               FormatStyle::SBPO_Always);
13959   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
13960               FormatStyle::SBPO_ControlStatements);
13961   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
13962               FormatStyle::SBPO_NonEmptyParentheses);
13963   // For backward compatibility:
13964   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
13965               FormatStyle::SBPO_Never);
13966   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
13967               FormatStyle::SBPO_ControlStatements);
13968 
13969   Style.ColumnLimit = 123;
13970   FormatStyle BaseStyle = getLLVMStyle();
13971   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
13972   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
13973 
13974   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
13975   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
13976               FormatStyle::BS_Attach);
13977   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
13978               FormatStyle::BS_Linux);
13979   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
13980               FormatStyle::BS_Mozilla);
13981   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
13982               FormatStyle::BS_Stroustrup);
13983   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
13984               FormatStyle::BS_Allman);
13985   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
13986               FormatStyle::BS_Whitesmiths);
13987   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
13988   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
13989               FormatStyle::BS_WebKit);
13990   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
13991               FormatStyle::BS_Custom);
13992 
13993   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
13994   CHECK_PARSE("BraceWrapping:\n"
13995               "  AfterControlStatement: MultiLine",
13996               BraceWrapping.AfterControlStatement,
13997               FormatStyle::BWACS_MultiLine);
13998   CHECK_PARSE("BraceWrapping:\n"
13999               "  AfterControlStatement: Always",
14000               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14001   CHECK_PARSE("BraceWrapping:\n"
14002               "  AfterControlStatement: Never",
14003               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14004   // For backward compatibility:
14005   CHECK_PARSE("BraceWrapping:\n"
14006               "  AfterControlStatement: true",
14007               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14008   CHECK_PARSE("BraceWrapping:\n"
14009               "  AfterControlStatement: false",
14010               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14011 
14012   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
14013   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
14014               FormatStyle::RTBS_None);
14015   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
14016               FormatStyle::RTBS_All);
14017   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
14018               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
14019   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
14020               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
14021   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
14022               AlwaysBreakAfterReturnType,
14023               FormatStyle::RTBS_TopLevelDefinitions);
14024 
14025   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
14026   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
14027               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
14028   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
14029               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14030   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
14031               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14032   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
14033               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14034   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
14035               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14036 
14037   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
14038   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
14039               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
14040   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
14041               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
14042   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
14043               AlwaysBreakAfterDefinitionReturnType,
14044               FormatStyle::DRTBS_TopLevel);
14045 
14046   Style.NamespaceIndentation = FormatStyle::NI_All;
14047   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
14048               FormatStyle::NI_None);
14049   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
14050               FormatStyle::NI_Inner);
14051   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
14052               FormatStyle::NI_All);
14053 
14054   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
14055   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
14056               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14057   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
14058               AllowShortIfStatementsOnASingleLine,
14059               FormatStyle::SIS_WithoutElse);
14060   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
14061               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
14062   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
14063               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14064   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
14065               AllowShortIfStatementsOnASingleLine,
14066               FormatStyle::SIS_WithoutElse);
14067 
14068   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
14069   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
14070               FormatStyle::IEBS_AfterExternBlock);
14071   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
14072               FormatStyle::IEBS_Indent);
14073   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
14074               FormatStyle::IEBS_NoIndent);
14075   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
14076               FormatStyle::IEBS_Indent);
14077   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
14078               FormatStyle::IEBS_NoIndent);
14079 
14080   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
14081   CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
14082               FormatStyle::BFCS_Both);
14083   CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
14084               FormatStyle::BFCS_None);
14085   CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
14086               FormatStyle::BFCS_Before);
14087   CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
14088               FormatStyle::BFCS_After);
14089 
14090   // FIXME: This is required because parsing a configuration simply overwrites
14091   // the first N elements of the list instead of resetting it.
14092   Style.ForEachMacros.clear();
14093   std::vector<std::string> BoostForeach;
14094   BoostForeach.push_back("BOOST_FOREACH");
14095   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
14096   std::vector<std::string> BoostAndQForeach;
14097   BoostAndQForeach.push_back("BOOST_FOREACH");
14098   BoostAndQForeach.push_back("Q_FOREACH");
14099   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
14100               BoostAndQForeach);
14101 
14102   Style.StatementMacros.clear();
14103   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
14104               std::vector<std::string>{"QUNUSED"});
14105   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
14106               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
14107 
14108   Style.NamespaceMacros.clear();
14109   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
14110               std::vector<std::string>{"TESTSUITE"});
14111   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
14112               std::vector<std::string>({"TESTSUITE", "SUITE"}));
14113 
14114   Style.WhitespaceSensitiveMacros.clear();
14115   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
14116               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14117   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
14118               WhitespaceSensitiveMacros,
14119               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14120   Style.WhitespaceSensitiveMacros.clear();
14121   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
14122               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14123   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
14124               WhitespaceSensitiveMacros,
14125               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14126 
14127   Style.IncludeStyle.IncludeCategories.clear();
14128   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
14129       {"abc/.*", 2, 0}, {".*", 1, 0}};
14130   CHECK_PARSE("IncludeCategories:\n"
14131               "  - Regex: abc/.*\n"
14132               "    Priority: 2\n"
14133               "  - Regex: .*\n"
14134               "    Priority: 1",
14135               IncludeStyle.IncludeCategories, ExpectedCategories);
14136   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
14137               "abc$");
14138   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
14139               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
14140 
14141   Style.RawStringFormats.clear();
14142   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
14143       {
14144           FormatStyle::LK_TextProto,
14145           {"pb", "proto"},
14146           {"PARSE_TEXT_PROTO"},
14147           /*CanonicalDelimiter=*/"",
14148           "llvm",
14149       },
14150       {
14151           FormatStyle::LK_Cpp,
14152           {"cc", "cpp"},
14153           {"C_CODEBLOCK", "CPPEVAL"},
14154           /*CanonicalDelimiter=*/"cc",
14155           /*BasedOnStyle=*/"",
14156       },
14157   };
14158 
14159   CHECK_PARSE("RawStringFormats:\n"
14160               "  - Language: TextProto\n"
14161               "    Delimiters:\n"
14162               "      - 'pb'\n"
14163               "      - 'proto'\n"
14164               "    EnclosingFunctions:\n"
14165               "      - 'PARSE_TEXT_PROTO'\n"
14166               "    BasedOnStyle: llvm\n"
14167               "  - Language: Cpp\n"
14168               "    Delimiters:\n"
14169               "      - 'cc'\n"
14170               "      - 'cpp'\n"
14171               "    EnclosingFunctions:\n"
14172               "      - 'C_CODEBLOCK'\n"
14173               "      - 'CPPEVAL'\n"
14174               "    CanonicalDelimiter: 'cc'",
14175               RawStringFormats, ExpectedRawStringFormats);
14176 }
14177 
14178 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
14179   FormatStyle Style = {};
14180   Style.Language = FormatStyle::LK_Cpp;
14181   CHECK_PARSE("Language: Cpp\n"
14182               "IndentWidth: 12",
14183               IndentWidth, 12u);
14184   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
14185                                "IndentWidth: 34",
14186                                &Style),
14187             ParseError::Unsuitable);
14188   FormatStyle BinPackedTCS = {};
14189   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
14190   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
14191                                "InsertTrailingCommas: Wrapped",
14192                                &BinPackedTCS),
14193             ParseError::BinPackTrailingCommaConflict);
14194   EXPECT_EQ(12u, Style.IndentWidth);
14195   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14196   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14197 
14198   Style.Language = FormatStyle::LK_JavaScript;
14199   CHECK_PARSE("Language: JavaScript\n"
14200               "IndentWidth: 12",
14201               IndentWidth, 12u);
14202   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14203   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14204                                "IndentWidth: 34",
14205                                &Style),
14206             ParseError::Unsuitable);
14207   EXPECT_EQ(23u, Style.IndentWidth);
14208   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14209   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14210 
14211   CHECK_PARSE("BasedOnStyle: LLVM\n"
14212               "IndentWidth: 67",
14213               IndentWidth, 67u);
14214 
14215   CHECK_PARSE("---\n"
14216               "Language: JavaScript\n"
14217               "IndentWidth: 12\n"
14218               "---\n"
14219               "Language: Cpp\n"
14220               "IndentWidth: 34\n"
14221               "...\n",
14222               IndentWidth, 12u);
14223 
14224   Style.Language = FormatStyle::LK_Cpp;
14225   CHECK_PARSE("---\n"
14226               "Language: JavaScript\n"
14227               "IndentWidth: 12\n"
14228               "---\n"
14229               "Language: Cpp\n"
14230               "IndentWidth: 34\n"
14231               "...\n",
14232               IndentWidth, 34u);
14233   CHECK_PARSE("---\n"
14234               "IndentWidth: 78\n"
14235               "---\n"
14236               "Language: JavaScript\n"
14237               "IndentWidth: 56\n"
14238               "...\n",
14239               IndentWidth, 78u);
14240 
14241   Style.ColumnLimit = 123;
14242   Style.IndentWidth = 234;
14243   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14244   Style.TabWidth = 345;
14245   EXPECT_FALSE(parseConfiguration("---\n"
14246                                   "IndentWidth: 456\n"
14247                                   "BreakBeforeBraces: Allman\n"
14248                                   "---\n"
14249                                   "Language: JavaScript\n"
14250                                   "IndentWidth: 111\n"
14251                                   "TabWidth: 111\n"
14252                                   "---\n"
14253                                   "Language: Cpp\n"
14254                                   "BreakBeforeBraces: Stroustrup\n"
14255                                   "TabWidth: 789\n"
14256                                   "...\n",
14257                                   &Style));
14258   EXPECT_EQ(123u, Style.ColumnLimit);
14259   EXPECT_EQ(456u, Style.IndentWidth);
14260   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14261   EXPECT_EQ(789u, Style.TabWidth);
14262 
14263   EXPECT_EQ(parseConfiguration("---\n"
14264                                "Language: JavaScript\n"
14265                                "IndentWidth: 56\n"
14266                                "---\n"
14267                                "IndentWidth: 78\n"
14268                                "...\n",
14269                                &Style),
14270             ParseError::Error);
14271   EXPECT_EQ(parseConfiguration("---\n"
14272                                "Language: JavaScript\n"
14273                                "IndentWidth: 56\n"
14274                                "---\n"
14275                                "Language: JavaScript\n"
14276                                "IndentWidth: 78\n"
14277                                "...\n",
14278                                &Style),
14279             ParseError::Error);
14280 
14281   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14282 }
14283 
14284 #undef CHECK_PARSE
14285 
14286 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14287   FormatStyle Style = {};
14288   Style.Language = FormatStyle::LK_JavaScript;
14289   Style.BreakBeforeTernaryOperators = true;
14290   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14291   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14292 
14293   Style.BreakBeforeTernaryOperators = true;
14294   EXPECT_EQ(0, parseConfiguration("---\n"
14295                                   "BasedOnStyle: Google\n"
14296                                   "---\n"
14297                                   "Language: JavaScript\n"
14298                                   "IndentWidth: 76\n"
14299                                   "...\n",
14300                                   &Style)
14301                    .value());
14302   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14303   EXPECT_EQ(76u, Style.IndentWidth);
14304   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14305 }
14306 
14307 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14308   FormatStyle Style = getLLVMStyle();
14309   std::string YAML = configurationAsText(Style);
14310   FormatStyle ParsedStyle = {};
14311   ParsedStyle.Language = FormatStyle::LK_Cpp;
14312   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14313   EXPECT_EQ(Style, ParsedStyle);
14314 }
14315 
14316 TEST_F(FormatTest, WorksFor8bitEncodings) {
14317   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14318             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14319             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14320             "\"\xef\xee\xf0\xf3...\"",
14321             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14322                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14323                    "\xef\xee\xf0\xf3...\"",
14324                    getLLVMStyleWithColumns(12)));
14325 }
14326 
14327 TEST_F(FormatTest, HandlesUTF8BOM) {
14328   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14329   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14330             format("\xef\xbb\xbf#include <iostream>"));
14331   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14332             format("\xef\xbb\xbf\n#include <iostream>"));
14333 }
14334 
14335 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14336 #if !defined(_MSC_VER)
14337 
14338 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14339   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14340                getLLVMStyleWithColumns(35));
14341   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14342                getLLVMStyleWithColumns(31));
14343   verifyFormat("// Однажды в студёную зимнюю пору...",
14344                getLLVMStyleWithColumns(36));
14345   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14346   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14347                getLLVMStyleWithColumns(39));
14348   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14349                getLLVMStyleWithColumns(35));
14350 }
14351 
14352 TEST_F(FormatTest, SplitsUTF8Strings) {
14353   // Non-printable characters' width is currently considered to be the length in
14354   // bytes in UTF8. The characters can be displayed in very different manner
14355   // (zero-width, single width with a substitution glyph, expanded to their code
14356   // (e.g. "<8d>"), so there's no single correct way to handle them.
14357   EXPECT_EQ("\"aaaaÄ\"\n"
14358             "\"\xc2\x8d\";",
14359             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14360   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14361             "\"\xc2\x8d\";",
14362             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14363   EXPECT_EQ("\"Однажды, в \"\n"
14364             "\"студёную \"\n"
14365             "\"зимнюю \"\n"
14366             "\"пору,\"",
14367             format("\"Однажды, в студёную зимнюю пору,\"",
14368                    getLLVMStyleWithColumns(13)));
14369   EXPECT_EQ(
14370       "\"一 二 三 \"\n"
14371       "\"四 五六 \"\n"
14372       "\"七 八 九 \"\n"
14373       "\"十\"",
14374       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14375   EXPECT_EQ("\"一\t\"\n"
14376             "\"二 \t\"\n"
14377             "\"三 四 \"\n"
14378             "\"五\t\"\n"
14379             "\"六 \t\"\n"
14380             "\"七 \"\n"
14381             "\"八九十\tqq\"",
14382             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14383                    getLLVMStyleWithColumns(11)));
14384 
14385   // UTF8 character in an escape sequence.
14386   EXPECT_EQ("\"aaaaaa\"\n"
14387             "\"\\\xC2\x8D\"",
14388             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14389 }
14390 
14391 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14392   EXPECT_EQ("const char *sssss =\n"
14393             "    \"一二三四五六七八\\\n"
14394             " 九 十\";",
14395             format("const char *sssss = \"一二三四五六七八\\\n"
14396                    " 九 十\";",
14397                    getLLVMStyleWithColumns(30)));
14398 }
14399 
14400 TEST_F(FormatTest, SplitsUTF8LineComments) {
14401   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14402             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14403   EXPECT_EQ("// Я из лесу\n"
14404             "// вышел; был\n"
14405             "// сильный\n"
14406             "// мороз.",
14407             format("// Я из лесу вышел; был сильный мороз.",
14408                    getLLVMStyleWithColumns(13)));
14409   EXPECT_EQ("// 一二三\n"
14410             "// 四五六七\n"
14411             "// 八  九\n"
14412             "// 十",
14413             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14414 }
14415 
14416 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14417   EXPECT_EQ("/* Гляжу,\n"
14418             " * поднимается\n"
14419             " * медленно в\n"
14420             " * гору\n"
14421             " * Лошадка,\n"
14422             " * везущая\n"
14423             " * хворосту\n"
14424             " * воз. */",
14425             format("/* Гляжу, поднимается медленно в гору\n"
14426                    " * Лошадка, везущая хворосту воз. */",
14427                    getLLVMStyleWithColumns(13)));
14428   EXPECT_EQ(
14429       "/* 一二三\n"
14430       " * 四五六七\n"
14431       " * 八  九\n"
14432       " * 十  */",
14433       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14434   EXPECT_EQ("/* �������� ��������\n"
14435             " * ��������\n"
14436             " * ������-�� */",
14437             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14438 }
14439 
14440 #endif // _MSC_VER
14441 
14442 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14443   FormatStyle Style = getLLVMStyle();
14444 
14445   Style.ConstructorInitializerIndentWidth = 4;
14446   verifyFormat(
14447       "SomeClass::Constructor()\n"
14448       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14449       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14450       Style);
14451 
14452   Style.ConstructorInitializerIndentWidth = 2;
14453   verifyFormat(
14454       "SomeClass::Constructor()\n"
14455       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14456       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14457       Style);
14458 
14459   Style.ConstructorInitializerIndentWidth = 0;
14460   verifyFormat(
14461       "SomeClass::Constructor()\n"
14462       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14463       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14464       Style);
14465   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14466   verifyFormat(
14467       "SomeLongTemplateVariableName<\n"
14468       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14469       Style);
14470   verifyFormat("bool smaller = 1 < "
14471                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14472                "                       "
14473                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14474                Style);
14475 
14476   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14477   verifyFormat("SomeClass::Constructor() :\n"
14478                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14479                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14480                Style);
14481 }
14482 
14483 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14484   FormatStyle Style = getLLVMStyle();
14485   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14486   Style.ConstructorInitializerIndentWidth = 4;
14487   verifyFormat("SomeClass::Constructor()\n"
14488                "    : a(a)\n"
14489                "    , b(b)\n"
14490                "    , c(c) {}",
14491                Style);
14492   verifyFormat("SomeClass::Constructor()\n"
14493                "    : a(a) {}",
14494                Style);
14495 
14496   Style.ColumnLimit = 0;
14497   verifyFormat("SomeClass::Constructor()\n"
14498                "    : a(a) {}",
14499                Style);
14500   verifyFormat("SomeClass::Constructor() noexcept\n"
14501                "    : a(a) {}",
14502                Style);
14503   verifyFormat("SomeClass::Constructor()\n"
14504                "    : a(a)\n"
14505                "    , b(b)\n"
14506                "    , c(c) {}",
14507                Style);
14508   verifyFormat("SomeClass::Constructor()\n"
14509                "    : a(a) {\n"
14510                "  foo();\n"
14511                "  bar();\n"
14512                "}",
14513                Style);
14514 
14515   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14516   verifyFormat("SomeClass::Constructor()\n"
14517                "    : a(a)\n"
14518                "    , b(b)\n"
14519                "    , c(c) {\n}",
14520                Style);
14521   verifyFormat("SomeClass::Constructor()\n"
14522                "    : a(a) {\n}",
14523                Style);
14524 
14525   Style.ColumnLimit = 80;
14526   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14527   Style.ConstructorInitializerIndentWidth = 2;
14528   verifyFormat("SomeClass::Constructor()\n"
14529                "  : a(a)\n"
14530                "  , b(b)\n"
14531                "  , c(c) {}",
14532                Style);
14533 
14534   Style.ConstructorInitializerIndentWidth = 0;
14535   verifyFormat("SomeClass::Constructor()\n"
14536                ": a(a)\n"
14537                ", b(b)\n"
14538                ", c(c) {}",
14539                Style);
14540 
14541   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14542   Style.ConstructorInitializerIndentWidth = 4;
14543   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14544   verifyFormat(
14545       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14546       Style);
14547   verifyFormat(
14548       "SomeClass::Constructor()\n"
14549       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14550       Style);
14551   Style.ConstructorInitializerIndentWidth = 4;
14552   Style.ColumnLimit = 60;
14553   verifyFormat("SomeClass::Constructor()\n"
14554                "    : aaaaaaaa(aaaaaaaa)\n"
14555                "    , aaaaaaaa(aaaaaaaa)\n"
14556                "    , aaaaaaaa(aaaaaaaa) {}",
14557                Style);
14558 }
14559 
14560 TEST_F(FormatTest, Destructors) {
14561   verifyFormat("void F(int &i) { i.~int(); }");
14562   verifyFormat("void F(int &i) { i->~int(); }");
14563 }
14564 
14565 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14566   FormatStyle Style = getWebKitStyle();
14567 
14568   // Don't indent in outer namespaces.
14569   verifyFormat("namespace outer {\n"
14570                "int i;\n"
14571                "namespace inner {\n"
14572                "    int i;\n"
14573                "} // namespace inner\n"
14574                "} // namespace outer\n"
14575                "namespace other_outer {\n"
14576                "int i;\n"
14577                "}",
14578                Style);
14579 
14580   // Don't indent case labels.
14581   verifyFormat("switch (variable) {\n"
14582                "case 1:\n"
14583                "case 2:\n"
14584                "    doSomething();\n"
14585                "    break;\n"
14586                "default:\n"
14587                "    ++variable;\n"
14588                "}",
14589                Style);
14590 
14591   // Wrap before binary operators.
14592   EXPECT_EQ("void f()\n"
14593             "{\n"
14594             "    if (aaaaaaaaaaaaaaaa\n"
14595             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14596             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14597             "        return;\n"
14598             "}",
14599             format("void f() {\n"
14600                    "if (aaaaaaaaaaaaaaaa\n"
14601                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
14602                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14603                    "return;\n"
14604                    "}",
14605                    Style));
14606 
14607   // Allow functions on a single line.
14608   verifyFormat("void f() { return; }", Style);
14609 
14610   // Allow empty blocks on a single line and insert a space in empty blocks.
14611   EXPECT_EQ("void f() { }", format("void f() {}", Style));
14612   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
14613   // However, don't merge non-empty short loops.
14614   EXPECT_EQ("while (true) {\n"
14615             "    continue;\n"
14616             "}",
14617             format("while (true) { continue; }", Style));
14618 
14619   // Constructor initializers are formatted one per line with the "," on the
14620   // new line.
14621   verifyFormat("Constructor()\n"
14622                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
14623                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
14624                "          aaaaaaaaaaaaaa)\n"
14625                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
14626                "{\n"
14627                "}",
14628                Style);
14629   verifyFormat("SomeClass::Constructor()\n"
14630                "    : a(a)\n"
14631                "{\n"
14632                "}",
14633                Style);
14634   EXPECT_EQ("SomeClass::Constructor()\n"
14635             "    : a(a)\n"
14636             "{\n"
14637             "}",
14638             format("SomeClass::Constructor():a(a){}", Style));
14639   verifyFormat("SomeClass::Constructor()\n"
14640                "    : a(a)\n"
14641                "    , b(b)\n"
14642                "    , c(c)\n"
14643                "{\n"
14644                "}",
14645                Style);
14646   verifyFormat("SomeClass::Constructor()\n"
14647                "    : a(a)\n"
14648                "{\n"
14649                "    foo();\n"
14650                "    bar();\n"
14651                "}",
14652                Style);
14653 
14654   // Access specifiers should be aligned left.
14655   verifyFormat("class C {\n"
14656                "public:\n"
14657                "    int i;\n"
14658                "};",
14659                Style);
14660 
14661   // Do not align comments.
14662   verifyFormat("int a; // Do not\n"
14663                "double b; // align comments.",
14664                Style);
14665 
14666   // Do not align operands.
14667   EXPECT_EQ("ASSERT(aaaa\n"
14668             "    || bbbb);",
14669             format("ASSERT ( aaaa\n||bbbb);", Style));
14670 
14671   // Accept input's line breaks.
14672   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
14673             "    || bbbbbbbbbbbbbbb) {\n"
14674             "    i++;\n"
14675             "}",
14676             format("if (aaaaaaaaaaaaaaa\n"
14677                    "|| bbbbbbbbbbbbbbb) { i++; }",
14678                    Style));
14679   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
14680             "    i++;\n"
14681             "}",
14682             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
14683 
14684   // Don't automatically break all macro definitions (llvm.org/PR17842).
14685   verifyFormat("#define aNumber 10", Style);
14686   // However, generally keep the line breaks that the user authored.
14687   EXPECT_EQ("#define aNumber \\\n"
14688             "    10",
14689             format("#define aNumber \\\n"
14690                    " 10",
14691                    Style));
14692 
14693   // Keep empty and one-element array literals on a single line.
14694   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
14695             "                                  copyItems:YES];",
14696             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
14697                    "copyItems:YES];",
14698                    Style));
14699   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
14700             "                                  copyItems:YES];",
14701             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
14702                    "             copyItems:YES];",
14703                    Style));
14704   // FIXME: This does not seem right, there should be more indentation before
14705   // the array literal's entries. Nested blocks have the same problem.
14706   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14707             "    @\"a\",\n"
14708             "    @\"a\"\n"
14709             "]\n"
14710             "                                  copyItems:YES];",
14711             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14712                    "     @\"a\",\n"
14713                    "     @\"a\"\n"
14714                    "     ]\n"
14715                    "       copyItems:YES];",
14716                    Style));
14717   EXPECT_EQ(
14718       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14719       "                                  copyItems:YES];",
14720       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14721              "   copyItems:YES];",
14722              Style));
14723 
14724   verifyFormat("[self.a b:c c:d];", Style);
14725   EXPECT_EQ("[self.a b:c\n"
14726             "        c:d];",
14727             format("[self.a b:c\n"
14728                    "c:d];",
14729                    Style));
14730 }
14731 
14732 TEST_F(FormatTest, FormatsLambdas) {
14733   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
14734   verifyFormat(
14735       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
14736   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
14737   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
14738   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
14739   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
14740   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
14741   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
14742   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
14743   verifyFormat("int x = f(*+[] {});");
14744   verifyFormat("void f() {\n"
14745                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
14746                "}\n");
14747   verifyFormat("void f() {\n"
14748                "  other(x.begin(), //\n"
14749                "        x.end(),   //\n"
14750                "        [&](int, int) { return 1; });\n"
14751                "}\n");
14752   verifyFormat("void f() {\n"
14753                "  other.other.other.other.other(\n"
14754                "      x.begin(), x.end(),\n"
14755                "      [something, rather](int, int, int, int, int, int, int) { "
14756                "return 1; });\n"
14757                "}\n");
14758   verifyFormat(
14759       "void f() {\n"
14760       "  other.other.other.other.other(\n"
14761       "      x.begin(), x.end(),\n"
14762       "      [something, rather](int, int, int, int, int, int, int) {\n"
14763       "        //\n"
14764       "      });\n"
14765       "}\n");
14766   verifyFormat("SomeFunction([]() { // A cool function...\n"
14767                "  return 43;\n"
14768                "});");
14769   EXPECT_EQ("SomeFunction([]() {\n"
14770             "#define A a\n"
14771             "  return 43;\n"
14772             "});",
14773             format("SomeFunction([](){\n"
14774                    "#define A a\n"
14775                    "return 43;\n"
14776                    "});"));
14777   verifyFormat("void f() {\n"
14778                "  SomeFunction([](decltype(x), A *a) {});\n"
14779                "}");
14780   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14781                "    [](const aaaaaaaaaa &a) { return a; });");
14782   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
14783                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
14784                "});");
14785   verifyFormat("Constructor()\n"
14786                "    : Field([] { // comment\n"
14787                "        int i;\n"
14788                "      }) {}");
14789   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
14790                "  return some_parameter.size();\n"
14791                "};");
14792   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
14793                "    [](const string &s) { return s; };");
14794   verifyFormat("int i = aaaaaa ? 1 //\n"
14795                "               : [] {\n"
14796                "                   return 2; //\n"
14797                "                 }();");
14798   verifyFormat("llvm::errs() << \"number of twos is \"\n"
14799                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
14800                "                  return x == 2; // force break\n"
14801                "                });");
14802   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14803                "    [=](int iiiiiiiiiiii) {\n"
14804                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
14805                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
14806                "    });",
14807                getLLVMStyleWithColumns(60));
14808   verifyFormat("SomeFunction({[&] {\n"
14809                "                // comment\n"
14810                "              },\n"
14811                "              [&] {\n"
14812                "                // comment\n"
14813                "              }});");
14814   verifyFormat("SomeFunction({[&] {\n"
14815                "  // comment\n"
14816                "}});");
14817   verifyFormat(
14818       "virtual aaaaaaaaaaaaaaaa(\n"
14819       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
14820       "    aaaaa aaaaaaaaa);");
14821 
14822   // Lambdas with return types.
14823   verifyFormat("int c = []() -> int { return 2; }();\n");
14824   verifyFormat("int c = []() -> int * { return 2; }();\n");
14825   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
14826   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
14827   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
14828   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
14829   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
14830   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
14831   verifyFormat("[a, a]() -> a<1> {};");
14832   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
14833   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
14834   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
14835   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
14836   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
14837   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
14838   verifyFormat("[]() -> foo<!5> { return {}; };");
14839   verifyFormat("[]() -> foo<~5> { return {}; };");
14840   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
14841   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
14842   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
14843   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
14844   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
14845   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
14846   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
14847   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
14848   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
14849   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
14850   verifyFormat("namespace bar {\n"
14851                "// broken:\n"
14852                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
14853                "} // namespace bar");
14854   verifyFormat("namespace bar {\n"
14855                "// broken:\n"
14856                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
14857                "} // namespace bar");
14858   verifyFormat("namespace bar {\n"
14859                "// broken:\n"
14860                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
14861                "} // namespace bar");
14862   verifyFormat("namespace bar {\n"
14863                "// broken:\n"
14864                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
14865                "} // namespace bar");
14866   verifyFormat("namespace bar {\n"
14867                "// broken:\n"
14868                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
14869                "} // namespace bar");
14870   verifyFormat("namespace bar {\n"
14871                "// broken:\n"
14872                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
14873                "} // namespace bar");
14874   verifyFormat("namespace bar {\n"
14875                "// broken:\n"
14876                "auto foo{[]() -> foo<!5> { return {}; }};\n"
14877                "} // namespace bar");
14878   verifyFormat("namespace bar {\n"
14879                "// broken:\n"
14880                "auto foo{[]() -> foo<~5> { return {}; }};\n"
14881                "} // namespace bar");
14882   verifyFormat("namespace bar {\n"
14883                "// broken:\n"
14884                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
14885                "} // namespace bar");
14886   verifyFormat("namespace bar {\n"
14887                "// broken:\n"
14888                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
14889                "} // namespace bar");
14890   verifyFormat("namespace bar {\n"
14891                "// broken:\n"
14892                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
14893                "} // namespace bar");
14894   verifyFormat("namespace bar {\n"
14895                "// broken:\n"
14896                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
14897                "} // namespace bar");
14898   verifyFormat("namespace bar {\n"
14899                "// broken:\n"
14900                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
14901                "} // namespace bar");
14902   verifyFormat("namespace bar {\n"
14903                "// broken:\n"
14904                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
14905                "} // namespace bar");
14906   verifyFormat("namespace bar {\n"
14907                "// broken:\n"
14908                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
14909                "} // namespace bar");
14910   verifyFormat("namespace bar {\n"
14911                "// broken:\n"
14912                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
14913                "} // namespace bar");
14914   verifyFormat("namespace bar {\n"
14915                "// broken:\n"
14916                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
14917                "} // namespace bar");
14918   verifyFormat("namespace bar {\n"
14919                "// broken:\n"
14920                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
14921                "} // namespace bar");
14922   verifyFormat("[]() -> a<1> {};");
14923   verifyFormat("[]() -> a<1> { ; };");
14924   verifyFormat("[]() -> a<1> { ; }();");
14925   verifyFormat("[a, a]() -> a<true> {};");
14926   verifyFormat("[]() -> a<true> {};");
14927   verifyFormat("[]() -> a<true> { ; };");
14928   verifyFormat("[]() -> a<true> { ; }();");
14929   verifyFormat("[a, a]() -> a<false> {};");
14930   verifyFormat("[]() -> a<false> {};");
14931   verifyFormat("[]() -> a<false> { ; };");
14932   verifyFormat("[]() -> a<false> { ; }();");
14933   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
14934   verifyFormat("namespace bar {\n"
14935                "auto foo{[]() -> foo<false> { ; }};\n"
14936                "} // namespace bar");
14937   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
14938                "                   int j) -> int {\n"
14939                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
14940                "};");
14941   verifyFormat(
14942       "aaaaaaaaaaaaaaaaaaaaaa(\n"
14943       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
14944       "      return aaaaaaaaaaaaaaaaa;\n"
14945       "    });",
14946       getLLVMStyleWithColumns(70));
14947   verifyFormat("[]() //\n"
14948                "    -> int {\n"
14949                "  return 1; //\n"
14950                "};");
14951   verifyFormat("[]() -> Void<T...> {};");
14952   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
14953 
14954   // Lambdas with explicit template argument lists.
14955   verifyFormat(
14956       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
14957 
14958   // Multiple lambdas in the same parentheses change indentation rules. These
14959   // lambdas are forced to start on new lines.
14960   verifyFormat("SomeFunction(\n"
14961                "    []() {\n"
14962                "      //\n"
14963                "    },\n"
14964                "    []() {\n"
14965                "      //\n"
14966                "    });");
14967 
14968   // A lambda passed as arg0 is always pushed to the next line.
14969   verifyFormat("SomeFunction(\n"
14970                "    [this] {\n"
14971                "      //\n"
14972                "    },\n"
14973                "    1);\n");
14974 
14975   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
14976   // the arg0 case above.
14977   auto Style = getGoogleStyle();
14978   Style.BinPackArguments = false;
14979   verifyFormat("SomeFunction(\n"
14980                "    a,\n"
14981                "    [this] {\n"
14982                "      //\n"
14983                "    },\n"
14984                "    b);\n",
14985                Style);
14986   verifyFormat("SomeFunction(\n"
14987                "    a,\n"
14988                "    [this] {\n"
14989                "      //\n"
14990                "    },\n"
14991                "    b);\n");
14992 
14993   // A lambda with a very long line forces arg0 to be pushed out irrespective of
14994   // the BinPackArguments value (as long as the code is wide enough).
14995   verifyFormat(
14996       "something->SomeFunction(\n"
14997       "    a,\n"
14998       "    [this] {\n"
14999       "      "
15000       "D0000000000000000000000000000000000000000000000000000000000001();\n"
15001       "    },\n"
15002       "    b);\n");
15003 
15004   // A multi-line lambda is pulled up as long as the introducer fits on the
15005   // previous line and there are no further args.
15006   verifyFormat("function(1, [this, that] {\n"
15007                "  //\n"
15008                "});\n");
15009   verifyFormat("function([this, that] {\n"
15010                "  //\n"
15011                "});\n");
15012   // FIXME: this format is not ideal and we should consider forcing the first
15013   // arg onto its own line.
15014   verifyFormat("function(a, b, c, //\n"
15015                "         d, [this, that] {\n"
15016                "           //\n"
15017                "         });\n");
15018 
15019   // Multiple lambdas are treated correctly even when there is a short arg0.
15020   verifyFormat("SomeFunction(\n"
15021                "    1,\n"
15022                "    [this] {\n"
15023                "      //\n"
15024                "    },\n"
15025                "    [this] {\n"
15026                "      //\n"
15027                "    },\n"
15028                "    1);\n");
15029 
15030   // More complex introducers.
15031   verifyFormat("return [i, args...] {};");
15032 
15033   // Not lambdas.
15034   verifyFormat("constexpr char hello[]{\"hello\"};");
15035   verifyFormat("double &operator[](int i) { return 0; }\n"
15036                "int i;");
15037   verifyFormat("std::unique_ptr<int[]> foo() {}");
15038   verifyFormat("int i = a[a][a]->f();");
15039   verifyFormat("int i = (*b)[a]->f();");
15040 
15041   // Other corner cases.
15042   verifyFormat("void f() {\n"
15043                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
15044                "  );\n"
15045                "}");
15046 
15047   // Lambdas created through weird macros.
15048   verifyFormat("void f() {\n"
15049                "  MACRO((const AA &a) { return 1; });\n"
15050                "  MACRO((AA &a) { return 1; });\n"
15051                "}");
15052 
15053   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
15054                "      doo_dah();\n"
15055                "      doo_dah();\n"
15056                "    })) {\n"
15057                "}");
15058   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
15059                "                doo_dah();\n"
15060                "                doo_dah();\n"
15061                "              })) {\n"
15062                "}");
15063   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
15064                "                doo_dah();\n"
15065                "                doo_dah();\n"
15066                "              })) {\n"
15067                "}");
15068   verifyFormat("auto lambda = []() {\n"
15069                "  int a = 2\n"
15070                "#if A\n"
15071                "          + 2\n"
15072                "#endif\n"
15073                "      ;\n"
15074                "};");
15075 
15076   // Lambdas with complex multiline introducers.
15077   verifyFormat(
15078       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15079       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
15080       "        -> ::std::unordered_set<\n"
15081       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
15082       "      //\n"
15083       "    });");
15084 
15085   FormatStyle DoNotMerge = getLLVMStyle();
15086   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
15087   verifyFormat("auto c = []() {\n"
15088                "  return b;\n"
15089                "};",
15090                "auto c = []() { return b; };", DoNotMerge);
15091   verifyFormat("auto c = []() {\n"
15092                "};",
15093                " auto c = []() {};", DoNotMerge);
15094 
15095   FormatStyle MergeEmptyOnly = getLLVMStyle();
15096   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
15097   verifyFormat("auto c = []() {\n"
15098                "  return b;\n"
15099                "};",
15100                "auto c = []() {\n"
15101                "  return b;\n"
15102                " };",
15103                MergeEmptyOnly);
15104   verifyFormat("auto c = []() {};",
15105                "auto c = []() {\n"
15106                "};",
15107                MergeEmptyOnly);
15108 
15109   FormatStyle MergeInline = getLLVMStyle();
15110   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
15111   verifyFormat("auto c = []() {\n"
15112                "  return b;\n"
15113                "};",
15114                "auto c = []() { return b; };", MergeInline);
15115   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
15116                MergeInline);
15117   verifyFormat("function([]() { return b; }, a)",
15118                "function([]() { return b; }, a)", MergeInline);
15119   verifyFormat("function(a, []() { return b; })",
15120                "function(a, []() { return b; })", MergeInline);
15121 
15122   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
15123   // AllowShortLambdasOnASingleLine
15124   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15125   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15126   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15127   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15128       FormatStyle::ShortLambdaStyle::SLS_None;
15129   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
15130                "    []()\n"
15131                "    {\n"
15132                "      return 17;\n"
15133                "    });",
15134                LLVMWithBeforeLambdaBody);
15135   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
15136                "    []()\n"
15137                "    {\n"
15138                "    });",
15139                LLVMWithBeforeLambdaBody);
15140   verifyFormat("auto fct_SLS_None = []()\n"
15141                "{\n"
15142                "  return 17;\n"
15143                "};",
15144                LLVMWithBeforeLambdaBody);
15145   verifyFormat("TwoNestedLambdas_SLS_None(\n"
15146                "    []()\n"
15147                "    {\n"
15148                "      return Call(\n"
15149                "          []()\n"
15150                "          {\n"
15151                "            return 17;\n"
15152                "          });\n"
15153                "    });",
15154                LLVMWithBeforeLambdaBody);
15155   verifyFormat("void Fct()\n"
15156                "{\n"
15157                "  return {[]()\n"
15158                "          {\n"
15159                "            return 17;\n"
15160                "          }};\n"
15161                "}",
15162                LLVMWithBeforeLambdaBody);
15163 
15164   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15165       FormatStyle::ShortLambdaStyle::SLS_Empty;
15166   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
15167                "    []()\n"
15168                "    {\n"
15169                "      return 17;\n"
15170                "    });",
15171                LLVMWithBeforeLambdaBody);
15172   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
15173                LLVMWithBeforeLambdaBody);
15174   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
15175                "ongFunctionName_SLS_Empty(\n"
15176                "    []() {});",
15177                LLVMWithBeforeLambdaBody);
15178   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
15179                "                                []()\n"
15180                "                                {\n"
15181                "                                  return 17;\n"
15182                "                                });",
15183                LLVMWithBeforeLambdaBody);
15184   verifyFormat("auto fct_SLS_Empty = []()\n"
15185                "{\n"
15186                "  return 17;\n"
15187                "};",
15188                LLVMWithBeforeLambdaBody);
15189   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
15190                "    []()\n"
15191                "    {\n"
15192                "      return Call([]() {});\n"
15193                "    });",
15194                LLVMWithBeforeLambdaBody);
15195   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15196                "                           []()\n"
15197                "                           {\n"
15198                "                             return Call([]() {});\n"
15199                "                           });",
15200                LLVMWithBeforeLambdaBody);
15201   verifyFormat(
15202       "FctWithLongLineInLambda_SLS_Empty(\n"
15203       "    []()\n"
15204       "    {\n"
15205       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15206       "                               AndShouldNotBeConsiderAsInline,\n"
15207       "                               LambdaBodyMustBeBreak);\n"
15208       "    });",
15209       LLVMWithBeforeLambdaBody);
15210 
15211   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15212       FormatStyle::ShortLambdaStyle::SLS_Inline;
15213   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15214                LLVMWithBeforeLambdaBody);
15215   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15216                LLVMWithBeforeLambdaBody);
15217   verifyFormat("auto fct_SLS_Inline = []()\n"
15218                "{\n"
15219                "  return 17;\n"
15220                "};",
15221                LLVMWithBeforeLambdaBody);
15222   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15223                "17; }); });",
15224                LLVMWithBeforeLambdaBody);
15225   verifyFormat(
15226       "FctWithLongLineInLambda_SLS_Inline(\n"
15227       "    []()\n"
15228       "    {\n"
15229       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15230       "                               AndShouldNotBeConsiderAsInline,\n"
15231       "                               LambdaBodyMustBeBreak);\n"
15232       "    });",
15233       LLVMWithBeforeLambdaBody);
15234   verifyFormat("FctWithMultipleParams_SLS_Inline("
15235                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15236                "                                 []() { return 17; });",
15237                LLVMWithBeforeLambdaBody);
15238   verifyFormat(
15239       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15240       LLVMWithBeforeLambdaBody);
15241 
15242   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15243       FormatStyle::ShortLambdaStyle::SLS_All;
15244   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15245                LLVMWithBeforeLambdaBody);
15246   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15247                LLVMWithBeforeLambdaBody);
15248   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15249                LLVMWithBeforeLambdaBody);
15250   verifyFormat("FctWithOneParam_SLS_All(\n"
15251                "    []()\n"
15252                "    {\n"
15253                "      // A cool function...\n"
15254                "      return 43;\n"
15255                "    });",
15256                LLVMWithBeforeLambdaBody);
15257   verifyFormat("FctWithMultipleParams_SLS_All("
15258                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15259                "                              []() { return 17; });",
15260                LLVMWithBeforeLambdaBody);
15261   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15262                LLVMWithBeforeLambdaBody);
15263   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15264                LLVMWithBeforeLambdaBody);
15265   verifyFormat(
15266       "FctWithLongLineInLambda_SLS_All(\n"
15267       "    []()\n"
15268       "    {\n"
15269       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15270       "                               AndShouldNotBeConsiderAsInline,\n"
15271       "                               LambdaBodyMustBeBreak);\n"
15272       "    });",
15273       LLVMWithBeforeLambdaBody);
15274   verifyFormat(
15275       "auto fct_SLS_All = []()\n"
15276       "{\n"
15277       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15278       "                           AndShouldNotBeConsiderAsInline,\n"
15279       "                           LambdaBodyMustBeBreak);\n"
15280       "};",
15281       LLVMWithBeforeLambdaBody);
15282   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15283   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15284                LLVMWithBeforeLambdaBody);
15285   verifyFormat(
15286       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15287       "                                FirstParam,\n"
15288       "                                SecondParam,\n"
15289       "                                ThirdParam,\n"
15290       "                                FourthParam);",
15291       LLVMWithBeforeLambdaBody);
15292   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15293                "    []() { return "
15294                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15295                "    FirstParam,\n"
15296                "    SecondParam,\n"
15297                "    ThirdParam,\n"
15298                "    FourthParam);",
15299                LLVMWithBeforeLambdaBody);
15300   verifyFormat(
15301       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15302       "                                SecondParam,\n"
15303       "                                ThirdParam,\n"
15304       "                                FourthParam,\n"
15305       "                                []() { return SomeValueNotSoLong; });",
15306       LLVMWithBeforeLambdaBody);
15307   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15308                "    []()\n"
15309                "    {\n"
15310                "      return "
15311                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15312                "eConsiderAsInline;\n"
15313                "    });",
15314                LLVMWithBeforeLambdaBody);
15315   verifyFormat(
15316       "FctWithLongLineInLambda_SLS_All(\n"
15317       "    []()\n"
15318       "    {\n"
15319       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15320       "                               AndShouldNotBeConsiderAsInline,\n"
15321       "                               LambdaBodyMustBeBreak);\n"
15322       "    });",
15323       LLVMWithBeforeLambdaBody);
15324   verifyFormat("FctWithTwoParams_SLS_All(\n"
15325                "    []()\n"
15326                "    {\n"
15327                "      // A cool function...\n"
15328                "      return 43;\n"
15329                "    },\n"
15330                "    87);",
15331                LLVMWithBeforeLambdaBody);
15332   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15333                LLVMWithBeforeLambdaBody);
15334   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15335                LLVMWithBeforeLambdaBody);
15336   verifyFormat(
15337       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15338       LLVMWithBeforeLambdaBody);
15339   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15340                "}); }, x);",
15341                LLVMWithBeforeLambdaBody);
15342   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15343                "    []()\n"
15344                "    {\n"
15345                "      // A cool function...\n"
15346                "      return Call([]() { return 17; });\n"
15347                "    });",
15348                LLVMWithBeforeLambdaBody);
15349   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15350                "    []()\n"
15351                "    {\n"
15352                "      return Call(\n"
15353                "          []()\n"
15354                "          {\n"
15355                "            // A cool function...\n"
15356                "            return 17;\n"
15357                "          });\n"
15358                "    });",
15359                LLVMWithBeforeLambdaBody);
15360 }
15361 
15362 TEST_F(FormatTest, LambdaWithLineComments) {
15363   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15364   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15365   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15366   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15367       FormatStyle::ShortLambdaStyle::SLS_All;
15368 
15369   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15370   verifyFormat("auto k = []() // comment\n"
15371                "{ return; }",
15372                LLVMWithBeforeLambdaBody);
15373   verifyFormat("auto k = []() /* comment */ { return; }",
15374                LLVMWithBeforeLambdaBody);
15375   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15376                LLVMWithBeforeLambdaBody);
15377   verifyFormat("auto k = []() // X\n"
15378                "{ return; }",
15379                LLVMWithBeforeLambdaBody);
15380   verifyFormat(
15381       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15382       "{ return; }",
15383       LLVMWithBeforeLambdaBody);
15384 }
15385 
15386 TEST_F(FormatTest, EmptyLinesInLambdas) {
15387   verifyFormat("auto lambda = []() {\n"
15388                "  x(); //\n"
15389                "};",
15390                "auto lambda = []() {\n"
15391                "\n"
15392                "  x(); //\n"
15393                "\n"
15394                "};");
15395 }
15396 
15397 TEST_F(FormatTest, FormatsBlocks) {
15398   FormatStyle ShortBlocks = getLLVMStyle();
15399   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15400   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15401   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15402   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15403   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15404   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15405   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15406 
15407   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15408   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15409   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15410 
15411   verifyFormat("[operation setCompletionBlock:^{\n"
15412                "  [self onOperationDone];\n"
15413                "}];");
15414   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15415                "  [self onOperationDone];\n"
15416                "}]};");
15417   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15418                "  f();\n"
15419                "}];");
15420   verifyFormat("int a = [operation block:^int(int *i) {\n"
15421                "  return 1;\n"
15422                "}];");
15423   verifyFormat("[myObject doSomethingWith:arg1\n"
15424                "                      aaa:^int(int *a) {\n"
15425                "                        return 1;\n"
15426                "                      }\n"
15427                "                      bbb:f(a * bbbbbbbb)];");
15428 
15429   verifyFormat("[operation setCompletionBlock:^{\n"
15430                "  [self.delegate newDataAvailable];\n"
15431                "}];",
15432                getLLVMStyleWithColumns(60));
15433   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15434                "  NSString *path = [self sessionFilePath];\n"
15435                "  if (path) {\n"
15436                "    // ...\n"
15437                "  }\n"
15438                "});");
15439   verifyFormat("[[SessionService sharedService]\n"
15440                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15441                "      if (window) {\n"
15442                "        [self windowDidLoad:window];\n"
15443                "      } else {\n"
15444                "        [self errorLoadingWindow];\n"
15445                "      }\n"
15446                "    }];");
15447   verifyFormat("void (^largeBlock)(void) = ^{\n"
15448                "  // ...\n"
15449                "};\n",
15450                getLLVMStyleWithColumns(40));
15451   verifyFormat("[[SessionService sharedService]\n"
15452                "    loadWindowWithCompletionBlock: //\n"
15453                "        ^(SessionWindow *window) {\n"
15454                "          if (window) {\n"
15455                "            [self windowDidLoad:window];\n"
15456                "          } else {\n"
15457                "            [self errorLoadingWindow];\n"
15458                "          }\n"
15459                "        }];",
15460                getLLVMStyleWithColumns(60));
15461   verifyFormat("[myObject doSomethingWith:arg1\n"
15462                "    firstBlock:^(Foo *a) {\n"
15463                "      // ...\n"
15464                "      int i;\n"
15465                "    }\n"
15466                "    secondBlock:^(Bar *b) {\n"
15467                "      // ...\n"
15468                "      int i;\n"
15469                "    }\n"
15470                "    thirdBlock:^Foo(Bar *b) {\n"
15471                "      // ...\n"
15472                "      int i;\n"
15473                "    }];");
15474   verifyFormat("[myObject doSomethingWith:arg1\n"
15475                "               firstBlock:-1\n"
15476                "              secondBlock:^(Bar *b) {\n"
15477                "                // ...\n"
15478                "                int i;\n"
15479                "              }];");
15480 
15481   verifyFormat("f(^{\n"
15482                "  @autoreleasepool {\n"
15483                "    if (a) {\n"
15484                "      g();\n"
15485                "    }\n"
15486                "  }\n"
15487                "});");
15488   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15489   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15490                "};");
15491 
15492   FormatStyle FourIndent = getLLVMStyle();
15493   FourIndent.ObjCBlockIndentWidth = 4;
15494   verifyFormat("[operation setCompletionBlock:^{\n"
15495                "    [self onOperationDone];\n"
15496                "}];",
15497                FourIndent);
15498 }
15499 
15500 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15501   FormatStyle ZeroColumn = getLLVMStyle();
15502   ZeroColumn.ColumnLimit = 0;
15503 
15504   verifyFormat("[[SessionService sharedService] "
15505                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15506                "  if (window) {\n"
15507                "    [self windowDidLoad:window];\n"
15508                "  } else {\n"
15509                "    [self errorLoadingWindow];\n"
15510                "  }\n"
15511                "}];",
15512                ZeroColumn);
15513   EXPECT_EQ("[[SessionService sharedService]\n"
15514             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15515             "      if (window) {\n"
15516             "        [self windowDidLoad:window];\n"
15517             "      } else {\n"
15518             "        [self errorLoadingWindow];\n"
15519             "      }\n"
15520             "    }];",
15521             format("[[SessionService sharedService]\n"
15522                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15523                    "                if (window) {\n"
15524                    "    [self windowDidLoad:window];\n"
15525                    "  } else {\n"
15526                    "    [self errorLoadingWindow];\n"
15527                    "  }\n"
15528                    "}];",
15529                    ZeroColumn));
15530   verifyFormat("[myObject doSomethingWith:arg1\n"
15531                "    firstBlock:^(Foo *a) {\n"
15532                "      // ...\n"
15533                "      int i;\n"
15534                "    }\n"
15535                "    secondBlock:^(Bar *b) {\n"
15536                "      // ...\n"
15537                "      int i;\n"
15538                "    }\n"
15539                "    thirdBlock:^Foo(Bar *b) {\n"
15540                "      // ...\n"
15541                "      int i;\n"
15542                "    }];",
15543                ZeroColumn);
15544   verifyFormat("f(^{\n"
15545                "  @autoreleasepool {\n"
15546                "    if (a) {\n"
15547                "      g();\n"
15548                "    }\n"
15549                "  }\n"
15550                "});",
15551                ZeroColumn);
15552   verifyFormat("void (^largeBlock)(void) = ^{\n"
15553                "  // ...\n"
15554                "};",
15555                ZeroColumn);
15556 
15557   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15558   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15559             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15560   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15561   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15562             "  int i;\n"
15563             "};",
15564             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15565 }
15566 
15567 TEST_F(FormatTest, SupportsCRLF) {
15568   EXPECT_EQ("int a;\r\n"
15569             "int b;\r\n"
15570             "int c;\r\n",
15571             format("int a;\r\n"
15572                    "  int b;\r\n"
15573                    "    int c;\r\n",
15574                    getLLVMStyle()));
15575   EXPECT_EQ("int a;\r\n"
15576             "int b;\r\n"
15577             "int c;\r\n",
15578             format("int a;\r\n"
15579                    "  int b;\n"
15580                    "    int c;\r\n",
15581                    getLLVMStyle()));
15582   EXPECT_EQ("int a;\n"
15583             "int b;\n"
15584             "int c;\n",
15585             format("int a;\r\n"
15586                    "  int b;\n"
15587                    "    int c;\n",
15588                    getLLVMStyle()));
15589   EXPECT_EQ("\"aaaaaaa \"\r\n"
15590             "\"bbbbbbb\";\r\n",
15591             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15592   EXPECT_EQ("#define A \\\r\n"
15593             "  b;      \\\r\n"
15594             "  c;      \\\r\n"
15595             "  d;\r\n",
15596             format("#define A \\\r\n"
15597                    "  b; \\\r\n"
15598                    "  c; d; \r\n",
15599                    getGoogleStyle()));
15600 
15601   EXPECT_EQ("/*\r\n"
15602             "multi line block comments\r\n"
15603             "should not introduce\r\n"
15604             "an extra carriage return\r\n"
15605             "*/\r\n",
15606             format("/*\r\n"
15607                    "multi line block comments\r\n"
15608                    "should not introduce\r\n"
15609                    "an extra carriage return\r\n"
15610                    "*/\r\n"));
15611   EXPECT_EQ("/*\r\n"
15612             "\r\n"
15613             "*/",
15614             format("/*\r\n"
15615                    "    \r\r\r\n"
15616                    "*/"));
15617 
15618   FormatStyle style = getLLVMStyle();
15619 
15620   style.DeriveLineEnding = true;
15621   style.UseCRLF = false;
15622   EXPECT_EQ("union FooBarBazQux {\n"
15623             "  int foo;\n"
15624             "  int bar;\n"
15625             "  int baz;\n"
15626             "};",
15627             format("union FooBarBazQux {\r\n"
15628                    "  int foo;\n"
15629                    "  int bar;\r\n"
15630                    "  int baz;\n"
15631                    "};",
15632                    style));
15633   style.UseCRLF = true;
15634   EXPECT_EQ("union FooBarBazQux {\r\n"
15635             "  int foo;\r\n"
15636             "  int bar;\r\n"
15637             "  int baz;\r\n"
15638             "};",
15639             format("union FooBarBazQux {\r\n"
15640                    "  int foo;\n"
15641                    "  int bar;\r\n"
15642                    "  int baz;\n"
15643                    "};",
15644                    style));
15645 
15646   style.DeriveLineEnding = false;
15647   style.UseCRLF = false;
15648   EXPECT_EQ("union FooBarBazQux {\n"
15649             "  int foo;\n"
15650             "  int bar;\n"
15651             "  int baz;\n"
15652             "  int qux;\n"
15653             "};",
15654             format("union FooBarBazQux {\r\n"
15655                    "  int foo;\n"
15656                    "  int bar;\r\n"
15657                    "  int baz;\n"
15658                    "  int qux;\r\n"
15659                    "};",
15660                    style));
15661   style.UseCRLF = true;
15662   EXPECT_EQ("union FooBarBazQux {\r\n"
15663             "  int foo;\r\n"
15664             "  int bar;\r\n"
15665             "  int baz;\r\n"
15666             "  int qux;\r\n"
15667             "};",
15668             format("union FooBarBazQux {\r\n"
15669                    "  int foo;\n"
15670                    "  int bar;\r\n"
15671                    "  int baz;\n"
15672                    "  int qux;\n"
15673                    "};",
15674                    style));
15675 
15676   style.DeriveLineEnding = true;
15677   style.UseCRLF = false;
15678   EXPECT_EQ("union FooBarBazQux {\r\n"
15679             "  int foo;\r\n"
15680             "  int bar;\r\n"
15681             "  int baz;\r\n"
15682             "  int qux;\r\n"
15683             "};",
15684             format("union FooBarBazQux {\r\n"
15685                    "  int foo;\n"
15686                    "  int bar;\r\n"
15687                    "  int baz;\n"
15688                    "  int qux;\r\n"
15689                    "};",
15690                    style));
15691   style.UseCRLF = true;
15692   EXPECT_EQ("union FooBarBazQux {\n"
15693             "  int foo;\n"
15694             "  int bar;\n"
15695             "  int baz;\n"
15696             "  int qux;\n"
15697             "};",
15698             format("union FooBarBazQux {\r\n"
15699                    "  int foo;\n"
15700                    "  int bar;\r\n"
15701                    "  int baz;\n"
15702                    "  int qux;\n"
15703                    "};",
15704                    style));
15705 }
15706 
15707 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
15708   verifyFormat("MY_CLASS(C) {\n"
15709                "  int i;\n"
15710                "  int j;\n"
15711                "};");
15712 }
15713 
15714 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
15715   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
15716   TwoIndent.ContinuationIndentWidth = 2;
15717 
15718   EXPECT_EQ("int i =\n"
15719             "  longFunction(\n"
15720             "    arg);",
15721             format("int i = longFunction(arg);", TwoIndent));
15722 
15723   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
15724   SixIndent.ContinuationIndentWidth = 6;
15725 
15726   EXPECT_EQ("int i =\n"
15727             "      longFunction(\n"
15728             "            arg);",
15729             format("int i = longFunction(arg);", SixIndent));
15730 }
15731 
15732 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
15733   FormatStyle Style = getLLVMStyle();
15734   verifyFormat("int Foo::getter(\n"
15735                "    //\n"
15736                ") const {\n"
15737                "  return foo;\n"
15738                "}",
15739                Style);
15740   verifyFormat("void Foo::setter(\n"
15741                "    //\n"
15742                ") {\n"
15743                "  foo = 1;\n"
15744                "}",
15745                Style);
15746 }
15747 
15748 TEST_F(FormatTest, SpacesInAngles) {
15749   FormatStyle Spaces = getLLVMStyle();
15750   Spaces.SpacesInAngles = true;
15751 
15752   verifyFormat("static_cast< int >(arg);", Spaces);
15753   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
15754   verifyFormat("f< int, float >();", Spaces);
15755   verifyFormat("template <> g() {}", Spaces);
15756   verifyFormat("template < std::vector< int > > f() {}", Spaces);
15757   verifyFormat("std::function< void(int, int) > fct;", Spaces);
15758   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
15759                Spaces);
15760 
15761   Spaces.Standard = FormatStyle::LS_Cpp03;
15762   Spaces.SpacesInAngles = true;
15763   verifyFormat("A< A< int > >();", Spaces);
15764 
15765   Spaces.SpacesInAngles = false;
15766   verifyFormat("A<A<int> >();", Spaces);
15767 
15768   Spaces.Standard = FormatStyle::LS_Cpp11;
15769   Spaces.SpacesInAngles = true;
15770   verifyFormat("A< A< int > >();", Spaces);
15771 
15772   Spaces.SpacesInAngles = false;
15773   verifyFormat("A<A<int>>();", Spaces);
15774 }
15775 
15776 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
15777   FormatStyle Style = getLLVMStyle();
15778   Style.SpaceAfterTemplateKeyword = false;
15779   verifyFormat("template<int> void foo();", Style);
15780 }
15781 
15782 TEST_F(FormatTest, TripleAngleBrackets) {
15783   verifyFormat("f<<<1, 1>>>();");
15784   verifyFormat("f<<<1, 1, 1, s>>>();");
15785   verifyFormat("f<<<a, b, c, d>>>();");
15786   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
15787   verifyFormat("f<param><<<1, 1>>>();");
15788   verifyFormat("f<1><<<1, 1>>>();");
15789   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
15790   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15791                "aaaaaaaaaaa<<<\n    1, 1>>>();");
15792   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
15793                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
15794 }
15795 
15796 TEST_F(FormatTest, MergeLessLessAtEnd) {
15797   verifyFormat("<<");
15798   EXPECT_EQ("< < <", format("\\\n<<<"));
15799   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15800                "aaallvm::outs() <<");
15801   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15802                "aaaallvm::outs()\n    <<");
15803 }
15804 
15805 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
15806   std::string code = "#if A\n"
15807                      "#if B\n"
15808                      "a.\n"
15809                      "#endif\n"
15810                      "    a = 1;\n"
15811                      "#else\n"
15812                      "#endif\n"
15813                      "#if C\n"
15814                      "#else\n"
15815                      "#endif\n";
15816   EXPECT_EQ(code, format(code));
15817 }
15818 
15819 TEST_F(FormatTest, HandleConflictMarkers) {
15820   // Git/SVN conflict markers.
15821   EXPECT_EQ("int a;\n"
15822             "void f() {\n"
15823             "  callme(some(parameter1,\n"
15824             "<<<<<<< text by the vcs\n"
15825             "              parameter2),\n"
15826             "||||||| text by the vcs\n"
15827             "              parameter2),\n"
15828             "         parameter3,\n"
15829             "======= text by the vcs\n"
15830             "              parameter2, parameter3),\n"
15831             ">>>>>>> text by the vcs\n"
15832             "         otherparameter);\n",
15833             format("int a;\n"
15834                    "void f() {\n"
15835                    "  callme(some(parameter1,\n"
15836                    "<<<<<<< text by the vcs\n"
15837                    "  parameter2),\n"
15838                    "||||||| text by the vcs\n"
15839                    "  parameter2),\n"
15840                    "  parameter3,\n"
15841                    "======= text by the vcs\n"
15842                    "  parameter2,\n"
15843                    "  parameter3),\n"
15844                    ">>>>>>> text by the vcs\n"
15845                    "  otherparameter);\n"));
15846 
15847   // Perforce markers.
15848   EXPECT_EQ("void f() {\n"
15849             "  function(\n"
15850             ">>>> text by the vcs\n"
15851             "      parameter,\n"
15852             "==== text by the vcs\n"
15853             "      parameter,\n"
15854             "==== text by the vcs\n"
15855             "      parameter,\n"
15856             "<<<< text by the vcs\n"
15857             "      parameter);\n",
15858             format("void f() {\n"
15859                    "  function(\n"
15860                    ">>>> text by the vcs\n"
15861                    "  parameter,\n"
15862                    "==== text by the vcs\n"
15863                    "  parameter,\n"
15864                    "==== text by the vcs\n"
15865                    "  parameter,\n"
15866                    "<<<< text by the vcs\n"
15867                    "  parameter);\n"));
15868 
15869   EXPECT_EQ("<<<<<<<\n"
15870             "|||||||\n"
15871             "=======\n"
15872             ">>>>>>>",
15873             format("<<<<<<<\n"
15874                    "|||||||\n"
15875                    "=======\n"
15876                    ">>>>>>>"));
15877 
15878   EXPECT_EQ("<<<<<<<\n"
15879             "|||||||\n"
15880             "int i;\n"
15881             "=======\n"
15882             ">>>>>>>",
15883             format("<<<<<<<\n"
15884                    "|||||||\n"
15885                    "int i;\n"
15886                    "=======\n"
15887                    ">>>>>>>"));
15888 
15889   // FIXME: Handle parsing of macros around conflict markers correctly:
15890   EXPECT_EQ("#define Macro \\\n"
15891             "<<<<<<<\n"
15892             "Something \\\n"
15893             "|||||||\n"
15894             "Else \\\n"
15895             "=======\n"
15896             "Other \\\n"
15897             ">>>>>>>\n"
15898             "    End int i;\n",
15899             format("#define Macro \\\n"
15900                    "<<<<<<<\n"
15901                    "  Something \\\n"
15902                    "|||||||\n"
15903                    "  Else \\\n"
15904                    "=======\n"
15905                    "  Other \\\n"
15906                    ">>>>>>>\n"
15907                    "  End\n"
15908                    "int i;\n"));
15909 }
15910 
15911 TEST_F(FormatTest, DisableRegions) {
15912   EXPECT_EQ("int i;\n"
15913             "// clang-format off\n"
15914             "  int j;\n"
15915             "// clang-format on\n"
15916             "int k;",
15917             format(" int  i;\n"
15918                    "   // clang-format off\n"
15919                    "  int j;\n"
15920                    " // clang-format on\n"
15921                    "   int   k;"));
15922   EXPECT_EQ("int i;\n"
15923             "/* clang-format off */\n"
15924             "  int j;\n"
15925             "/* clang-format on */\n"
15926             "int k;",
15927             format(" int  i;\n"
15928                    "   /* clang-format off */\n"
15929                    "  int j;\n"
15930                    " /* clang-format on */\n"
15931                    "   int   k;"));
15932 
15933   // Don't reflow comments within disabled regions.
15934   EXPECT_EQ("// clang-format off\n"
15935             "// long long long long long long line\n"
15936             "/* clang-format on */\n"
15937             "/* long long long\n"
15938             " * long long long\n"
15939             " * line */\n"
15940             "int i;\n"
15941             "/* clang-format off */\n"
15942             "/* long long long long long long line */\n",
15943             format("// clang-format off\n"
15944                    "// long long long long long long line\n"
15945                    "/* clang-format on */\n"
15946                    "/* long long long long long long line */\n"
15947                    "int i;\n"
15948                    "/* clang-format off */\n"
15949                    "/* long long long long long long line */\n",
15950                    getLLVMStyleWithColumns(20)));
15951 }
15952 
15953 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
15954   format("? ) =");
15955   verifyNoCrash("#define a\\\n /**/}");
15956 }
15957 
15958 TEST_F(FormatTest, FormatsTableGenCode) {
15959   FormatStyle Style = getLLVMStyle();
15960   Style.Language = FormatStyle::LK_TableGen;
15961   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
15962 }
15963 
15964 TEST_F(FormatTest, ArrayOfTemplates) {
15965   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
15966             format("auto a = new unique_ptr<int > [ 10];"));
15967 
15968   FormatStyle Spaces = getLLVMStyle();
15969   Spaces.SpacesInSquareBrackets = true;
15970   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
15971             format("auto a = new unique_ptr<int > [10];", Spaces));
15972 }
15973 
15974 TEST_F(FormatTest, ArrayAsTemplateType) {
15975   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
15976             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
15977 
15978   FormatStyle Spaces = getLLVMStyle();
15979   Spaces.SpacesInSquareBrackets = true;
15980   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
15981             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
15982 }
15983 
15984 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
15985 
15986 TEST(FormatStyle, GetStyleWithEmptyFileName) {
15987   llvm::vfs::InMemoryFileSystem FS;
15988   auto Style1 = getStyle("file", "", "Google", "", &FS);
15989   ASSERT_TRUE((bool)Style1);
15990   ASSERT_EQ(*Style1, getGoogleStyle());
15991 }
15992 
15993 TEST(FormatStyle, GetStyleOfFile) {
15994   llvm::vfs::InMemoryFileSystem FS;
15995   // Test 1: format file in the same directory.
15996   ASSERT_TRUE(
15997       FS.addFile("/a/.clang-format", 0,
15998                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
15999   ASSERT_TRUE(
16000       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16001   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
16002   ASSERT_TRUE((bool)Style1);
16003   ASSERT_EQ(*Style1, getLLVMStyle());
16004 
16005   // Test 2.1: fallback to default.
16006   ASSERT_TRUE(
16007       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16008   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
16009   ASSERT_TRUE((bool)Style2);
16010   ASSERT_EQ(*Style2, getMozillaStyle());
16011 
16012   // Test 2.2: no format on 'none' fallback style.
16013   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16014   ASSERT_TRUE((bool)Style2);
16015   ASSERT_EQ(*Style2, getNoStyle());
16016 
16017   // Test 2.3: format if config is found with no based style while fallback is
16018   // 'none'.
16019   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
16020                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
16021   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16022   ASSERT_TRUE((bool)Style2);
16023   ASSERT_EQ(*Style2, getLLVMStyle());
16024 
16025   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
16026   Style2 = getStyle("{}", "a.h", "none", "", &FS);
16027   ASSERT_TRUE((bool)Style2);
16028   ASSERT_EQ(*Style2, getLLVMStyle());
16029 
16030   // Test 3: format file in parent directory.
16031   ASSERT_TRUE(
16032       FS.addFile("/c/.clang-format", 0,
16033                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
16034   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
16035                          llvm::MemoryBuffer::getMemBuffer("int i;")));
16036   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
16037   ASSERT_TRUE((bool)Style3);
16038   ASSERT_EQ(*Style3, getGoogleStyle());
16039 
16040   // Test 4: error on invalid fallback style
16041   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
16042   ASSERT_FALSE((bool)Style4);
16043   llvm::consumeError(Style4.takeError());
16044 
16045   // Test 5: error on invalid yaml on command line
16046   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
16047   ASSERT_FALSE((bool)Style5);
16048   llvm::consumeError(Style5.takeError());
16049 
16050   // Test 6: error on invalid style
16051   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
16052   ASSERT_FALSE((bool)Style6);
16053   llvm::consumeError(Style6.takeError());
16054 
16055   // Test 7: found config file, error on parsing it
16056   ASSERT_TRUE(
16057       FS.addFile("/d/.clang-format", 0,
16058                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
16059                                                   "InvalidKey: InvalidValue")));
16060   ASSERT_TRUE(
16061       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16062   auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
16063   ASSERT_FALSE((bool)Style7);
16064   llvm::consumeError(Style7.takeError());
16065 
16066   // Test 8: inferred per-language defaults apply.
16067   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
16068   ASSERT_TRUE((bool)StyleTd);
16069   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
16070 }
16071 
16072 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
16073   // Column limit is 20.
16074   std::string Code = "Type *a =\n"
16075                      "    new Type();\n"
16076                      "g(iiiii, 0, jjjjj,\n"
16077                      "  0, kkkkk, 0, mm);\n"
16078                      "int  bad     = format   ;";
16079   std::string Expected = "auto a = new Type();\n"
16080                          "g(iiiii, nullptr,\n"
16081                          "  jjjjj, nullptr,\n"
16082                          "  kkkkk, nullptr,\n"
16083                          "  mm);\n"
16084                          "int  bad     = format   ;";
16085   FileID ID = Context.createInMemoryFile("format.cpp", Code);
16086   tooling::Replacements Replaces = toReplacements(
16087       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
16088                             "auto "),
16089        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
16090                             "nullptr"),
16091        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
16092                             "nullptr"),
16093        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
16094                             "nullptr")});
16095 
16096   format::FormatStyle Style = format::getLLVMStyle();
16097   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
16098   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16099   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16100       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16101   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16102   EXPECT_TRUE(static_cast<bool>(Result));
16103   EXPECT_EQ(Expected, *Result);
16104 }
16105 
16106 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
16107   std::string Code = "#include \"a.h\"\n"
16108                      "#include \"c.h\"\n"
16109                      "\n"
16110                      "int main() {\n"
16111                      "  return 0;\n"
16112                      "}";
16113   std::string Expected = "#include \"a.h\"\n"
16114                          "#include \"b.h\"\n"
16115                          "#include \"c.h\"\n"
16116                          "\n"
16117                          "int main() {\n"
16118                          "  return 0;\n"
16119                          "}";
16120   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
16121   tooling::Replacements Replaces = toReplacements(
16122       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
16123                             "#include \"b.h\"\n")});
16124 
16125   format::FormatStyle Style = format::getLLVMStyle();
16126   Style.SortIncludes = true;
16127   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16128   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16129       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16130   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16131   EXPECT_TRUE(static_cast<bool>(Result));
16132   EXPECT_EQ(Expected, *Result);
16133 }
16134 
16135 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
16136   EXPECT_EQ("using std::cin;\n"
16137             "using std::cout;",
16138             format("using std::cout;\n"
16139                    "using std::cin;",
16140                    getGoogleStyle()));
16141 }
16142 
16143 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
16144   format::FormatStyle Style = format::getLLVMStyle();
16145   Style.Standard = FormatStyle::LS_Cpp03;
16146   // cpp03 recognize this string as identifier u8 and literal character 'a'
16147   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
16148 }
16149 
16150 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
16151   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
16152   // all modes, including C++11, C++14 and C++17
16153   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
16154 }
16155 
16156 TEST_F(FormatTest, DoNotFormatLikelyXml) {
16157   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
16158   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
16159 }
16160 
16161 TEST_F(FormatTest, StructuredBindings) {
16162   // Structured bindings is a C++17 feature.
16163   // all modes, including C++11, C++14 and C++17
16164   verifyFormat("auto [a, b] = f();");
16165   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
16166   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
16167   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
16168   EXPECT_EQ("auto const volatile [a, b] = f();",
16169             format("auto  const   volatile[a, b] = f();"));
16170   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
16171   EXPECT_EQ("auto &[a, b, c] = f();",
16172             format("auto   &[  a  ,  b,c   ] = f();"));
16173   EXPECT_EQ("auto &&[a, b, c] = f();",
16174             format("auto   &&[  a  ,  b,c   ] = f();"));
16175   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
16176   EXPECT_EQ("auto const volatile &&[a, b] = f();",
16177             format("auto  const  volatile  &&[a, b] = f();"));
16178   EXPECT_EQ("auto const &&[a, b] = f();",
16179             format("auto  const   &&  [a, b] = f();"));
16180   EXPECT_EQ("const auto &[a, b] = f();",
16181             format("const  auto  &  [a, b] = f();"));
16182   EXPECT_EQ("const auto volatile &&[a, b] = f();",
16183             format("const  auto   volatile  &&[a, b] = f();"));
16184   EXPECT_EQ("volatile const auto &&[a, b] = f();",
16185             format("volatile  const  auto   &&[a, b] = f();"));
16186   EXPECT_EQ("const auto &&[a, b] = f();",
16187             format("const  auto  &&  [a, b] = f();"));
16188 
16189   // Make sure we don't mistake structured bindings for lambdas.
16190   FormatStyle PointerMiddle = getLLVMStyle();
16191   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16192   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16193   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16194   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16195   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16196   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16197   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16198   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16199   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16200   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16201   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16202   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16203   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16204 
16205   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16206             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16207   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16208             format("for (const auto   &   [a, b] : some_range) {\n}"));
16209   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16210             format("for (const auto[a, b] : some_range) {\n}"));
16211   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16212   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16213   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16214   EXPECT_EQ("auto const &[x, y](expr);",
16215             format("auto  const  &  [x,y]  (expr);"));
16216   EXPECT_EQ("auto const &&[x, y](expr);",
16217             format("auto  const  &&  [x,y]  (expr);"));
16218   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16219   EXPECT_EQ("auto const &[x, y]{expr};",
16220             format("auto  const  &  [x,y]  {expr};"));
16221   EXPECT_EQ("auto const &&[x, y]{expr};",
16222             format("auto  const  &&  [x,y]  {expr};"));
16223 
16224   format::FormatStyle Spaces = format::getLLVMStyle();
16225   Spaces.SpacesInSquareBrackets = true;
16226   verifyFormat("auto [ a, b ] = f();", Spaces);
16227   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16228   verifyFormat("auto &[ a, b ] = f();", Spaces);
16229   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16230   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16231 }
16232 
16233 TEST_F(FormatTest, FileAndCode) {
16234   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16235   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16236   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16237   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16238   EXPECT_EQ(FormatStyle::LK_ObjC,
16239             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16240   EXPECT_EQ(
16241       FormatStyle::LK_ObjC,
16242       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16243   EXPECT_EQ(FormatStyle::LK_ObjC,
16244             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16245   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16246   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16247   EXPECT_EQ(FormatStyle::LK_ObjC,
16248             guessLanguage("foo", "@interface Foo\n@end\n"));
16249   EXPECT_EQ(FormatStyle::LK_ObjC,
16250             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16251   EXPECT_EQ(
16252       FormatStyle::LK_ObjC,
16253       guessLanguage("foo.h",
16254                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16255   EXPECT_EQ(
16256       FormatStyle::LK_Cpp,
16257       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16258 }
16259 
16260 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16261   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16262   EXPECT_EQ(FormatStyle::LK_ObjC,
16263             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16264   EXPECT_EQ(FormatStyle::LK_Cpp,
16265             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16266   EXPECT_EQ(
16267       FormatStyle::LK_Cpp,
16268       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16269   EXPECT_EQ(FormatStyle::LK_ObjC,
16270             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16271   EXPECT_EQ(FormatStyle::LK_Cpp,
16272             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16273   EXPECT_EQ(FormatStyle::LK_ObjC,
16274             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16275   EXPECT_EQ(FormatStyle::LK_Cpp,
16276             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16277   EXPECT_EQ(FormatStyle::LK_Cpp,
16278             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16279   EXPECT_EQ(FormatStyle::LK_ObjC,
16280             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16281   EXPECT_EQ(FormatStyle::LK_Cpp,
16282             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16283   EXPECT_EQ(
16284       FormatStyle::LK_Cpp,
16285       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16286   EXPECT_EQ(
16287       FormatStyle::LK_Cpp,
16288       guessLanguage("foo.h",
16289                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16290   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16291 }
16292 
16293 TEST_F(FormatTest, GuessLanguageWithCaret) {
16294   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16295   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16296   EXPECT_EQ(FormatStyle::LK_ObjC,
16297             guessLanguage("foo.h", "int(^)(char, float);"));
16298   EXPECT_EQ(FormatStyle::LK_ObjC,
16299             guessLanguage("foo.h", "int(^foo)(char, float);"));
16300   EXPECT_EQ(FormatStyle::LK_ObjC,
16301             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16302   EXPECT_EQ(FormatStyle::LK_ObjC,
16303             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16304   EXPECT_EQ(
16305       FormatStyle::LK_ObjC,
16306       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16307 }
16308 
16309 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16310   // ASM symbolic names are identifiers that must be surrounded by [] without
16311   // space in between:
16312   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16313 
16314   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16315   verifyFormat(R"(//
16316 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16317 )");
16318 
16319   // A list of several ASM symbolic names.
16320   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16321 
16322   // ASM symbolic names in inline ASM with inputs and outputs.
16323   verifyFormat(R"(//
16324 asm("cmoveq %1, %2, %[result]"
16325     : [result] "=r"(result)
16326     : "r"(test), "r"(new), "[result]"(old));
16327 )");
16328 
16329   // ASM symbolic names in inline ASM with no outputs.
16330   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16331 }
16332 
16333 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
16334   EXPECT_EQ(FormatStyle::LK_Cpp,
16335             guessLanguage("foo.h", "void f() {\n"
16336                                    "  asm (\"mov %[e], %[d]\"\n"
16337                                    "     : [d] \"=rm\" (d)\n"
16338                                    "       [e] \"rm\" (*e));\n"
16339                                    "}"));
16340   EXPECT_EQ(FormatStyle::LK_Cpp,
16341             guessLanguage("foo.h", "void f() {\n"
16342                                    "  _asm (\"mov %[e], %[d]\"\n"
16343                                    "     : [d] \"=rm\" (d)\n"
16344                                    "       [e] \"rm\" (*e));\n"
16345                                    "}"));
16346   EXPECT_EQ(FormatStyle::LK_Cpp,
16347             guessLanguage("foo.h", "void f() {\n"
16348                                    "  __asm (\"mov %[e], %[d]\"\n"
16349                                    "     : [d] \"=rm\" (d)\n"
16350                                    "       [e] \"rm\" (*e));\n"
16351                                    "}"));
16352   EXPECT_EQ(FormatStyle::LK_Cpp,
16353             guessLanguage("foo.h", "void f() {\n"
16354                                    "  __asm__ (\"mov %[e], %[d]\"\n"
16355                                    "     : [d] \"=rm\" (d)\n"
16356                                    "       [e] \"rm\" (*e));\n"
16357                                    "}"));
16358   EXPECT_EQ(FormatStyle::LK_Cpp,
16359             guessLanguage("foo.h", "void f() {\n"
16360                                    "  asm (\"mov %[e], %[d]\"\n"
16361                                    "     : [d] \"=rm\" (d),\n"
16362                                    "       [e] \"rm\" (*e));\n"
16363                                    "}"));
16364   EXPECT_EQ(FormatStyle::LK_Cpp,
16365             guessLanguage("foo.h", "void f() {\n"
16366                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16367                                    "     : [d] \"=rm\" (d)\n"
16368                                    "       [e] \"rm\" (*e));\n"
16369                                    "}"));
16370 }
16371 
16372 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16373   EXPECT_EQ(FormatStyle::LK_Cpp,
16374             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16375   EXPECT_EQ(FormatStyle::LK_ObjC,
16376             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16377   EXPECT_EQ(
16378       FormatStyle::LK_Cpp,
16379       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16380   EXPECT_EQ(
16381       FormatStyle::LK_ObjC,
16382       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16383 }
16384 
16385 TEST_F(FormatTest, TypenameMacros) {
16386   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16387 
16388   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16389   FormatStyle Google = getGoogleStyleWithColumns(0);
16390   Google.TypenameMacros = TypenameMacros;
16391   verifyFormat("struct foo {\n"
16392                "  int bar;\n"
16393                "  TAILQ_ENTRY(a) bleh;\n"
16394                "};",
16395                Google);
16396 
16397   FormatStyle Macros = getLLVMStyle();
16398   Macros.TypenameMacros = TypenameMacros;
16399 
16400   verifyFormat("STACK_OF(int) a;", Macros);
16401   verifyFormat("STACK_OF(int) *a;", Macros);
16402   verifyFormat("STACK_OF(int const *) *a;", Macros);
16403   verifyFormat("STACK_OF(int *const) *a;", Macros);
16404   verifyFormat("STACK_OF(int, string) a;", Macros);
16405   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16406   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16407   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16408   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16409 
16410   Macros.PointerAlignment = FormatStyle::PAS_Left;
16411   verifyFormat("STACK_OF(int)* a;", Macros);
16412   verifyFormat("STACK_OF(int*)* a;", Macros);
16413 }
16414 
16415 TEST_F(FormatTest, AmbersandInLamda) {
16416   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16417   FormatStyle AlignStyle = getLLVMStyle();
16418   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16419   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16420   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16421   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16422 }
16423 
16424 TEST_F(FormatTest, SpacesInConditionalStatement) {
16425   FormatStyle Spaces = getLLVMStyle();
16426   Spaces.SpacesInConditionalStatement = true;
16427   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16428   verifyFormat("if ( !a )\n  return;", Spaces);
16429   verifyFormat("if ( a )\n  return;", Spaces);
16430   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16431   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16432   verifyFormat("while ( a )\n  return;", Spaces);
16433   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16434   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16435   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16436   // Check that space on the left of "::" is inserted as expected at beginning
16437   // of condition.
16438   verifyFormat("while ( ::func() )\n  return;", Spaces);
16439 }
16440 
16441 TEST_F(FormatTest, AlternativeOperators) {
16442   // Test case for ensuring alternate operators are not
16443   // combined with their right most neighbour.
16444   verifyFormat("int a and b;");
16445   verifyFormat("int a and_eq b;");
16446   verifyFormat("int a bitand b;");
16447   verifyFormat("int a bitor b;");
16448   verifyFormat("int a compl b;");
16449   verifyFormat("int a not b;");
16450   verifyFormat("int a not_eq b;");
16451   verifyFormat("int a or b;");
16452   verifyFormat("int a xor b;");
16453   verifyFormat("int a xor_eq b;");
16454   verifyFormat("return this not_eq bitand other;");
16455   verifyFormat("bool operator not_eq(const X bitand other)");
16456 
16457   verifyFormat("int a and 5;");
16458   verifyFormat("int a and_eq 5;");
16459   verifyFormat("int a bitand 5;");
16460   verifyFormat("int a bitor 5;");
16461   verifyFormat("int a compl 5;");
16462   verifyFormat("int a not 5;");
16463   verifyFormat("int a not_eq 5;");
16464   verifyFormat("int a or 5;");
16465   verifyFormat("int a xor 5;");
16466   verifyFormat("int a xor_eq 5;");
16467 
16468   verifyFormat("int a compl(5);");
16469   verifyFormat("int a not(5);");
16470 
16471   /* FIXME handle alternate tokens
16472    * https://en.cppreference.com/w/cpp/language/operator_alternative
16473   // alternative tokens
16474   verifyFormat("compl foo();");     //  ~foo();
16475   verifyFormat("foo() <%%>;");      // foo();
16476   verifyFormat("void foo() <%%>;"); // void foo(){}
16477   verifyFormat("int a <:1:>;");     // int a[1];[
16478   verifyFormat("%:define ABC abc"); // #define ABC abc
16479   verifyFormat("%:%:");             // ##
16480   */
16481 }
16482 
16483 TEST_F(FormatTest, STLWhileNotDefineChed) {
16484   verifyFormat("#if defined(while)\n"
16485                "#define while EMIT WARNING C4005\n"
16486                "#endif // while");
16487 }
16488 
16489 TEST_F(FormatTest, OperatorSpacing) {
16490   FormatStyle Style = getLLVMStyle();
16491   Style.PointerAlignment = FormatStyle::PAS_Right;
16492   verifyFormat("Foo::operator*();", Style);
16493   verifyFormat("Foo::operator void *();", Style);
16494   verifyFormat("Foo::operator void **();", Style);
16495   verifyFormat("Foo::operator void *&();", Style);
16496   verifyFormat("Foo::operator void *&&();", Style);
16497   verifyFormat("Foo::operator()(void *);", Style);
16498   verifyFormat("Foo::operator*(void *);", Style);
16499   verifyFormat("Foo::operator*();", Style);
16500   verifyFormat("Foo::operator**();", Style);
16501   verifyFormat("Foo::operator&();", Style);
16502   verifyFormat("Foo::operator<int> *();", Style);
16503   verifyFormat("Foo::operator<Foo> *();", Style);
16504   verifyFormat("Foo::operator<int> **();", Style);
16505   verifyFormat("Foo::operator<Foo> **();", Style);
16506   verifyFormat("Foo::operator<int> &();", Style);
16507   verifyFormat("Foo::operator<Foo> &();", Style);
16508   verifyFormat("Foo::operator<int> &&();", Style);
16509   verifyFormat("Foo::operator<Foo> &&();", Style);
16510   verifyFormat("Foo::operator<int> *&();", Style);
16511   verifyFormat("Foo::operator<Foo> *&();", Style);
16512   verifyFormat("Foo::operator<int> *&&();", Style);
16513   verifyFormat("Foo::operator<Foo> *&&();", Style);
16514   verifyFormat("operator*(int (*)(), class Foo);", Style);
16515 
16516   verifyFormat("Foo::operator&();", Style);
16517   verifyFormat("Foo::operator void &();", Style);
16518   verifyFormat("Foo::operator()(void &);", Style);
16519   verifyFormat("Foo::operator&(void &);", Style);
16520   verifyFormat("Foo::operator&();", Style);
16521   verifyFormat("operator&(int (&)(), class Foo);", Style);
16522 
16523   verifyFormat("Foo::operator&&();", Style);
16524   verifyFormat("Foo::operator**();", Style);
16525   verifyFormat("Foo::operator void &&();", Style);
16526   verifyFormat("Foo::operator()(void &&);", Style);
16527   verifyFormat("Foo::operator&&(void &&);", Style);
16528   verifyFormat("Foo::operator&&();", Style);
16529   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16530   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16531   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16532                Style);
16533   verifyFormat("operator void **()", Style);
16534   verifyFormat("operator const FooRight<Object> &()", Style);
16535   verifyFormat("operator const FooRight<Object> *()", Style);
16536   verifyFormat("operator const FooRight<Object> **()", Style);
16537   verifyFormat("operator const FooRight<Object> *&()", Style);
16538   verifyFormat("operator const FooRight<Object> *&&()", Style);
16539 
16540   Style.PointerAlignment = FormatStyle::PAS_Left;
16541   verifyFormat("Foo::operator*();", Style);
16542   verifyFormat("Foo::operator**();", Style);
16543   verifyFormat("Foo::operator void*();", Style);
16544   verifyFormat("Foo::operator void**();", Style);
16545   verifyFormat("Foo::operator void*&();", Style);
16546   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16547   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16548   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16549   verifyFormat("Foo::operator()(void*);", Style);
16550   verifyFormat("Foo::operator*(void*);", Style);
16551   verifyFormat("Foo::operator*();", Style);
16552   verifyFormat("Foo::operator<int>*();", Style);
16553   verifyFormat("Foo::operator<Foo>*();", Style);
16554   verifyFormat("Foo::operator<int>**();", Style);
16555   verifyFormat("Foo::operator<Foo>**();", Style);
16556   verifyFormat("Foo::operator<Foo>*&();", Style);
16557   verifyFormat("Foo::operator<int>&();", Style);
16558   verifyFormat("Foo::operator<Foo>&();", Style);
16559   verifyFormat("Foo::operator<int>&&();", Style);
16560   verifyFormat("Foo::operator<Foo>&&();", Style);
16561   verifyFormat("Foo::operator<int>*&();", Style);
16562   verifyFormat("Foo::operator<Foo>*&();", Style);
16563   verifyFormat("operator*(int (*)(), class Foo);", Style);
16564 
16565   verifyFormat("Foo::operator&();", Style);
16566   verifyFormat("Foo::operator void&();", Style);
16567   verifyFormat("Foo::operator/*comment*/ void&();", Style);
16568   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
16569   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
16570   verifyFormat("Foo::operator()(void&);", Style);
16571   verifyFormat("Foo::operator&(void&);", Style);
16572   verifyFormat("Foo::operator&();", Style);
16573   verifyFormat("operator&(int (&)(), class Foo);", Style);
16574 
16575   verifyFormat("Foo::operator&&();", Style);
16576   verifyFormat("Foo::operator void&&();", Style);
16577   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
16578   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
16579   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
16580   verifyFormat("Foo::operator()(void&&);", Style);
16581   verifyFormat("Foo::operator&&(void&&);", Style);
16582   verifyFormat("Foo::operator&&();", Style);
16583   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16584   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
16585   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
16586                Style);
16587   verifyFormat("operator void**()", Style);
16588   verifyFormat("operator const FooLeft<Object>&()", Style);
16589   verifyFormat("operator const FooLeft<Object>*()", Style);
16590   verifyFormat("operator const FooLeft<Object>**()", Style);
16591   verifyFormat("operator const FooLeft<Object>*&()", Style);
16592   verifyFormat("operator const FooLeft<Object>*&&()", Style);
16593 
16594   // PR45107
16595   verifyFormat("operator Vector<String>&();", Style);
16596   verifyFormat("operator const Vector<String>&();", Style);
16597   verifyFormat("operator foo::Bar*();", Style);
16598   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
16599   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
16600                Style);
16601 
16602   Style.PointerAlignment = FormatStyle::PAS_Middle;
16603   verifyFormat("Foo::operator*();", Style);
16604   verifyFormat("Foo::operator void *();", Style);
16605   verifyFormat("Foo::operator()(void *);", Style);
16606   verifyFormat("Foo::operator*(void *);", Style);
16607   verifyFormat("Foo::operator*();", Style);
16608   verifyFormat("operator*(int (*)(), class Foo);", Style);
16609 
16610   verifyFormat("Foo::operator&();", Style);
16611   verifyFormat("Foo::operator void &();", Style);
16612   verifyFormat("Foo::operator()(void &);", Style);
16613   verifyFormat("Foo::operator&(void &);", Style);
16614   verifyFormat("Foo::operator&();", Style);
16615   verifyFormat("operator&(int (&)(), class Foo);", Style);
16616 
16617   verifyFormat("Foo::operator&&();", Style);
16618   verifyFormat("Foo::operator void &&();", Style);
16619   verifyFormat("Foo::operator()(void &&);", Style);
16620   verifyFormat("Foo::operator&&(void &&);", Style);
16621   verifyFormat("Foo::operator&&();", Style);
16622   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16623 }
16624 
16625 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
16626   FormatStyle Style = getLLVMStyle();
16627   // PR46157
16628   verifyFormat("foo(operator+, -42);", Style);
16629   verifyFormat("foo(operator++, -42);", Style);
16630   verifyFormat("foo(operator--, -42);", Style);
16631   verifyFormat("foo(-42, operator--);", Style);
16632   verifyFormat("foo(-42, operator, );", Style);
16633   verifyFormat("foo(operator, , -42);", Style);
16634 }
16635 
16636 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
16637   FormatStyle Style = getLLVMStyle();
16638   Style.WhitespaceSensitiveMacros.push_back("FOO");
16639 
16640   // Don't use the helpers here, since 'mess up' will change the whitespace
16641   // and these are all whitespace sensitive by definition
16642   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
16643             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
16644   EXPECT_EQ(
16645       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
16646       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
16647   EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
16648             format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
16649   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
16650             "       Still=Intentional);",
16651             format("FOO(String-ized&Messy+But,: :\n"
16652                    "       Still=Intentional);",
16653                    Style));
16654   Style.AlignConsecutiveAssignments = true;
16655   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
16656             "       Still=Intentional);",
16657             format("FOO(String-ized=&Messy+But,: :\n"
16658                    "       Still=Intentional);",
16659                    Style));
16660 
16661   Style.ColumnLimit = 21;
16662   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
16663             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
16664 }
16665 
16666 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
16667   // These tests are not in NamespaceFixer because that doesn't
16668   // test its interaction with line wrapping
16669   FormatStyle Style = getLLVMStyle();
16670   Style.ColumnLimit = 80;
16671   verifyFormat("namespace {\n"
16672                "int i;\n"
16673                "int j;\n"
16674                "} // namespace",
16675                Style);
16676 
16677   verifyFormat("namespace AAA {\n"
16678                "int i;\n"
16679                "int j;\n"
16680                "} // namespace AAA",
16681                Style);
16682 
16683   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
16684             "int i;\n"
16685             "int j;\n"
16686             "} // namespace Averyveryveryverylongnamespace",
16687             format("namespace Averyveryveryverylongnamespace {\n"
16688                    "int i;\n"
16689                    "int j;\n"
16690                    "}",
16691                    Style));
16692 
16693   EXPECT_EQ(
16694       "namespace "
16695       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16696       "    went::mad::now {\n"
16697       "int i;\n"
16698       "int j;\n"
16699       "} // namespace\n"
16700       "  // "
16701       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16702       "went::mad::now",
16703       format("namespace "
16704              "would::it::save::you::a::lot::of::time::if_::i::"
16705              "just::gave::up::and_::went::mad::now {\n"
16706              "int i;\n"
16707              "int j;\n"
16708              "}",
16709              Style));
16710 
16711   // This used to duplicate the comment again and again on subsequent runs
16712   EXPECT_EQ(
16713       "namespace "
16714       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16715       "    went::mad::now {\n"
16716       "int i;\n"
16717       "int j;\n"
16718       "} // namespace\n"
16719       "  // "
16720       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16721       "went::mad::now",
16722       format("namespace "
16723              "would::it::save::you::a::lot::of::time::if_::i::"
16724              "just::gave::up::and_::went::mad::now {\n"
16725              "int i;\n"
16726              "int j;\n"
16727              "} // namespace\n"
16728              "  // "
16729              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
16730              "and_::went::mad::now",
16731              Style));
16732 }
16733 
16734 TEST_F(FormatTest, LikelyUnlikely) {
16735   FormatStyle Style = getLLVMStyle();
16736 
16737   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16738                "  return 29;\n"
16739                "}",
16740                Style);
16741 
16742   verifyFormat("if (argc > 5) [[likely]] {\n"
16743                "  return 29;\n"
16744                "}",
16745                Style);
16746 
16747   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16748                "  return 29;\n"
16749                "} else [[likely]] {\n"
16750                "  return 42;\n"
16751                "}\n",
16752                Style);
16753 
16754   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16755                "  return 29;\n"
16756                "} else if (argc > 10) [[likely]] {\n"
16757                "  return 99;\n"
16758                "} else {\n"
16759                "  return 42;\n"
16760                "}\n",
16761                Style);
16762 
16763   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
16764                "  return 29;\n"
16765                "}",
16766                Style);
16767 }
16768 
16769 TEST_F(FormatTest, LLVMDefaultStyle) {
16770   FormatStyle Style = getLLVMStyle();
16771   verifyFormat("extern \"C\" {\n"
16772                "int foo();\n"
16773                "}",
16774                Style);
16775 }
16776 TEST_F(FormatTest, GNUDefaultStyle) {
16777   FormatStyle Style = getGNUStyle();
16778   verifyFormat("extern \"C\"\n"
16779                "{\n"
16780                "  int foo ();\n"
16781                "}",
16782                Style);
16783 }
16784 TEST_F(FormatTest, MozillaDefaultStyle) {
16785   FormatStyle Style = getMozillaStyle();
16786   verifyFormat("extern \"C\"\n"
16787                "{\n"
16788                "  int foo();\n"
16789                "}",
16790                Style);
16791 }
16792 TEST_F(FormatTest, GoogleDefaultStyle) {
16793   FormatStyle Style = getGoogleStyle();
16794   verifyFormat("extern \"C\" {\n"
16795                "int foo();\n"
16796                "}",
16797                Style);
16798 }
16799 TEST_F(FormatTest, ChromiumDefaultStyle) {
16800   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
16801   verifyFormat("extern \"C\" {\n"
16802                "int foo();\n"
16803                "}",
16804                Style);
16805 }
16806 TEST_F(FormatTest, MicrosoftDefaultStyle) {
16807   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
16808   verifyFormat("extern \"C\"\n"
16809                "{\n"
16810                "    int foo();\n"
16811                "}",
16812                Style);
16813 }
16814 TEST_F(FormatTest, WebKitDefaultStyle) {
16815   FormatStyle Style = getWebKitStyle();
16816   verifyFormat("extern \"C\" {\n"
16817                "int foo();\n"
16818                "}",
16819                Style);
16820 }
16821 } // namespace
16822 } // namespace format
16823 } // namespace clang
16824