1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "clang/Format/Format.h"
10 
11 #include "../Tooling/ReplacementTest.h"
12 #include "FormatTestUtils.h"
13 
14 #include "clang/Frontend/TextDiagnosticPrinter.h"
15 #include "llvm/Support/Debug.h"
16 #include "llvm/Support/MemoryBuffer.h"
17 #include "gtest/gtest.h"
18 
19 #define DEBUG_TYPE "format-test"
20 
21 using clang::tooling::ReplacementTest;
22 using clang::tooling::toReplacements;
23 
24 namespace clang {
25 namespace format {
26 namespace {
27 
28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
29 
30 class FormatTest : public ::testing::Test {
31 protected:
32   enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck };
33 
34   std::string format(llvm::StringRef Code,
35                      const FormatStyle &Style = getLLVMStyle(),
36                      StatusCheck CheckComplete = SC_ExpectComplete) {
37     LLVM_DEBUG(llvm::errs() << "---\n");
38     LLVM_DEBUG(llvm::errs() << Code << "\n\n");
39     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
40     FormattingAttemptStatus Status;
41     tooling::Replacements Replaces =
42         reformat(Style, Code, Ranges, "<stdin>", &Status);
43     if (CheckComplete != SC_DoNotCheck) {
44       bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete;
45       EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
46           << Code << "\n\n";
47     }
48     ReplacementCount = Replaces.size();
49     auto Result = applyAllReplacements(Code, Replaces);
50     EXPECT_TRUE(static_cast<bool>(Result));
51     LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
52     return *Result;
53   }
54 
55   FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) {
56     Style.ColumnLimit = ColumnLimit;
57     return Style;
58   }
59 
60   FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
61     return getStyleWithColumns(getLLVMStyle(), ColumnLimit);
62   }
63 
64   FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
65     return getStyleWithColumns(getGoogleStyle(), ColumnLimit);
66   }
67 
68   void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code,
69                     const FormatStyle &Style = getLLVMStyle()) {
70     EXPECT_EQ(Expected.str(), format(Expected, Style))
71         << "Expected code is not stable";
72     EXPECT_EQ(Expected.str(), format(Code, Style));
73     if (Style.Language == FormatStyle::LK_Cpp) {
74       // Objective-C++ is a superset of C++, so everything checked for C++
75       // needs to be checked for Objective-C++ as well.
76       FormatStyle ObjCStyle = Style;
77       ObjCStyle.Language = FormatStyle::LK_ObjC;
78       EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
79     }
80   }
81 
82   void verifyFormat(llvm::StringRef Code,
83                     const FormatStyle &Style = getLLVMStyle()) {
84     verifyFormat(Code, test::messUp(Code), Style);
85   }
86 
87   void verifyIncompleteFormat(llvm::StringRef Code,
88                               const FormatStyle &Style = getLLVMStyle()) {
89     EXPECT_EQ(Code.str(),
90               format(test::messUp(Code), Style, SC_ExpectIncomplete));
91   }
92 
93   void verifyGoogleFormat(llvm::StringRef Code) {
94     verifyFormat(Code, getGoogleStyle());
95   }
96 
97   void verifyIndependentOfContext(llvm::StringRef text) {
98     verifyFormat(text);
99     verifyFormat(llvm::Twine("void f() { " + text + " }").str());
100   }
101 
102   /// \brief Verify that clang-format does not crash on the given input.
103   void verifyNoCrash(llvm::StringRef Code,
104                      const FormatStyle &Style = getLLVMStyle()) {
105     format(Code, Style, SC_DoNotCheck);
106   }
107 
108   int ReplacementCount;
109 };
110 
111 TEST_F(FormatTest, MessUp) {
112   EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
113   EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
114   EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
115   EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
116   EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
117 }
118 
119 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) {
120   EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language);
121 }
122 
123 TEST_F(FormatTest, LLVMStyleOverride) {
124   EXPECT_EQ(FormatStyle::LK_Proto,
125             getLLVMStyle(FormatStyle::LK_Proto).Language);
126 }
127 
128 //===----------------------------------------------------------------------===//
129 // Basic function tests.
130 //===----------------------------------------------------------------------===//
131 
132 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
133   EXPECT_EQ(";", format(";"));
134 }
135 
136 TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
137   EXPECT_EQ("int i;", format("  int i;"));
138   EXPECT_EQ("\nint i;", format(" \n\t \v \f  int i;"));
139   EXPECT_EQ("int i;\nint j;", format("    int i; int j;"));
140   EXPECT_EQ("int i;\nint j;", format("    int i;\n  int j;"));
141 }
142 
143 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
144   EXPECT_EQ("int i;", format("int\ni;"));
145 }
146 
147 TEST_F(FormatTest, FormatsNestedBlockStatements) {
148   EXPECT_EQ("{\n  {\n    {}\n  }\n}", format("{{{}}}"));
149 }
150 
151 TEST_F(FormatTest, FormatsNestedCall) {
152   verifyFormat("Method(f1, f2(f3));");
153   verifyFormat("Method(f1(f2, f3()));");
154   verifyFormat("Method(f1(f2, (f3())));");
155 }
156 
157 TEST_F(FormatTest, NestedNameSpecifiers) {
158   verifyFormat("vector<::Type> v;");
159   verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
160   verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
161   verifyFormat("bool a = 2 < ::SomeFunction();");
162   verifyFormat("ALWAYS_INLINE ::std::string getName();");
163   verifyFormat("some::string getName();");
164 }
165 
166 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
167   EXPECT_EQ("if (a) {\n"
168             "  f();\n"
169             "}",
170             format("if(a){f();}"));
171   EXPECT_EQ(4, ReplacementCount);
172   EXPECT_EQ("if (a) {\n"
173             "  f();\n"
174             "}",
175             format("if (a) {\n"
176                    "  f();\n"
177                    "}"));
178   EXPECT_EQ(0, ReplacementCount);
179   EXPECT_EQ("/*\r\n"
180             "\r\n"
181             "*/\r\n",
182             format("/*\r\n"
183                    "\r\n"
184                    "*/\r\n"));
185   EXPECT_EQ(0, ReplacementCount);
186 }
187 
188 TEST_F(FormatTest, RemovesEmptyLines) {
189   EXPECT_EQ("class C {\n"
190             "  int i;\n"
191             "};",
192             format("class C {\n"
193                    " int i;\n"
194                    "\n"
195                    "};"));
196 
197   // Don't remove empty lines at the start of namespaces or extern "C" blocks.
198   EXPECT_EQ("namespace N {\n"
199             "\n"
200             "int i;\n"
201             "}",
202             format("namespace N {\n"
203                    "\n"
204                    "int    i;\n"
205                    "}",
206                    getGoogleStyle()));
207   EXPECT_EQ("/* something */ namespace N {\n"
208             "\n"
209             "int i;\n"
210             "}",
211             format("/* something */ namespace N {\n"
212                    "\n"
213                    "int    i;\n"
214                    "}",
215                    getGoogleStyle()));
216   EXPECT_EQ("inline namespace N {\n"
217             "\n"
218             "int i;\n"
219             "}",
220             format("inline namespace N {\n"
221                    "\n"
222                    "int    i;\n"
223                    "}",
224                    getGoogleStyle()));
225   EXPECT_EQ("/* something */ inline namespace N {\n"
226             "\n"
227             "int i;\n"
228             "}",
229             format("/* something */ inline namespace N {\n"
230                    "\n"
231                    "int    i;\n"
232                    "}",
233                    getGoogleStyle()));
234   EXPECT_EQ("export namespace N {\n"
235             "\n"
236             "int i;\n"
237             "}",
238             format("export namespace N {\n"
239                    "\n"
240                    "int    i;\n"
241                    "}",
242                    getGoogleStyle()));
243   EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
244             "\n"
245             "int i;\n"
246             "}",
247             format("extern /**/ \"C\" /**/ {\n"
248                    "\n"
249                    "int    i;\n"
250                    "}",
251                    getGoogleStyle()));
252 
253   // ...but do keep inlining and removing empty lines for non-block extern "C"
254   // functions.
255   verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
256   EXPECT_EQ("extern \"C\" int f() {\n"
257             "  int i = 42;\n"
258             "  return i;\n"
259             "}",
260             format("extern \"C\" int f() {\n"
261                    "\n"
262                    "  int i = 42;\n"
263                    "  return i;\n"
264                    "}",
265                    getGoogleStyle()));
266 
267   // Remove empty lines at the beginning and end of blocks.
268   EXPECT_EQ("void f() {\n"
269             "\n"
270             "  if (a) {\n"
271             "\n"
272             "    f();\n"
273             "  }\n"
274             "}",
275             format("void f() {\n"
276                    "\n"
277                    "  if (a) {\n"
278                    "\n"
279                    "    f();\n"
280                    "\n"
281                    "  }\n"
282                    "\n"
283                    "}",
284                    getLLVMStyle()));
285   EXPECT_EQ("void f() {\n"
286             "  if (a) {\n"
287             "    f();\n"
288             "  }\n"
289             "}",
290             format("void f() {\n"
291                    "\n"
292                    "  if (a) {\n"
293                    "\n"
294                    "    f();\n"
295                    "\n"
296                    "  }\n"
297                    "\n"
298                    "}",
299                    getGoogleStyle()));
300 
301   // Don't remove empty lines in more complex control statements.
302   EXPECT_EQ("void f() {\n"
303             "  if (a) {\n"
304             "    f();\n"
305             "\n"
306             "  } else if (b) {\n"
307             "    f();\n"
308             "  }\n"
309             "}",
310             format("void f() {\n"
311                    "  if (a) {\n"
312                    "    f();\n"
313                    "\n"
314                    "  } else if (b) {\n"
315                    "    f();\n"
316                    "\n"
317                    "  }\n"
318                    "\n"
319                    "}"));
320 
321   // Don't remove empty lines before namespace endings.
322   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
323   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
324   EXPECT_EQ("namespace {\n"
325             "int i;\n"
326             "\n"
327             "}",
328             format("namespace {\n"
329                    "int i;\n"
330                    "\n"
331                    "}",
332                    LLVMWithNoNamespaceFix));
333   EXPECT_EQ("namespace {\n"
334             "int i;\n"
335             "}",
336             format("namespace {\n"
337                    "int i;\n"
338                    "}",
339                    LLVMWithNoNamespaceFix));
340   EXPECT_EQ("namespace {\n"
341             "int i;\n"
342             "\n"
343             "};",
344             format("namespace {\n"
345                    "int i;\n"
346                    "\n"
347                    "};",
348                    LLVMWithNoNamespaceFix));
349   EXPECT_EQ("namespace {\n"
350             "int i;\n"
351             "};",
352             format("namespace {\n"
353                    "int i;\n"
354                    "};",
355                    LLVMWithNoNamespaceFix));
356   EXPECT_EQ("namespace {\n"
357             "int i;\n"
358             "\n"
359             "}",
360             format("namespace {\n"
361                    "int i;\n"
362                    "\n"
363                    "}"));
364   EXPECT_EQ("namespace {\n"
365             "int i;\n"
366             "\n"
367             "} // namespace",
368             format("namespace {\n"
369                    "int i;\n"
370                    "\n"
371                    "}  // namespace"));
372 
373   FormatStyle Style = getLLVMStyle();
374   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
375   Style.MaxEmptyLinesToKeep = 2;
376   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
377   Style.BraceWrapping.AfterClass = true;
378   Style.BraceWrapping.AfterFunction = true;
379   Style.KeepEmptyLinesAtTheStartOfBlocks = false;
380 
381   EXPECT_EQ("class Foo\n"
382             "{\n"
383             "  Foo() {}\n"
384             "\n"
385             "  void funk() {}\n"
386             "};",
387             format("class Foo\n"
388                    "{\n"
389                    "  Foo()\n"
390                    "  {\n"
391                    "  }\n"
392                    "\n"
393                    "  void funk() {}\n"
394                    "};",
395                    Style));
396 }
397 
398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
399   verifyFormat("x = (a) and (b);");
400   verifyFormat("x = (a) or (b);");
401   verifyFormat("x = (a) bitand (b);");
402   verifyFormat("x = (a) bitor (b);");
403   verifyFormat("x = (a) not_eq (b);");
404   verifyFormat("x = (a) and_eq (b);");
405   verifyFormat("x = (a) or_eq (b);");
406   verifyFormat("x = (a) xor (b);");
407 }
408 
409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) {
410   verifyFormat("x = compl(a);");
411   verifyFormat("x = not(a);");
412   verifyFormat("x = bitand(a);");
413   // Unary operator must not be merged with the next identifier
414   verifyFormat("x = compl a;");
415   verifyFormat("x = not a;");
416   verifyFormat("x = bitand a;");
417 }
418 
419 //===----------------------------------------------------------------------===//
420 // Tests for control statements.
421 //===----------------------------------------------------------------------===//
422 
423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
424   verifyFormat("if (true)\n  f();\ng();");
425   verifyFormat("if (a)\n  if (b)\n    if (c)\n      g();\nh();");
426   verifyFormat("if (a)\n  if (b) {\n    f();\n  }\ng();");
427   verifyFormat("if constexpr (true)\n"
428                "  f();\ng();");
429   verifyFormat("if CONSTEXPR (true)\n"
430                "  f();\ng();");
431   verifyFormat("if constexpr (a)\n"
432                "  if constexpr (b)\n"
433                "    if constexpr (c)\n"
434                "      g();\n"
435                "h();");
436   verifyFormat("if CONSTEXPR (a)\n"
437                "  if CONSTEXPR (b)\n"
438                "    if CONSTEXPR (c)\n"
439                "      g();\n"
440                "h();");
441   verifyFormat("if constexpr (a)\n"
442                "  if constexpr (b) {\n"
443                "    f();\n"
444                "  }\n"
445                "g();");
446   verifyFormat("if CONSTEXPR (a)\n"
447                "  if CONSTEXPR (b) {\n"
448                "    f();\n"
449                "  }\n"
450                "g();");
451 
452   FormatStyle AllowsMergedIf = getLLVMStyle();
453   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
454   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
455       FormatStyle::SIS_WithoutElse;
456   verifyFormat("if (a)\n"
457                "  // comment\n"
458                "  f();",
459                AllowsMergedIf);
460   verifyFormat("{\n"
461                "  if (a)\n"
462                "  label:\n"
463                "    f();\n"
464                "}",
465                AllowsMergedIf);
466   verifyFormat("#define A \\\n"
467                "  if (a)  \\\n"
468                "  label:  \\\n"
469                "    f()",
470                AllowsMergedIf);
471   verifyFormat("if (a)\n"
472                "  ;",
473                AllowsMergedIf);
474   verifyFormat("if (a)\n"
475                "  if (b) return;",
476                AllowsMergedIf);
477 
478   verifyFormat("if (a) // Can't merge this\n"
479                "  f();\n",
480                AllowsMergedIf);
481   verifyFormat("if (a) /* still don't merge */\n"
482                "  f();",
483                AllowsMergedIf);
484   verifyFormat("if (a) { // Never merge this\n"
485                "  f();\n"
486                "}",
487                AllowsMergedIf);
488   verifyFormat("if (a) { /* Never merge this */\n"
489                "  f();\n"
490                "}",
491                AllowsMergedIf);
492 
493   AllowsMergedIf.ColumnLimit = 14;
494   verifyFormat("if (a) return;", AllowsMergedIf);
495   verifyFormat("if (aaaaaaaaa)\n"
496                "  return;",
497                AllowsMergedIf);
498 
499   AllowsMergedIf.ColumnLimit = 13;
500   verifyFormat("if (a)\n  return;", AllowsMergedIf);
501 }
502 
503 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) {
504   FormatStyle AllowsMergedIf = getLLVMStyle();
505   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
506   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
507       FormatStyle::SIS_WithoutElse;
508   verifyFormat("if (a)\n"
509                "  f();\n"
510                "else {\n"
511                "  g();\n"
512                "}",
513                AllowsMergedIf);
514   verifyFormat("if (a)\n"
515                "  f();\n"
516                "else\n"
517                "  g();\n",
518                AllowsMergedIf);
519 
520   AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
521 
522   verifyFormat("if (a) f();\n"
523                "else {\n"
524                "  g();\n"
525                "}",
526                AllowsMergedIf);
527   verifyFormat("if (a) f();\n"
528                "else {\n"
529                "  if (a) f();\n"
530                "  else {\n"
531                "    g();\n"
532                "  }\n"
533                "  g();\n"
534                "}",
535                AllowsMergedIf);
536 }
537 
538 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
539   FormatStyle AllowsMergedLoops = getLLVMStyle();
540   AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
541   verifyFormat("while (true) continue;", AllowsMergedLoops);
542   verifyFormat("for (;;) continue;", AllowsMergedLoops);
543   verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
544   verifyFormat("while (true)\n"
545                "  ;",
546                AllowsMergedLoops);
547   verifyFormat("for (;;)\n"
548                "  ;",
549                AllowsMergedLoops);
550   verifyFormat("for (;;)\n"
551                "  for (;;) continue;",
552                AllowsMergedLoops);
553   verifyFormat("for (;;) // Can't merge this\n"
554                "  continue;",
555                AllowsMergedLoops);
556   verifyFormat("for (;;) /* still don't merge */\n"
557                "  continue;",
558                AllowsMergedLoops);
559   verifyFormat("do a++;\n"
560                "while (true);",
561                AllowsMergedLoops);
562   verifyFormat("do /* Don't merge */\n"
563                "  a++;\n"
564                "while (true);",
565                AllowsMergedLoops);
566   verifyFormat("do // Don't merge\n"
567                "  a++;\n"
568                "while (true);",
569                AllowsMergedLoops);
570   verifyFormat("do\n"
571                "  // Don't merge\n"
572                "  a++;\n"
573                "while (true);",
574                AllowsMergedLoops);
575   // Without braces labels are interpreted differently.
576   verifyFormat("{\n"
577                "  do\n"
578                "  label:\n"
579                "    a++;\n"
580                "  while (true);\n"
581                "}",
582                AllowsMergedLoops);
583 }
584 
585 TEST_F(FormatTest, FormatShortBracedStatements) {
586   FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
587   AllowSimpleBracedStatements.ColumnLimit = 40;
588   AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine =
589       FormatStyle::SBS_Always;
590 
591   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
592       FormatStyle::SIS_WithoutElse;
593   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
594 
595   AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom;
596   AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true;
597   AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false;
598 
599   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
600   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
601   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
602   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
603   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
604   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
605   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
606   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
607   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
608   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
609   verifyFormat("if (true) { fffffffffffffffffffffff(); }",
610                AllowSimpleBracedStatements);
611   verifyFormat("if (true) {\n"
612                "  ffffffffffffffffffffffff();\n"
613                "}",
614                AllowSimpleBracedStatements);
615   verifyFormat("if (true) {\n"
616                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
617                "}",
618                AllowSimpleBracedStatements);
619   verifyFormat("if (true) { //\n"
620                "  f();\n"
621                "}",
622                AllowSimpleBracedStatements);
623   verifyFormat("if (true) {\n"
624                "  f();\n"
625                "  f();\n"
626                "}",
627                AllowSimpleBracedStatements);
628   verifyFormat("if (true) {\n"
629                "  f();\n"
630                "} else {\n"
631                "  f();\n"
632                "}",
633                AllowSimpleBracedStatements);
634 
635   verifyFormat("struct A2 {\n"
636                "  int X;\n"
637                "};",
638                AllowSimpleBracedStatements);
639   verifyFormat("typedef struct A2 {\n"
640                "  int X;\n"
641                "} A2_t;",
642                AllowSimpleBracedStatements);
643   verifyFormat("template <int> struct A2 {\n"
644                "  struct B {};\n"
645                "};",
646                AllowSimpleBracedStatements);
647 
648   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
649       FormatStyle::SIS_Never;
650   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
651   verifyFormat("if (true) {\n"
652                "  f();\n"
653                "}",
654                AllowSimpleBracedStatements);
655   verifyFormat("if (true) {\n"
656                "  f();\n"
657                "} else {\n"
658                "  f();\n"
659                "}",
660                AllowSimpleBracedStatements);
661 
662   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
663   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
664   verifyFormat("while (true) {\n"
665                "  f();\n"
666                "}",
667                AllowSimpleBracedStatements);
668   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
669   verifyFormat("for (;;) {\n"
670                "  f();\n"
671                "}",
672                AllowSimpleBracedStatements);
673 
674   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
675       FormatStyle::SIS_WithoutElse;
676   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
677   AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement =
678       FormatStyle::BWACS_Always;
679 
680   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
681   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
682   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
683   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
684   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
685   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
686   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
687   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
688   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
689   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
690   verifyFormat("if (true) { fffffffffffffffffffffff(); }",
691                AllowSimpleBracedStatements);
692   verifyFormat("if (true)\n"
693                "{\n"
694                "  ffffffffffffffffffffffff();\n"
695                "}",
696                AllowSimpleBracedStatements);
697   verifyFormat("if (true)\n"
698                "{\n"
699                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
700                "}",
701                AllowSimpleBracedStatements);
702   verifyFormat("if (true)\n"
703                "{ //\n"
704                "  f();\n"
705                "}",
706                AllowSimpleBracedStatements);
707   verifyFormat("if (true)\n"
708                "{\n"
709                "  f();\n"
710                "  f();\n"
711                "}",
712                AllowSimpleBracedStatements);
713   verifyFormat("if (true)\n"
714                "{\n"
715                "  f();\n"
716                "} else\n"
717                "{\n"
718                "  f();\n"
719                "}",
720                AllowSimpleBracedStatements);
721 
722   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
723       FormatStyle::SIS_Never;
724   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
725   verifyFormat("if (true)\n"
726                "{\n"
727                "  f();\n"
728                "}",
729                AllowSimpleBracedStatements);
730   verifyFormat("if (true)\n"
731                "{\n"
732                "  f();\n"
733                "} else\n"
734                "{\n"
735                "  f();\n"
736                "}",
737                AllowSimpleBracedStatements);
738 
739   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
740   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
741   verifyFormat("while (true)\n"
742                "{\n"
743                "  f();\n"
744                "}",
745                AllowSimpleBracedStatements);
746   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
747   verifyFormat("for (;;)\n"
748                "{\n"
749                "  f();\n"
750                "}",
751                AllowSimpleBracedStatements);
752 }
753 
754 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) {
755   FormatStyle Style = getLLVMStyleWithColumns(60);
756   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
757   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
758   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
759   EXPECT_EQ("#define A                                                  \\\n"
760             "  if (HANDLEwernufrnuLwrmviferuvnierv)                     \\\n"
761             "  {                                                        \\\n"
762             "    RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier;               \\\n"
763             "  }\n"
764             "X;",
765             format("#define A \\\n"
766                    "   if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"
767                    "      RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
768                    "   }\n"
769                    "X;",
770                    Style));
771 }
772 
773 TEST_F(FormatTest, ParseIfElse) {
774   verifyFormat("if (true)\n"
775                "  if (true)\n"
776                "    if (true)\n"
777                "      f();\n"
778                "    else\n"
779                "      g();\n"
780                "  else\n"
781                "    h();\n"
782                "else\n"
783                "  i();");
784   verifyFormat("if (true)\n"
785                "  if (true)\n"
786                "    if (true) {\n"
787                "      if (true)\n"
788                "        f();\n"
789                "    } else {\n"
790                "      g();\n"
791                "    }\n"
792                "  else\n"
793                "    h();\n"
794                "else {\n"
795                "  i();\n"
796                "}");
797   verifyFormat("if (true)\n"
798                "  if constexpr (true)\n"
799                "    if (true) {\n"
800                "      if constexpr (true)\n"
801                "        f();\n"
802                "    } else {\n"
803                "      g();\n"
804                "    }\n"
805                "  else\n"
806                "    h();\n"
807                "else {\n"
808                "  i();\n"
809                "}");
810   verifyFormat("if (true)\n"
811                "  if CONSTEXPR (true)\n"
812                "    if (true) {\n"
813                "      if CONSTEXPR (true)\n"
814                "        f();\n"
815                "    } else {\n"
816                "      g();\n"
817                "    }\n"
818                "  else\n"
819                "    h();\n"
820                "else {\n"
821                "  i();\n"
822                "}");
823   verifyFormat("void f() {\n"
824                "  if (a) {\n"
825                "  } else {\n"
826                "  }\n"
827                "}");
828 }
829 
830 TEST_F(FormatTest, ElseIf) {
831   verifyFormat("if (a) {\n} else if (b) {\n}");
832   verifyFormat("if (a)\n"
833                "  f();\n"
834                "else if (b)\n"
835                "  g();\n"
836                "else\n"
837                "  h();");
838   verifyFormat("if constexpr (a)\n"
839                "  f();\n"
840                "else if constexpr (b)\n"
841                "  g();\n"
842                "else\n"
843                "  h();");
844   verifyFormat("if CONSTEXPR (a)\n"
845                "  f();\n"
846                "else if CONSTEXPR (b)\n"
847                "  g();\n"
848                "else\n"
849                "  h();");
850   verifyFormat("if (a) {\n"
851                "  f();\n"
852                "}\n"
853                "// or else ..\n"
854                "else {\n"
855                "  g()\n"
856                "}");
857 
858   verifyFormat("if (a) {\n"
859                "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
860                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
861                "}");
862   verifyFormat("if (a) {\n"
863                "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
864                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
865                "}");
866   verifyFormat("if (a) {\n"
867                "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
868                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
869                "}");
870   verifyFormat("if (a) {\n"
871                "} else if (\n"
872                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
873                "}",
874                getLLVMStyleWithColumns(62));
875   verifyFormat("if (a) {\n"
876                "} else if constexpr (\n"
877                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
878                "}",
879                getLLVMStyleWithColumns(62));
880   verifyFormat("if (a) {\n"
881                "} else if CONSTEXPR (\n"
882                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
883                "}",
884                getLLVMStyleWithColumns(62));
885 }
886 
887 TEST_F(FormatTest, FormatsForLoop) {
888   verifyFormat(
889       "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
890       "     ++VeryVeryLongLoopVariable)\n"
891       "  ;");
892   verifyFormat("for (;;)\n"
893                "  f();");
894   verifyFormat("for (;;) {\n}");
895   verifyFormat("for (;;) {\n"
896                "  f();\n"
897                "}");
898   verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
899 
900   verifyFormat(
901       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
902       "                                          E = UnwrappedLines.end();\n"
903       "     I != E; ++I) {\n}");
904 
905   verifyFormat(
906       "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
907       "     ++IIIII) {\n}");
908   verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
909                "         aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
910                "     aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
911   verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
912                "         I = FD->getDeclsInPrototypeScope().begin(),\n"
913                "         E = FD->getDeclsInPrototypeScope().end();\n"
914                "     I != E; ++I) {\n}");
915   verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
916                "         I = Container.begin(),\n"
917                "         E = Container.end();\n"
918                "     I != E; ++I) {\n}",
919                getLLVMStyleWithColumns(76));
920 
921   verifyFormat(
922       "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
923       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
924       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
925       "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
926       "     ++aaaaaaaaaaa) {\n}");
927   verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
928                "                bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
929                "     ++i) {\n}");
930   verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
931                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
932                "}");
933   verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
934                "         aaaaaaaaaa);\n"
935                "     iter; ++iter) {\n"
936                "}");
937   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
938                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
939                "     aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
940                "     ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
941 
942   // These should not be formatted as Objective-C for-in loops.
943   verifyFormat("for (Foo *x = 0; x != in; x++) {\n}");
944   verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}");
945   verifyFormat("Foo *x;\nfor (x in y) {\n}");
946   verifyFormat(
947       "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}");
948 
949   FormatStyle NoBinPacking = getLLVMStyle();
950   NoBinPacking.BinPackParameters = false;
951   verifyFormat("for (int aaaaaaaaaaa = 1;\n"
952                "     aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
953                "                                           aaaaaaaaaaaaaaaa,\n"
954                "                                           aaaaaaaaaaaaaaaa,\n"
955                "                                           aaaaaaaaaaaaaaaa);\n"
956                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
957                "}",
958                NoBinPacking);
959   verifyFormat(
960       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
961       "                                          E = UnwrappedLines.end();\n"
962       "     I != E;\n"
963       "     ++I) {\n}",
964       NoBinPacking);
965 
966   FormatStyle AlignLeft = getLLVMStyle();
967   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
968   verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
969 }
970 
971 TEST_F(FormatTest, RangeBasedForLoops) {
972   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
973                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
974   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
975                "     aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
976   verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
977                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
978   verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
979                "     aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
980 }
981 
982 TEST_F(FormatTest, ForEachLoops) {
983   verifyFormat("void f() {\n"
984                "  foreach (Item *item, itemlist) {}\n"
985                "  Q_FOREACH (Item *item, itemlist) {}\n"
986                "  BOOST_FOREACH (Item *item, itemlist) {}\n"
987                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
988                "}");
989 
990   FormatStyle Style = getLLVMStyle();
991   Style.SpaceBeforeParens =
992       FormatStyle::SBPO_ControlStatementsExceptForEachMacros;
993   verifyFormat("void f() {\n"
994                "  foreach(Item *item, itemlist) {}\n"
995                "  Q_FOREACH(Item *item, itemlist) {}\n"
996                "  BOOST_FOREACH(Item *item, itemlist) {}\n"
997                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
998                "}",
999                Style);
1000 
1001   // As function-like macros.
1002   verifyFormat("#define foreach(x, y)\n"
1003                "#define Q_FOREACH(x, y)\n"
1004                "#define BOOST_FOREACH(x, y)\n"
1005                "#define UNKNOWN_FOREACH(x, y)\n");
1006 
1007   // Not as function-like macros.
1008   verifyFormat("#define foreach (x, y)\n"
1009                "#define Q_FOREACH (x, y)\n"
1010                "#define BOOST_FOREACH (x, y)\n"
1011                "#define UNKNOWN_FOREACH (x, y)\n");
1012 
1013   // handle microsoft non standard extension
1014   verifyFormat("for each (char c in x->MyStringProperty)");
1015 }
1016 
1017 TEST_F(FormatTest, FormatsWhileLoop) {
1018   verifyFormat("while (true) {\n}");
1019   verifyFormat("while (true)\n"
1020                "  f();");
1021   verifyFormat("while () {\n}");
1022   verifyFormat("while () {\n"
1023                "  f();\n"
1024                "}");
1025 }
1026 
1027 TEST_F(FormatTest, FormatsDoWhile) {
1028   verifyFormat("do {\n"
1029                "  do_something();\n"
1030                "} while (something());");
1031   verifyFormat("do\n"
1032                "  do_something();\n"
1033                "while (something());");
1034 }
1035 
1036 TEST_F(FormatTest, FormatsSwitchStatement) {
1037   verifyFormat("switch (x) {\n"
1038                "case 1:\n"
1039                "  f();\n"
1040                "  break;\n"
1041                "case kFoo:\n"
1042                "case ns::kBar:\n"
1043                "case kBaz:\n"
1044                "  break;\n"
1045                "default:\n"
1046                "  g();\n"
1047                "  break;\n"
1048                "}");
1049   verifyFormat("switch (x) {\n"
1050                "case 1: {\n"
1051                "  f();\n"
1052                "  break;\n"
1053                "}\n"
1054                "case 2: {\n"
1055                "  break;\n"
1056                "}\n"
1057                "}");
1058   verifyFormat("switch (x) {\n"
1059                "case 1: {\n"
1060                "  f();\n"
1061                "  {\n"
1062                "    g();\n"
1063                "    h();\n"
1064                "  }\n"
1065                "  break;\n"
1066                "}\n"
1067                "}");
1068   verifyFormat("switch (x) {\n"
1069                "case 1: {\n"
1070                "  f();\n"
1071                "  if (foo) {\n"
1072                "    g();\n"
1073                "    h();\n"
1074                "  }\n"
1075                "  break;\n"
1076                "}\n"
1077                "}");
1078   verifyFormat("switch (x) {\n"
1079                "case 1: {\n"
1080                "  f();\n"
1081                "  g();\n"
1082                "} break;\n"
1083                "}");
1084   verifyFormat("switch (test)\n"
1085                "  ;");
1086   verifyFormat("switch (x) {\n"
1087                "default: {\n"
1088                "  // Do nothing.\n"
1089                "}\n"
1090                "}");
1091   verifyFormat("switch (x) {\n"
1092                "// comment\n"
1093                "// if 1, do f()\n"
1094                "case 1:\n"
1095                "  f();\n"
1096                "}");
1097   verifyFormat("switch (x) {\n"
1098                "case 1:\n"
1099                "  // Do amazing stuff\n"
1100                "  {\n"
1101                "    f();\n"
1102                "    g();\n"
1103                "  }\n"
1104                "  break;\n"
1105                "}");
1106   verifyFormat("#define A          \\\n"
1107                "  switch (x) {     \\\n"
1108                "  case a:          \\\n"
1109                "    foo = b;       \\\n"
1110                "  }",
1111                getLLVMStyleWithColumns(20));
1112   verifyFormat("#define OPERATION_CASE(name)           \\\n"
1113                "  case OP_name:                        \\\n"
1114                "    return operations::Operation##name\n",
1115                getLLVMStyleWithColumns(40));
1116   verifyFormat("switch (x) {\n"
1117                "case 1:;\n"
1118                "default:;\n"
1119                "  int i;\n"
1120                "}");
1121 
1122   verifyGoogleFormat("switch (x) {\n"
1123                      "  case 1:\n"
1124                      "    f();\n"
1125                      "    break;\n"
1126                      "  case kFoo:\n"
1127                      "  case ns::kBar:\n"
1128                      "  case kBaz:\n"
1129                      "    break;\n"
1130                      "  default:\n"
1131                      "    g();\n"
1132                      "    break;\n"
1133                      "}");
1134   verifyGoogleFormat("switch (x) {\n"
1135                      "  case 1: {\n"
1136                      "    f();\n"
1137                      "    break;\n"
1138                      "  }\n"
1139                      "}");
1140   verifyGoogleFormat("switch (test)\n"
1141                      "  ;");
1142 
1143   verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
1144                      "  case OP_name:              \\\n"
1145                      "    return operations::Operation##name\n");
1146   verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
1147                      "  // Get the correction operation class.\n"
1148                      "  switch (OpCode) {\n"
1149                      "    CASE(Add);\n"
1150                      "    CASE(Subtract);\n"
1151                      "    default:\n"
1152                      "      return operations::Unknown;\n"
1153                      "  }\n"
1154                      "#undef OPERATION_CASE\n"
1155                      "}");
1156   verifyFormat("DEBUG({\n"
1157                "  switch (x) {\n"
1158                "  case A:\n"
1159                "    f();\n"
1160                "    break;\n"
1161                "    // fallthrough\n"
1162                "  case B:\n"
1163                "    g();\n"
1164                "    break;\n"
1165                "  }\n"
1166                "});");
1167   EXPECT_EQ("DEBUG({\n"
1168             "  switch (x) {\n"
1169             "  case A:\n"
1170             "    f();\n"
1171             "    break;\n"
1172             "  // On B:\n"
1173             "  case B:\n"
1174             "    g();\n"
1175             "    break;\n"
1176             "  }\n"
1177             "});",
1178             format("DEBUG({\n"
1179                    "  switch (x) {\n"
1180                    "  case A:\n"
1181                    "    f();\n"
1182                    "    break;\n"
1183                    "  // On B:\n"
1184                    "  case B:\n"
1185                    "    g();\n"
1186                    "    break;\n"
1187                    "  }\n"
1188                    "});",
1189                    getLLVMStyle()));
1190   EXPECT_EQ("switch (n) {\n"
1191             "case 0: {\n"
1192             "  return false;\n"
1193             "}\n"
1194             "default: {\n"
1195             "  return true;\n"
1196             "}\n"
1197             "}",
1198             format("switch (n)\n"
1199                    "{\n"
1200                    "case 0: {\n"
1201                    "  return false;\n"
1202                    "}\n"
1203                    "default: {\n"
1204                    "  return true;\n"
1205                    "}\n"
1206                    "}",
1207                    getLLVMStyle()));
1208   verifyFormat("switch (a) {\n"
1209                "case (b):\n"
1210                "  return;\n"
1211                "}");
1212 
1213   verifyFormat("switch (a) {\n"
1214                "case some_namespace::\n"
1215                "    some_constant:\n"
1216                "  return;\n"
1217                "}",
1218                getLLVMStyleWithColumns(34));
1219 
1220   FormatStyle Style = getLLVMStyle();
1221   Style.IndentCaseLabels = true;
1222   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
1223   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1224   Style.BraceWrapping.AfterCaseLabel = true;
1225   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1226   EXPECT_EQ("switch (n)\n"
1227             "{\n"
1228             "  case 0:\n"
1229             "  {\n"
1230             "    return false;\n"
1231             "  }\n"
1232             "  default:\n"
1233             "  {\n"
1234             "    return true;\n"
1235             "  }\n"
1236             "}",
1237             format("switch (n) {\n"
1238                    "  case 0: {\n"
1239                    "    return false;\n"
1240                    "  }\n"
1241                    "  default: {\n"
1242                    "    return true;\n"
1243                    "  }\n"
1244                    "}",
1245                    Style));
1246   Style.BraceWrapping.AfterCaseLabel = false;
1247   EXPECT_EQ("switch (n)\n"
1248             "{\n"
1249             "  case 0: {\n"
1250             "    return false;\n"
1251             "  }\n"
1252             "  default: {\n"
1253             "    return true;\n"
1254             "  }\n"
1255             "}",
1256             format("switch (n) {\n"
1257                    "  case 0:\n"
1258                    "  {\n"
1259                    "    return false;\n"
1260                    "  }\n"
1261                    "  default:\n"
1262                    "  {\n"
1263                    "    return true;\n"
1264                    "  }\n"
1265                    "}",
1266                    Style));
1267   Style.IndentCaseLabels = false;
1268   Style.IndentCaseBlocks = true;
1269   EXPECT_EQ("switch (n)\n"
1270             "{\n"
1271             "case 0:\n"
1272             "  {\n"
1273             "    return false;\n"
1274             "  }\n"
1275             "case 1:\n"
1276             "  break;\n"
1277             "default:\n"
1278             "  {\n"
1279             "    return true;\n"
1280             "  }\n"
1281             "}",
1282             format("switch (n) {\n"
1283                    "case 0: {\n"
1284                    "  return false;\n"
1285                    "}\n"
1286                    "case 1:\n"
1287                    "  break;\n"
1288                    "default: {\n"
1289                    "  return true;\n"
1290                    "}\n"
1291                    "}",
1292                    Style));
1293   Style.IndentCaseLabels = true;
1294   Style.IndentCaseBlocks = true;
1295   EXPECT_EQ("switch (n)\n"
1296             "{\n"
1297             "  case 0:\n"
1298             "    {\n"
1299             "      return false;\n"
1300             "    }\n"
1301             "  case 1:\n"
1302             "    break;\n"
1303             "  default:\n"
1304             "    {\n"
1305             "      return true;\n"
1306             "    }\n"
1307             "}",
1308             format("switch (n) {\n"
1309                    "case 0: {\n"
1310                    "  return false;\n"
1311                    "}\n"
1312                    "case 1:\n"
1313                    "  break;\n"
1314                    "default: {\n"
1315                    "  return true;\n"
1316                    "}\n"
1317                    "}",
1318                    Style));
1319 }
1320 
1321 TEST_F(FormatTest, CaseRanges) {
1322   verifyFormat("switch (x) {\n"
1323                "case 'A' ... 'Z':\n"
1324                "case 1 ... 5:\n"
1325                "case a ... b:\n"
1326                "  break;\n"
1327                "}");
1328 }
1329 
1330 TEST_F(FormatTest, ShortEnums) {
1331   FormatStyle Style = getLLVMStyle();
1332   Style.AllowShortEnumsOnASingleLine = true;
1333   verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style);
1334   Style.AllowShortEnumsOnASingleLine = false;
1335   verifyFormat("enum\n"
1336                "{\n"
1337                "  A,\n"
1338                "  B,\n"
1339                "  C\n"
1340                "} ShortEnum1, ShortEnum2;",
1341                Style);
1342 }
1343 
1344 TEST_F(FormatTest, ShortCaseLabels) {
1345   FormatStyle Style = getLLVMStyle();
1346   Style.AllowShortCaseLabelsOnASingleLine = true;
1347   verifyFormat("switch (a) {\n"
1348                "case 1: x = 1; break;\n"
1349                "case 2: return;\n"
1350                "case 3:\n"
1351                "case 4:\n"
1352                "case 5: return;\n"
1353                "case 6: // comment\n"
1354                "  return;\n"
1355                "case 7:\n"
1356                "  // comment\n"
1357                "  return;\n"
1358                "case 8:\n"
1359                "  x = 8; // comment\n"
1360                "  break;\n"
1361                "default: y = 1; break;\n"
1362                "}",
1363                Style);
1364   verifyFormat("switch (a) {\n"
1365                "case 0: return; // comment\n"
1366                "case 1: break;  // comment\n"
1367                "case 2: return;\n"
1368                "// comment\n"
1369                "case 3: return;\n"
1370                "// comment 1\n"
1371                "// comment 2\n"
1372                "// comment 3\n"
1373                "case 4: break; /* comment */\n"
1374                "case 5:\n"
1375                "  // comment\n"
1376                "  break;\n"
1377                "case 6: /* comment */ x = 1; break;\n"
1378                "case 7: x = /* comment */ 1; break;\n"
1379                "case 8:\n"
1380                "  x = 1; /* comment */\n"
1381                "  break;\n"
1382                "case 9:\n"
1383                "  break; // comment line 1\n"
1384                "         // comment line 2\n"
1385                "}",
1386                Style);
1387   EXPECT_EQ("switch (a) {\n"
1388             "case 1:\n"
1389             "  x = 8;\n"
1390             "  // fall through\n"
1391             "case 2: x = 8;\n"
1392             "// comment\n"
1393             "case 3:\n"
1394             "  return; /* comment line 1\n"
1395             "           * comment line 2 */\n"
1396             "case 4: i = 8;\n"
1397             "// something else\n"
1398             "#if FOO\n"
1399             "case 5: break;\n"
1400             "#endif\n"
1401             "}",
1402             format("switch (a) {\n"
1403                    "case 1: x = 8;\n"
1404                    "  // fall through\n"
1405                    "case 2:\n"
1406                    "  x = 8;\n"
1407                    "// comment\n"
1408                    "case 3:\n"
1409                    "  return; /* comment line 1\n"
1410                    "           * comment line 2 */\n"
1411                    "case 4:\n"
1412                    "  i = 8;\n"
1413                    "// something else\n"
1414                    "#if FOO\n"
1415                    "case 5: break;\n"
1416                    "#endif\n"
1417                    "}",
1418                    Style));
1419   EXPECT_EQ("switch (a) {\n"
1420             "case 0:\n"
1421             "  return; // long long long long long long long long long long "
1422             "long long comment\n"
1423             "          // line\n"
1424             "}",
1425             format("switch (a) {\n"
1426                    "case 0: return; // long long long long long long long long "
1427                    "long long long long comment line\n"
1428                    "}",
1429                    Style));
1430   EXPECT_EQ("switch (a) {\n"
1431             "case 0:\n"
1432             "  return; /* long long long long long long long long long long "
1433             "long long comment\n"
1434             "             line */\n"
1435             "}",
1436             format("switch (a) {\n"
1437                    "case 0: return; /* long long long long long long long long "
1438                    "long long long long comment line */\n"
1439                    "}",
1440                    Style));
1441   verifyFormat("switch (a) {\n"
1442                "#if FOO\n"
1443                "case 0: return 0;\n"
1444                "#endif\n"
1445                "}",
1446                Style);
1447   verifyFormat("switch (a) {\n"
1448                "case 1: {\n"
1449                "}\n"
1450                "case 2: {\n"
1451                "  return;\n"
1452                "}\n"
1453                "case 3: {\n"
1454                "  x = 1;\n"
1455                "  return;\n"
1456                "}\n"
1457                "case 4:\n"
1458                "  if (x)\n"
1459                "    return;\n"
1460                "}",
1461                Style);
1462   Style.ColumnLimit = 21;
1463   verifyFormat("switch (a) {\n"
1464                "case 1: x = 1; break;\n"
1465                "case 2: return;\n"
1466                "case 3:\n"
1467                "case 4:\n"
1468                "case 5: return;\n"
1469                "default:\n"
1470                "  y = 1;\n"
1471                "  break;\n"
1472                "}",
1473                Style);
1474   Style.ColumnLimit = 80;
1475   Style.AllowShortCaseLabelsOnASingleLine = false;
1476   Style.IndentCaseLabels = true;
1477   EXPECT_EQ("switch (n) {\n"
1478             "  default /*comments*/:\n"
1479             "    return true;\n"
1480             "  case 0:\n"
1481             "    return false;\n"
1482             "}",
1483             format("switch (n) {\n"
1484                    "default/*comments*/:\n"
1485                    "  return true;\n"
1486                    "case 0:\n"
1487                    "  return false;\n"
1488                    "}",
1489                    Style));
1490   Style.AllowShortCaseLabelsOnASingleLine = true;
1491   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1492   Style.BraceWrapping.AfterCaseLabel = true;
1493   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1494   EXPECT_EQ("switch (n)\n"
1495             "{\n"
1496             "  case 0:\n"
1497             "  {\n"
1498             "    return false;\n"
1499             "  }\n"
1500             "  default:\n"
1501             "  {\n"
1502             "    return true;\n"
1503             "  }\n"
1504             "}",
1505             format("switch (n) {\n"
1506                    "  case 0: {\n"
1507                    "    return false;\n"
1508                    "  }\n"
1509                    "  default:\n"
1510                    "  {\n"
1511                    "    return true;\n"
1512                    "  }\n"
1513                    "}",
1514                    Style));
1515 }
1516 
1517 TEST_F(FormatTest, FormatsLabels) {
1518   verifyFormat("void f() {\n"
1519                "  some_code();\n"
1520                "test_label:\n"
1521                "  some_other_code();\n"
1522                "  {\n"
1523                "    some_more_code();\n"
1524                "  another_label:\n"
1525                "    some_more_code();\n"
1526                "  }\n"
1527                "}");
1528   verifyFormat("{\n"
1529                "  some_code();\n"
1530                "test_label:\n"
1531                "  some_other_code();\n"
1532                "}");
1533   verifyFormat("{\n"
1534                "  some_code();\n"
1535                "test_label:;\n"
1536                "  int i = 0;\n"
1537                "}");
1538   FormatStyle Style = getLLVMStyle();
1539   Style.IndentGotoLabels = false;
1540   verifyFormat("void f() {\n"
1541                "  some_code();\n"
1542                "test_label:\n"
1543                "  some_other_code();\n"
1544                "  {\n"
1545                "    some_more_code();\n"
1546                "another_label:\n"
1547                "    some_more_code();\n"
1548                "  }\n"
1549                "}",
1550                Style);
1551   verifyFormat("{\n"
1552                "  some_code();\n"
1553                "test_label:\n"
1554                "  some_other_code();\n"
1555                "}",
1556                Style);
1557   verifyFormat("{\n"
1558                "  some_code();\n"
1559                "test_label:;\n"
1560                "  int i = 0;\n"
1561                "}");
1562 }
1563 
1564 TEST_F(FormatTest, MultiLineControlStatements) {
1565   FormatStyle Style = getLLVMStyle();
1566   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1567   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine;
1568   Style.ColumnLimit = 20;
1569   // Short lines should keep opening brace on same line.
1570   EXPECT_EQ("if (foo) {\n"
1571             "  bar();\n"
1572             "}",
1573             format("if(foo){bar();}", Style));
1574   EXPECT_EQ("if (foo) {\n"
1575             "  bar();\n"
1576             "} else {\n"
1577             "  baz();\n"
1578             "}",
1579             format("if(foo){bar();}else{baz();}", Style));
1580   EXPECT_EQ("if (foo && bar) {\n"
1581             "  baz();\n"
1582             "}",
1583             format("if(foo&&bar){baz();}", Style));
1584   EXPECT_EQ("if (foo) {\n"
1585             "  bar();\n"
1586             "} else if (baz) {\n"
1587             "  quux();\n"
1588             "}",
1589             format("if(foo){bar();}else if(baz){quux();}", Style));
1590   EXPECT_EQ(
1591       "if (foo) {\n"
1592       "  bar();\n"
1593       "} else if (baz) {\n"
1594       "  quux();\n"
1595       "} else {\n"
1596       "  foobar();\n"
1597       "}",
1598       format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style));
1599   EXPECT_EQ("for (;;) {\n"
1600             "  foo();\n"
1601             "}",
1602             format("for(;;){foo();}"));
1603   EXPECT_EQ("while (1) {\n"
1604             "  foo();\n"
1605             "}",
1606             format("while(1){foo();}", Style));
1607   EXPECT_EQ("switch (foo) {\n"
1608             "case bar:\n"
1609             "  return;\n"
1610             "}",
1611             format("switch(foo){case bar:return;}", Style));
1612   EXPECT_EQ("try {\n"
1613             "  foo();\n"
1614             "} catch (...) {\n"
1615             "  bar();\n"
1616             "}",
1617             format("try{foo();}catch(...){bar();}", Style));
1618   EXPECT_EQ("do {\n"
1619             "  foo();\n"
1620             "} while (bar &&\n"
1621             "         baz);",
1622             format("do{foo();}while(bar&&baz);", Style));
1623   // Long lines should put opening brace on new line.
1624   EXPECT_EQ("if (foo && bar &&\n"
1625             "    baz)\n"
1626             "{\n"
1627             "  quux();\n"
1628             "}",
1629             format("if(foo&&bar&&baz){quux();}", Style));
1630   EXPECT_EQ("if (foo && bar &&\n"
1631             "    baz)\n"
1632             "{\n"
1633             "  quux();\n"
1634             "}",
1635             format("if (foo && bar &&\n"
1636                    "    baz) {\n"
1637                    "  quux();\n"
1638                    "}",
1639                    Style));
1640   EXPECT_EQ("if (foo) {\n"
1641             "  bar();\n"
1642             "} else if (baz ||\n"
1643             "           quux)\n"
1644             "{\n"
1645             "  foobar();\n"
1646             "}",
1647             format("if(foo){bar();}else if(baz||quux){foobar();}", Style));
1648   EXPECT_EQ(
1649       "if (foo) {\n"
1650       "  bar();\n"
1651       "} else if (baz ||\n"
1652       "           quux)\n"
1653       "{\n"
1654       "  foobar();\n"
1655       "} else {\n"
1656       "  barbaz();\n"
1657       "}",
1658       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1659              Style));
1660   EXPECT_EQ("for (int i = 0;\n"
1661             "     i < 10; ++i)\n"
1662             "{\n"
1663             "  foo();\n"
1664             "}",
1665             format("for(int i=0;i<10;++i){foo();}", Style));
1666   EXPECT_EQ("while (foo || bar ||\n"
1667             "       baz)\n"
1668             "{\n"
1669             "  quux();\n"
1670             "}",
1671             format("while(foo||bar||baz){quux();}", Style));
1672   EXPECT_EQ("switch (\n"
1673             "    foo = barbaz)\n"
1674             "{\n"
1675             "case quux:\n"
1676             "  return;\n"
1677             "}",
1678             format("switch(foo=barbaz){case quux:return;}", Style));
1679   EXPECT_EQ("try {\n"
1680             "  foo();\n"
1681             "} catch (\n"
1682             "    Exception &bar)\n"
1683             "{\n"
1684             "  baz();\n"
1685             "}",
1686             format("try{foo();}catch(Exception&bar){baz();}", Style));
1687   Style.ColumnLimit =
1688       40; // to concentrate at brace wrapping, not line wrap due to column limit
1689   EXPECT_EQ("try {\n"
1690             "  foo();\n"
1691             "} catch (Exception &bar) {\n"
1692             "  baz();\n"
1693             "}",
1694             format("try{foo();}catch(Exception&bar){baz();}", Style));
1695   Style.ColumnLimit =
1696       20; // to concentrate at brace wrapping, not line wrap due to column limit
1697 
1698   Style.BraceWrapping.BeforeElse = true;
1699   EXPECT_EQ(
1700       "if (foo) {\n"
1701       "  bar();\n"
1702       "}\n"
1703       "else if (baz ||\n"
1704       "         quux)\n"
1705       "{\n"
1706       "  foobar();\n"
1707       "}\n"
1708       "else {\n"
1709       "  barbaz();\n"
1710       "}",
1711       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1712              Style));
1713 
1714   Style.BraceWrapping.BeforeCatch = true;
1715   EXPECT_EQ("try {\n"
1716             "  foo();\n"
1717             "}\n"
1718             "catch (...) {\n"
1719             "  baz();\n"
1720             "}",
1721             format("try{foo();}catch(...){baz();}", Style));
1722 }
1723 
1724 TEST_F(FormatTest, BeforeWhile) {
1725   FormatStyle Style = getLLVMStyle();
1726   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1727 
1728   verifyFormat("do {\n"
1729                "  foo();\n"
1730                "} while (1);",
1731                Style);
1732   Style.BraceWrapping.BeforeWhile = true;
1733   verifyFormat("do {\n"
1734                "  foo();\n"
1735                "}\n"
1736                "while (1);",
1737                Style);
1738 }
1739 
1740 //===----------------------------------------------------------------------===//
1741 // Tests for classes, namespaces, etc.
1742 //===----------------------------------------------------------------------===//
1743 
1744 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
1745   verifyFormat("class A {};");
1746 }
1747 
1748 TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1749   verifyFormat("class A {\n"
1750                "public:\n"
1751                "public: // comment\n"
1752                "protected:\n"
1753                "private:\n"
1754                "  void f() {}\n"
1755                "};");
1756   verifyFormat("export class A {\n"
1757                "public:\n"
1758                "public: // comment\n"
1759                "protected:\n"
1760                "private:\n"
1761                "  void f() {}\n"
1762                "};");
1763   verifyGoogleFormat("class A {\n"
1764                      " public:\n"
1765                      " protected:\n"
1766                      " private:\n"
1767                      "  void f() {}\n"
1768                      "};");
1769   verifyGoogleFormat("export class A {\n"
1770                      " public:\n"
1771                      " protected:\n"
1772                      " private:\n"
1773                      "  void f() {}\n"
1774                      "};");
1775   verifyFormat("class A {\n"
1776                "public slots:\n"
1777                "  void f1() {}\n"
1778                "public Q_SLOTS:\n"
1779                "  void f2() {}\n"
1780                "protected slots:\n"
1781                "  void f3() {}\n"
1782                "protected Q_SLOTS:\n"
1783                "  void f4() {}\n"
1784                "private slots:\n"
1785                "  void f5() {}\n"
1786                "private Q_SLOTS:\n"
1787                "  void f6() {}\n"
1788                "signals:\n"
1789                "  void g1();\n"
1790                "Q_SIGNALS:\n"
1791                "  void g2();\n"
1792                "};");
1793 
1794   // Don't interpret 'signals' the wrong way.
1795   verifyFormat("signals.set();");
1796   verifyFormat("for (Signals signals : f()) {\n}");
1797   verifyFormat("{\n"
1798                "  signals.set(); // This needs indentation.\n"
1799                "}");
1800   verifyFormat("void f() {\n"
1801                "label:\n"
1802                "  signals.baz();\n"
1803                "}");
1804 }
1805 
1806 TEST_F(FormatTest, SeparatesLogicalBlocks) {
1807   EXPECT_EQ("class A {\n"
1808             "public:\n"
1809             "  void f();\n"
1810             "\n"
1811             "private:\n"
1812             "  void g() {}\n"
1813             "  // test\n"
1814             "protected:\n"
1815             "  int h;\n"
1816             "};",
1817             format("class A {\n"
1818                    "public:\n"
1819                    "void f();\n"
1820                    "private:\n"
1821                    "void g() {}\n"
1822                    "// test\n"
1823                    "protected:\n"
1824                    "int h;\n"
1825                    "};"));
1826   EXPECT_EQ("class A {\n"
1827             "protected:\n"
1828             "public:\n"
1829             "  void f();\n"
1830             "};",
1831             format("class A {\n"
1832                    "protected:\n"
1833                    "\n"
1834                    "public:\n"
1835                    "\n"
1836                    "  void f();\n"
1837                    "};"));
1838 
1839   // Even ensure proper spacing inside macros.
1840   EXPECT_EQ("#define B     \\\n"
1841             "  class A {   \\\n"
1842             "   protected: \\\n"
1843             "   public:    \\\n"
1844             "    void f(); \\\n"
1845             "  };",
1846             format("#define B     \\\n"
1847                    "  class A {   \\\n"
1848                    "   protected: \\\n"
1849                    "              \\\n"
1850                    "   public:    \\\n"
1851                    "              \\\n"
1852                    "    void f(); \\\n"
1853                    "  };",
1854                    getGoogleStyle()));
1855   // But don't remove empty lines after macros ending in access specifiers.
1856   EXPECT_EQ("#define A private:\n"
1857             "\n"
1858             "int i;",
1859             format("#define A         private:\n"
1860                    "\n"
1861                    "int              i;"));
1862 }
1863 
1864 TEST_F(FormatTest, FormatsClasses) {
1865   verifyFormat("class A : public B {};");
1866   verifyFormat("class A : public ::B {};");
1867 
1868   verifyFormat(
1869       "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1870       "                             public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1871   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1872                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1873                "      public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1874   verifyFormat(
1875       "class A : public B, public C, public D, public E, public F {};");
1876   verifyFormat("class AAAAAAAAAAAA : public B,\n"
1877                "                     public C,\n"
1878                "                     public D,\n"
1879                "                     public E,\n"
1880                "                     public F,\n"
1881                "                     public G {};");
1882 
1883   verifyFormat("class\n"
1884                "    ReallyReallyLongClassName {\n"
1885                "  int i;\n"
1886                "};",
1887                getLLVMStyleWithColumns(32));
1888   verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1889                "                           aaaaaaaaaaaaaaaa> {};");
1890   verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1891                "    : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1892                "                                 aaaaaaaaaaaaaaaaaaaaaa> {};");
1893   verifyFormat("template <class R, class C>\n"
1894                "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1895                "    : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
1896   verifyFormat("class ::A::B {};");
1897 }
1898 
1899 TEST_F(FormatTest, BreakInheritanceStyle) {
1900   FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle();
1901   StyleWithInheritanceBreakBeforeComma.BreakInheritanceList =
1902       FormatStyle::BILS_BeforeComma;
1903   verifyFormat("class MyClass : public X {};",
1904                StyleWithInheritanceBreakBeforeComma);
1905   verifyFormat("class MyClass\n"
1906                "    : public X\n"
1907                "    , public Y {};",
1908                StyleWithInheritanceBreakBeforeComma);
1909   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
1910                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"
1911                "    , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1912                StyleWithInheritanceBreakBeforeComma);
1913   verifyFormat("struct aaaaaaaaaaaaa\n"
1914                "    : public aaaaaaaaaaaaaaaaaaa< // break\n"
1915                "          aaaaaaaaaaaaaaaa> {};",
1916                StyleWithInheritanceBreakBeforeComma);
1917 
1918   FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle();
1919   StyleWithInheritanceBreakAfterColon.BreakInheritanceList =
1920       FormatStyle::BILS_AfterColon;
1921   verifyFormat("class MyClass : public X {};",
1922                StyleWithInheritanceBreakAfterColon);
1923   verifyFormat("class MyClass : public X, public Y {};",
1924                StyleWithInheritanceBreakAfterColon);
1925   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
1926                "    public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1927                "    public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1928                StyleWithInheritanceBreakAfterColon);
1929   verifyFormat("struct aaaaaaaaaaaaa :\n"
1930                "    public aaaaaaaaaaaaaaaaaaa< // break\n"
1931                "        aaaaaaaaaaaaaaaa> {};",
1932                StyleWithInheritanceBreakAfterColon);
1933 }
1934 
1935 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
1936   verifyFormat("class A {\n} a, b;");
1937   verifyFormat("struct A {\n} a, b;");
1938   verifyFormat("union A {\n} a;");
1939 }
1940 
1941 TEST_F(FormatTest, FormatsEnum) {
1942   verifyFormat("enum {\n"
1943                "  Zero,\n"
1944                "  One = 1,\n"
1945                "  Two = One + 1,\n"
1946                "  Three = (One + Two),\n"
1947                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1948                "  Five = (One, Two, Three, Four, 5)\n"
1949                "};");
1950   verifyGoogleFormat("enum {\n"
1951                      "  Zero,\n"
1952                      "  One = 1,\n"
1953                      "  Two = One + 1,\n"
1954                      "  Three = (One + Two),\n"
1955                      "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1956                      "  Five = (One, Two, Three, Four, 5)\n"
1957                      "};");
1958   verifyFormat("enum Enum {};");
1959   verifyFormat("enum {};");
1960   verifyFormat("enum X E {} d;");
1961   verifyFormat("enum __attribute__((...)) E {} d;");
1962   verifyFormat("enum __declspec__((...)) E {} d;");
1963   verifyFormat("enum {\n"
1964                "  Bar = Foo<int, int>::value\n"
1965                "};",
1966                getLLVMStyleWithColumns(30));
1967 
1968   verifyFormat("enum ShortEnum { A, B, C };");
1969   verifyGoogleFormat("enum ShortEnum { A, B, C };");
1970 
1971   EXPECT_EQ("enum KeepEmptyLines {\n"
1972             "  ONE,\n"
1973             "\n"
1974             "  TWO,\n"
1975             "\n"
1976             "  THREE\n"
1977             "}",
1978             format("enum KeepEmptyLines {\n"
1979                    "  ONE,\n"
1980                    "\n"
1981                    "  TWO,\n"
1982                    "\n"
1983                    "\n"
1984                    "  THREE\n"
1985                    "}"));
1986   verifyFormat("enum E { // comment\n"
1987                "  ONE,\n"
1988                "  TWO\n"
1989                "};\n"
1990                "int i;");
1991 
1992   FormatStyle EightIndent = getLLVMStyle();
1993   EightIndent.IndentWidth = 8;
1994   verifyFormat("enum {\n"
1995                "        VOID,\n"
1996                "        CHAR,\n"
1997                "        SHORT,\n"
1998                "        INT,\n"
1999                "        LONG,\n"
2000                "        SIGNED,\n"
2001                "        UNSIGNED,\n"
2002                "        BOOL,\n"
2003                "        FLOAT,\n"
2004                "        DOUBLE,\n"
2005                "        COMPLEX\n"
2006                "};",
2007                EightIndent);
2008 
2009   // Not enums.
2010   verifyFormat("enum X f() {\n"
2011                "  a();\n"
2012                "  return 42;\n"
2013                "}");
2014   verifyFormat("enum X Type::f() {\n"
2015                "  a();\n"
2016                "  return 42;\n"
2017                "}");
2018   verifyFormat("enum ::X f() {\n"
2019                "  a();\n"
2020                "  return 42;\n"
2021                "}");
2022   verifyFormat("enum ns::X f() {\n"
2023                "  a();\n"
2024                "  return 42;\n"
2025                "}");
2026 }
2027 
2028 TEST_F(FormatTest, FormatsEnumsWithErrors) {
2029   verifyFormat("enum Type {\n"
2030                "  One = 0; // These semicolons should be commas.\n"
2031                "  Two = 1;\n"
2032                "};");
2033   verifyFormat("namespace n {\n"
2034                "enum Type {\n"
2035                "  One,\n"
2036                "  Two, // missing };\n"
2037                "  int i;\n"
2038                "}\n"
2039                "void g() {}");
2040 }
2041 
2042 TEST_F(FormatTest, FormatsEnumStruct) {
2043   verifyFormat("enum struct {\n"
2044                "  Zero,\n"
2045                "  One = 1,\n"
2046                "  Two = One + 1,\n"
2047                "  Three = (One + Two),\n"
2048                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2049                "  Five = (One, Two, Three, Four, 5)\n"
2050                "};");
2051   verifyFormat("enum struct Enum {};");
2052   verifyFormat("enum struct {};");
2053   verifyFormat("enum struct X E {} d;");
2054   verifyFormat("enum struct __attribute__((...)) E {} d;");
2055   verifyFormat("enum struct __declspec__((...)) E {} d;");
2056   verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
2057 }
2058 
2059 TEST_F(FormatTest, FormatsEnumClass) {
2060   verifyFormat("enum class {\n"
2061                "  Zero,\n"
2062                "  One = 1,\n"
2063                "  Two = One + 1,\n"
2064                "  Three = (One + Two),\n"
2065                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2066                "  Five = (One, Two, Three, Four, 5)\n"
2067                "};");
2068   verifyFormat("enum class Enum {};");
2069   verifyFormat("enum class {};");
2070   verifyFormat("enum class X E {} d;");
2071   verifyFormat("enum class __attribute__((...)) E {} d;");
2072   verifyFormat("enum class __declspec__((...)) E {} d;");
2073   verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
2074 }
2075 
2076 TEST_F(FormatTest, FormatsEnumTypes) {
2077   verifyFormat("enum X : int {\n"
2078                "  A, // Force multiple lines.\n"
2079                "  B\n"
2080                "};");
2081   verifyFormat("enum X : int { A, B };");
2082   verifyFormat("enum X : std::uint32_t { A, B };");
2083 }
2084 
2085 TEST_F(FormatTest, FormatsTypedefEnum) {
2086   FormatStyle Style = getLLVMStyle();
2087   Style.ColumnLimit = 40;
2088   verifyFormat("typedef enum {} EmptyEnum;");
2089   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2090   verifyFormat("typedef enum {\n"
2091                "  ZERO = 0,\n"
2092                "  ONE = 1,\n"
2093                "  TWO = 2,\n"
2094                "  THREE = 3\n"
2095                "} LongEnum;",
2096                Style);
2097   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2098   Style.BraceWrapping.AfterEnum = true;
2099   verifyFormat("typedef enum {} EmptyEnum;");
2100   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2101   verifyFormat("typedef enum\n"
2102                "{\n"
2103                "  ZERO = 0,\n"
2104                "  ONE = 1,\n"
2105                "  TWO = 2,\n"
2106                "  THREE = 3\n"
2107                "} LongEnum;",
2108                Style);
2109 }
2110 
2111 TEST_F(FormatTest, FormatsNSEnums) {
2112   verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
2113   verifyGoogleFormat(
2114       "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }");
2115   verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
2116                      "  // Information about someDecentlyLongValue.\n"
2117                      "  someDecentlyLongValue,\n"
2118                      "  // Information about anotherDecentlyLongValue.\n"
2119                      "  anotherDecentlyLongValue,\n"
2120                      "  // Information about aThirdDecentlyLongValue.\n"
2121                      "  aThirdDecentlyLongValue\n"
2122                      "};");
2123   verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n"
2124                      "  // Information about someDecentlyLongValue.\n"
2125                      "  someDecentlyLongValue,\n"
2126                      "  // Information about anotherDecentlyLongValue.\n"
2127                      "  anotherDecentlyLongValue,\n"
2128                      "  // Information about aThirdDecentlyLongValue.\n"
2129                      "  aThirdDecentlyLongValue\n"
2130                      "};");
2131   verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
2132                      "  a = 1,\n"
2133                      "  b = 2,\n"
2134                      "  c = 3,\n"
2135                      "};");
2136   verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
2137                      "  a = 1,\n"
2138                      "  b = 2,\n"
2139                      "  c = 3,\n"
2140                      "};");
2141   verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n"
2142                      "  a = 1,\n"
2143                      "  b = 2,\n"
2144                      "  c = 3,\n"
2145                      "};");
2146   verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
2147                      "  a = 1,\n"
2148                      "  b = 2,\n"
2149                      "  c = 3,\n"
2150                      "};");
2151 }
2152 
2153 TEST_F(FormatTest, FormatsBitfields) {
2154   verifyFormat("struct Bitfields {\n"
2155                "  unsigned sClass : 8;\n"
2156                "  unsigned ValueKind : 2;\n"
2157                "};");
2158   verifyFormat("struct A {\n"
2159                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
2160                "      bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
2161                "};");
2162   verifyFormat("struct MyStruct {\n"
2163                "  uchar data;\n"
2164                "  uchar : 8;\n"
2165                "  uchar : 8;\n"
2166                "  uchar other;\n"
2167                "};");
2168 }
2169 
2170 TEST_F(FormatTest, FormatsNamespaces) {
2171   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
2172   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
2173 
2174   verifyFormat("namespace some_namespace {\n"
2175                "class A {};\n"
2176                "void f() { f(); }\n"
2177                "}",
2178                LLVMWithNoNamespaceFix);
2179   verifyFormat("namespace N::inline D {\n"
2180                "class A {};\n"
2181                "void f() { f(); }\n"
2182                "}",
2183                LLVMWithNoNamespaceFix);
2184   verifyFormat("namespace N::inline D::E {\n"
2185                "class A {};\n"
2186                "void f() { f(); }\n"
2187                "}",
2188                LLVMWithNoNamespaceFix);
2189   verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
2190                "class A {};\n"
2191                "void f() { f(); }\n"
2192                "}",
2193                LLVMWithNoNamespaceFix);
2194   verifyFormat("/* something */ namespace some_namespace {\n"
2195                "class A {};\n"
2196                "void f() { f(); }\n"
2197                "}",
2198                LLVMWithNoNamespaceFix);
2199   verifyFormat("namespace {\n"
2200                "class A {};\n"
2201                "void f() { f(); }\n"
2202                "}",
2203                LLVMWithNoNamespaceFix);
2204   verifyFormat("/* something */ namespace {\n"
2205                "class A {};\n"
2206                "void f() { f(); }\n"
2207                "}",
2208                LLVMWithNoNamespaceFix);
2209   verifyFormat("inline namespace X {\n"
2210                "class A {};\n"
2211                "void f() { f(); }\n"
2212                "}",
2213                LLVMWithNoNamespaceFix);
2214   verifyFormat("/* something */ inline namespace X {\n"
2215                "class A {};\n"
2216                "void f() { f(); }\n"
2217                "}",
2218                LLVMWithNoNamespaceFix);
2219   verifyFormat("export namespace X {\n"
2220                "class A {};\n"
2221                "void f() { f(); }\n"
2222                "}",
2223                LLVMWithNoNamespaceFix);
2224   verifyFormat("using namespace some_namespace;\n"
2225                "class A {};\n"
2226                "void f() { f(); }",
2227                LLVMWithNoNamespaceFix);
2228 
2229   // This code is more common than we thought; if we
2230   // layout this correctly the semicolon will go into
2231   // its own line, which is undesirable.
2232   verifyFormat("namespace {};", LLVMWithNoNamespaceFix);
2233   verifyFormat("namespace {\n"
2234                "class A {};\n"
2235                "};",
2236                LLVMWithNoNamespaceFix);
2237 
2238   verifyFormat("namespace {\n"
2239                "int SomeVariable = 0; // comment\n"
2240                "} // namespace",
2241                LLVMWithNoNamespaceFix);
2242   EXPECT_EQ("#ifndef HEADER_GUARD\n"
2243             "#define HEADER_GUARD\n"
2244             "namespace my_namespace {\n"
2245             "int i;\n"
2246             "} // my_namespace\n"
2247             "#endif // HEADER_GUARD",
2248             format("#ifndef HEADER_GUARD\n"
2249                    " #define HEADER_GUARD\n"
2250                    "   namespace my_namespace {\n"
2251                    "int i;\n"
2252                    "}    // my_namespace\n"
2253                    "#endif    // HEADER_GUARD",
2254                    LLVMWithNoNamespaceFix));
2255 
2256   EXPECT_EQ("namespace A::B {\n"
2257             "class C {};\n"
2258             "}",
2259             format("namespace A::B {\n"
2260                    "class C {};\n"
2261                    "}",
2262                    LLVMWithNoNamespaceFix));
2263 
2264   FormatStyle Style = getLLVMStyle();
2265   Style.NamespaceIndentation = FormatStyle::NI_All;
2266   EXPECT_EQ("namespace out {\n"
2267             "  int i;\n"
2268             "  namespace in {\n"
2269             "    int i;\n"
2270             "  } // namespace in\n"
2271             "} // namespace out",
2272             format("namespace out {\n"
2273                    "int i;\n"
2274                    "namespace in {\n"
2275                    "int i;\n"
2276                    "} // namespace in\n"
2277                    "} // namespace out",
2278                    Style));
2279 
2280   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2281   EXPECT_EQ("namespace out {\n"
2282             "int i;\n"
2283             "namespace in {\n"
2284             "  int i;\n"
2285             "} // namespace in\n"
2286             "} // namespace out",
2287             format("namespace out {\n"
2288                    "int i;\n"
2289                    "namespace in {\n"
2290                    "int i;\n"
2291                    "} // namespace in\n"
2292                    "} // namespace out",
2293                    Style));
2294 }
2295 
2296 TEST_F(FormatTest, NamespaceMacros) {
2297   FormatStyle Style = getLLVMStyle();
2298   Style.NamespaceMacros.push_back("TESTSUITE");
2299 
2300   verifyFormat("TESTSUITE(A) {\n"
2301                "int foo();\n"
2302                "} // TESTSUITE(A)",
2303                Style);
2304 
2305   verifyFormat("TESTSUITE(A, B) {\n"
2306                "int foo();\n"
2307                "} // TESTSUITE(A)",
2308                Style);
2309 
2310   // Properly indent according to NamespaceIndentation style
2311   Style.NamespaceIndentation = FormatStyle::NI_All;
2312   verifyFormat("TESTSUITE(A) {\n"
2313                "  int foo();\n"
2314                "} // TESTSUITE(A)",
2315                Style);
2316   verifyFormat("TESTSUITE(A) {\n"
2317                "  namespace B {\n"
2318                "    int foo();\n"
2319                "  } // namespace B\n"
2320                "} // TESTSUITE(A)",
2321                Style);
2322   verifyFormat("namespace A {\n"
2323                "  TESTSUITE(B) {\n"
2324                "    int foo();\n"
2325                "  } // TESTSUITE(B)\n"
2326                "} // namespace A",
2327                Style);
2328 
2329   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2330   verifyFormat("TESTSUITE(A) {\n"
2331                "TESTSUITE(B) {\n"
2332                "  int foo();\n"
2333                "} // TESTSUITE(B)\n"
2334                "} // TESTSUITE(A)",
2335                Style);
2336   verifyFormat("TESTSUITE(A) {\n"
2337                "namespace B {\n"
2338                "  int foo();\n"
2339                "} // namespace B\n"
2340                "} // TESTSUITE(A)",
2341                Style);
2342   verifyFormat("namespace A {\n"
2343                "TESTSUITE(B) {\n"
2344                "  int foo();\n"
2345                "} // TESTSUITE(B)\n"
2346                "} // namespace A",
2347                Style);
2348 
2349   // Properly merge namespace-macros blocks in CompactNamespaces mode
2350   Style.NamespaceIndentation = FormatStyle::NI_None;
2351   Style.CompactNamespaces = true;
2352   verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
2353                "}} // TESTSUITE(A::B)",
2354                Style);
2355 
2356   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2357             "}} // TESTSUITE(out::in)",
2358             format("TESTSUITE(out) {\n"
2359                    "TESTSUITE(in) {\n"
2360                    "} // TESTSUITE(in)\n"
2361                    "} // TESTSUITE(out)",
2362                    Style));
2363 
2364   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2365             "}} // TESTSUITE(out::in)",
2366             format("TESTSUITE(out) {\n"
2367                    "TESTSUITE(in) {\n"
2368                    "} // TESTSUITE(in)\n"
2369                    "} // TESTSUITE(out)",
2370                    Style));
2371 
2372   // Do not merge different namespaces/macros
2373   EXPECT_EQ("namespace out {\n"
2374             "TESTSUITE(in) {\n"
2375             "} // TESTSUITE(in)\n"
2376             "} // namespace out",
2377             format("namespace out {\n"
2378                    "TESTSUITE(in) {\n"
2379                    "} // TESTSUITE(in)\n"
2380                    "} // namespace out",
2381                    Style));
2382   EXPECT_EQ("TESTSUITE(out) {\n"
2383             "namespace in {\n"
2384             "} // namespace in\n"
2385             "} // TESTSUITE(out)",
2386             format("TESTSUITE(out) {\n"
2387                    "namespace in {\n"
2388                    "} // namespace in\n"
2389                    "} // TESTSUITE(out)",
2390                    Style));
2391   Style.NamespaceMacros.push_back("FOOBAR");
2392   EXPECT_EQ("TESTSUITE(out) {\n"
2393             "FOOBAR(in) {\n"
2394             "} // FOOBAR(in)\n"
2395             "} // TESTSUITE(out)",
2396             format("TESTSUITE(out) {\n"
2397                    "FOOBAR(in) {\n"
2398                    "} // FOOBAR(in)\n"
2399                    "} // TESTSUITE(out)",
2400                    Style));
2401 }
2402 
2403 TEST_F(FormatTest, FormatsCompactNamespaces) {
2404   FormatStyle Style = getLLVMStyle();
2405   Style.CompactNamespaces = true;
2406   Style.NamespaceMacros.push_back("TESTSUITE");
2407 
2408   verifyFormat("namespace A { namespace B {\n"
2409                "}} // namespace A::B",
2410                Style);
2411 
2412   EXPECT_EQ("namespace out { namespace in {\n"
2413             "}} // namespace out::in",
2414             format("namespace out {\n"
2415                    "namespace in {\n"
2416                    "} // namespace in\n"
2417                    "} // namespace out",
2418                    Style));
2419 
2420   // Only namespaces which have both consecutive opening and end get compacted
2421   EXPECT_EQ("namespace out {\n"
2422             "namespace in1 {\n"
2423             "} // namespace in1\n"
2424             "namespace in2 {\n"
2425             "} // namespace in2\n"
2426             "} // namespace out",
2427             format("namespace out {\n"
2428                    "namespace in1 {\n"
2429                    "} // namespace in1\n"
2430                    "namespace in2 {\n"
2431                    "} // namespace in2\n"
2432                    "} // namespace out",
2433                    Style));
2434 
2435   EXPECT_EQ("namespace out {\n"
2436             "int i;\n"
2437             "namespace in {\n"
2438             "int j;\n"
2439             "} // namespace in\n"
2440             "int k;\n"
2441             "} // namespace out",
2442             format("namespace out { int i;\n"
2443                    "namespace in { int j; } // namespace in\n"
2444                    "int k; } // namespace out",
2445                    Style));
2446 
2447   EXPECT_EQ("namespace A { namespace B { namespace C {\n"
2448             "}}} // namespace A::B::C\n",
2449             format("namespace A { namespace B {\n"
2450                    "namespace C {\n"
2451                    "}} // namespace B::C\n"
2452                    "} // namespace A\n",
2453                    Style));
2454 
2455   Style.ColumnLimit = 40;
2456   EXPECT_EQ("namespace aaaaaaaaaa {\n"
2457             "namespace bbbbbbbbbb {\n"
2458             "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
2459             format("namespace aaaaaaaaaa {\n"
2460                    "namespace bbbbbbbbbb {\n"
2461                    "} // namespace bbbbbbbbbb\n"
2462                    "} // namespace aaaaaaaaaa",
2463                    Style));
2464 
2465   EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
2466             "namespace cccccc {\n"
2467             "}}} // namespace aaaaaa::bbbbbb::cccccc",
2468             format("namespace aaaaaa {\n"
2469                    "namespace bbbbbb {\n"
2470                    "namespace cccccc {\n"
2471                    "} // namespace cccccc\n"
2472                    "} // namespace bbbbbb\n"
2473                    "} // namespace aaaaaa",
2474                    Style));
2475   Style.ColumnLimit = 80;
2476 
2477   // Extra semicolon after 'inner' closing brace prevents merging
2478   EXPECT_EQ("namespace out { namespace in {\n"
2479             "}; } // namespace out::in",
2480             format("namespace out {\n"
2481                    "namespace in {\n"
2482                    "}; // namespace in\n"
2483                    "} // namespace out",
2484                    Style));
2485 
2486   // Extra semicolon after 'outer' closing brace is conserved
2487   EXPECT_EQ("namespace out { namespace in {\n"
2488             "}}; // namespace out::in",
2489             format("namespace out {\n"
2490                    "namespace in {\n"
2491                    "} // namespace in\n"
2492                    "}; // namespace out",
2493                    Style));
2494 
2495   Style.NamespaceIndentation = FormatStyle::NI_All;
2496   EXPECT_EQ("namespace out { namespace in {\n"
2497             "  int i;\n"
2498             "}} // namespace out::in",
2499             format("namespace out {\n"
2500                    "namespace in {\n"
2501                    "int i;\n"
2502                    "} // namespace in\n"
2503                    "} // namespace out",
2504                    Style));
2505   EXPECT_EQ("namespace out { namespace mid {\n"
2506             "  namespace in {\n"
2507             "    int j;\n"
2508             "  } // namespace in\n"
2509             "  int k;\n"
2510             "}} // namespace out::mid",
2511             format("namespace out { namespace mid {\n"
2512                    "namespace in { int j; } // namespace in\n"
2513                    "int k; }} // namespace out::mid",
2514                    Style));
2515 
2516   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2517   EXPECT_EQ("namespace out { namespace in {\n"
2518             "  int i;\n"
2519             "}} // namespace out::in",
2520             format("namespace out {\n"
2521                    "namespace in {\n"
2522                    "int i;\n"
2523                    "} // namespace in\n"
2524                    "} // namespace out",
2525                    Style));
2526   EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
2527             "  int i;\n"
2528             "}}} // namespace out::mid::in",
2529             format("namespace out {\n"
2530                    "namespace mid {\n"
2531                    "namespace in {\n"
2532                    "int i;\n"
2533                    "} // namespace in\n"
2534                    "} // namespace mid\n"
2535                    "} // namespace out",
2536                    Style));
2537 }
2538 
2539 TEST_F(FormatTest, FormatsExternC) {
2540   verifyFormat("extern \"C\" {\nint a;");
2541   verifyFormat("extern \"C\" {}");
2542   verifyFormat("extern \"C\" {\n"
2543                "int foo();\n"
2544                "}");
2545   verifyFormat("extern \"C\" int foo() {}");
2546   verifyFormat("extern \"C\" int foo();");
2547   verifyFormat("extern \"C\" int foo() {\n"
2548                "  int i = 42;\n"
2549                "  return i;\n"
2550                "}");
2551 
2552   FormatStyle Style = getLLVMStyle();
2553   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2554   Style.BraceWrapping.AfterFunction = true;
2555   verifyFormat("extern \"C\" int foo() {}", Style);
2556   verifyFormat("extern \"C\" int foo();", Style);
2557   verifyFormat("extern \"C\" int foo()\n"
2558                "{\n"
2559                "  int i = 42;\n"
2560                "  return i;\n"
2561                "}",
2562                Style);
2563 
2564   Style.BraceWrapping.AfterExternBlock = true;
2565   Style.BraceWrapping.SplitEmptyRecord = false;
2566   verifyFormat("extern \"C\"\n"
2567                "{}",
2568                Style);
2569   verifyFormat("extern \"C\"\n"
2570                "{\n"
2571                "  int foo();\n"
2572                "}",
2573                Style);
2574 }
2575 
2576 TEST_F(FormatTest, IndentExternBlockStyle) {
2577   FormatStyle Style = getLLVMStyle();
2578   Style.IndentWidth = 2;
2579 
2580   Style.IndentExternBlock = FormatStyle::IEBS_Indent;
2581   verifyFormat("extern \"C\" { /*9*/\n}", Style);
2582   verifyFormat("extern \"C\" {\n"
2583                "  int foo10();\n"
2584                "}",
2585                Style);
2586 
2587   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
2588   verifyFormat("extern \"C\" { /*11*/\n}", Style);
2589   verifyFormat("extern \"C\" {\n"
2590                "int foo12();\n"
2591                "}",
2592                Style);
2593 
2594   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2595   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2596   Style.BraceWrapping.AfterExternBlock = true;
2597   verifyFormat("extern \"C\"\n{ /*13*/\n}", Style);
2598   verifyFormat("extern \"C\"\n{\n"
2599                "  int foo14();\n"
2600                "}",
2601                Style);
2602 
2603   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2604   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2605   Style.BraceWrapping.AfterExternBlock = false;
2606   verifyFormat("extern \"C\" { /*15*/\n}", Style);
2607   verifyFormat("extern \"C\" {\n"
2608                "int foo16();\n"
2609                "}",
2610                Style);
2611 }
2612 
2613 TEST_F(FormatTest, FormatsInlineASM) {
2614   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
2615   verifyFormat("asm(\"nop\" ::: \"memory\");");
2616   verifyFormat(
2617       "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
2618       "    \"cpuid\\n\\t\"\n"
2619       "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
2620       "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
2621       "    : \"a\"(value));");
2622   EXPECT_EQ(
2623       "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
2624       "  __asm {\n"
2625       "        mov     edx,[that] // vtable in edx\n"
2626       "        mov     eax,methodIndex\n"
2627       "        call    [edx][eax*4] // stdcall\n"
2628       "  }\n"
2629       "}",
2630       format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
2631              "    __asm {\n"
2632              "        mov     edx,[that] // vtable in edx\n"
2633              "        mov     eax,methodIndex\n"
2634              "        call    [edx][eax*4] // stdcall\n"
2635              "    }\n"
2636              "}"));
2637   EXPECT_EQ("_asm {\n"
2638             "  xor eax, eax;\n"
2639             "  cpuid;\n"
2640             "}",
2641             format("_asm {\n"
2642                    "  xor eax, eax;\n"
2643                    "  cpuid;\n"
2644                    "}"));
2645   verifyFormat("void function() {\n"
2646                "  // comment\n"
2647                "  asm(\"\");\n"
2648                "}");
2649   EXPECT_EQ("__asm {\n"
2650             "}\n"
2651             "int i;",
2652             format("__asm   {\n"
2653                    "}\n"
2654                    "int   i;"));
2655 }
2656 
2657 TEST_F(FormatTest, FormatTryCatch) {
2658   verifyFormat("try {\n"
2659                "  throw a * b;\n"
2660                "} catch (int a) {\n"
2661                "  // Do nothing.\n"
2662                "} catch (...) {\n"
2663                "  exit(42);\n"
2664                "}");
2665 
2666   // Function-level try statements.
2667   verifyFormat("int f() try { return 4; } catch (...) {\n"
2668                "  return 5;\n"
2669                "}");
2670   verifyFormat("class A {\n"
2671                "  int a;\n"
2672                "  A() try : a(0) {\n"
2673                "  } catch (...) {\n"
2674                "    throw;\n"
2675                "  }\n"
2676                "};\n");
2677 
2678   // Incomplete try-catch blocks.
2679   verifyIncompleteFormat("try {} catch (");
2680 }
2681 
2682 TEST_F(FormatTest, FormatTryAsAVariable) {
2683   verifyFormat("int try;");
2684   verifyFormat("int try, size;");
2685   verifyFormat("try = foo();");
2686   verifyFormat("if (try < size) {\n  return true;\n}");
2687 
2688   verifyFormat("int catch;");
2689   verifyFormat("int catch, size;");
2690   verifyFormat("catch = foo();");
2691   verifyFormat("if (catch < size) {\n  return true;\n}");
2692 }
2693 
2694 TEST_F(FormatTest, FormatSEHTryCatch) {
2695   verifyFormat("__try {\n"
2696                "  int a = b * c;\n"
2697                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2698                "  // Do nothing.\n"
2699                "}");
2700 
2701   verifyFormat("__try {\n"
2702                "  int a = b * c;\n"
2703                "} __finally {\n"
2704                "  // Do nothing.\n"
2705                "}");
2706 
2707   verifyFormat("DEBUG({\n"
2708                "  __try {\n"
2709                "  } __finally {\n"
2710                "  }\n"
2711                "});\n");
2712 }
2713 
2714 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2715   verifyFormat("try {\n"
2716                "  f();\n"
2717                "} catch {\n"
2718                "  g();\n"
2719                "}");
2720   verifyFormat("try {\n"
2721                "  f();\n"
2722                "} catch (A a) MACRO(x) {\n"
2723                "  g();\n"
2724                "} catch (B b) MACRO(x) {\n"
2725                "  g();\n"
2726                "}");
2727 }
2728 
2729 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2730   FormatStyle Style = getLLVMStyle();
2731   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2732                           FormatStyle::BS_WebKit}) {
2733     Style.BreakBeforeBraces = BraceStyle;
2734     verifyFormat("try {\n"
2735                  "  // something\n"
2736                  "} catch (...) {\n"
2737                  "  // something\n"
2738                  "}",
2739                  Style);
2740   }
2741   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2742   verifyFormat("try {\n"
2743                "  // something\n"
2744                "}\n"
2745                "catch (...) {\n"
2746                "  // something\n"
2747                "}",
2748                Style);
2749   verifyFormat("__try {\n"
2750                "  // something\n"
2751                "}\n"
2752                "__finally {\n"
2753                "  // something\n"
2754                "}",
2755                Style);
2756   verifyFormat("@try {\n"
2757                "  // something\n"
2758                "}\n"
2759                "@finally {\n"
2760                "  // something\n"
2761                "}",
2762                Style);
2763   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2764   verifyFormat("try\n"
2765                "{\n"
2766                "  // something\n"
2767                "}\n"
2768                "catch (...)\n"
2769                "{\n"
2770                "  // something\n"
2771                "}",
2772                Style);
2773   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2774   verifyFormat("try\n"
2775                "  {\n"
2776                "  // something white\n"
2777                "  }\n"
2778                "catch (...)\n"
2779                "  {\n"
2780                "  // something white\n"
2781                "  }",
2782                Style);
2783   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2784   verifyFormat("try\n"
2785                "  {\n"
2786                "    // something\n"
2787                "  }\n"
2788                "catch (...)\n"
2789                "  {\n"
2790                "    // something\n"
2791                "  }",
2792                Style);
2793   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2794   Style.BraceWrapping.BeforeCatch = true;
2795   verifyFormat("try {\n"
2796                "  // something\n"
2797                "}\n"
2798                "catch (...) {\n"
2799                "  // something\n"
2800                "}",
2801                Style);
2802 }
2803 
2804 TEST_F(FormatTest, StaticInitializers) {
2805   verifyFormat("static SomeClass SC = {1, 'a'};");
2806 
2807   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2808                "    100000000, "
2809                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2810 
2811   // Here, everything other than the "}" would fit on a line.
2812   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2813                "    10000000000000000000000000};");
2814   EXPECT_EQ("S s = {a,\n"
2815             "\n"
2816             "       b};",
2817             format("S s = {\n"
2818                    "  a,\n"
2819                    "\n"
2820                    "  b\n"
2821                    "};"));
2822 
2823   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2824   // line. However, the formatting looks a bit off and this probably doesn't
2825   // happen often in practice.
2826   verifyFormat("static int Variable[1] = {\n"
2827                "    {1000000000000000000000000000000000000}};",
2828                getLLVMStyleWithColumns(40));
2829 }
2830 
2831 TEST_F(FormatTest, DesignatedInitializers) {
2832   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2833   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2834                "                    .bbbbbbbbbb = 2,\n"
2835                "                    .cccccccccc = 3,\n"
2836                "                    .dddddddddd = 4,\n"
2837                "                    .eeeeeeeeee = 5};");
2838   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2839                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2840                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2841                "    .ccccccccccccccccccccccccccc = 3,\n"
2842                "    .ddddddddddddddddddddddddddd = 4,\n"
2843                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2844 
2845   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2846 
2847   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2848   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2849                "                    [2] = bbbbbbbbbb,\n"
2850                "                    [3] = cccccccccc,\n"
2851                "                    [4] = dddddddddd,\n"
2852                "                    [5] = eeeeeeeeee};");
2853   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2854                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2855                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2856                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2857                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2858                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2859 }
2860 
2861 TEST_F(FormatTest, NestedStaticInitializers) {
2862   verifyFormat("static A x = {{{}}};\n");
2863   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2864                "               {init1, init2, init3, init4}}};",
2865                getLLVMStyleWithColumns(50));
2866 
2867   verifyFormat("somes Status::global_reps[3] = {\n"
2868                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2869                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2870                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2871                getLLVMStyleWithColumns(60));
2872   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2873                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2874                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2875                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2876   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2877                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
2878                "rect.fTop}};");
2879 
2880   verifyFormat(
2881       "SomeArrayOfSomeType a = {\n"
2882       "    {{1, 2, 3},\n"
2883       "     {1, 2, 3},\n"
2884       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
2885       "      333333333333333333333333333333},\n"
2886       "     {1, 2, 3},\n"
2887       "     {1, 2, 3}}};");
2888   verifyFormat(
2889       "SomeArrayOfSomeType a = {\n"
2890       "    {{1, 2, 3}},\n"
2891       "    {{1, 2, 3}},\n"
2892       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2893       "      333333333333333333333333333333}},\n"
2894       "    {{1, 2, 3}},\n"
2895       "    {{1, 2, 3}}};");
2896 
2897   verifyFormat("struct {\n"
2898                "  unsigned bit;\n"
2899                "  const char *const name;\n"
2900                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2901                "                 {kOsWin, \"Windows\"},\n"
2902                "                 {kOsLinux, \"Linux\"},\n"
2903                "                 {kOsCrOS, \"Chrome OS\"}};");
2904   verifyFormat("struct {\n"
2905                "  unsigned bit;\n"
2906                "  const char *const name;\n"
2907                "} kBitsToOs[] = {\n"
2908                "    {kOsMac, \"Mac\"},\n"
2909                "    {kOsWin, \"Windows\"},\n"
2910                "    {kOsLinux, \"Linux\"},\n"
2911                "    {kOsCrOS, \"Chrome OS\"},\n"
2912                "};");
2913 }
2914 
2915 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2916   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2917                "                      \\\n"
2918                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2919 }
2920 
2921 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
2922   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2923                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
2924 
2925   // Do break defaulted and deleted functions.
2926   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2927                "    default;",
2928                getLLVMStyleWithColumns(40));
2929   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2930                "    delete;",
2931                getLLVMStyleWithColumns(40));
2932 }
2933 
2934 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2935   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2936                getLLVMStyleWithColumns(40));
2937   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2938                getLLVMStyleWithColumns(40));
2939   EXPECT_EQ("#define Q                              \\\n"
2940             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
2941             "  \"aaaaaaaa.cpp\"",
2942             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2943                    getLLVMStyleWithColumns(40)));
2944 }
2945 
2946 TEST_F(FormatTest, UnderstandsLinePPDirective) {
2947   EXPECT_EQ("# 123 \"A string literal\"",
2948             format("   #     123    \"A string literal\""));
2949 }
2950 
2951 TEST_F(FormatTest, LayoutUnknownPPDirective) {
2952   EXPECT_EQ("#;", format("#;"));
2953   verifyFormat("#\n;\n;\n;");
2954 }
2955 
2956 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
2957   EXPECT_EQ("#line 42 \"test\"\n",
2958             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
2959   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
2960                                     getLLVMStyleWithColumns(12)));
2961 }
2962 
2963 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
2964   EXPECT_EQ("#line 42 \"test\"",
2965             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
2966   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
2967 }
2968 
2969 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
2970   verifyFormat("#define A \\x20");
2971   verifyFormat("#define A \\ x20");
2972   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
2973   verifyFormat("#define A ''");
2974   verifyFormat("#define A ''qqq");
2975   verifyFormat("#define A `qqq");
2976   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
2977   EXPECT_EQ("const char *c = STRINGIFY(\n"
2978             "\\na : b);",
2979             format("const char * c = STRINGIFY(\n"
2980                    "\\na : b);"));
2981 
2982   verifyFormat("a\r\\");
2983   verifyFormat("a\v\\");
2984   verifyFormat("a\f\\");
2985 }
2986 
2987 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
2988   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
2989   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
2990   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
2991   // FIXME: We never break before the macro name.
2992   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
2993 
2994   verifyFormat("#define A A\n#define A A");
2995   verifyFormat("#define A(X) A\n#define A A");
2996 
2997   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
2998   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
2999 }
3000 
3001 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
3002   EXPECT_EQ("// somecomment\n"
3003             "#include \"a.h\"\n"
3004             "#define A(  \\\n"
3005             "    A, B)\n"
3006             "#include \"b.h\"\n"
3007             "// somecomment\n",
3008             format("  // somecomment\n"
3009                    "  #include \"a.h\"\n"
3010                    "#define A(A,\\\n"
3011                    "    B)\n"
3012                    "    #include \"b.h\"\n"
3013                    " // somecomment\n",
3014                    getLLVMStyleWithColumns(13)));
3015 }
3016 
3017 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
3018 
3019 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
3020   EXPECT_EQ("#define A    \\\n"
3021             "  c;         \\\n"
3022             "  e;\n"
3023             "f;",
3024             format("#define A c; e;\n"
3025                    "f;",
3026                    getLLVMStyleWithColumns(14)));
3027 }
3028 
3029 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
3030 
3031 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
3032   EXPECT_EQ("int x,\n"
3033             "#define A\n"
3034             "    y;",
3035             format("int x,\n#define A\ny;"));
3036 }
3037 
3038 TEST_F(FormatTest, HashInMacroDefinition) {
3039   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
3040   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
3041   verifyFormat("#define A  \\\n"
3042                "  {        \\\n"
3043                "    f(#c); \\\n"
3044                "  }",
3045                getLLVMStyleWithColumns(11));
3046 
3047   verifyFormat("#define A(X)         \\\n"
3048                "  void function##X()",
3049                getLLVMStyleWithColumns(22));
3050 
3051   verifyFormat("#define A(a, b, c)   \\\n"
3052                "  void a##b##c()",
3053                getLLVMStyleWithColumns(22));
3054 
3055   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
3056 }
3057 
3058 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
3059   EXPECT_EQ("#define A (x)", format("#define A (x)"));
3060   EXPECT_EQ("#define A(x)", format("#define A(x)"));
3061 
3062   FormatStyle Style = getLLVMStyle();
3063   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
3064   verifyFormat("#define true ((foo)1)", Style);
3065   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
3066   verifyFormat("#define false((foo)0)", Style);
3067 }
3068 
3069 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
3070   EXPECT_EQ("#define A b;", format("#define A \\\n"
3071                                    "          \\\n"
3072                                    "  b;",
3073                                    getLLVMStyleWithColumns(25)));
3074   EXPECT_EQ("#define A \\\n"
3075             "          \\\n"
3076             "  a;      \\\n"
3077             "  b;",
3078             format("#define A \\\n"
3079                    "          \\\n"
3080                    "  a;      \\\n"
3081                    "  b;",
3082                    getLLVMStyleWithColumns(11)));
3083   EXPECT_EQ("#define A \\\n"
3084             "  a;      \\\n"
3085             "          \\\n"
3086             "  b;",
3087             format("#define A \\\n"
3088                    "  a;      \\\n"
3089                    "          \\\n"
3090                    "  b;",
3091                    getLLVMStyleWithColumns(11)));
3092 }
3093 
3094 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
3095   verifyIncompleteFormat("#define A :");
3096   verifyFormat("#define SOMECASES  \\\n"
3097                "  case 1:          \\\n"
3098                "  case 2\n",
3099                getLLVMStyleWithColumns(20));
3100   verifyFormat("#define MACRO(a) \\\n"
3101                "  if (a)         \\\n"
3102                "    f();         \\\n"
3103                "  else           \\\n"
3104                "    g()",
3105                getLLVMStyleWithColumns(18));
3106   verifyFormat("#define A template <typename T>");
3107   verifyIncompleteFormat("#define STR(x) #x\n"
3108                          "f(STR(this_is_a_string_literal{));");
3109   verifyFormat("#pragma omp threadprivate( \\\n"
3110                "    y)), // expected-warning",
3111                getLLVMStyleWithColumns(28));
3112   verifyFormat("#d, = };");
3113   verifyFormat("#if \"a");
3114   verifyIncompleteFormat("({\n"
3115                          "#define b     \\\n"
3116                          "  }           \\\n"
3117                          "  a\n"
3118                          "a",
3119                          getLLVMStyleWithColumns(15));
3120   verifyFormat("#define A     \\\n"
3121                "  {           \\\n"
3122                "    {\n"
3123                "#define B     \\\n"
3124                "  }           \\\n"
3125                "  }",
3126                getLLVMStyleWithColumns(15));
3127   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
3128   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
3129   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
3130   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
3131 }
3132 
3133 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
3134   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
3135   EXPECT_EQ("class A : public QObject {\n"
3136             "  Q_OBJECT\n"
3137             "\n"
3138             "  A() {}\n"
3139             "};",
3140             format("class A  :  public QObject {\n"
3141                    "     Q_OBJECT\n"
3142                    "\n"
3143                    "  A() {\n}\n"
3144                    "}  ;"));
3145   EXPECT_EQ("MACRO\n"
3146             "/*static*/ int i;",
3147             format("MACRO\n"
3148                    " /*static*/ int   i;"));
3149   EXPECT_EQ("SOME_MACRO\n"
3150             "namespace {\n"
3151             "void f();\n"
3152             "} // namespace",
3153             format("SOME_MACRO\n"
3154                    "  namespace    {\n"
3155                    "void   f(  );\n"
3156                    "} // namespace"));
3157   // Only if the identifier contains at least 5 characters.
3158   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
3159   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
3160   // Only if everything is upper case.
3161   EXPECT_EQ("class A : public QObject {\n"
3162             "  Q_Object A() {}\n"
3163             "};",
3164             format("class A  :  public QObject {\n"
3165                    "     Q_Object\n"
3166                    "  A() {\n}\n"
3167                    "}  ;"));
3168 
3169   // Only if the next line can actually start an unwrapped line.
3170   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
3171             format("SOME_WEIRD_LOG_MACRO\n"
3172                    "<< SomeThing;"));
3173 
3174   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3175                "(n, buffers))\n",
3176                getChromiumStyle(FormatStyle::LK_Cpp));
3177 
3178   // See PR41483
3179   EXPECT_EQ("/**/ FOO(a)\n"
3180             "FOO(b)",
3181             format("/**/ FOO(a)\n"
3182                    "FOO(b)"));
3183 }
3184 
3185 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
3186   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3187             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3188             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3189             "class X {};\n"
3190             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3191             "int *createScopDetectionPass() { return 0; }",
3192             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3193                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3194                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3195                    "  class X {};\n"
3196                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3197                    "  int *createScopDetectionPass() { return 0; }"));
3198   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
3199   // braces, so that inner block is indented one level more.
3200   EXPECT_EQ("int q() {\n"
3201             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3202             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3203             "  IPC_END_MESSAGE_MAP()\n"
3204             "}",
3205             format("int q() {\n"
3206                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3207                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3208                    "  IPC_END_MESSAGE_MAP()\n"
3209                    "}"));
3210 
3211   // Same inside macros.
3212   EXPECT_EQ("#define LIST(L) \\\n"
3213             "  L(A)          \\\n"
3214             "  L(B)          \\\n"
3215             "  L(C)",
3216             format("#define LIST(L) \\\n"
3217                    "  L(A) \\\n"
3218                    "  L(B) \\\n"
3219                    "  L(C)",
3220                    getGoogleStyle()));
3221 
3222   // These must not be recognized as macros.
3223   EXPECT_EQ("int q() {\n"
3224             "  f(x);\n"
3225             "  f(x) {}\n"
3226             "  f(x)->g();\n"
3227             "  f(x)->*g();\n"
3228             "  f(x).g();\n"
3229             "  f(x) = x;\n"
3230             "  f(x) += x;\n"
3231             "  f(x) -= x;\n"
3232             "  f(x) *= x;\n"
3233             "  f(x) /= x;\n"
3234             "  f(x) %= x;\n"
3235             "  f(x) &= x;\n"
3236             "  f(x) |= x;\n"
3237             "  f(x) ^= x;\n"
3238             "  f(x) >>= x;\n"
3239             "  f(x) <<= x;\n"
3240             "  f(x)[y].z();\n"
3241             "  LOG(INFO) << x;\n"
3242             "  ifstream(x) >> x;\n"
3243             "}\n",
3244             format("int q() {\n"
3245                    "  f(x)\n;\n"
3246                    "  f(x)\n {}\n"
3247                    "  f(x)\n->g();\n"
3248                    "  f(x)\n->*g();\n"
3249                    "  f(x)\n.g();\n"
3250                    "  f(x)\n = x;\n"
3251                    "  f(x)\n += x;\n"
3252                    "  f(x)\n -= x;\n"
3253                    "  f(x)\n *= x;\n"
3254                    "  f(x)\n /= x;\n"
3255                    "  f(x)\n %= x;\n"
3256                    "  f(x)\n &= x;\n"
3257                    "  f(x)\n |= x;\n"
3258                    "  f(x)\n ^= x;\n"
3259                    "  f(x)\n >>= x;\n"
3260                    "  f(x)\n <<= x;\n"
3261                    "  f(x)\n[y].z();\n"
3262                    "  LOG(INFO)\n << x;\n"
3263                    "  ifstream(x)\n >> x;\n"
3264                    "}\n"));
3265   EXPECT_EQ("int q() {\n"
3266             "  F(x)\n"
3267             "  if (1) {\n"
3268             "  }\n"
3269             "  F(x)\n"
3270             "  while (1) {\n"
3271             "  }\n"
3272             "  F(x)\n"
3273             "  G(x);\n"
3274             "  F(x)\n"
3275             "  try {\n"
3276             "    Q();\n"
3277             "  } catch (...) {\n"
3278             "  }\n"
3279             "}\n",
3280             format("int q() {\n"
3281                    "F(x)\n"
3282                    "if (1) {}\n"
3283                    "F(x)\n"
3284                    "while (1) {}\n"
3285                    "F(x)\n"
3286                    "G(x);\n"
3287                    "F(x)\n"
3288                    "try { Q(); } catch (...) {}\n"
3289                    "}\n"));
3290   EXPECT_EQ("class A {\n"
3291             "  A() : t(0) {}\n"
3292             "  A(int i) noexcept() : {}\n"
3293             "  A(X x)\n" // FIXME: function-level try blocks are broken.
3294             "  try : t(0) {\n"
3295             "  } catch (...) {\n"
3296             "  }\n"
3297             "};",
3298             format("class A {\n"
3299                    "  A()\n : t(0) {}\n"
3300                    "  A(int i)\n noexcept() : {}\n"
3301                    "  A(X x)\n"
3302                    "  try : t(0) {} catch (...) {}\n"
3303                    "};"));
3304   FormatStyle Style = getLLVMStyle();
3305   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3306   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3307   Style.BraceWrapping.AfterFunction = true;
3308   EXPECT_EQ("void f()\n"
3309             "try\n"
3310             "{\n"
3311             "}",
3312             format("void f() try {\n"
3313                    "}",
3314                    Style));
3315   EXPECT_EQ("class SomeClass {\n"
3316             "public:\n"
3317             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3318             "};",
3319             format("class SomeClass {\n"
3320                    "public:\n"
3321                    "  SomeClass()\n"
3322                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3323                    "};"));
3324   EXPECT_EQ("class SomeClass {\n"
3325             "public:\n"
3326             "  SomeClass()\n"
3327             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3328             "};",
3329             format("class SomeClass {\n"
3330                    "public:\n"
3331                    "  SomeClass()\n"
3332                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3333                    "};",
3334                    getLLVMStyleWithColumns(40)));
3335 
3336   verifyFormat("MACRO(>)");
3337 
3338   // Some macros contain an implicit semicolon.
3339   Style = getLLVMStyle();
3340   Style.StatementMacros.push_back("FOO");
3341   verifyFormat("FOO(a) int b = 0;");
3342   verifyFormat("FOO(a)\n"
3343                "int b = 0;",
3344                Style);
3345   verifyFormat("FOO(a);\n"
3346                "int b = 0;",
3347                Style);
3348   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3349                "int b = 0;",
3350                Style);
3351   verifyFormat("FOO()\n"
3352                "int b = 0;",
3353                Style);
3354   verifyFormat("FOO\n"
3355                "int b = 0;",
3356                Style);
3357   verifyFormat("void f() {\n"
3358                "  FOO(a)\n"
3359                "  return a;\n"
3360                "}",
3361                Style);
3362   verifyFormat("FOO(a)\n"
3363                "FOO(b)",
3364                Style);
3365   verifyFormat("int a = 0;\n"
3366                "FOO(b)\n"
3367                "int c = 0;",
3368                Style);
3369   verifyFormat("int a = 0;\n"
3370                "int x = FOO(a)\n"
3371                "int b = 0;",
3372                Style);
3373   verifyFormat("void foo(int a) { FOO(a) }\n"
3374                "uint32_t bar() {}",
3375                Style);
3376 }
3377 
3378 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3379   verifyFormat("#define A \\\n"
3380                "  f({     \\\n"
3381                "    g();  \\\n"
3382                "  });",
3383                getLLVMStyleWithColumns(11));
3384 }
3385 
3386 TEST_F(FormatTest, IndentPreprocessorDirectives) {
3387   FormatStyle Style = getLLVMStyle();
3388   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3389   Style.ColumnLimit = 40;
3390   verifyFormat("#ifdef _WIN32\n"
3391                "#define A 0\n"
3392                "#ifdef VAR2\n"
3393                "#define B 1\n"
3394                "#include <someheader.h>\n"
3395                "#define MACRO                          \\\n"
3396                "  some_very_long_func_aaaaaaaaaa();\n"
3397                "#endif\n"
3398                "#else\n"
3399                "#define A 1\n"
3400                "#endif",
3401                Style);
3402   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3403   verifyFormat("#ifdef _WIN32\n"
3404                "#  define A 0\n"
3405                "#  ifdef VAR2\n"
3406                "#    define B 1\n"
3407                "#    include <someheader.h>\n"
3408                "#    define MACRO                      \\\n"
3409                "      some_very_long_func_aaaaaaaaaa();\n"
3410                "#  endif\n"
3411                "#else\n"
3412                "#  define A 1\n"
3413                "#endif",
3414                Style);
3415   verifyFormat("#if A\n"
3416                "#  define MACRO                        \\\n"
3417                "    void a(int x) {                    \\\n"
3418                "      b();                             \\\n"
3419                "      c();                             \\\n"
3420                "      d();                             \\\n"
3421                "      e();                             \\\n"
3422                "      f();                             \\\n"
3423                "    }\n"
3424                "#endif",
3425                Style);
3426   // Comments before include guard.
3427   verifyFormat("// file comment\n"
3428                "// file comment\n"
3429                "#ifndef HEADER_H\n"
3430                "#define HEADER_H\n"
3431                "code();\n"
3432                "#endif",
3433                Style);
3434   // Test with include guards.
3435   verifyFormat("#ifndef HEADER_H\n"
3436                "#define HEADER_H\n"
3437                "code();\n"
3438                "#endif",
3439                Style);
3440   // Include guards must have a #define with the same variable immediately
3441   // after #ifndef.
3442   verifyFormat("#ifndef NOT_GUARD\n"
3443                "#  define FOO\n"
3444                "code();\n"
3445                "#endif",
3446                Style);
3447 
3448   // Include guards must cover the entire file.
3449   verifyFormat("code();\n"
3450                "code();\n"
3451                "#ifndef NOT_GUARD\n"
3452                "#  define NOT_GUARD\n"
3453                "code();\n"
3454                "#endif",
3455                Style);
3456   verifyFormat("#ifndef NOT_GUARD\n"
3457                "#  define NOT_GUARD\n"
3458                "code();\n"
3459                "#endif\n"
3460                "code();",
3461                Style);
3462   // Test with trailing blank lines.
3463   verifyFormat("#ifndef HEADER_H\n"
3464                "#define HEADER_H\n"
3465                "code();\n"
3466                "#endif\n",
3467                Style);
3468   // Include guards don't have #else.
3469   verifyFormat("#ifndef NOT_GUARD\n"
3470                "#  define NOT_GUARD\n"
3471                "code();\n"
3472                "#else\n"
3473                "#endif",
3474                Style);
3475   verifyFormat("#ifndef NOT_GUARD\n"
3476                "#  define NOT_GUARD\n"
3477                "code();\n"
3478                "#elif FOO\n"
3479                "#endif",
3480                Style);
3481   // Non-identifier #define after potential include guard.
3482   verifyFormat("#ifndef FOO\n"
3483                "#  define 1\n"
3484                "#endif\n",
3485                Style);
3486   // #if closes past last non-preprocessor line.
3487   verifyFormat("#ifndef FOO\n"
3488                "#define FOO\n"
3489                "#if 1\n"
3490                "int i;\n"
3491                "#  define A 0\n"
3492                "#endif\n"
3493                "#endif\n",
3494                Style);
3495   // Don't crash if there is an #elif directive without a condition.
3496   verifyFormat("#if 1\n"
3497                "int x;\n"
3498                "#elif\n"
3499                "int y;\n"
3500                "#else\n"
3501                "int z;\n"
3502                "#endif",
3503                Style);
3504   // FIXME: This doesn't handle the case where there's code between the
3505   // #ifndef and #define but all other conditions hold. This is because when
3506   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3507   // previous code line yet, so we can't detect it.
3508   EXPECT_EQ("#ifndef NOT_GUARD\n"
3509             "code();\n"
3510             "#define NOT_GUARD\n"
3511             "code();\n"
3512             "#endif",
3513             format("#ifndef NOT_GUARD\n"
3514                    "code();\n"
3515                    "#  define NOT_GUARD\n"
3516                    "code();\n"
3517                    "#endif",
3518                    Style));
3519   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3520   // be outside an include guard. Examples are #pragma once and
3521   // #pragma GCC diagnostic, or anything else that does not change the meaning
3522   // of the file if it's included multiple times.
3523   EXPECT_EQ("#ifdef WIN32\n"
3524             "#  pragma once\n"
3525             "#endif\n"
3526             "#ifndef HEADER_H\n"
3527             "#  define HEADER_H\n"
3528             "code();\n"
3529             "#endif",
3530             format("#ifdef WIN32\n"
3531                    "#  pragma once\n"
3532                    "#endif\n"
3533                    "#ifndef HEADER_H\n"
3534                    "#define HEADER_H\n"
3535                    "code();\n"
3536                    "#endif",
3537                    Style));
3538   // FIXME: This does not detect when there is a single non-preprocessor line
3539   // in front of an include-guard-like structure where other conditions hold
3540   // because ScopedLineState hides the line.
3541   EXPECT_EQ("code();\n"
3542             "#ifndef HEADER_H\n"
3543             "#define HEADER_H\n"
3544             "code();\n"
3545             "#endif",
3546             format("code();\n"
3547                    "#ifndef HEADER_H\n"
3548                    "#  define HEADER_H\n"
3549                    "code();\n"
3550                    "#endif",
3551                    Style));
3552   // Keep comments aligned with #, otherwise indent comments normally. These
3553   // tests cannot use verifyFormat because messUp manipulates leading
3554   // whitespace.
3555   {
3556     const char *Expected = ""
3557                            "void f() {\n"
3558                            "#if 1\n"
3559                            "// Preprocessor aligned.\n"
3560                            "#  define A 0\n"
3561                            "  // Code. Separated by blank line.\n"
3562                            "\n"
3563                            "#  define B 0\n"
3564                            "  // Code. Not aligned with #\n"
3565                            "#  define C 0\n"
3566                            "#endif";
3567     const char *ToFormat = ""
3568                            "void f() {\n"
3569                            "#if 1\n"
3570                            "// Preprocessor aligned.\n"
3571                            "#  define A 0\n"
3572                            "// Code. Separated by blank line.\n"
3573                            "\n"
3574                            "#  define B 0\n"
3575                            "   // Code. Not aligned with #\n"
3576                            "#  define C 0\n"
3577                            "#endif";
3578     EXPECT_EQ(Expected, format(ToFormat, Style));
3579     EXPECT_EQ(Expected, format(Expected, Style));
3580   }
3581   // Keep block quotes aligned.
3582   {
3583     const char *Expected = ""
3584                            "void f() {\n"
3585                            "#if 1\n"
3586                            "/* Preprocessor aligned. */\n"
3587                            "#  define A 0\n"
3588                            "  /* Code. Separated by blank line. */\n"
3589                            "\n"
3590                            "#  define B 0\n"
3591                            "  /* Code. Not aligned with # */\n"
3592                            "#  define C 0\n"
3593                            "#endif";
3594     const char *ToFormat = ""
3595                            "void f() {\n"
3596                            "#if 1\n"
3597                            "/* Preprocessor aligned. */\n"
3598                            "#  define A 0\n"
3599                            "/* Code. Separated by blank line. */\n"
3600                            "\n"
3601                            "#  define B 0\n"
3602                            "   /* Code. Not aligned with # */\n"
3603                            "#  define C 0\n"
3604                            "#endif";
3605     EXPECT_EQ(Expected, format(ToFormat, Style));
3606     EXPECT_EQ(Expected, format(Expected, Style));
3607   }
3608   // Keep comments aligned with un-indented directives.
3609   {
3610     const char *Expected = ""
3611                            "void f() {\n"
3612                            "// Preprocessor aligned.\n"
3613                            "#define A 0\n"
3614                            "  // Code. Separated by blank line.\n"
3615                            "\n"
3616                            "#define B 0\n"
3617                            "  // Code. Not aligned with #\n"
3618                            "#define C 0\n";
3619     const char *ToFormat = ""
3620                            "void f() {\n"
3621                            "// Preprocessor aligned.\n"
3622                            "#define A 0\n"
3623                            "// Code. Separated by blank line.\n"
3624                            "\n"
3625                            "#define B 0\n"
3626                            "   // Code. Not aligned with #\n"
3627                            "#define C 0\n";
3628     EXPECT_EQ(Expected, format(ToFormat, Style));
3629     EXPECT_EQ(Expected, format(Expected, Style));
3630   }
3631   // Test AfterHash with tabs.
3632   {
3633     FormatStyle Tabbed = Style;
3634     Tabbed.UseTab = FormatStyle::UT_Always;
3635     Tabbed.IndentWidth = 8;
3636     Tabbed.TabWidth = 8;
3637     verifyFormat("#ifdef _WIN32\n"
3638                  "#\tdefine A 0\n"
3639                  "#\tifdef VAR2\n"
3640                  "#\t\tdefine B 1\n"
3641                  "#\t\tinclude <someheader.h>\n"
3642                  "#\t\tdefine MACRO          \\\n"
3643                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3644                  "#\tendif\n"
3645                  "#else\n"
3646                  "#\tdefine A 1\n"
3647                  "#endif",
3648                  Tabbed);
3649   }
3650 
3651   // Regression test: Multiline-macro inside include guards.
3652   verifyFormat("#ifndef HEADER_H\n"
3653                "#define HEADER_H\n"
3654                "#define A()        \\\n"
3655                "  int i;           \\\n"
3656                "  int j;\n"
3657                "#endif // HEADER_H",
3658                getLLVMStyleWithColumns(20));
3659 
3660   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3661   // Basic before hash indent tests
3662   verifyFormat("#ifdef _WIN32\n"
3663                "  #define A 0\n"
3664                "  #ifdef VAR2\n"
3665                "    #define B 1\n"
3666                "    #include <someheader.h>\n"
3667                "    #define MACRO                      \\\n"
3668                "      some_very_long_func_aaaaaaaaaa();\n"
3669                "  #endif\n"
3670                "#else\n"
3671                "  #define A 1\n"
3672                "#endif",
3673                Style);
3674   verifyFormat("#if A\n"
3675                "  #define MACRO                        \\\n"
3676                "    void a(int x) {                    \\\n"
3677                "      b();                             \\\n"
3678                "      c();                             \\\n"
3679                "      d();                             \\\n"
3680                "      e();                             \\\n"
3681                "      f();                             \\\n"
3682                "    }\n"
3683                "#endif",
3684                Style);
3685   // Keep comments aligned with indented directives. These
3686   // tests cannot use verifyFormat because messUp manipulates leading
3687   // whitespace.
3688   {
3689     const char *Expected = "void f() {\n"
3690                            "// Aligned to preprocessor.\n"
3691                            "#if 1\n"
3692                            "  // Aligned to code.\n"
3693                            "  int a;\n"
3694                            "  #if 1\n"
3695                            "    // Aligned to preprocessor.\n"
3696                            "    #define A 0\n"
3697                            "  // Aligned to code.\n"
3698                            "  int b;\n"
3699                            "  #endif\n"
3700                            "#endif\n"
3701                            "}";
3702     const char *ToFormat = "void f() {\n"
3703                            "// Aligned to preprocessor.\n"
3704                            "#if 1\n"
3705                            "// Aligned to code.\n"
3706                            "int a;\n"
3707                            "#if 1\n"
3708                            "// Aligned to preprocessor.\n"
3709                            "#define A 0\n"
3710                            "// Aligned to code.\n"
3711                            "int b;\n"
3712                            "#endif\n"
3713                            "#endif\n"
3714                            "}";
3715     EXPECT_EQ(Expected, format(ToFormat, Style));
3716     EXPECT_EQ(Expected, format(Expected, Style));
3717   }
3718   {
3719     const char *Expected = "void f() {\n"
3720                            "/* Aligned to preprocessor. */\n"
3721                            "#if 1\n"
3722                            "  /* Aligned to code. */\n"
3723                            "  int a;\n"
3724                            "  #if 1\n"
3725                            "    /* Aligned to preprocessor. */\n"
3726                            "    #define A 0\n"
3727                            "  /* Aligned to code. */\n"
3728                            "  int b;\n"
3729                            "  #endif\n"
3730                            "#endif\n"
3731                            "}";
3732     const char *ToFormat = "void f() {\n"
3733                            "/* Aligned to preprocessor. */\n"
3734                            "#if 1\n"
3735                            "/* Aligned to code. */\n"
3736                            "int a;\n"
3737                            "#if 1\n"
3738                            "/* Aligned to preprocessor. */\n"
3739                            "#define A 0\n"
3740                            "/* Aligned to code. */\n"
3741                            "int b;\n"
3742                            "#endif\n"
3743                            "#endif\n"
3744                            "}";
3745     EXPECT_EQ(Expected, format(ToFormat, Style));
3746     EXPECT_EQ(Expected, format(Expected, Style));
3747   }
3748 
3749   // Test single comment before preprocessor
3750   verifyFormat("// Comment\n"
3751                "\n"
3752                "#if 1\n"
3753                "#endif",
3754                Style);
3755 }
3756 
3757 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3758   verifyFormat("{\n  { a #c; }\n}");
3759 }
3760 
3761 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3762   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
3763             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3764   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
3765             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3766 }
3767 
3768 TEST_F(FormatTest, EscapedNewlines) {
3769   FormatStyle Narrow = getLLVMStyleWithColumns(11);
3770   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
3771             format("#define A \\\nint i;\\\n  int j;", Narrow));
3772   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3773   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3774   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
3775   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3776 
3777   FormatStyle AlignLeft = getLLVMStyle();
3778   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3779   EXPECT_EQ("#define MACRO(x) \\\n"
3780             "private:         \\\n"
3781             "  int x(int a);\n",
3782             format("#define MACRO(x) \\\n"
3783                    "private:         \\\n"
3784                    "  int x(int a);\n",
3785                    AlignLeft));
3786 
3787   // CRLF line endings
3788   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
3789             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
3790   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3791   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3792   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
3793   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3794   EXPECT_EQ("#define MACRO(x) \\\r\n"
3795             "private:         \\\r\n"
3796             "  int x(int a);\r\n",
3797             format("#define MACRO(x) \\\r\n"
3798                    "private:         \\\r\n"
3799                    "  int x(int a);\r\n",
3800                    AlignLeft));
3801 
3802   FormatStyle DontAlign = getLLVMStyle();
3803   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3804   DontAlign.MaxEmptyLinesToKeep = 3;
3805   // FIXME: can't use verifyFormat here because the newline before
3806   // "public:" is not inserted the first time it's reformatted
3807   EXPECT_EQ("#define A \\\n"
3808             "  class Foo { \\\n"
3809             "    void bar(); \\\n"
3810             "\\\n"
3811             "\\\n"
3812             "\\\n"
3813             "  public: \\\n"
3814             "    void baz(); \\\n"
3815             "  };",
3816             format("#define A \\\n"
3817                    "  class Foo { \\\n"
3818                    "    void bar(); \\\n"
3819                    "\\\n"
3820                    "\\\n"
3821                    "\\\n"
3822                    "  public: \\\n"
3823                    "    void baz(); \\\n"
3824                    "  };",
3825                    DontAlign));
3826 }
3827 
3828 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3829   verifyFormat("#define A \\\n"
3830                "  int v(  \\\n"
3831                "      a); \\\n"
3832                "  int i;",
3833                getLLVMStyleWithColumns(11));
3834 }
3835 
3836 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3837   EXPECT_EQ(
3838       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3839       "                      \\\n"
3840       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3841       "\n"
3842       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3843       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3844       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
3845              "\\\n"
3846              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3847              "  \n"
3848              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3849              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3850 }
3851 
3852 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3853   EXPECT_EQ("int\n"
3854             "#define A\n"
3855             "    a;",
3856             format("int\n#define A\na;"));
3857   verifyFormat("functionCallTo(\n"
3858                "    someOtherFunction(\n"
3859                "        withSomeParameters, whichInSequence,\n"
3860                "        areLongerThanALine(andAnotherCall,\n"
3861                "#define A B\n"
3862                "                           withMoreParamters,\n"
3863                "                           whichStronglyInfluenceTheLayout),\n"
3864                "        andMoreParameters),\n"
3865                "    trailing);",
3866                getLLVMStyleWithColumns(69));
3867   verifyFormat("Foo::Foo()\n"
3868                "#ifdef BAR\n"
3869                "    : baz(0)\n"
3870                "#endif\n"
3871                "{\n"
3872                "}");
3873   verifyFormat("void f() {\n"
3874                "  if (true)\n"
3875                "#ifdef A\n"
3876                "    f(42);\n"
3877                "  x();\n"
3878                "#else\n"
3879                "    g();\n"
3880                "  x();\n"
3881                "#endif\n"
3882                "}");
3883   verifyFormat("void f(param1, param2,\n"
3884                "       param3,\n"
3885                "#ifdef A\n"
3886                "       param4(param5,\n"
3887                "#ifdef A1\n"
3888                "              param6,\n"
3889                "#ifdef A2\n"
3890                "              param7),\n"
3891                "#else\n"
3892                "              param8),\n"
3893                "       param9,\n"
3894                "#endif\n"
3895                "       param10,\n"
3896                "#endif\n"
3897                "       param11)\n"
3898                "#else\n"
3899                "       param12)\n"
3900                "#endif\n"
3901                "{\n"
3902                "  x();\n"
3903                "}",
3904                getLLVMStyleWithColumns(28));
3905   verifyFormat("#if 1\n"
3906                "int i;");
3907   verifyFormat("#if 1\n"
3908                "#endif\n"
3909                "#if 1\n"
3910                "#else\n"
3911                "#endif\n");
3912   verifyFormat("DEBUG({\n"
3913                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3914                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
3915                "});\n"
3916                "#if a\n"
3917                "#else\n"
3918                "#endif");
3919 
3920   verifyIncompleteFormat("void f(\n"
3921                          "#if A\n"
3922                          ");\n"
3923                          "#else\n"
3924                          "#endif");
3925 }
3926 
3927 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
3928   verifyFormat("#endif\n"
3929                "#if B");
3930 }
3931 
3932 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
3933   FormatStyle SingleLine = getLLVMStyle();
3934   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
3935   verifyFormat("#if 0\n"
3936                "#elif 1\n"
3937                "#endif\n"
3938                "void foo() {\n"
3939                "  if (test) foo2();\n"
3940                "}",
3941                SingleLine);
3942 }
3943 
3944 TEST_F(FormatTest, LayoutBlockInsideParens) {
3945   verifyFormat("functionCall({ int i; });");
3946   verifyFormat("functionCall({\n"
3947                "  int i;\n"
3948                "  int j;\n"
3949                "});");
3950   verifyFormat("functionCall(\n"
3951                "    {\n"
3952                "      int i;\n"
3953                "      int j;\n"
3954                "    },\n"
3955                "    aaaa, bbbb, cccc);");
3956   verifyFormat("functionA(functionB({\n"
3957                "            int i;\n"
3958                "            int j;\n"
3959                "          }),\n"
3960                "          aaaa, bbbb, cccc);");
3961   verifyFormat("functionCall(\n"
3962                "    {\n"
3963                "      int i;\n"
3964                "      int j;\n"
3965                "    },\n"
3966                "    aaaa, bbbb, // comment\n"
3967                "    cccc);");
3968   verifyFormat("functionA(functionB({\n"
3969                "            int i;\n"
3970                "            int j;\n"
3971                "          }),\n"
3972                "          aaaa, bbbb, // comment\n"
3973                "          cccc);");
3974   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
3975   verifyFormat("functionCall(aaaa, bbbb, {\n"
3976                "  int i;\n"
3977                "  int j;\n"
3978                "});");
3979   verifyFormat(
3980       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
3981       "    {\n"
3982       "      int i; // break\n"
3983       "    },\n"
3984       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
3985       "                                     ccccccccccccccccc));");
3986   verifyFormat("DEBUG({\n"
3987                "  if (a)\n"
3988                "    f();\n"
3989                "});");
3990 }
3991 
3992 TEST_F(FormatTest, LayoutBlockInsideStatement) {
3993   EXPECT_EQ("SOME_MACRO { int i; }\n"
3994             "int i;",
3995             format("  SOME_MACRO  {int i;}  int i;"));
3996 }
3997 
3998 TEST_F(FormatTest, LayoutNestedBlocks) {
3999   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
4000                "  struct s {\n"
4001                "    int i;\n"
4002                "  };\n"
4003                "  s kBitsToOs[] = {{10}};\n"
4004                "  for (int i = 0; i < 10; ++i)\n"
4005                "    return;\n"
4006                "}");
4007   verifyFormat("call(parameter, {\n"
4008                "  something();\n"
4009                "  // Comment using all columns.\n"
4010                "  somethingelse();\n"
4011                "});",
4012                getLLVMStyleWithColumns(40));
4013   verifyFormat("DEBUG( //\n"
4014                "    { f(); }, a);");
4015   verifyFormat("DEBUG( //\n"
4016                "    {\n"
4017                "      f(); //\n"
4018                "    },\n"
4019                "    a);");
4020 
4021   EXPECT_EQ("call(parameter, {\n"
4022             "  something();\n"
4023             "  // Comment too\n"
4024             "  // looooooooooong.\n"
4025             "  somethingElse();\n"
4026             "});",
4027             format("call(parameter, {\n"
4028                    "  something();\n"
4029                    "  // Comment too looooooooooong.\n"
4030                    "  somethingElse();\n"
4031                    "});",
4032                    getLLVMStyleWithColumns(29)));
4033   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
4034   EXPECT_EQ("DEBUG({ // comment\n"
4035             "  int i;\n"
4036             "});",
4037             format("DEBUG({ // comment\n"
4038                    "int  i;\n"
4039                    "});"));
4040   EXPECT_EQ("DEBUG({\n"
4041             "  int i;\n"
4042             "\n"
4043             "  // comment\n"
4044             "  int j;\n"
4045             "});",
4046             format("DEBUG({\n"
4047                    "  int  i;\n"
4048                    "\n"
4049                    "  // comment\n"
4050                    "  int  j;\n"
4051                    "});"));
4052 
4053   verifyFormat("DEBUG({\n"
4054                "  if (a)\n"
4055                "    return;\n"
4056                "});");
4057   verifyGoogleFormat("DEBUG({\n"
4058                      "  if (a) return;\n"
4059                      "});");
4060   FormatStyle Style = getGoogleStyle();
4061   Style.ColumnLimit = 45;
4062   verifyFormat("Debug(\n"
4063                "    aaaaa,\n"
4064                "    {\n"
4065                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
4066                "    },\n"
4067                "    a);",
4068                Style);
4069 
4070   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
4071 
4072   verifyNoCrash("^{v^{a}}");
4073 }
4074 
4075 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
4076   EXPECT_EQ("#define MACRO()                     \\\n"
4077             "  Debug(aaa, /* force line break */ \\\n"
4078             "        {                           \\\n"
4079             "          int i;                    \\\n"
4080             "          int j;                    \\\n"
4081             "        })",
4082             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
4083                    "          {  int   i;  int  j;   })",
4084                    getGoogleStyle()));
4085 
4086   EXPECT_EQ("#define A                                       \\\n"
4087             "  [] {                                          \\\n"
4088             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
4089             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
4090             "  }",
4091             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4092                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
4093                    getGoogleStyle()));
4094 }
4095 
4096 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
4097   EXPECT_EQ("{}", format("{}"));
4098   verifyFormat("enum E {};");
4099   verifyFormat("enum E {}");
4100   FormatStyle Style = getLLVMStyle();
4101   Style.SpaceInEmptyBlock = true;
4102   EXPECT_EQ("void f() { }", format("void f() {}", Style));
4103   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
4104   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4105 }
4106 
4107 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
4108   FormatStyle Style = getLLVMStyle();
4109   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
4110   Style.MacroBlockEnd = "^[A-Z_]+_END$";
4111   verifyFormat("FOO_BEGIN\n"
4112                "  FOO_ENTRY\n"
4113                "FOO_END",
4114                Style);
4115   verifyFormat("FOO_BEGIN\n"
4116                "  NESTED_FOO_BEGIN\n"
4117                "    NESTED_FOO_ENTRY\n"
4118                "  NESTED_FOO_END\n"
4119                "FOO_END",
4120                Style);
4121   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
4122                "  int x;\n"
4123                "  x = 1;\n"
4124                "FOO_END(Baz)",
4125                Style);
4126 }
4127 
4128 //===----------------------------------------------------------------------===//
4129 // Line break tests.
4130 //===----------------------------------------------------------------------===//
4131 
4132 TEST_F(FormatTest, PreventConfusingIndents) {
4133   verifyFormat(
4134       "void f() {\n"
4135       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
4136       "                         parameter, parameter, parameter)),\n"
4137       "                     SecondLongCall(parameter));\n"
4138       "}");
4139   verifyFormat(
4140       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4141       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4142       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4143       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
4144   verifyFormat(
4145       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4146       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
4147       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4148       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
4149   verifyFormat(
4150       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
4151       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
4152       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
4153       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
4154   verifyFormat("int a = bbbb && ccc &&\n"
4155                "        fffff(\n"
4156                "#define A Just forcing a new line\n"
4157                "            ddd);");
4158 }
4159 
4160 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
4161   verifyFormat(
4162       "bool aaaaaaa =\n"
4163       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
4164       "    bbbbbbbb();");
4165   verifyFormat(
4166       "bool aaaaaaa =\n"
4167       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
4168       "    bbbbbbbb();");
4169 
4170   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4171                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
4172                "    ccccccccc == ddddddddddd;");
4173   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4174                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
4175                "    ccccccccc == ddddddddddd;");
4176   verifyFormat(
4177       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
4178       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
4179       "    ccccccccc == ddddddddddd;");
4180 
4181   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4182                "                 aaaaaa) &&\n"
4183                "         bbbbbb && cccccc;");
4184   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4185                "                 aaaaaa) >>\n"
4186                "         bbbbbb;");
4187   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
4188                "    SourceMgr.getSpellingColumnNumber(\n"
4189                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
4190                "    1);");
4191 
4192   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4193                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
4194                "    cccccc) {\n}");
4195   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4196                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4197                "              cccccc) {\n}");
4198   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4199                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4200                "              cccccc) {\n}");
4201   verifyFormat("b = a &&\n"
4202                "    // Comment\n"
4203                "    b.c && d;");
4204 
4205   // If the LHS of a comparison is not a binary expression itself, the
4206   // additional linebreak confuses many people.
4207   verifyFormat(
4208       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4209       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
4210       "}");
4211   verifyFormat(
4212       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4213       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4214       "}");
4215   verifyFormat(
4216       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
4217       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4218       "}");
4219   verifyFormat(
4220       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4221       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
4222       "}");
4223   // Even explicit parentheses stress the precedence enough to make the
4224   // additional break unnecessary.
4225   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4226                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4227                "}");
4228   // This cases is borderline, but with the indentation it is still readable.
4229   verifyFormat(
4230       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4231       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4232       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4233       "}",
4234       getLLVMStyleWithColumns(75));
4235 
4236   // If the LHS is a binary expression, we should still use the additional break
4237   // as otherwise the formatting hides the operator precedence.
4238   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4239                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4240                "    5) {\n"
4241                "}");
4242   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4243                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4244                "    5) {\n"
4245                "}");
4246 
4247   FormatStyle OnePerLine = getLLVMStyle();
4248   OnePerLine.BinPackParameters = false;
4249   verifyFormat(
4250       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4251       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4252       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4253       OnePerLine);
4254 
4255   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4256                "                .aaa(aaaaaaaaaaaaa) *\n"
4257                "            aaaaaaa +\n"
4258                "        aaaaaaa;",
4259                getLLVMStyleWithColumns(40));
4260 }
4261 
4262 TEST_F(FormatTest, ExpressionIndentation) {
4263   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4264                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4265                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4266                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4267                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4268                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4269                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4270                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4271                "                 ccccccccccccccccccccccccccccccccccccccccc;");
4272   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4273                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4274                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4275                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4276   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4277                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4278                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4279                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4280   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4281                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4282                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4283                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4284   verifyFormat("if () {\n"
4285                "} else if (aaaaa && bbbbb > // break\n"
4286                "                        ccccc) {\n"
4287                "}");
4288   verifyFormat("if () {\n"
4289                "} else if constexpr (aaaaa && bbbbb > // break\n"
4290                "                                  ccccc) {\n"
4291                "}");
4292   verifyFormat("if () {\n"
4293                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4294                "                                  ccccc) {\n"
4295                "}");
4296   verifyFormat("if () {\n"
4297                "} else if (aaaaa &&\n"
4298                "           bbbbb > // break\n"
4299                "               ccccc &&\n"
4300                "           ddddd) {\n"
4301                "}");
4302 
4303   // Presence of a trailing comment used to change indentation of b.
4304   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4305                "       b;\n"
4306                "return aaaaaaaaaaaaaaaaaaa +\n"
4307                "       b; //",
4308                getLLVMStyleWithColumns(30));
4309 }
4310 
4311 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4312   // Not sure what the best system is here. Like this, the LHS can be found
4313   // immediately above an operator (everything with the same or a higher
4314   // indent). The RHS is aligned right of the operator and so compasses
4315   // everything until something with the same indent as the operator is found.
4316   // FIXME: Is this a good system?
4317   FormatStyle Style = getLLVMStyle();
4318   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4319   verifyFormat(
4320       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4321       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4322       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4323       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4324       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4325       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4326       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4327       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4328       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
4329       Style);
4330   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4331                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4332                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4333                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4334                Style);
4335   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4336                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4337                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4338                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4339                Style);
4340   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4341                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4342                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4343                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4344                Style);
4345   verifyFormat("if () {\n"
4346                "} else if (aaaaa\n"
4347                "           && bbbbb // break\n"
4348                "                  > ccccc) {\n"
4349                "}",
4350                Style);
4351   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4352                "       && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4353                Style);
4354   verifyFormat("return (a)\n"
4355                "       // comment\n"
4356                "       + b;",
4357                Style);
4358   verifyFormat(
4359       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4360       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4361       "             + cc;",
4362       Style);
4363 
4364   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4365                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4366                Style);
4367 
4368   // Forced by comments.
4369   verifyFormat(
4370       "unsigned ContentSize =\n"
4371       "    sizeof(int16_t)   // DWARF ARange version number\n"
4372       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4373       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4374       "    + sizeof(int8_t); // Segment Size (in bytes)");
4375 
4376   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4377                "       == boost::fusion::at_c<1>(iiii).second;",
4378                Style);
4379 
4380   Style.ColumnLimit = 60;
4381   verifyFormat("zzzzzzzzzz\n"
4382                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4383                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4384                Style);
4385 
4386   Style.ColumnLimit = 80;
4387   Style.IndentWidth = 4;
4388   Style.TabWidth = 4;
4389   Style.UseTab = FormatStyle::UT_Always;
4390   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4391   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4392   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4393             "\t&& (someOtherLongishConditionPart1\n"
4394             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4395             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4396                    "(someOtherLongishConditionPart1 || "
4397                    "someOtherEvenLongerNestedConditionPart2);",
4398                    Style));
4399 }
4400 
4401 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
4402   FormatStyle Style = getLLVMStyle();
4403   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4404   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
4405 
4406   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4407                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4408                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4409                "              == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4410                "                         * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4411                "                     + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4412                "          && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4413                "                     * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4414                "                 > ccccccccccccccccccccccccccccccccccccccccc;",
4415                Style);
4416   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4417                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4418                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4419                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4420                Style);
4421   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4422                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4423                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4424                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4425                Style);
4426   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4427                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4428                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4429                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4430                Style);
4431   verifyFormat("if () {\n"
4432                "} else if (aaaaa\n"
4433                "           && bbbbb // break\n"
4434                "                  > ccccc) {\n"
4435                "}",
4436                Style);
4437   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4438                "    && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4439                Style);
4440   verifyFormat("return (a)\n"
4441                "     // comment\n"
4442                "     + b;",
4443                Style);
4444   verifyFormat(
4445       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4446       "               * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4447       "           + cc;",
4448       Style);
4449   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
4450                "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4451                "                        : 3333333333333333;",
4452                Style);
4453   verifyFormat(
4454       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
4455       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
4456       "                                             : eeeeeeeeeeeeeeeeee)\n"
4457       "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4458       "                        : 3333333333333333;",
4459       Style);
4460   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4461                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4462                Style);
4463 
4464   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4465                "    == boost::fusion::at_c<1>(iiii).second;",
4466                Style);
4467 
4468   Style.ColumnLimit = 60;
4469   verifyFormat("zzzzzzzzzzzzz\n"
4470                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4471                "   >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4472                Style);
4473 
4474   // Forced by comments.
4475   Style.ColumnLimit = 80;
4476   verifyFormat(
4477       "unsigned ContentSize\n"
4478       "    = sizeof(int16_t) // DWARF ARange version number\n"
4479       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4480       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4481       "    + sizeof(int8_t); // Segment Size (in bytes)",
4482       Style);
4483 
4484   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4485   verifyFormat(
4486       "unsigned ContentSize =\n"
4487       "    sizeof(int16_t)   // DWARF ARange version number\n"
4488       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4489       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4490       "    + sizeof(int8_t); // Segment Size (in bytes)",
4491       Style);
4492 
4493   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4494   verifyFormat(
4495       "unsigned ContentSize =\n"
4496       "    sizeof(int16_t)   // DWARF ARange version number\n"
4497       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4498       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4499       "    + sizeof(int8_t); // Segment Size (in bytes)",
4500       Style);
4501 }
4502 
4503 TEST_F(FormatTest, EnforcedOperatorWraps) {
4504   // Here we'd like to wrap after the || operators, but a comment is forcing an
4505   // earlier wrap.
4506   verifyFormat("bool x = aaaaa //\n"
4507                "         || bbbbb\n"
4508                "         //\n"
4509                "         || cccc;");
4510 }
4511 
4512 TEST_F(FormatTest, NoOperandAlignment) {
4513   FormatStyle Style = getLLVMStyle();
4514   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4515   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4516                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4517                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4518                Style);
4519   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4520   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4521                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4522                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4523                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4524                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4525                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4526                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4527                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4528                "        > ccccccccccccccccccccccccccccccccccccccccc;",
4529                Style);
4530 
4531   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4532                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4533                "    + cc;",
4534                Style);
4535   verifyFormat("int a = aa\n"
4536                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4537                "        * cccccccccccccccccccccccccccccccccccc;\n",
4538                Style);
4539 
4540   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4541   verifyFormat("return (a > b\n"
4542                "    // comment1\n"
4543                "    // comment2\n"
4544                "    || c);",
4545                Style);
4546 }
4547 
4548 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4549   FormatStyle Style = getLLVMStyle();
4550   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4551   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4552                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4553                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4554                Style);
4555 }
4556 
4557 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4558   FormatStyle Style = getLLVMStyle();
4559   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4560   Style.BinPackArguments = false;
4561   Style.ColumnLimit = 40;
4562   verifyFormat("void test() {\n"
4563                "  someFunction(\n"
4564                "      this + argument + is + quite\n"
4565                "      + long + so + it + gets + wrapped\n"
4566                "      + but + remains + bin - packed);\n"
4567                "}",
4568                Style);
4569   verifyFormat("void test() {\n"
4570                "  someFunction(arg1,\n"
4571                "               this + argument + is\n"
4572                "                   + quite + long + so\n"
4573                "                   + it + gets + wrapped\n"
4574                "                   + but + remains + bin\n"
4575                "                   - packed,\n"
4576                "               arg3);\n"
4577                "}",
4578                Style);
4579   verifyFormat("void test() {\n"
4580                "  someFunction(\n"
4581                "      arg1,\n"
4582                "      this + argument + has\n"
4583                "          + anotherFunc(nested,\n"
4584                "                        calls + whose\n"
4585                "                            + arguments\n"
4586                "                            + are + also\n"
4587                "                            + wrapped,\n"
4588                "                        in + addition)\n"
4589                "          + to + being + bin - packed,\n"
4590                "      arg3);\n"
4591                "}",
4592                Style);
4593 
4594   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4595   verifyFormat("void test() {\n"
4596                "  someFunction(\n"
4597                "      arg1,\n"
4598                "      this + argument + has +\n"
4599                "          anotherFunc(nested,\n"
4600                "                      calls + whose +\n"
4601                "                          arguments +\n"
4602                "                          are + also +\n"
4603                "                          wrapped,\n"
4604                "                      in + addition) +\n"
4605                "          to + being + bin - packed,\n"
4606                "      arg3);\n"
4607                "}",
4608                Style);
4609 }
4610 
4611 TEST_F(FormatTest, ConstructorInitializers) {
4612   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4613   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4614                getLLVMStyleWithColumns(45));
4615   verifyFormat("Constructor()\n"
4616                "    : Inttializer(FitsOnTheLine) {}",
4617                getLLVMStyleWithColumns(44));
4618   verifyFormat("Constructor()\n"
4619                "    : Inttializer(FitsOnTheLine) {}",
4620                getLLVMStyleWithColumns(43));
4621 
4622   verifyFormat("template <typename T>\n"
4623                "Constructor() : Initializer(FitsOnTheLine) {}",
4624                getLLVMStyleWithColumns(45));
4625 
4626   verifyFormat(
4627       "SomeClass::Constructor()\n"
4628       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4629 
4630   verifyFormat(
4631       "SomeClass::Constructor()\n"
4632       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4633       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4634   verifyFormat(
4635       "SomeClass::Constructor()\n"
4636       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4637       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4638   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4639                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4640                "    : aaaaaaaaaa(aaaaaa) {}");
4641 
4642   verifyFormat("Constructor()\n"
4643                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4644                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4645                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4646                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
4647 
4648   verifyFormat("Constructor()\n"
4649                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4650                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4651 
4652   verifyFormat("Constructor(int Parameter = 0)\n"
4653                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4654                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4655   verifyFormat("Constructor()\n"
4656                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4657                "}",
4658                getLLVMStyleWithColumns(60));
4659   verifyFormat("Constructor()\n"
4660                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4661                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4662 
4663   // Here a line could be saved by splitting the second initializer onto two
4664   // lines, but that is not desirable.
4665   verifyFormat("Constructor()\n"
4666                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4667                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
4668                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4669 
4670   FormatStyle OnePerLine = getLLVMStyle();
4671   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4672   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4673   verifyFormat("SomeClass::Constructor()\n"
4674                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4675                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4676                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4677                OnePerLine);
4678   verifyFormat("SomeClass::Constructor()\n"
4679                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4680                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4681                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4682                OnePerLine);
4683   verifyFormat("MyClass::MyClass(int var)\n"
4684                "    : some_var_(var),            // 4 space indent\n"
4685                "      some_other_var_(var + 1) { // lined up\n"
4686                "}",
4687                OnePerLine);
4688   verifyFormat("Constructor()\n"
4689                "    : aaaaa(aaaaaa),\n"
4690                "      aaaaa(aaaaaa),\n"
4691                "      aaaaa(aaaaaa),\n"
4692                "      aaaaa(aaaaaa),\n"
4693                "      aaaaa(aaaaaa) {}",
4694                OnePerLine);
4695   verifyFormat("Constructor()\n"
4696                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4697                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
4698                OnePerLine);
4699   OnePerLine.BinPackParameters = false;
4700   verifyFormat(
4701       "Constructor()\n"
4702       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4703       "          aaaaaaaaaaa().aaa(),\n"
4704       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4705       OnePerLine);
4706   OnePerLine.ColumnLimit = 60;
4707   verifyFormat("Constructor()\n"
4708                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4709                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4710                OnePerLine);
4711 
4712   EXPECT_EQ("Constructor()\n"
4713             "    : // Comment forcing unwanted break.\n"
4714             "      aaaa(aaaa) {}",
4715             format("Constructor() :\n"
4716                    "    // Comment forcing unwanted break.\n"
4717                    "    aaaa(aaaa) {}"));
4718 }
4719 
4720 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4721   FormatStyle Style = getLLVMStyle();
4722   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4723   Style.ColumnLimit = 60;
4724   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4725   Style.AllowAllConstructorInitializersOnNextLine = true;
4726   Style.BinPackParameters = false;
4727 
4728   for (int i = 0; i < 4; ++i) {
4729     // Test all combinations of parameters that should not have an effect.
4730     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4731     Style.AllowAllArgumentsOnNextLine = i & 2;
4732 
4733     Style.AllowAllConstructorInitializersOnNextLine = true;
4734     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4735     verifyFormat("Constructor()\n"
4736                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4737                  Style);
4738     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4739 
4740     Style.AllowAllConstructorInitializersOnNextLine = false;
4741     verifyFormat("Constructor()\n"
4742                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4743                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4744                  Style);
4745     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4746 
4747     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4748     Style.AllowAllConstructorInitializersOnNextLine = true;
4749     verifyFormat("Constructor()\n"
4750                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4751                  Style);
4752 
4753     Style.AllowAllConstructorInitializersOnNextLine = false;
4754     verifyFormat("Constructor()\n"
4755                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4756                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4757                  Style);
4758 
4759     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4760     Style.AllowAllConstructorInitializersOnNextLine = true;
4761     verifyFormat("Constructor() :\n"
4762                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4763                  Style);
4764 
4765     Style.AllowAllConstructorInitializersOnNextLine = false;
4766     verifyFormat("Constructor() :\n"
4767                  "    aaaaaaaaaaaaaaaaaa(a),\n"
4768                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4769                  Style);
4770   }
4771 
4772   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4773   // AllowAllConstructorInitializersOnNextLine in all
4774   // BreakConstructorInitializers modes
4775   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4776   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4777   Style.AllowAllConstructorInitializersOnNextLine = false;
4778   verifyFormat("SomeClassWithALongName::Constructor(\n"
4779                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4780                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4781                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4782                Style);
4783 
4784   Style.AllowAllConstructorInitializersOnNextLine = true;
4785   verifyFormat("SomeClassWithALongName::Constructor(\n"
4786                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4787                "    int bbbbbbbbbbbbb,\n"
4788                "    int cccccccccccccccc)\n"
4789                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4790                Style);
4791 
4792   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4793   Style.AllowAllConstructorInitializersOnNextLine = false;
4794   verifyFormat("SomeClassWithALongName::Constructor(\n"
4795                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4796                "    int bbbbbbbbbbbbb)\n"
4797                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4798                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4799                Style);
4800 
4801   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4802 
4803   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4804   verifyFormat("SomeClassWithALongName::Constructor(\n"
4805                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4806                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4807                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4808                Style);
4809 
4810   Style.AllowAllConstructorInitializersOnNextLine = true;
4811   verifyFormat("SomeClassWithALongName::Constructor(\n"
4812                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4813                "    int bbbbbbbbbbbbb,\n"
4814                "    int cccccccccccccccc)\n"
4815                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4816                Style);
4817 
4818   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4819   Style.AllowAllConstructorInitializersOnNextLine = false;
4820   verifyFormat("SomeClassWithALongName::Constructor(\n"
4821                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4822                "    int bbbbbbbbbbbbb)\n"
4823                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4824                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4825                Style);
4826 
4827   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4828   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4829   verifyFormat("SomeClassWithALongName::Constructor(\n"
4830                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4831                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4832                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4833                Style);
4834 
4835   Style.AllowAllConstructorInitializersOnNextLine = true;
4836   verifyFormat("SomeClassWithALongName::Constructor(\n"
4837                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4838                "    int bbbbbbbbbbbbb,\n"
4839                "    int cccccccccccccccc) :\n"
4840                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4841                Style);
4842 
4843   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4844   Style.AllowAllConstructorInitializersOnNextLine = false;
4845   verifyFormat("SomeClassWithALongName::Constructor(\n"
4846                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4847                "    int bbbbbbbbbbbbb) :\n"
4848                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4849                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4850                Style);
4851 }
4852 
4853 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4854   FormatStyle Style = getLLVMStyle();
4855   Style.ColumnLimit = 60;
4856   Style.BinPackArguments = false;
4857   for (int i = 0; i < 4; ++i) {
4858     // Test all combinations of parameters that should not have an effect.
4859     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4860     Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4861 
4862     Style.AllowAllArgumentsOnNextLine = true;
4863     verifyFormat("void foo() {\n"
4864                  "  FunctionCallWithReallyLongName(\n"
4865                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4866                  "}",
4867                  Style);
4868     Style.AllowAllArgumentsOnNextLine = false;
4869     verifyFormat("void foo() {\n"
4870                  "  FunctionCallWithReallyLongName(\n"
4871                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4872                  "      bbbbbbbbbbbb);\n"
4873                  "}",
4874                  Style);
4875 
4876     Style.AllowAllArgumentsOnNextLine = true;
4877     verifyFormat("void foo() {\n"
4878                  "  auto VariableWithReallyLongName = {\n"
4879                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4880                  "}",
4881                  Style);
4882     Style.AllowAllArgumentsOnNextLine = false;
4883     verifyFormat("void foo() {\n"
4884                  "  auto VariableWithReallyLongName = {\n"
4885                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4886                  "      bbbbbbbbbbbb};\n"
4887                  "}",
4888                  Style);
4889   }
4890 
4891   // This parameter should not affect declarations.
4892   Style.BinPackParameters = false;
4893   Style.AllowAllArgumentsOnNextLine = false;
4894   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4895   verifyFormat("void FunctionCallWithReallyLongName(\n"
4896                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
4897                Style);
4898   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4899   verifyFormat("void FunctionCallWithReallyLongName(\n"
4900                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
4901                "    int bbbbbbbbbbbb);",
4902                Style);
4903 }
4904 
4905 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
4906   FormatStyle Style = getLLVMStyle();
4907   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4908 
4909   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4910   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
4911                getStyleWithColumns(Style, 45));
4912   verifyFormat("Constructor() :\n"
4913                "    Initializer(FitsOnTheLine) {}",
4914                getStyleWithColumns(Style, 44));
4915   verifyFormat("Constructor() :\n"
4916                "    Initializer(FitsOnTheLine) {}",
4917                getStyleWithColumns(Style, 43));
4918 
4919   verifyFormat("template <typename T>\n"
4920                "Constructor() : Initializer(FitsOnTheLine) {}",
4921                getStyleWithColumns(Style, 50));
4922   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4923   verifyFormat(
4924       "SomeClass::Constructor() :\n"
4925       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4926       Style);
4927 
4928   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
4929   verifyFormat(
4930       "SomeClass::Constructor() :\n"
4931       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4932       Style);
4933 
4934   verifyFormat(
4935       "SomeClass::Constructor() :\n"
4936       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4937       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4938       Style);
4939   verifyFormat(
4940       "SomeClass::Constructor() :\n"
4941       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4942       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4943       Style);
4944   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4945                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4946                "    aaaaaaaaaa(aaaaaa) {}",
4947                Style);
4948 
4949   verifyFormat("Constructor() :\n"
4950                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4951                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4952                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4953                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
4954                Style);
4955 
4956   verifyFormat("Constructor() :\n"
4957                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4958                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4959                Style);
4960 
4961   verifyFormat("Constructor(int Parameter = 0) :\n"
4962                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4963                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
4964                Style);
4965   verifyFormat("Constructor() :\n"
4966                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4967                "}",
4968                getStyleWithColumns(Style, 60));
4969   verifyFormat("Constructor() :\n"
4970                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4971                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
4972                Style);
4973 
4974   // Here a line could be saved by splitting the second initializer onto two
4975   // lines, but that is not desirable.
4976   verifyFormat("Constructor() :\n"
4977                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4978                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
4979                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4980                Style);
4981 
4982   FormatStyle OnePerLine = Style;
4983   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4984   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
4985   verifyFormat("SomeClass::Constructor() :\n"
4986                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4987                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4988                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4989                OnePerLine);
4990   verifyFormat("SomeClass::Constructor() :\n"
4991                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4992                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4993                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4994                OnePerLine);
4995   verifyFormat("MyClass::MyClass(int var) :\n"
4996                "    some_var_(var),            // 4 space indent\n"
4997                "    some_other_var_(var + 1) { // lined up\n"
4998                "}",
4999                OnePerLine);
5000   verifyFormat("Constructor() :\n"
5001                "    aaaaa(aaaaaa),\n"
5002                "    aaaaa(aaaaaa),\n"
5003                "    aaaaa(aaaaaa),\n"
5004                "    aaaaa(aaaaaa),\n"
5005                "    aaaaa(aaaaaa) {}",
5006                OnePerLine);
5007   verifyFormat("Constructor() :\n"
5008                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5009                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
5010                OnePerLine);
5011   OnePerLine.BinPackParameters = false;
5012   verifyFormat("Constructor() :\n"
5013                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5014                "        aaaaaaaaaaa().aaa(),\n"
5015                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5016                OnePerLine);
5017   OnePerLine.ColumnLimit = 60;
5018   verifyFormat("Constructor() :\n"
5019                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
5020                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
5021                OnePerLine);
5022 
5023   EXPECT_EQ("Constructor() :\n"
5024             "    // Comment forcing unwanted break.\n"
5025             "    aaaa(aaaa) {}",
5026             format("Constructor() :\n"
5027                    "    // Comment forcing unwanted break.\n"
5028                    "    aaaa(aaaa) {}",
5029                    Style));
5030 
5031   Style.ColumnLimit = 0;
5032   verifyFormat("SomeClass::Constructor() :\n"
5033                "    a(a) {}",
5034                Style);
5035   verifyFormat("SomeClass::Constructor() noexcept :\n"
5036                "    a(a) {}",
5037                Style);
5038   verifyFormat("SomeClass::Constructor() :\n"
5039                "    a(a), b(b), c(c) {}",
5040                Style);
5041   verifyFormat("SomeClass::Constructor() :\n"
5042                "    a(a) {\n"
5043                "  foo();\n"
5044                "  bar();\n"
5045                "}",
5046                Style);
5047 
5048   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5049   verifyFormat("SomeClass::Constructor() :\n"
5050                "    a(a), b(b), c(c) {\n"
5051                "}",
5052                Style);
5053   verifyFormat("SomeClass::Constructor() :\n"
5054                "    a(a) {\n"
5055                "}",
5056                Style);
5057 
5058   Style.ColumnLimit = 80;
5059   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5060   Style.ConstructorInitializerIndentWidth = 2;
5061   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5062   verifyFormat("SomeClass::Constructor() :\n"
5063                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5064                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5065                Style);
5066 
5067   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5068   // well
5069   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5070   verifyFormat(
5071       "class SomeClass\n"
5072       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5073       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5074       Style);
5075   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5076   verifyFormat(
5077       "class SomeClass\n"
5078       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5079       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5080       Style);
5081   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5082   verifyFormat(
5083       "class SomeClass :\n"
5084       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5085       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5086       Style);
5087 }
5088 
5089 #ifndef EXPENSIVE_CHECKS
5090 // Expensive checks enables libstdc++ checking which includes validating the
5091 // state of ranges used in std::priority_queue - this blows out the
5092 // runtime/scalability of the function and makes this test unacceptably slow.
5093 TEST_F(FormatTest, MemoizationTests) {
5094   // This breaks if the memoization lookup does not take \c Indent and
5095   // \c LastSpace into account.
5096   verifyFormat(
5097       "extern CFRunLoopTimerRef\n"
5098       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5099       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
5100       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
5101       "                     CFRunLoopTimerContext *context) {}");
5102 
5103   // Deep nesting somewhat works around our memoization.
5104   verifyFormat(
5105       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5106       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5107       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5108       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5109       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
5110       getLLVMStyleWithColumns(65));
5111   verifyFormat(
5112       "aaaaa(\n"
5113       "    aaaaa,\n"
5114       "    aaaaa(\n"
5115       "        aaaaa,\n"
5116       "        aaaaa(\n"
5117       "            aaaaa,\n"
5118       "            aaaaa(\n"
5119       "                aaaaa,\n"
5120       "                aaaaa(\n"
5121       "                    aaaaa,\n"
5122       "                    aaaaa(\n"
5123       "                        aaaaa,\n"
5124       "                        aaaaa(\n"
5125       "                            aaaaa,\n"
5126       "                            aaaaa(\n"
5127       "                                aaaaa,\n"
5128       "                                aaaaa(\n"
5129       "                                    aaaaa,\n"
5130       "                                    aaaaa(\n"
5131       "                                        aaaaa,\n"
5132       "                                        aaaaa(\n"
5133       "                                            aaaaa,\n"
5134       "                                            aaaaa(\n"
5135       "                                                aaaaa,\n"
5136       "                                                aaaaa))))))))))));",
5137       getLLVMStyleWithColumns(65));
5138   verifyFormat(
5139       "a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(), a), a), a), a),\n"
5140       "                                  a),\n"
5141       "                                a),\n"
5142       "                              a),\n"
5143       "                            a),\n"
5144       "                          a),\n"
5145       "                        a),\n"
5146       "                      a),\n"
5147       "                    a),\n"
5148       "                  a),\n"
5149       "                a),\n"
5150       "              a),\n"
5151       "            a),\n"
5152       "          a),\n"
5153       "        a),\n"
5154       "      a),\n"
5155       "    a),\n"
5156       "  a)",
5157       getLLVMStyleWithColumns(65));
5158 
5159   // This test takes VERY long when memoization is broken.
5160   FormatStyle OnePerLine = getLLVMStyle();
5161   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5162   OnePerLine.BinPackParameters = false;
5163   std::string input = "Constructor()\n"
5164                       "    : aaaa(a,\n";
5165   for (unsigned i = 0, e = 80; i != e; ++i) {
5166     input += "           a,\n";
5167   }
5168   input += "           a) {}";
5169   verifyFormat(input, OnePerLine);
5170 }
5171 #endif
5172 
5173 TEST_F(FormatTest, BreaksAsHighAsPossible) {
5174   verifyFormat(
5175       "void f() {\n"
5176       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5177       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5178       "    f();\n"
5179       "}");
5180   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5181                "    Intervals[i - 1].getRange().getLast()) {\n}");
5182 }
5183 
5184 TEST_F(FormatTest, BreaksFunctionDeclarations) {
5185   // Principially, we break function declarations in a certain order:
5186   // 1) break amongst arguments.
5187   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5188                "                              Cccccccccccccc cccccccccccccc);");
5189   verifyFormat("template <class TemplateIt>\n"
5190                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5191                "                            TemplateIt *stop) {}");
5192 
5193   // 2) break after return type.
5194   verifyFormat(
5195       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5196       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5197       getGoogleStyle());
5198 
5199   // 3) break after (.
5200   verifyFormat(
5201       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5202       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5203       getGoogleStyle());
5204 
5205   // 4) break before after nested name specifiers.
5206   verifyFormat(
5207       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5208       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5209       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5210       getGoogleStyle());
5211 
5212   // However, there are exceptions, if a sufficient amount of lines can be
5213   // saved.
5214   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5215   // more adjusting.
5216   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5217                "                                  Cccccccccccccc cccccccccc,\n"
5218                "                                  Cccccccccccccc cccccccccc,\n"
5219                "                                  Cccccccccccccc cccccccccc,\n"
5220                "                                  Cccccccccccccc cccccccccc);");
5221   verifyFormat(
5222       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5223       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5224       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5225       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5226       getGoogleStyle());
5227   verifyFormat(
5228       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5229       "                                          Cccccccccccccc cccccccccc,\n"
5230       "                                          Cccccccccccccc cccccccccc,\n"
5231       "                                          Cccccccccccccc cccccccccc,\n"
5232       "                                          Cccccccccccccc cccccccccc,\n"
5233       "                                          Cccccccccccccc cccccccccc,\n"
5234       "                                          Cccccccccccccc cccccccccc);");
5235   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5236                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5237                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5238                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5239                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5240 
5241   // Break after multi-line parameters.
5242   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5243                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5244                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5245                "    bbbb bbbb);");
5246   verifyFormat("void SomeLoooooooooooongFunction(\n"
5247                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5248                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5249                "    int bbbbbbbbbbbbb);");
5250 
5251   // Treat overloaded operators like other functions.
5252   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5253                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5254   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5255                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5256   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5257                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5258   verifyGoogleFormat(
5259       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5260       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5261   verifyGoogleFormat(
5262       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5263       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5264   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5265                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5266   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5267                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5268   verifyGoogleFormat(
5269       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5270       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5271       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5272   verifyGoogleFormat("template <typename T>\n"
5273                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5274                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5275                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5276 
5277   FormatStyle Style = getLLVMStyle();
5278   Style.PointerAlignment = FormatStyle::PAS_Left;
5279   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5280                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5281                Style);
5282   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5283                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5284                Style);
5285 }
5286 
5287 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5288   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5289   // Prefer keeping `::` followed by `operator` together.
5290   EXPECT_EQ("const aaaa::bbbbbbb &\n"
5291             "ccccccccc::operator++() {\n"
5292             "  stuff();\n"
5293             "}",
5294             format("const aaaa::bbbbbbb\n"
5295                    "&ccccccccc::operator++() { stuff(); }",
5296                    getLLVMStyleWithColumns(40)));
5297 }
5298 
5299 TEST_F(FormatTest, TrailingReturnType) {
5300   verifyFormat("auto foo() -> int;\n");
5301   // correct trailing return type spacing
5302   verifyFormat("auto operator->() -> int;\n");
5303   verifyFormat("auto operator++(int) -> int;\n");
5304 
5305   verifyFormat("struct S {\n"
5306                "  auto bar() const -> int;\n"
5307                "};");
5308   verifyFormat("template <size_t Order, typename T>\n"
5309                "auto load_img(const std::string &filename)\n"
5310                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
5311   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5312                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5313   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5314   verifyFormat("template <typename T>\n"
5315                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5316                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5317 
5318   // Not trailing return types.
5319   verifyFormat("void f() { auto a = b->c(); }");
5320 }
5321 
5322 TEST_F(FormatTest, DeductionGuides) {
5323   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5324   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5325   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5326   verifyFormat(
5327       "template <class... T>\n"
5328       "array(T &&...t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5329   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5330   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5331   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5332   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5333   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5334   verifyFormat("template <class T> x() -> x<1>;");
5335   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5336 
5337   // Ensure not deduction guides.
5338   verifyFormat("c()->f<int>();");
5339   verifyFormat("x()->foo<1>;");
5340   verifyFormat("x = p->foo<3>();");
5341   verifyFormat("x()->x<1>();");
5342   verifyFormat("x()->x<1>;");
5343 }
5344 
5345 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5346   // Avoid breaking before trailing 'const' or other trailing annotations, if
5347   // they are not function-like.
5348   FormatStyle Style = getGoogleStyle();
5349   Style.ColumnLimit = 47;
5350   verifyFormat("void someLongFunction(\n"
5351                "    int someLoooooooooooooongParameter) const {\n}",
5352                getLLVMStyleWithColumns(47));
5353   verifyFormat("LoooooongReturnType\n"
5354                "someLoooooooongFunction() const {}",
5355                getLLVMStyleWithColumns(47));
5356   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5357                "    const {}",
5358                Style);
5359   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5360                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5361   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5362                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5363   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5364                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5365   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5366                "                   aaaaaaaaaaa aaaaa) const override;");
5367   verifyGoogleFormat(
5368       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5369       "    const override;");
5370 
5371   // Even if the first parameter has to be wrapped.
5372   verifyFormat("void someLongFunction(\n"
5373                "    int someLongParameter) const {}",
5374                getLLVMStyleWithColumns(46));
5375   verifyFormat("void someLongFunction(\n"
5376                "    int someLongParameter) const {}",
5377                Style);
5378   verifyFormat("void someLongFunction(\n"
5379                "    int someLongParameter) override {}",
5380                Style);
5381   verifyFormat("void someLongFunction(\n"
5382                "    int someLongParameter) OVERRIDE {}",
5383                Style);
5384   verifyFormat("void someLongFunction(\n"
5385                "    int someLongParameter) final {}",
5386                Style);
5387   verifyFormat("void someLongFunction(\n"
5388                "    int someLongParameter) FINAL {}",
5389                Style);
5390   verifyFormat("void someLongFunction(\n"
5391                "    int parameter) const override {}",
5392                Style);
5393 
5394   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5395   verifyFormat("void someLongFunction(\n"
5396                "    int someLongParameter) const\n"
5397                "{\n"
5398                "}",
5399                Style);
5400 
5401   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5402   verifyFormat("void someLongFunction(\n"
5403                "    int someLongParameter) const\n"
5404                "  {\n"
5405                "  }",
5406                Style);
5407 
5408   // Unless these are unknown annotations.
5409   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5410                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5411                "    LONG_AND_UGLY_ANNOTATION;");
5412 
5413   // Breaking before function-like trailing annotations is fine to keep them
5414   // close to their arguments.
5415   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5416                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5417   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5418                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5419   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5420                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5421   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5422                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5423   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5424 
5425   verifyFormat(
5426       "void aaaaaaaaaaaaaaaaaa()\n"
5427       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5428       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5429   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5430                "    __attribute__((unused));");
5431   verifyGoogleFormat(
5432       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5433       "    GUARDED_BY(aaaaaaaaaaaa);");
5434   verifyGoogleFormat(
5435       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5436       "    GUARDED_BY(aaaaaaaaaaaa);");
5437   verifyGoogleFormat(
5438       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5439       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5440   verifyGoogleFormat(
5441       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5442       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5443 }
5444 
5445 TEST_F(FormatTest, FunctionAnnotations) {
5446   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5447                "int OldFunction(const string &parameter) {}");
5448   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5449                "string OldFunction(const string &parameter) {}");
5450   verifyFormat("template <typename T>\n"
5451                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5452                "string OldFunction(const string &parameter) {}");
5453 
5454   // Not function annotations.
5455   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5456                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5457   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5458                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5459   verifyFormat("MACRO(abc).function() // wrap\n"
5460                "    << abc;");
5461   verifyFormat("MACRO(abc)->function() // wrap\n"
5462                "    << abc;");
5463   verifyFormat("MACRO(abc)::function() // wrap\n"
5464                "    << abc;");
5465 }
5466 
5467 TEST_F(FormatTest, BreaksDesireably) {
5468   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5469                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5470                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5471   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5472                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5473                "}");
5474 
5475   verifyFormat(
5476       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5477       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5478 
5479   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5480                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5481                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5482 
5483   verifyFormat(
5484       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5485       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5486       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5487       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5488       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5489 
5490   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5491                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5492 
5493   verifyFormat(
5494       "void f() {\n"
5495       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5496       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5497       "}");
5498   verifyFormat(
5499       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5500       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5501   verifyFormat(
5502       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5503       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5504   verifyFormat(
5505       "aaaaaa(aaa,\n"
5506       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5507       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5508       "       aaaa);");
5509   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5510                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5511                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5512 
5513   // Indent consistently independent of call expression and unary operator.
5514   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5515                "    dddddddddddddddddddddddddddddd));");
5516   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5517                "    dddddddddddddddddddddddddddddd));");
5518   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5519                "    dddddddddddddddddddddddddddddd));");
5520 
5521   // This test case breaks on an incorrect memoization, i.e. an optimization not
5522   // taking into account the StopAt value.
5523   verifyFormat(
5524       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5525       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5526       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5527       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5528 
5529   verifyFormat("{\n  {\n    {\n"
5530                "      Annotation.SpaceRequiredBefore =\n"
5531                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5532                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5533                "    }\n  }\n}");
5534 
5535   // Break on an outer level if there was a break on an inner level.
5536   EXPECT_EQ("f(g(h(a, // comment\n"
5537             "      b, c),\n"
5538             "    d, e),\n"
5539             "  x, y);",
5540             format("f(g(h(a, // comment\n"
5541                    "    b, c), d, e), x, y);"));
5542 
5543   // Prefer breaking similar line breaks.
5544   verifyFormat(
5545       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5546       "                             NSTrackingMouseEnteredAndExited |\n"
5547       "                             NSTrackingActiveAlways;");
5548 }
5549 
5550 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5551   FormatStyle NoBinPacking = getGoogleStyle();
5552   NoBinPacking.BinPackParameters = false;
5553   NoBinPacking.BinPackArguments = true;
5554   verifyFormat("void f() {\n"
5555                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5556                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5557                "}",
5558                NoBinPacking);
5559   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5560                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5561                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5562                NoBinPacking);
5563 
5564   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5565   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5566                "                        vector<int> bbbbbbbbbbbbbbb);",
5567                NoBinPacking);
5568   // FIXME: This behavior difference is probably not wanted. However, currently
5569   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5570   // template arguments from BreakBeforeParameter being set because of the
5571   // one-per-line formatting.
5572   verifyFormat(
5573       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5574       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5575       NoBinPacking);
5576   verifyFormat(
5577       "void fffffffffff(\n"
5578       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5579       "        aaaaaaaaaa);");
5580 }
5581 
5582 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5583   FormatStyle NoBinPacking = getGoogleStyle();
5584   NoBinPacking.BinPackParameters = false;
5585   NoBinPacking.BinPackArguments = false;
5586   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5587                "  aaaaaaaaaaaaaaaaaaaa,\n"
5588                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5589                NoBinPacking);
5590   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5591                "        aaaaaaaaaaaaa,\n"
5592                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5593                NoBinPacking);
5594   verifyFormat(
5595       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5596       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5597       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5598       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5599       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5600       NoBinPacking);
5601   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5602                "    .aaaaaaaaaaaaaaaaaa();",
5603                NoBinPacking);
5604   verifyFormat("void f() {\n"
5605                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5606                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5607                "}",
5608                NoBinPacking);
5609 
5610   verifyFormat(
5611       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5612       "             aaaaaaaaaaaa,\n"
5613       "             aaaaaaaaaaaa);",
5614       NoBinPacking);
5615   verifyFormat(
5616       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5617       "                               ddddddddddddddddddddddddddddd),\n"
5618       "             test);",
5619       NoBinPacking);
5620 
5621   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5622                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5623                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5624                "    aaaaaaaaaaaaaaaaaa;",
5625                NoBinPacking);
5626   verifyFormat("a(\"a\"\n"
5627                "  \"a\",\n"
5628                "  a);");
5629 
5630   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5631   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5632                "                aaaaaaaaa,\n"
5633                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5634                NoBinPacking);
5635   verifyFormat(
5636       "void f() {\n"
5637       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5638       "      .aaaaaaa();\n"
5639       "}",
5640       NoBinPacking);
5641   verifyFormat(
5642       "template <class SomeType, class SomeOtherType>\n"
5643       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5644       NoBinPacking);
5645 }
5646 
5647 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5648   FormatStyle Style = getLLVMStyleWithColumns(15);
5649   Style.ExperimentalAutoDetectBinPacking = true;
5650   EXPECT_EQ("aaa(aaaa,\n"
5651             "    aaaa,\n"
5652             "    aaaa);\n"
5653             "aaa(aaaa,\n"
5654             "    aaaa,\n"
5655             "    aaaa);",
5656             format("aaa(aaaa,\n" // one-per-line
5657                    "  aaaa,\n"
5658                    "    aaaa  );\n"
5659                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5660                    Style));
5661   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5662             "    aaaa);\n"
5663             "aaa(aaaa, aaaa,\n"
5664             "    aaaa);",
5665             format("aaa(aaaa,  aaaa,\n" // bin-packed
5666                    "    aaaa  );\n"
5667                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5668                    Style));
5669 }
5670 
5671 TEST_F(FormatTest, FormatsBuilderPattern) {
5672   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5673                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5674                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5675                "    .StartsWith(\".init\", ORDER_INIT)\n"
5676                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5677                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5678                "    .Default(ORDER_TEXT);\n");
5679 
5680   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5681                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5682   verifyFormat("aaaaaaa->aaaaaaa\n"
5683                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5684                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5685                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5686   verifyFormat(
5687       "aaaaaaa->aaaaaaa\n"
5688       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5689       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5690   verifyFormat(
5691       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5692       "    aaaaaaaaaaaaaa);");
5693   verifyFormat(
5694       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5695       "    aaaaaa->aaaaaaaaaaaa()\n"
5696       "        ->aaaaaaaaaaaaaaaa(\n"
5697       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5698       "        ->aaaaaaaaaaaaaaaaa();");
5699   verifyGoogleFormat(
5700       "void f() {\n"
5701       "  someo->Add((new util::filetools::Handler(dir))\n"
5702       "                 ->OnEvent1(NewPermanentCallback(\n"
5703       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5704       "                 ->OnEvent2(NewPermanentCallback(\n"
5705       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5706       "                 ->OnEvent3(NewPermanentCallback(\n"
5707       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5708       "                 ->OnEvent5(NewPermanentCallback(\n"
5709       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5710       "                 ->OnEvent6(NewPermanentCallback(\n"
5711       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5712       "}");
5713 
5714   verifyFormat(
5715       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5716   verifyFormat("aaaaaaaaaaaaaaa()\n"
5717                "    .aaaaaaaaaaaaaaa()\n"
5718                "    .aaaaaaaaaaaaaaa()\n"
5719                "    .aaaaaaaaaaaaaaa()\n"
5720                "    .aaaaaaaaaaaaaaa();");
5721   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5722                "    .aaaaaaaaaaaaaaa()\n"
5723                "    .aaaaaaaaaaaaaaa()\n"
5724                "    .aaaaaaaaaaaaaaa();");
5725   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5726                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5727                "    .aaaaaaaaaaaaaaa();");
5728   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5729                "    ->aaaaaaaaaaaaaae(0)\n"
5730                "    ->aaaaaaaaaaaaaaa();");
5731 
5732   // Don't linewrap after very short segments.
5733   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5734                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5735                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5736   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5737                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5738                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5739   verifyFormat("aaa()\n"
5740                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5741                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5742                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5743 
5744   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5745                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5746                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5747   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5748                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5749                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5750 
5751   // Prefer not to break after empty parentheses.
5752   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5753                "    First->LastNewlineOffset);");
5754 
5755   // Prefer not to create "hanging" indents.
5756   verifyFormat(
5757       "return !soooooooooooooome_map\n"
5758       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5759       "            .second;");
5760   verifyFormat(
5761       "return aaaaaaaaaaaaaaaa\n"
5762       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5763       "    .aaaa(aaaaaaaaaaaaaa);");
5764   // No hanging indent here.
5765   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5766                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5767   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5768                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5769   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5770                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5771                getLLVMStyleWithColumns(60));
5772   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5773                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5774                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5775                getLLVMStyleWithColumns(59));
5776   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5777                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5778                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5779 
5780   // Dont break if only closing statements before member call
5781   verifyFormat("test() {\n"
5782                "  ([]() -> {\n"
5783                "    int b = 32;\n"
5784                "    return 3;\n"
5785                "  }).foo();\n"
5786                "}");
5787   verifyFormat("test() {\n"
5788                "  (\n"
5789                "      []() -> {\n"
5790                "        int b = 32;\n"
5791                "        return 3;\n"
5792                "      },\n"
5793                "      foo, bar)\n"
5794                "      .foo();\n"
5795                "}");
5796   verifyFormat("test() {\n"
5797                "  ([]() -> {\n"
5798                "    int b = 32;\n"
5799                "    return 3;\n"
5800                "  })\n"
5801                "      .foo()\n"
5802                "      .bar();\n"
5803                "}");
5804   verifyFormat("test() {\n"
5805                "  ([]() -> {\n"
5806                "    int b = 32;\n"
5807                "    return 3;\n"
5808                "  })\n"
5809                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5810                "           \"bbbb\");\n"
5811                "}",
5812                getLLVMStyleWithColumns(30));
5813 }
5814 
5815 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5816   verifyFormat(
5817       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5818       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5819   verifyFormat(
5820       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5821       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5822 
5823   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5824                "    ccccccccccccccccccccccccc) {\n}");
5825   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5826                "    ccccccccccccccccccccccccc) {\n}");
5827 
5828   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5829                "    ccccccccccccccccccccccccc) {\n}");
5830   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5831                "    ccccccccccccccccccccccccc) {\n}");
5832 
5833   verifyFormat(
5834       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
5835       "    ccccccccccccccccccccccccc) {\n}");
5836   verifyFormat(
5837       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
5838       "    ccccccccccccccccccccccccc) {\n}");
5839 
5840   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5841                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
5842                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
5843                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5844   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5845                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
5846                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
5847                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5848 
5849   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5850                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
5851                "    aaaaaaaaaaaaaaa != aa) {\n}");
5852   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5853                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
5854                "    aaaaaaaaaaaaaaa != aa) {\n}");
5855 }
5856 
5857 TEST_F(FormatTest, BreaksAfterAssignments) {
5858   verifyFormat(
5859       "unsigned Cost =\n"
5860       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
5861       "                        SI->getPointerAddressSpaceee());\n");
5862   verifyFormat(
5863       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
5864       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
5865 
5866   verifyFormat(
5867       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
5868       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
5869   verifyFormat("unsigned OriginalStartColumn =\n"
5870                "    SourceMgr.getSpellingColumnNumber(\n"
5871                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
5872                "    1;");
5873 }
5874 
5875 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
5876   FormatStyle Style = getLLVMStyle();
5877   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5878                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
5879                Style);
5880 
5881   Style.PenaltyBreakAssignment = 20;
5882   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5883                "                                 cccccccccccccccccccccccccc;",
5884                Style);
5885 }
5886 
5887 TEST_F(FormatTest, AlignsAfterAssignments) {
5888   verifyFormat(
5889       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5890       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
5891   verifyFormat(
5892       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5893       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
5894   verifyFormat(
5895       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5896       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
5897   verifyFormat(
5898       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5899       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
5900   verifyFormat(
5901       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5902       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5903       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
5904 }
5905 
5906 TEST_F(FormatTest, AlignsAfterReturn) {
5907   verifyFormat(
5908       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5909       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
5910   verifyFormat(
5911       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5912       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
5913   verifyFormat(
5914       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5915       "       aaaaaaaaaaaaaaaaaaaaaa();");
5916   verifyFormat(
5917       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5918       "        aaaaaaaaaaaaaaaaaaaaaa());");
5919   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5920                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5921   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5922                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
5923                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5924   verifyFormat("return\n"
5925                "    // true if code is one of a or b.\n"
5926                "    code == a || code == b;");
5927 }
5928 
5929 TEST_F(FormatTest, AlignsAfterOpenBracket) {
5930   verifyFormat(
5931       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5932       "                                                aaaaaaaaa aaaaaaa) {}");
5933   verifyFormat(
5934       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5935       "                                               aaaaaaaaaaa aaaaaaaaa);");
5936   verifyFormat(
5937       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5938       "                                             aaaaaaaaaaaaaaaaaaaaa));");
5939   FormatStyle Style = getLLVMStyle();
5940   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5941   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5942                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
5943                Style);
5944   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5945                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
5946                Style);
5947   verifyFormat("SomeLongVariableName->someFunction(\n"
5948                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
5949                Style);
5950   verifyFormat(
5951       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5952       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5953       Style);
5954   verifyFormat(
5955       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5956       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5957       Style);
5958   verifyFormat(
5959       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5960       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
5961       Style);
5962 
5963   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
5964                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
5965                "        b));",
5966                Style);
5967 
5968   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5969   Style.BinPackArguments = false;
5970   Style.BinPackParameters = false;
5971   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5972                "    aaaaaaaaaaa aaaaaaaa,\n"
5973                "    aaaaaaaaa aaaaaaa,\n"
5974                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5975                Style);
5976   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5977                "    aaaaaaaaaaa aaaaaaaaa,\n"
5978                "    aaaaaaaaaaa aaaaaaaaa,\n"
5979                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5980                Style);
5981   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
5982                "    aaaaaaaaaaaaaaa,\n"
5983                "    aaaaaaaaaaaaaaaaaaaaa,\n"
5984                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
5985                Style);
5986   verifyFormat(
5987       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
5988       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
5989       Style);
5990   verifyFormat(
5991       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
5992       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
5993       Style);
5994   verifyFormat(
5995       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5996       "    aaaaaaaaaaaaaaaaaaaaa(\n"
5997       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
5998       "    aaaaaaaaaaaaaaaa);",
5999       Style);
6000   verifyFormat(
6001       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6002       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6003       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
6004       "    aaaaaaaaaaaaaaaa);",
6005       Style);
6006 }
6007 
6008 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
6009   FormatStyle Style = getLLVMStyleWithColumns(40);
6010   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6011                "          bbbbbbbbbbbbbbbbbbbbbb);",
6012                Style);
6013   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6014   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6015   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6016                "          bbbbbbbbbbbbbbbbbbbbbb);",
6017                Style);
6018   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6019   Style.AlignOperands = FormatStyle::OAS_Align;
6020   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6021                "          bbbbbbbbbbbbbbbbbbbbbb);",
6022                Style);
6023   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6024   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6025   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6026                "    bbbbbbbbbbbbbbbbbbbbbb);",
6027                Style);
6028 }
6029 
6030 TEST_F(FormatTest, BreaksConditionalExpressions) {
6031   verifyFormat(
6032       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6033       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6034       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6035   verifyFormat(
6036       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6037       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6038       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6039   verifyFormat(
6040       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6041       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6042   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6043                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6044                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6045   verifyFormat(
6046       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6047       "                                                    : aaaaaaaaaaaaa);");
6048   verifyFormat(
6049       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6050       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6051       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6052       "                   aaaaaaaaaaaaa);");
6053   verifyFormat(
6054       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6055       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6056       "                   aaaaaaaaaaaaa);");
6057   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6058                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6059                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6060                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6061                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6062   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6063                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6064                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6065                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6066                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6067                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6068                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6069   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6070                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6071                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6072                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6073                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6074   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6075                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6076                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6077   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6078                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6079                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6080                "        : aaaaaaaaaaaaaaaa;");
6081   verifyFormat(
6082       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6083       "    ? aaaaaaaaaaaaaaa\n"
6084       "    : aaaaaaaaaaaaaaa;");
6085   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6086                "          aaaaaaaaa\n"
6087                "      ? b\n"
6088                "      : c);");
6089   verifyFormat("return aaaa == bbbb\n"
6090                "           // comment\n"
6091                "           ? aaaa\n"
6092                "           : bbbb;");
6093   verifyFormat("unsigned Indent =\n"
6094                "    format(TheLine.First,\n"
6095                "           IndentForLevel[TheLine.Level] >= 0\n"
6096                "               ? IndentForLevel[TheLine.Level]\n"
6097                "               : TheLine * 2,\n"
6098                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6099                getLLVMStyleWithColumns(60));
6100   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6101                "                  ? aaaaaaaaaaaaaaa\n"
6102                "                  : bbbbbbbbbbbbbbb //\n"
6103                "                        ? ccccccccccccccc\n"
6104                "                        : ddddddddddddddd;");
6105   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6106                "                  ? aaaaaaaaaaaaaaa\n"
6107                "                  : (bbbbbbbbbbbbbbb //\n"
6108                "                         ? ccccccccccccccc\n"
6109                "                         : ddddddddddddddd);");
6110   verifyFormat(
6111       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6112       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6113       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
6114       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
6115       "                                      : aaaaaaaaaa;");
6116   verifyFormat(
6117       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6118       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
6119       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6120 
6121   FormatStyle NoBinPacking = getLLVMStyle();
6122   NoBinPacking.BinPackArguments = false;
6123   verifyFormat(
6124       "void f() {\n"
6125       "  g(aaa,\n"
6126       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6127       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6128       "        ? aaaaaaaaaaaaaaa\n"
6129       "        : aaaaaaaaaaaaaaa);\n"
6130       "}",
6131       NoBinPacking);
6132   verifyFormat(
6133       "void f() {\n"
6134       "  g(aaa,\n"
6135       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6136       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6137       "        ?: aaaaaaaaaaaaaaa);\n"
6138       "}",
6139       NoBinPacking);
6140 
6141   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6142                "             // comment.\n"
6143                "             ccccccccccccccccccccccccccccccccccccccc\n"
6144                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6145                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6146 
6147   // Assignments in conditional expressions. Apparently not uncommon :-(.
6148   verifyFormat("return a != b\n"
6149                "           // comment\n"
6150                "           ? a = b\n"
6151                "           : a = b;");
6152   verifyFormat("return a != b\n"
6153                "           // comment\n"
6154                "           ? a = a != b\n"
6155                "                     // comment\n"
6156                "                     ? a = b\n"
6157                "                     : a\n"
6158                "           : a;\n");
6159   verifyFormat("return a != b\n"
6160                "           // comment\n"
6161                "           ? a\n"
6162                "           : a = a != b\n"
6163                "                     // comment\n"
6164                "                     ? a = b\n"
6165                "                     : a;");
6166 
6167   // Chained conditionals
6168   FormatStyle Style = getLLVMStyle();
6169   Style.ColumnLimit = 70;
6170   Style.AlignOperands = FormatStyle::OAS_Align;
6171   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6172                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6173                "                        : 3333333333333333;",
6174                Style);
6175   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6176                "       : bbbbbbbbbb     ? 2222222222222222\n"
6177                "                        : 3333333333333333;",
6178                Style);
6179   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
6180                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6181                "                          : 3333333333333333;",
6182                Style);
6183   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6184                "       : bbbbbbbbbbbbbb ? 222222\n"
6185                "                        : 333333;",
6186                Style);
6187   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6188                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6189                "       : cccccccccccccc ? 3333333333333333\n"
6190                "                        : 4444444444444444;",
6191                Style);
6192   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6193                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6194                "                        : 3333333333333333;",
6195                Style);
6196   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6197                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6198                "                        : (aaa ? bbb : ccc);",
6199                Style);
6200   verifyFormat(
6201       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6202       "                                             : cccccccccccccccccc)\n"
6203       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6204       "                        : 3333333333333333;",
6205       Style);
6206   verifyFormat(
6207       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6208       "                                             : cccccccccccccccccc)\n"
6209       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6210       "                        : 3333333333333333;",
6211       Style);
6212   verifyFormat(
6213       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6214       "                                             : dddddddddddddddddd)\n"
6215       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6216       "                        : 3333333333333333;",
6217       Style);
6218   verifyFormat(
6219       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6220       "                                             : dddddddddddddddddd)\n"
6221       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6222       "                        : 3333333333333333;",
6223       Style);
6224   verifyFormat(
6225       "return aaaaaaaaa        ? 1111111111111111\n"
6226       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6227       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6228       "                                             : dddddddddddddddddd)\n",
6229       Style);
6230   verifyFormat(
6231       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6232       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6233       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6234       "                                             : cccccccccccccccccc);",
6235       Style);
6236   verifyFormat(
6237       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6238       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6239       "                                             : eeeeeeeeeeeeeeeeee)\n"
6240       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6241       "                        : 3333333333333333;",
6242       Style);
6243   verifyFormat(
6244       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
6245       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6246       "                                             : eeeeeeeeeeeeeeeeee)\n"
6247       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6248       "                        : 3333333333333333;",
6249       Style);
6250   verifyFormat(
6251       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6252       "                           : cccccccccccc    ? dddddddddddddddddd\n"
6253       "                                             : eeeeeeeeeeeeeeeeee)\n"
6254       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6255       "                        : 3333333333333333;",
6256       Style);
6257   verifyFormat(
6258       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6259       "                                             : cccccccccccccccccc\n"
6260       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6261       "                        : 3333333333333333;",
6262       Style);
6263   verifyFormat(
6264       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6265       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
6266       "                                             : eeeeeeeeeeeeeeeeee\n"
6267       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6268       "                        : 3333333333333333;",
6269       Style);
6270   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6271                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
6272                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
6273                "                                   : eeeeeeeeeeeeeeeeee)\n"
6274                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6275                "                             : 3333333333333333;",
6276                Style);
6277   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6278                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6279                "             : cccccccccccccccc ? dddddddddddddddddd\n"
6280                "                                : eeeeeeeeeeeeeeeeee\n"
6281                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6282                "                                 : 3333333333333333;",
6283                Style);
6284 
6285   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6286   Style.BreakBeforeTernaryOperators = false;
6287   // FIXME: Aligning the question marks is weird given DontAlign.
6288   // Consider disabling this alignment in this case. Also check whether this
6289   // will render the adjustment from https://reviews.llvm.org/D82199
6290   // unnecessary.
6291   verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
6292                "    bbbb                ? cccccccccccccccccc :\n"
6293                "                          ddddd;\n",
6294                Style);
6295 }
6296 
6297 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6298   FormatStyle Style = getLLVMStyle();
6299   Style.BreakBeforeTernaryOperators = false;
6300   Style.ColumnLimit = 70;
6301   verifyFormat(
6302       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6303       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6304       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6305       Style);
6306   verifyFormat(
6307       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6308       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6309       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6310       Style);
6311   verifyFormat(
6312       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6313       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6314       Style);
6315   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6316                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6317                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6318                Style);
6319   verifyFormat(
6320       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6321       "                                                      aaaaaaaaaaaaa);",
6322       Style);
6323   verifyFormat(
6324       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6325       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6326       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6327       "                   aaaaaaaaaaaaa);",
6328       Style);
6329   verifyFormat(
6330       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6331       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6332       "                   aaaaaaaaaaaaa);",
6333       Style);
6334   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6335                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6336                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6337                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6338                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6339                Style);
6340   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6341                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6342                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6343                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6344                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6345                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6346                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6347                Style);
6348   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6349                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6350                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6351                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6352                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6353                Style);
6354   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6355                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6356                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6357                Style);
6358   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6359                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6360                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6361                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6362                Style);
6363   verifyFormat(
6364       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6365       "    aaaaaaaaaaaaaaa :\n"
6366       "    aaaaaaaaaaaaaaa;",
6367       Style);
6368   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6369                "          aaaaaaaaa ?\n"
6370                "      b :\n"
6371                "      c);",
6372                Style);
6373   verifyFormat("unsigned Indent =\n"
6374                "    format(TheLine.First,\n"
6375                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
6376                "               IndentForLevel[TheLine.Level] :\n"
6377                "               TheLine * 2,\n"
6378                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6379                Style);
6380   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6381                "                  aaaaaaaaaaaaaaa :\n"
6382                "                  bbbbbbbbbbbbbbb ? //\n"
6383                "                      ccccccccccccccc :\n"
6384                "                      ddddddddddddddd;",
6385                Style);
6386   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6387                "                  aaaaaaaaaaaaaaa :\n"
6388                "                  (bbbbbbbbbbbbbbb ? //\n"
6389                "                       ccccccccccccccc :\n"
6390                "                       ddddddddddddddd);",
6391                Style);
6392   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6393                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6394                "            ccccccccccccccccccccccccccc;",
6395                Style);
6396   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6397                "           aaaaa :\n"
6398                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
6399                Style);
6400 
6401   // Chained conditionals
6402   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6403                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6404                "                          3333333333333333;",
6405                Style);
6406   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6407                "       bbbbbbbbbb       ? 2222222222222222 :\n"
6408                "                          3333333333333333;",
6409                Style);
6410   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
6411                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6412                "                          3333333333333333;",
6413                Style);
6414   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6415                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
6416                "                          333333;",
6417                Style);
6418   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6419                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6420                "       cccccccccccccccc ? 3333333333333333 :\n"
6421                "                          4444444444444444;",
6422                Style);
6423   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6424                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6425                "                          3333333333333333;",
6426                Style);
6427   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6428                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6429                "                          (aaa ? bbb : ccc);",
6430                Style);
6431   verifyFormat(
6432       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6433       "                                               cccccccccccccccccc) :\n"
6434       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6435       "                          3333333333333333;",
6436       Style);
6437   verifyFormat(
6438       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6439       "                                               cccccccccccccccccc) :\n"
6440       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6441       "                          3333333333333333;",
6442       Style);
6443   verifyFormat(
6444       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6445       "                                               dddddddddddddddddd) :\n"
6446       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6447       "                          3333333333333333;",
6448       Style);
6449   verifyFormat(
6450       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6451       "                                               dddddddddddddddddd) :\n"
6452       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6453       "                          3333333333333333;",
6454       Style);
6455   verifyFormat(
6456       "return aaaaaaaaa        ? 1111111111111111 :\n"
6457       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6458       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6459       "                                               dddddddddddddddddd)\n",
6460       Style);
6461   verifyFormat(
6462       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6463       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6464       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6465       "                                               cccccccccccccccccc);",
6466       Style);
6467   verifyFormat(
6468       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6469       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6470       "                                               eeeeeeeeeeeeeeeeee) :\n"
6471       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6472       "                          3333333333333333;",
6473       Style);
6474   verifyFormat(
6475       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6476       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
6477       "                                               eeeeeeeeeeeeeeeeee) :\n"
6478       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6479       "                          3333333333333333;",
6480       Style);
6481   verifyFormat(
6482       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
6483       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6484       "                                               eeeeeeeeeeeeeeeeee) :\n"
6485       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6486       "                          3333333333333333;",
6487       Style);
6488   verifyFormat(
6489       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6490       "                                               cccccccccccccccccc :\n"
6491       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6492       "                          3333333333333333;",
6493       Style);
6494   verifyFormat(
6495       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6496       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
6497       "                                               eeeeeeeeeeeeeeeeee :\n"
6498       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6499       "                          3333333333333333;",
6500       Style);
6501   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6502                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6503                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
6504                "                                 eeeeeeeeeeeeeeeeee) :\n"
6505                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6506                "                               3333333333333333;",
6507                Style);
6508   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6509                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6510                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
6511                "                                  eeeeeeeeeeeeeeeeee :\n"
6512                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6513                "                               3333333333333333;",
6514                Style);
6515 }
6516 
6517 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6518   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6519                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6520   verifyFormat("bool a = true, b = false;");
6521 
6522   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6523                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6524                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6525                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6526   verifyFormat(
6527       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6528       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6529       "     d = e && f;");
6530   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6531                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6532   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6533                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6534   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6535                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6536 
6537   FormatStyle Style = getGoogleStyle();
6538   Style.PointerAlignment = FormatStyle::PAS_Left;
6539   Style.DerivePointerAlignment = false;
6540   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6541                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6542                "    *b = bbbbbbbbbbbbbbbbbbb;",
6543                Style);
6544   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6545                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6546                Style);
6547   verifyFormat("vector<int*> a, b;", Style);
6548   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6549 }
6550 
6551 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6552   verifyFormat("arr[foo ? bar : baz];");
6553   verifyFormat("f()[foo ? bar : baz];");
6554   verifyFormat("(a + b)[foo ? bar : baz];");
6555   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6556 }
6557 
6558 TEST_F(FormatTest, AlignsStringLiterals) {
6559   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6560                "                                      \"short literal\");");
6561   verifyFormat(
6562       "looooooooooooooooooooooooongFunction(\n"
6563       "    \"short literal\"\n"
6564       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6565   verifyFormat("someFunction(\"Always break between multi-line\"\n"
6566                "             \" string literals\",\n"
6567                "             and, other, parameters);");
6568   EXPECT_EQ("fun + \"1243\" /* comment */\n"
6569             "      \"5678\";",
6570             format("fun + \"1243\" /* comment */\n"
6571                    "    \"5678\";",
6572                    getLLVMStyleWithColumns(28)));
6573   EXPECT_EQ(
6574       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6575       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6576       "         \"aaaaaaaaaaaaaaaa\";",
6577       format("aaaaaa ="
6578              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6579              "aaaaaaaaaaaaaaaaaaaaa\" "
6580              "\"aaaaaaaaaaaaaaaa\";"));
6581   verifyFormat("a = a + \"a\"\n"
6582                "        \"a\"\n"
6583                "        \"a\";");
6584   verifyFormat("f(\"a\", \"b\"\n"
6585                "       \"c\");");
6586 
6587   verifyFormat(
6588       "#define LL_FORMAT \"ll\"\n"
6589       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6590       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6591 
6592   verifyFormat("#define A(X)          \\\n"
6593                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
6594                "  \"ccccc\"",
6595                getLLVMStyleWithColumns(23));
6596   verifyFormat("#define A \"def\"\n"
6597                "f(\"abc\" A \"ghi\"\n"
6598                "  \"jkl\");");
6599 
6600   verifyFormat("f(L\"a\"\n"
6601                "  L\"b\");");
6602   verifyFormat("#define A(X)            \\\n"
6603                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6604                "  L\"ccccc\"",
6605                getLLVMStyleWithColumns(25));
6606 
6607   verifyFormat("f(@\"a\"\n"
6608                "  @\"b\");");
6609   verifyFormat("NSString s = @\"a\"\n"
6610                "             @\"b\"\n"
6611                "             @\"c\";");
6612   verifyFormat("NSString s = @\"a\"\n"
6613                "              \"b\"\n"
6614                "              \"c\";");
6615 }
6616 
6617 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6618   FormatStyle Style = getLLVMStyle();
6619   // No declarations or definitions should be moved to own line.
6620   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6621   verifyFormat("class A {\n"
6622                "  int f() { return 1; }\n"
6623                "  int g();\n"
6624                "};\n"
6625                "int f() { return 1; }\n"
6626                "int g();\n",
6627                Style);
6628 
6629   // All declarations and definitions should have the return type moved to its
6630   // own
6631   // line.
6632   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6633   verifyFormat("class E {\n"
6634                "  int\n"
6635                "  f() {\n"
6636                "    return 1;\n"
6637                "  }\n"
6638                "  int\n"
6639                "  g();\n"
6640                "};\n"
6641                "int\n"
6642                "f() {\n"
6643                "  return 1;\n"
6644                "}\n"
6645                "int\n"
6646                "g();\n",
6647                Style);
6648 
6649   // Top-level definitions, and no kinds of declarations should have the
6650   // return type moved to its own line.
6651   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6652   verifyFormat("class B {\n"
6653                "  int f() { return 1; }\n"
6654                "  int g();\n"
6655                "};\n"
6656                "int\n"
6657                "f() {\n"
6658                "  return 1;\n"
6659                "}\n"
6660                "int g();\n",
6661                Style);
6662 
6663   // Top-level definitions and declarations should have the return type moved
6664   // to its own line.
6665   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6666   verifyFormat("class C {\n"
6667                "  int f() { return 1; }\n"
6668                "  int g();\n"
6669                "};\n"
6670                "int\n"
6671                "f() {\n"
6672                "  return 1;\n"
6673                "}\n"
6674                "int\n"
6675                "g();\n",
6676                Style);
6677 
6678   // All definitions should have the return type moved to its own line, but no
6679   // kinds of declarations.
6680   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6681   verifyFormat("class D {\n"
6682                "  int\n"
6683                "  f() {\n"
6684                "    return 1;\n"
6685                "  }\n"
6686                "  int g();\n"
6687                "};\n"
6688                "int\n"
6689                "f() {\n"
6690                "  return 1;\n"
6691                "}\n"
6692                "int g();\n",
6693                Style);
6694   verifyFormat("const char *\n"
6695                "f(void) {\n" // Break here.
6696                "  return \"\";\n"
6697                "}\n"
6698                "const char *bar(void);\n", // No break here.
6699                Style);
6700   verifyFormat("template <class T>\n"
6701                "T *\n"
6702                "f(T &c) {\n" // Break here.
6703                "  return NULL;\n"
6704                "}\n"
6705                "template <class T> T *f(T &c);\n", // No break here.
6706                Style);
6707   verifyFormat("class C {\n"
6708                "  int\n"
6709                "  operator+() {\n"
6710                "    return 1;\n"
6711                "  }\n"
6712                "  int\n"
6713                "  operator()() {\n"
6714                "    return 1;\n"
6715                "  }\n"
6716                "};\n",
6717                Style);
6718   verifyFormat("void\n"
6719                "A::operator()() {}\n"
6720                "void\n"
6721                "A::operator>>() {}\n"
6722                "void\n"
6723                "A::operator+() {}\n"
6724                "void\n"
6725                "A::operator*() {}\n"
6726                "void\n"
6727                "A::operator->() {}\n"
6728                "void\n"
6729                "A::operator void *() {}\n"
6730                "void\n"
6731                "A::operator void &() {}\n"
6732                "void\n"
6733                "A::operator void &&() {}\n"
6734                "void\n"
6735                "A::operator char *() {}\n"
6736                "void\n"
6737                "A::operator[]() {}\n"
6738                "void\n"
6739                "A::operator!() {}\n"
6740                "void\n"
6741                "A::operator**() {}\n"
6742                "void\n"
6743                "A::operator<Foo> *() {}\n"
6744                "void\n"
6745                "A::operator<Foo> **() {}\n"
6746                "void\n"
6747                "A::operator<Foo> &() {}\n"
6748                "void\n"
6749                "A::operator void **() {}\n",
6750                Style);
6751   verifyFormat("constexpr auto\n"
6752                "operator()() const -> reference {}\n"
6753                "constexpr auto\n"
6754                "operator>>() const -> reference {}\n"
6755                "constexpr auto\n"
6756                "operator+() const -> reference {}\n"
6757                "constexpr auto\n"
6758                "operator*() const -> reference {}\n"
6759                "constexpr auto\n"
6760                "operator->() const -> reference {}\n"
6761                "constexpr auto\n"
6762                "operator++() const -> reference {}\n"
6763                "constexpr auto\n"
6764                "operator void *() const -> reference {}\n"
6765                "constexpr auto\n"
6766                "operator void **() const -> reference {}\n"
6767                "constexpr auto\n"
6768                "operator void *() const -> reference {}\n"
6769                "constexpr auto\n"
6770                "operator void &() const -> reference {}\n"
6771                "constexpr auto\n"
6772                "operator void &&() const -> reference {}\n"
6773                "constexpr auto\n"
6774                "operator char *() const -> reference {}\n"
6775                "constexpr auto\n"
6776                "operator!() const -> reference {}\n"
6777                "constexpr auto\n"
6778                "operator[]() const -> reference {}\n",
6779                Style);
6780   verifyFormat("void *operator new(std::size_t s);", // No break here.
6781                Style);
6782   verifyFormat("void *\n"
6783                "operator new(std::size_t s) {}",
6784                Style);
6785   verifyFormat("void *\n"
6786                "operator delete[](void *ptr) {}",
6787                Style);
6788   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6789   verifyFormat("const char *\n"
6790                "f(void)\n" // Break here.
6791                "{\n"
6792                "  return \"\";\n"
6793                "}\n"
6794                "const char *bar(void);\n", // No break here.
6795                Style);
6796   verifyFormat("template <class T>\n"
6797                "T *\n"     // Problem here: no line break
6798                "f(T &c)\n" // Break here.
6799                "{\n"
6800                "  return NULL;\n"
6801                "}\n"
6802                "template <class T> T *f(T &c);\n", // No break here.
6803                Style);
6804   verifyFormat("int\n"
6805                "foo(A<bool> a)\n"
6806                "{\n"
6807                "  return a;\n"
6808                "}\n",
6809                Style);
6810   verifyFormat("int\n"
6811                "foo(A<8> a)\n"
6812                "{\n"
6813                "  return a;\n"
6814                "}\n",
6815                Style);
6816   verifyFormat("int\n"
6817                "foo(A<B<bool>, 8> a)\n"
6818                "{\n"
6819                "  return a;\n"
6820                "}\n",
6821                Style);
6822   verifyFormat("int\n"
6823                "foo(A<B<8>, bool> a)\n"
6824                "{\n"
6825                "  return a;\n"
6826                "}\n",
6827                Style);
6828   verifyFormat("int\n"
6829                "foo(A<B<bool>, bool> a)\n"
6830                "{\n"
6831                "  return a;\n"
6832                "}\n",
6833                Style);
6834   verifyFormat("int\n"
6835                "foo(A<B<8>, 8> a)\n"
6836                "{\n"
6837                "  return a;\n"
6838                "}\n",
6839                Style);
6840 
6841   Style = getGNUStyle();
6842 
6843   // Test for comments at the end of function declarations.
6844   verifyFormat("void\n"
6845                "foo (int a, /*abc*/ int b) // def\n"
6846                "{\n"
6847                "}\n",
6848                Style);
6849 
6850   verifyFormat("void\n"
6851                "foo (int a, /* abc */ int b) /* def */\n"
6852                "{\n"
6853                "}\n",
6854                Style);
6855 
6856   // Definitions that should not break after return type
6857   verifyFormat("void foo (int a, int b); // def\n", Style);
6858   verifyFormat("void foo (int a, int b); /* def */\n", Style);
6859   verifyFormat("void foo (int a, int b);\n", Style);
6860 }
6861 
6862 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
6863   FormatStyle NoBreak = getLLVMStyle();
6864   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
6865   FormatStyle Break = getLLVMStyle();
6866   Break.AlwaysBreakBeforeMultilineStrings = true;
6867   verifyFormat("aaaa = \"bbbb\"\n"
6868                "       \"cccc\";",
6869                NoBreak);
6870   verifyFormat("aaaa =\n"
6871                "    \"bbbb\"\n"
6872                "    \"cccc\";",
6873                Break);
6874   verifyFormat("aaaa(\"bbbb\"\n"
6875                "     \"cccc\");",
6876                NoBreak);
6877   verifyFormat("aaaa(\n"
6878                "    \"bbbb\"\n"
6879                "    \"cccc\");",
6880                Break);
6881   verifyFormat("aaaa(qqq, \"bbbb\"\n"
6882                "          \"cccc\");",
6883                NoBreak);
6884   verifyFormat("aaaa(qqq,\n"
6885                "     \"bbbb\"\n"
6886                "     \"cccc\");",
6887                Break);
6888   verifyFormat("aaaa(qqq,\n"
6889                "     L\"bbbb\"\n"
6890                "     L\"cccc\");",
6891                Break);
6892   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
6893                "                      \"bbbb\"));",
6894                Break);
6895   verifyFormat("string s = someFunction(\n"
6896                "    \"abc\"\n"
6897                "    \"abc\");",
6898                Break);
6899 
6900   // As we break before unary operators, breaking right after them is bad.
6901   verifyFormat("string foo = abc ? \"x\"\n"
6902                "                   \"blah blah blah blah blah blah\"\n"
6903                "                 : \"y\";",
6904                Break);
6905 
6906   // Don't break if there is no column gain.
6907   verifyFormat("f(\"aaaa\"\n"
6908                "  \"bbbb\");",
6909                Break);
6910 
6911   // Treat literals with escaped newlines like multi-line string literals.
6912   EXPECT_EQ("x = \"a\\\n"
6913             "b\\\n"
6914             "c\";",
6915             format("x = \"a\\\n"
6916                    "b\\\n"
6917                    "c\";",
6918                    NoBreak));
6919   EXPECT_EQ("xxxx =\n"
6920             "    \"a\\\n"
6921             "b\\\n"
6922             "c\";",
6923             format("xxxx = \"a\\\n"
6924                    "b\\\n"
6925                    "c\";",
6926                    Break));
6927 
6928   EXPECT_EQ("NSString *const kString =\n"
6929             "    @\"aaaa\"\n"
6930             "    @\"bbbb\";",
6931             format("NSString *const kString = @\"aaaa\"\n"
6932                    "@\"bbbb\";",
6933                    Break));
6934 
6935   Break.ColumnLimit = 0;
6936   verifyFormat("const char *hello = \"hello llvm\";", Break);
6937 }
6938 
6939 TEST_F(FormatTest, AlignsPipes) {
6940   verifyFormat(
6941       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6942       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6943       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6944   verifyFormat(
6945       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
6946       "                     << aaaaaaaaaaaaaaaaaaaa;");
6947   verifyFormat(
6948       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6949       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6950   verifyFormat(
6951       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
6952       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6953   verifyFormat(
6954       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
6955       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
6956       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
6957   verifyFormat(
6958       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6959       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6960       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6961   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6962                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6963                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6964                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
6965   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
6966                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
6967   verifyFormat(
6968       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6969       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6970   verifyFormat(
6971       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
6972       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
6973 
6974   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
6975                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
6976   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6977                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6978                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
6979                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
6980   verifyFormat("LOG_IF(aaa == //\n"
6981                "       bbb)\n"
6982                "    << a << b;");
6983 
6984   // But sometimes, breaking before the first "<<" is desirable.
6985   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6986                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
6987   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
6988                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6989                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6990   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
6991                "    << BEF << IsTemplate << Description << E->getType();");
6992   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6993                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6994                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6995   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6996                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6997                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6998                "    << aaa;");
6999 
7000   verifyFormat(
7001       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7002       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7003 
7004   // Incomplete string literal.
7005   EXPECT_EQ("llvm::errs() << \"\n"
7006             "             << a;",
7007             format("llvm::errs() << \"\n<<a;"));
7008 
7009   verifyFormat("void f() {\n"
7010                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
7011                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
7012                "}");
7013 
7014   // Handle 'endl'.
7015   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
7016                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7017   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7018 
7019   // Handle '\n'.
7020   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
7021                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7022   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
7023                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
7024   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
7025                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
7026   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7027 }
7028 
7029 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
7030   verifyFormat("return out << \"somepacket = {\\n\"\n"
7031                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
7032                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
7033                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
7034                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
7035                "           << \"}\";");
7036 
7037   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7038                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7039                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7040   verifyFormat(
7041       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7042       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7043       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7044       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7045       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7046   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7047                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7048   verifyFormat(
7049       "void f() {\n"
7050       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7051       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7052       "}");
7053 
7054   // Breaking before the first "<<" is generally not desirable.
7055   verifyFormat(
7056       "llvm::errs()\n"
7057       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7058       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7059       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7060       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7061       getLLVMStyleWithColumns(70));
7062   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7063                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7064                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7065                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7066                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7067                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7068                getLLVMStyleWithColumns(70));
7069 
7070   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7071                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7072                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7073   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7074                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7075                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7076   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7077                "           (aaaa + aaaa);",
7078                getLLVMStyleWithColumns(40));
7079   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7080                "                  (aaaaaaa + aaaaa));",
7081                getLLVMStyleWithColumns(40));
7082   verifyFormat(
7083       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7084       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7085       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
7086 }
7087 
7088 TEST_F(FormatTest, UnderstandsEquals) {
7089   verifyFormat(
7090       "aaaaaaaaaaaaaaaaa =\n"
7091       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7092   verifyFormat(
7093       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7094       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7095   verifyFormat(
7096       "if (a) {\n"
7097       "  f();\n"
7098       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7099       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7100       "}");
7101 
7102   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7103                "        100000000 + 10000000) {\n}");
7104 }
7105 
7106 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7107   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7108                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
7109 
7110   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7111                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
7112 
7113   verifyFormat(
7114       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7115       "                                                          Parameter2);");
7116 
7117   verifyFormat(
7118       "ShortObject->shortFunction(\n"
7119       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7120       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7121 
7122   verifyFormat("loooooooooooooongFunction(\n"
7123                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
7124 
7125   verifyFormat(
7126       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7127       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7128 
7129   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7130                "    .WillRepeatedly(Return(SomeValue));");
7131   verifyFormat("void f() {\n"
7132                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7133                "      .Times(2)\n"
7134                "      .WillRepeatedly(Return(SomeValue));\n"
7135                "}");
7136   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7137                "    ccccccccccccccccccccccc);");
7138   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7139                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7140                "          .aaaaa(aaaaa),\n"
7141                "      aaaaaaaaaaaaaaaaaaaaa);");
7142   verifyFormat("void f() {\n"
7143                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7144                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7145                "}");
7146   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7147                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7148                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7149                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7150                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7151   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7152                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7153                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7154                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7155                "}");
7156 
7157   // Here, it is not necessary to wrap at "." or "->".
7158   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7159                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7160   verifyFormat(
7161       "aaaaaaaaaaa->aaaaaaaaa(\n"
7162       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7163       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7164 
7165   verifyFormat(
7166       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7167       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7168   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7169                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7170   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7171                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7172 
7173   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7174                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7175                "    .a();");
7176 
7177   FormatStyle NoBinPacking = getLLVMStyle();
7178   NoBinPacking.BinPackParameters = false;
7179   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7180                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7181                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7182                "                         aaaaaaaaaaaaaaaaaaa,\n"
7183                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7184                NoBinPacking);
7185 
7186   // If there is a subsequent call, change to hanging indentation.
7187   verifyFormat(
7188       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7189       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7190       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7191   verifyFormat(
7192       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7193       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7194   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7195                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7196                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7197   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7198                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7199                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7200 }
7201 
7202 TEST_F(FormatTest, WrapsTemplateDeclarations) {
7203   verifyFormat("template <typename T>\n"
7204                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7205   verifyFormat("template <typename T>\n"
7206                "// T should be one of {A, B}.\n"
7207                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7208   verifyFormat(
7209       "template <typename T>\n"
7210       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7211   verifyFormat("template <typename T>\n"
7212                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7213                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7214   verifyFormat(
7215       "template <typename T>\n"
7216       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7217       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
7218   verifyFormat(
7219       "template <typename T>\n"
7220       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7221       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7222       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7223   verifyFormat("template <typename T>\n"
7224                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7225                "    int aaaaaaaaaaaaaaaaaaaaaa);");
7226   verifyFormat(
7227       "template <typename T1, typename T2 = char, typename T3 = char,\n"
7228       "          typename T4 = char>\n"
7229       "void f();");
7230   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7231                "          template <typename> class cccccccccccccccccccccc,\n"
7232                "          typename ddddddddddddd>\n"
7233                "class C {};");
7234   verifyFormat(
7235       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7236       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7237 
7238   verifyFormat("void f() {\n"
7239                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7240                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7241                "}");
7242 
7243   verifyFormat("template <typename T> class C {};");
7244   verifyFormat("template <typename T> void f();");
7245   verifyFormat("template <typename T> void f() {}");
7246   verifyFormat(
7247       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7248       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7249       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7250       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7251       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7252       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7253       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
7254       getLLVMStyleWithColumns(72));
7255   EXPECT_EQ("static_cast<A< //\n"
7256             "    B> *>(\n"
7257             "\n"
7258             ");",
7259             format("static_cast<A<//\n"
7260                    "    B>*>(\n"
7261                    "\n"
7262                    "    );"));
7263   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7264                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7265 
7266   FormatStyle AlwaysBreak = getLLVMStyle();
7267   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7268   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7269   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7270   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7271   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7272                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7273                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
7274   verifyFormat("template <template <typename> class Fooooooo,\n"
7275                "          template <typename> class Baaaaaaar>\n"
7276                "struct C {};",
7277                AlwaysBreak);
7278   verifyFormat("template <typename T> // T can be A, B or C.\n"
7279                "struct C {};",
7280                AlwaysBreak);
7281   verifyFormat("template <enum E> class A {\n"
7282                "public:\n"
7283                "  E *f();\n"
7284                "};");
7285 
7286   FormatStyle NeverBreak = getLLVMStyle();
7287   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7288   verifyFormat("template <typename T> class C {};", NeverBreak);
7289   verifyFormat("template <typename T> void f();", NeverBreak);
7290   verifyFormat("template <typename T> void f() {}", NeverBreak);
7291   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7292                "bbbbbbbbbbbbbbbbbbbb) {}",
7293                NeverBreak);
7294   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7295                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7296                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
7297                NeverBreak);
7298   verifyFormat("template <template <typename> class Fooooooo,\n"
7299                "          template <typename> class Baaaaaaar>\n"
7300                "struct C {};",
7301                NeverBreak);
7302   verifyFormat("template <typename T> // T can be A, B or C.\n"
7303                "struct C {};",
7304                NeverBreak);
7305   verifyFormat("template <enum E> class A {\n"
7306                "public:\n"
7307                "  E *f();\n"
7308                "};",
7309                NeverBreak);
7310   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7311   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7312                "bbbbbbbbbbbbbbbbbbbb) {}",
7313                NeverBreak);
7314 }
7315 
7316 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7317   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7318   Style.ColumnLimit = 60;
7319   EXPECT_EQ("// Baseline - no comments.\n"
7320             "template <\n"
7321             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7322             "void f() {}",
7323             format("// Baseline - no comments.\n"
7324                    "template <\n"
7325                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7326                    "void f() {}",
7327                    Style));
7328 
7329   EXPECT_EQ("template <\n"
7330             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7331             "void f() {}",
7332             format("template <\n"
7333                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7334                    "void f() {}",
7335                    Style));
7336 
7337   EXPECT_EQ(
7338       "template <\n"
7339       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7340       "void f() {}",
7341       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
7342              "void f() {}",
7343              Style));
7344 
7345   EXPECT_EQ(
7346       "template <\n"
7347       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7348       "                                               // multiline\n"
7349       "void f() {}",
7350       format("template <\n"
7351              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7352              "                                              // multiline\n"
7353              "void f() {}",
7354              Style));
7355 
7356   EXPECT_EQ(
7357       "template <typename aaaaaaaaaa<\n"
7358       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
7359       "void f() {}",
7360       format(
7361           "template <\n"
7362           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7363           "void f() {}",
7364           Style));
7365 }
7366 
7367 TEST_F(FormatTest, WrapsTemplateParameters) {
7368   FormatStyle Style = getLLVMStyle();
7369   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7370   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7371   verifyFormat(
7372       "template <typename... a> struct q {};\n"
7373       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7374       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7375       "    y;",
7376       Style);
7377   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7378   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7379   verifyFormat(
7380       "template <typename... a> struct r {};\n"
7381       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7382       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7383       "    y;",
7384       Style);
7385   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7386   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7387   verifyFormat("template <typename... a> struct s {};\n"
7388                "extern s<\n"
7389                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7390                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7391                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7392                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7393                "    y;",
7394                Style);
7395   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7396   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7397   verifyFormat("template <typename... a> struct t {};\n"
7398                "extern t<\n"
7399                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7400                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7401                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7402                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7403                "    y;",
7404                Style);
7405 }
7406 
7407 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7408   verifyFormat(
7409       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7410       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7411   verifyFormat(
7412       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7413       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7414       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7415 
7416   // FIXME: Should we have the extra indent after the second break?
7417   verifyFormat(
7418       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7419       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7420       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7421 
7422   verifyFormat(
7423       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7424       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
7425 
7426   // Breaking at nested name specifiers is generally not desirable.
7427   verifyFormat(
7428       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7429       "    aaaaaaaaaaaaaaaaaaaaaaa);");
7430 
7431   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7432                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7433                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7434                "                   aaaaaaaaaaaaaaaaaaaaa);",
7435                getLLVMStyleWithColumns(74));
7436 
7437   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7438                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7439                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7440 }
7441 
7442 TEST_F(FormatTest, UnderstandsTemplateParameters) {
7443   verifyFormat("A<int> a;");
7444   verifyFormat("A<A<A<int>>> a;");
7445   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7446   verifyFormat("bool x = a < 1 || 2 > a;");
7447   verifyFormat("bool x = 5 < f<int>();");
7448   verifyFormat("bool x = f<int>() > 5;");
7449   verifyFormat("bool x = 5 < a<int>::x;");
7450   verifyFormat("bool x = a < 4 ? a > 2 : false;");
7451   verifyFormat("bool x = f() ? a < 2 : a > 2;");
7452 
7453   verifyGoogleFormat("A<A<int>> a;");
7454   verifyGoogleFormat("A<A<A<int>>> a;");
7455   verifyGoogleFormat("A<A<A<A<int>>>> a;");
7456   verifyGoogleFormat("A<A<int> > a;");
7457   verifyGoogleFormat("A<A<A<int> > > a;");
7458   verifyGoogleFormat("A<A<A<A<int> > > > a;");
7459   verifyGoogleFormat("A<::A<int>> a;");
7460   verifyGoogleFormat("A<::A> a;");
7461   verifyGoogleFormat("A< ::A> a;");
7462   verifyGoogleFormat("A< ::A<int> > a;");
7463   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7464   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7465   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7466   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7467   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7468             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7469 
7470   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7471 
7472   // template closer followed by a token that starts with > or =
7473   verifyFormat("bool b = a<1> > 1;");
7474   verifyFormat("bool b = a<1> >= 1;");
7475   verifyFormat("int i = a<1> >> 1;");
7476   FormatStyle Style = getLLVMStyle();
7477   Style.SpaceBeforeAssignmentOperators = false;
7478   verifyFormat("bool b= a<1> == 1;", Style);
7479   verifyFormat("a<int> = 1;", Style);
7480   verifyFormat("a<int> >>= 1;", Style);
7481 
7482   verifyFormat("test >> a >> b;");
7483   verifyFormat("test << a >> b;");
7484 
7485   verifyFormat("f<int>();");
7486   verifyFormat("template <typename T> void f() {}");
7487   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7488   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7489                "sizeof(char)>::type>;");
7490   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7491   verifyFormat("f(a.operator()<A>());");
7492   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7493                "      .template operator()<A>());",
7494                getLLVMStyleWithColumns(35));
7495 
7496   // Not template parameters.
7497   verifyFormat("return a < b && c > d;");
7498   verifyFormat("void f() {\n"
7499                "  while (a < b && c > d) {\n"
7500                "  }\n"
7501                "}");
7502   verifyFormat("template <typename... Types>\n"
7503                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7504 
7505   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7506                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7507                getLLVMStyleWithColumns(60));
7508   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7509   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7510   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7511 }
7512 
7513 TEST_F(FormatTest, BitshiftOperatorWidth) {
7514   EXPECT_EQ("int a = 1 << 2; /* foo\n"
7515             "                   bar */",
7516             format("int    a=1<<2;  /* foo\n"
7517                    "                   bar */"));
7518 
7519   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7520             "                     bar */",
7521             format("int  b  =256>>1 ;  /* foo\n"
7522                    "                      bar */"));
7523 }
7524 
7525 TEST_F(FormatTest, UnderstandsBinaryOperators) {
7526   verifyFormat("COMPARE(a, ==, b);");
7527   verifyFormat("auto s = sizeof...(Ts) - 1;");
7528 }
7529 
7530 TEST_F(FormatTest, UnderstandsPointersToMembers) {
7531   verifyFormat("int A::*x;");
7532   verifyFormat("int (S::*func)(void *);");
7533   verifyFormat("void f() { int (S::*func)(void *); }");
7534   verifyFormat("typedef bool *(Class::*Member)() const;");
7535   verifyFormat("void f() {\n"
7536                "  (a->*f)();\n"
7537                "  a->*x;\n"
7538                "  (a.*f)();\n"
7539                "  ((*a).*f)();\n"
7540                "  a.*x;\n"
7541                "}");
7542   verifyFormat("void f() {\n"
7543                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7544                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7545                "}");
7546   verifyFormat(
7547       "(aaaaaaaaaa->*bbbbbbb)(\n"
7548       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7549   FormatStyle Style = getLLVMStyle();
7550   Style.PointerAlignment = FormatStyle::PAS_Left;
7551   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7552 }
7553 
7554 TEST_F(FormatTest, UnderstandsUnaryOperators) {
7555   verifyFormat("int a = -2;");
7556   verifyFormat("f(-1, -2, -3);");
7557   verifyFormat("a[-1] = 5;");
7558   verifyFormat("int a = 5 + -2;");
7559   verifyFormat("if (i == -1) {\n}");
7560   verifyFormat("if (i != -1) {\n}");
7561   verifyFormat("if (i > -1) {\n}");
7562   verifyFormat("if (i < -1) {\n}");
7563   verifyFormat("++(a->f());");
7564   verifyFormat("--(a->f());");
7565   verifyFormat("(a->f())++;");
7566   verifyFormat("a[42]++;");
7567   verifyFormat("if (!(a->f())) {\n}");
7568   verifyFormat("if (!+i) {\n}");
7569   verifyFormat("~&a;");
7570 
7571   verifyFormat("a-- > b;");
7572   verifyFormat("b ? -a : c;");
7573   verifyFormat("n * sizeof char16;");
7574   verifyFormat("n * alignof char16;", getGoogleStyle());
7575   verifyFormat("sizeof(char);");
7576   verifyFormat("alignof(char);", getGoogleStyle());
7577 
7578   verifyFormat("return -1;");
7579   verifyFormat("throw -1;");
7580   verifyFormat("switch (a) {\n"
7581                "case -1:\n"
7582                "  break;\n"
7583                "}");
7584   verifyFormat("#define X -1");
7585   verifyFormat("#define X -kConstant");
7586 
7587   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7588   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7589 
7590   verifyFormat("int a = /* confusing comment */ -1;");
7591   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7592   verifyFormat("int a = i /* confusing comment */++;");
7593 
7594   verifyFormat("co_yield -1;");
7595   verifyFormat("co_return -1;");
7596 }
7597 
7598 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7599   verifyFormat("if (!aaaaaaaaaa( // break\n"
7600                "        aaaaa)) {\n"
7601                "}");
7602   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7603                "    aaaaa));");
7604   verifyFormat("*aaa = aaaaaaa( // break\n"
7605                "    bbbbbb);");
7606 }
7607 
7608 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7609   verifyFormat("bool operator<();");
7610   verifyFormat("bool operator>();");
7611   verifyFormat("bool operator=();");
7612   verifyFormat("bool operator==();");
7613   verifyFormat("bool operator!=();");
7614   verifyFormat("int operator+();");
7615   verifyFormat("int operator++();");
7616   verifyFormat("int operator++(int) volatile noexcept;");
7617   verifyFormat("bool operator,();");
7618   verifyFormat("bool operator();");
7619   verifyFormat("bool operator()();");
7620   verifyFormat("bool operator[]();");
7621   verifyFormat("operator bool();");
7622   verifyFormat("operator int();");
7623   verifyFormat("operator void *();");
7624   verifyFormat("operator SomeType<int>();");
7625   verifyFormat("operator SomeType<int, int>();");
7626   verifyFormat("operator SomeType<SomeType<int>>();");
7627   verifyFormat("void *operator new(std::size_t size);");
7628   verifyFormat("void *operator new[](std::size_t size);");
7629   verifyFormat("void operator delete(void *ptr);");
7630   verifyFormat("void operator delete[](void *ptr);");
7631   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7632                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7633   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7634                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7635 
7636   verifyFormat(
7637       "ostream &operator<<(ostream &OutputStream,\n"
7638       "                    SomeReallyLongType WithSomeReallyLongValue);");
7639   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7640                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7641                "  return left.group < right.group;\n"
7642                "}");
7643   verifyFormat("SomeType &operator=(const SomeType &S);");
7644   verifyFormat("f.template operator()<int>();");
7645 
7646   verifyGoogleFormat("operator void*();");
7647   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7648   verifyGoogleFormat("operator ::A();");
7649 
7650   verifyFormat("using A::operator+;");
7651   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7652                "int i;");
7653 }
7654 
7655 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7656   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7657   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7658   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7659   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7660   verifyFormat("Deleted &operator=(const Deleted &) &;");
7661   verifyFormat("Deleted &operator=(const Deleted &) &&;");
7662   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7663   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7664   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7665   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7666   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7667   verifyFormat("void Fn(T const &) const &;");
7668   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7669   verifyFormat("template <typename T>\n"
7670                "void F(T) && = delete;",
7671                getGoogleStyle());
7672 
7673   FormatStyle AlignLeft = getLLVMStyle();
7674   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7675   verifyFormat("void A::b() && {}", AlignLeft);
7676   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7677   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7678                AlignLeft);
7679   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7680   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7681   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7682   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7683   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7684   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7685   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7686   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7687 
7688   FormatStyle Spaces = getLLVMStyle();
7689   Spaces.SpacesInCStyleCastParentheses = true;
7690   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7691   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7692   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7693   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7694 
7695   Spaces.SpacesInCStyleCastParentheses = false;
7696   Spaces.SpacesInParentheses = true;
7697   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7698   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7699                Spaces);
7700   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7701   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7702 
7703   FormatStyle BreakTemplate = getLLVMStyle();
7704   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7705 
7706   verifyFormat("struct f {\n"
7707                "  template <class T>\n"
7708                "  int &foo(const std::string &str) &noexcept {}\n"
7709                "};",
7710                BreakTemplate);
7711 
7712   verifyFormat("struct f {\n"
7713                "  template <class T>\n"
7714                "  int &foo(const std::string &str) &&noexcept {}\n"
7715                "};",
7716                BreakTemplate);
7717 
7718   verifyFormat("struct f {\n"
7719                "  template <class T>\n"
7720                "  int &foo(const std::string &str) const &noexcept {}\n"
7721                "};",
7722                BreakTemplate);
7723 
7724   verifyFormat("struct f {\n"
7725                "  template <class T>\n"
7726                "  int &foo(const std::string &str) const &noexcept {}\n"
7727                "};",
7728                BreakTemplate);
7729 
7730   verifyFormat("struct f {\n"
7731                "  template <class T>\n"
7732                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
7733                "};",
7734                BreakTemplate);
7735 
7736   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7737   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7738       FormatStyle::BTDS_Yes;
7739   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7740 
7741   verifyFormat("struct f {\n"
7742                "  template <class T>\n"
7743                "  int& foo(const std::string& str) & noexcept {}\n"
7744                "};",
7745                AlignLeftBreakTemplate);
7746 
7747   verifyFormat("struct f {\n"
7748                "  template <class T>\n"
7749                "  int& foo(const std::string& str) && noexcept {}\n"
7750                "};",
7751                AlignLeftBreakTemplate);
7752 
7753   verifyFormat("struct f {\n"
7754                "  template <class T>\n"
7755                "  int& foo(const std::string& str) const& noexcept {}\n"
7756                "};",
7757                AlignLeftBreakTemplate);
7758 
7759   verifyFormat("struct f {\n"
7760                "  template <class T>\n"
7761                "  int& foo(const std::string& str) const&& noexcept {}\n"
7762                "};",
7763                AlignLeftBreakTemplate);
7764 
7765   verifyFormat("struct f {\n"
7766                "  template <class T>\n"
7767                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7768                "};",
7769                AlignLeftBreakTemplate);
7770 
7771   // The `&` in `Type&` should not be confused with a trailing `&` of
7772   // DEPRECATED(reason) member function.
7773   verifyFormat("struct f {\n"
7774                "  template <class T>\n"
7775                "  DEPRECATED(reason)\n"
7776                "  Type &foo(arguments) {}\n"
7777                "};",
7778                BreakTemplate);
7779 
7780   verifyFormat("struct f {\n"
7781                "  template <class T>\n"
7782                "  DEPRECATED(reason)\n"
7783                "  Type& foo(arguments) {}\n"
7784                "};",
7785                AlignLeftBreakTemplate);
7786 
7787   verifyFormat("void (*foopt)(int) = &func;");
7788 }
7789 
7790 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7791   verifyFormat("void f() {\n"
7792                "  A *a = new A;\n"
7793                "  A *a = new (placement) A;\n"
7794                "  delete a;\n"
7795                "  delete (A *)a;\n"
7796                "}");
7797   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7798                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7799   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7800                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7801                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7802   verifyFormat("delete[] h->p;");
7803 }
7804 
7805 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
7806   verifyFormat("int *f(int *a) {}");
7807   verifyFormat("int main(int argc, char **argv) {}");
7808   verifyFormat("Test::Test(int b) : a(b * b) {}");
7809   verifyIndependentOfContext("f(a, *a);");
7810   verifyFormat("void g() { f(*a); }");
7811   verifyIndependentOfContext("int a = b * 10;");
7812   verifyIndependentOfContext("int a = 10 * b;");
7813   verifyIndependentOfContext("int a = b * c;");
7814   verifyIndependentOfContext("int a += b * c;");
7815   verifyIndependentOfContext("int a -= b * c;");
7816   verifyIndependentOfContext("int a *= b * c;");
7817   verifyIndependentOfContext("int a /= b * c;");
7818   verifyIndependentOfContext("int a = *b;");
7819   verifyIndependentOfContext("int a = *b * c;");
7820   verifyIndependentOfContext("int a = b * *c;");
7821   verifyIndependentOfContext("int a = b * (10);");
7822   verifyIndependentOfContext("S << b * (10);");
7823   verifyIndependentOfContext("return 10 * b;");
7824   verifyIndependentOfContext("return *b * *c;");
7825   verifyIndependentOfContext("return a & ~b;");
7826   verifyIndependentOfContext("f(b ? *c : *d);");
7827   verifyIndependentOfContext("int a = b ? *c : *d;");
7828   verifyIndependentOfContext("*b = a;");
7829   verifyIndependentOfContext("a * ~b;");
7830   verifyIndependentOfContext("a * !b;");
7831   verifyIndependentOfContext("a * +b;");
7832   verifyIndependentOfContext("a * -b;");
7833   verifyIndependentOfContext("a * ++b;");
7834   verifyIndependentOfContext("a * --b;");
7835   verifyIndependentOfContext("a[4] * b;");
7836   verifyIndependentOfContext("a[a * a] = 1;");
7837   verifyIndependentOfContext("f() * b;");
7838   verifyIndependentOfContext("a * [self dostuff];");
7839   verifyIndependentOfContext("int x = a * (a + b);");
7840   verifyIndependentOfContext("(a *)(a + b);");
7841   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
7842   verifyIndependentOfContext("int *pa = (int *)&a;");
7843   verifyIndependentOfContext("return sizeof(int **);");
7844   verifyIndependentOfContext("return sizeof(int ******);");
7845   verifyIndependentOfContext("return (int **&)a;");
7846   verifyIndependentOfContext("f((*PointerToArray)[10]);");
7847   verifyFormat("void f(Type (*parameter)[10]) {}");
7848   verifyFormat("void f(Type (&parameter)[10]) {}");
7849   verifyGoogleFormat("return sizeof(int**);");
7850   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
7851   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
7852   verifyFormat("auto a = [](int **&, int ***) {};");
7853   verifyFormat("auto PointerBinding = [](const char *S) {};");
7854   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
7855   verifyFormat("[](const decltype(*a) &value) {}");
7856   verifyFormat("decltype(a * b) F();");
7857   verifyFormat("#define MACRO() [](A *a) { return 1; }");
7858   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
7859   verifyIndependentOfContext("typedef void (*f)(int *a);");
7860   verifyIndependentOfContext("int i{a * b};");
7861   verifyIndependentOfContext("aaa && aaa->f();");
7862   verifyIndependentOfContext("int x = ~*p;");
7863   verifyFormat("Constructor() : a(a), area(width * height) {}");
7864   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
7865   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
7866   verifyFormat("void f() { f(a, c * d); }");
7867   verifyFormat("void f() { f(new a(), c * d); }");
7868   verifyFormat("void f(const MyOverride &override);");
7869   verifyFormat("void f(const MyFinal &final);");
7870   verifyIndependentOfContext("bool a = f() && override.f();");
7871   verifyIndependentOfContext("bool a = f() && final.f();");
7872 
7873   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
7874 
7875   verifyIndependentOfContext("A<int *> a;");
7876   verifyIndependentOfContext("A<int **> a;");
7877   verifyIndependentOfContext("A<int *, int *> a;");
7878   verifyIndependentOfContext("A<int *[]> a;");
7879   verifyIndependentOfContext(
7880       "const char *const p = reinterpret_cast<const char *const>(q);");
7881   verifyIndependentOfContext("A<int **, int **> a;");
7882   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
7883   verifyFormat("for (char **a = b; *a; ++a) {\n}");
7884   verifyFormat("for (; a && b;) {\n}");
7885   verifyFormat("bool foo = true && [] { return false; }();");
7886 
7887   verifyFormat(
7888       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7889       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7890 
7891   verifyGoogleFormat("int const* a = &b;");
7892   verifyGoogleFormat("**outparam = 1;");
7893   verifyGoogleFormat("*outparam = a * b;");
7894   verifyGoogleFormat("int main(int argc, char** argv) {}");
7895   verifyGoogleFormat("A<int*> a;");
7896   verifyGoogleFormat("A<int**> a;");
7897   verifyGoogleFormat("A<int*, int*> a;");
7898   verifyGoogleFormat("A<int**, int**> a;");
7899   verifyGoogleFormat("f(b ? *c : *d);");
7900   verifyGoogleFormat("int a = b ? *c : *d;");
7901   verifyGoogleFormat("Type* t = **x;");
7902   verifyGoogleFormat("Type* t = *++*x;");
7903   verifyGoogleFormat("*++*x;");
7904   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
7905   verifyGoogleFormat("Type* t = x++ * y;");
7906   verifyGoogleFormat(
7907       "const char* const p = reinterpret_cast<const char* const>(q);");
7908   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
7909   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
7910   verifyGoogleFormat("template <typename T>\n"
7911                      "void f(int i = 0, SomeType** temps = NULL);");
7912 
7913   FormatStyle Left = getLLVMStyle();
7914   Left.PointerAlignment = FormatStyle::PAS_Left;
7915   verifyFormat("x = *a(x) = *a(y);", Left);
7916   verifyFormat("for (;; *a = b) {\n}", Left);
7917   verifyFormat("return *this += 1;", Left);
7918   verifyFormat("throw *x;", Left);
7919   verifyFormat("delete *x;", Left);
7920   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
7921   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
7922   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
7923   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
7924   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
7925   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
7926 
7927   verifyIndependentOfContext("a = *(x + y);");
7928   verifyIndependentOfContext("a = &(x + y);");
7929   verifyIndependentOfContext("*(x + y).call();");
7930   verifyIndependentOfContext("&(x + y)->call();");
7931   verifyFormat("void f() { &(*I).first; }");
7932 
7933   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
7934   verifyFormat(
7935       "int *MyValues = {\n"
7936       "    *A, // Operator detection might be confused by the '{'\n"
7937       "    *BB // Operator detection might be confused by previous comment\n"
7938       "};");
7939 
7940   verifyIndependentOfContext("if (int *a = &b)");
7941   verifyIndependentOfContext("if (int &a = *b)");
7942   verifyIndependentOfContext("if (a & b[i])");
7943   verifyIndependentOfContext("if constexpr (a & b[i])");
7944   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
7945   verifyIndependentOfContext("if (a * (b * c))");
7946   verifyIndependentOfContext("if constexpr (a * (b * c))");
7947   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
7948   verifyIndependentOfContext("if (a::b::c::d & b[i])");
7949   verifyIndependentOfContext("if (*b[i])");
7950   verifyIndependentOfContext("if (int *a = (&b))");
7951   verifyIndependentOfContext("while (int *a = &b)");
7952   verifyIndependentOfContext("while (a * (b * c))");
7953   verifyIndependentOfContext("size = sizeof *a;");
7954   verifyIndependentOfContext("if (a && (b = c))");
7955   verifyFormat("void f() {\n"
7956                "  for (const int &v : Values) {\n"
7957                "  }\n"
7958                "}");
7959   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
7960   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
7961   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
7962 
7963   verifyFormat("#define A (!a * b)");
7964   verifyFormat("#define MACRO     \\\n"
7965                "  int *i = a * b; \\\n"
7966                "  void f(a *b);",
7967                getLLVMStyleWithColumns(19));
7968 
7969   verifyIndependentOfContext("A = new SomeType *[Length];");
7970   verifyIndependentOfContext("A = new SomeType *[Length]();");
7971   verifyIndependentOfContext("T **t = new T *;");
7972   verifyIndependentOfContext("T **t = new T *();");
7973   verifyGoogleFormat("A = new SomeType*[Length]();");
7974   verifyGoogleFormat("A = new SomeType*[Length];");
7975   verifyGoogleFormat("T** t = new T*;");
7976   verifyGoogleFormat("T** t = new T*();");
7977 
7978   verifyFormat("STATIC_ASSERT((a & b) == 0);");
7979   verifyFormat("STATIC_ASSERT(0 == (a & b));");
7980   verifyFormat("template <bool a, bool b> "
7981                "typename t::if<x && y>::type f() {}");
7982   verifyFormat("template <int *y> f() {}");
7983   verifyFormat("vector<int *> v;");
7984   verifyFormat("vector<int *const> v;");
7985   verifyFormat("vector<int *const **const *> v;");
7986   verifyFormat("vector<int *volatile> v;");
7987   verifyFormat("vector<a * b> v;");
7988   verifyFormat("foo<b && false>();");
7989   verifyFormat("foo<b & 1>();");
7990   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
7991   verifyFormat(
7992       "template <class T, class = typename std::enable_if<\n"
7993       "                       std::is_integral<T>::value &&\n"
7994       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
7995       "void F();",
7996       getLLVMStyleWithColumns(70));
7997   verifyFormat("template <class T,\n"
7998                "          class = typename std::enable_if<\n"
7999                "              std::is_integral<T>::value &&\n"
8000                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
8001                "          class U>\n"
8002                "void F();",
8003                getLLVMStyleWithColumns(70));
8004   verifyFormat(
8005       "template <class T,\n"
8006       "          class = typename ::std::enable_if<\n"
8007       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
8008       "void F();",
8009       getGoogleStyleWithColumns(68));
8010 
8011   verifyIndependentOfContext("MACRO(int *i);");
8012   verifyIndependentOfContext("MACRO(auto *a);");
8013   verifyIndependentOfContext("MACRO(const A *a);");
8014   verifyIndependentOfContext("MACRO(A *const a);");
8015   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
8016   verifyFormat("void f() { f(float{1}, a * a); }");
8017   // FIXME: Is there a way to make this work?
8018   // verifyIndependentOfContext("MACRO(A *a);");
8019 
8020   verifyFormat("DatumHandle const *operator->() const { return input_; }");
8021   verifyFormat("return options != nullptr && operator==(*options);");
8022 
8023   EXPECT_EQ("#define OP(x)                                    \\\n"
8024             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
8025             "    return s << a.DebugString();                 \\\n"
8026             "  }",
8027             format("#define OP(x) \\\n"
8028                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
8029                    "    return s << a.DebugString(); \\\n"
8030                    "  }",
8031                    getLLVMStyleWithColumns(50)));
8032 
8033   // FIXME: We cannot handle this case yet; we might be able to figure out that
8034   // foo<x> d > v; doesn't make sense.
8035   verifyFormat("foo<a<b && c> d> v;");
8036 
8037   FormatStyle PointerMiddle = getLLVMStyle();
8038   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8039   verifyFormat("delete *x;", PointerMiddle);
8040   verifyFormat("int * x;", PointerMiddle);
8041   verifyFormat("int *[] x;", PointerMiddle);
8042   verifyFormat("template <int * y> f() {}", PointerMiddle);
8043   verifyFormat("int * f(int * a) {}", PointerMiddle);
8044   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8045   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8046   verifyFormat("A<int *> a;", PointerMiddle);
8047   verifyFormat("A<int **> a;", PointerMiddle);
8048   verifyFormat("A<int *, int *> a;", PointerMiddle);
8049   verifyFormat("A<int *[]> a;", PointerMiddle);
8050   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8051   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8052   verifyFormat("T ** t = new T *;", PointerMiddle);
8053 
8054   // Member function reference qualifiers aren't binary operators.
8055   verifyFormat("string // break\n"
8056                "operator()() & {}");
8057   verifyFormat("string // break\n"
8058                "operator()() && {}");
8059   verifyGoogleFormat("template <typename T>\n"
8060                      "auto x() & -> int {}");
8061 }
8062 
8063 TEST_F(FormatTest, UnderstandsAttributes) {
8064   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8065   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8066                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8067   FormatStyle AfterType = getLLVMStyle();
8068   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
8069   verifyFormat("__attribute__((nodebug)) void\n"
8070                "foo() {}\n",
8071                AfterType);
8072 }
8073 
8074 TEST_F(FormatTest, UnderstandsSquareAttributes) {
8075   verifyFormat("SomeType s [[unused]] (InitValue);");
8076   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8077   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8078   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8079   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8080   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8081                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8082   verifyFormat("[[nodiscard]] bool f() { return false; }");
8083   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
8084   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
8085   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
8086 
8087   // Make sure we do not mistake attributes for array subscripts.
8088   verifyFormat("int a() {}\n"
8089                "[[unused]] int b() {}\n");
8090   verifyFormat("NSArray *arr;\n"
8091                "arr[[Foo() bar]];");
8092 
8093   // On the other hand, we still need to correctly find array subscripts.
8094   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8095 
8096   // Make sure that we do not mistake Objective-C method inside array literals
8097   // as attributes, even if those method names are also keywords.
8098   verifyFormat("@[ [foo bar] ];");
8099   verifyFormat("@[ [NSArray class] ];");
8100   verifyFormat("@[ [foo enum] ];");
8101 
8102   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8103 
8104   // Make sure we do not parse attributes as lambda introducers.
8105   FormatStyle MultiLineFunctions = getLLVMStyle();
8106   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8107   verifyFormat("[[unused]] int b() {\n"
8108                "  return 42;\n"
8109                "}\n",
8110                MultiLineFunctions);
8111 }
8112 
8113 TEST_F(FormatTest, AttributeClass) {
8114   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8115   verifyFormat("class S {\n"
8116                "  S(S&&) = default;\n"
8117                "};",
8118                Style);
8119   verifyFormat("class [[nodiscard]] S {\n"
8120                "  S(S&&) = default;\n"
8121                "};",
8122                Style);
8123   verifyFormat("class __attribute((maybeunused)) S {\n"
8124                "  S(S&&) = default;\n"
8125                "};",
8126                Style);
8127   verifyFormat("struct S {\n"
8128                "  S(S&&) = default;\n"
8129                "};",
8130                Style);
8131   verifyFormat("struct [[nodiscard]] S {\n"
8132                "  S(S&&) = default;\n"
8133                "};",
8134                Style);
8135 }
8136 
8137 TEST_F(FormatTest, AttributesAfterMacro) {
8138   FormatStyle Style = getLLVMStyle();
8139   verifyFormat("MACRO;\n"
8140                "__attribute__((maybe_unused)) int foo() {\n"
8141                "  //...\n"
8142                "}");
8143 
8144   verifyFormat("MACRO;\n"
8145                "[[nodiscard]] int foo() {\n"
8146                "  //...\n"
8147                "}");
8148 
8149   EXPECT_EQ("MACRO\n\n"
8150             "__attribute__((maybe_unused)) int foo() {\n"
8151             "  //...\n"
8152             "}",
8153             format("MACRO\n\n"
8154                    "__attribute__((maybe_unused)) int foo() {\n"
8155                    "  //...\n"
8156                    "}"));
8157 
8158   EXPECT_EQ("MACRO\n\n"
8159             "[[nodiscard]] int foo() {\n"
8160             "  //...\n"
8161             "}",
8162             format("MACRO\n\n"
8163                    "[[nodiscard]] int foo() {\n"
8164                    "  //...\n"
8165                    "}"));
8166 }
8167 
8168 TEST_F(FormatTest, AttributePenaltyBreaking) {
8169   FormatStyle Style = getLLVMStyle();
8170   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8171                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8172                Style);
8173   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8174                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8175                Style);
8176   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8177                "shared_ptr<ALongTypeName> &C d) {\n}",
8178                Style);
8179 }
8180 
8181 TEST_F(FormatTest, UnderstandsEllipsis) {
8182   FormatStyle Style = getLLVMStyle();
8183   verifyFormat("int printf(const char *fmt, ...);");
8184   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8185   verifyFormat("template <class... Ts> void Foo(Ts *...ts) {}");
8186 
8187   verifyFormat("template <int *...PP> a;", Style);
8188 
8189   Style.PointerAlignment = FormatStyle::PAS_Left;
8190   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", Style);
8191 
8192   verifyFormat("template <int*... PP> a;", Style);
8193 
8194   Style.PointerAlignment = FormatStyle::PAS_Middle;
8195   verifyFormat("template <int *... PP> a;", Style);
8196 }
8197 
8198 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8199   EXPECT_EQ("int *a;\n"
8200             "int *a;\n"
8201             "int *a;",
8202             format("int *a;\n"
8203                    "int* a;\n"
8204                    "int *a;",
8205                    getGoogleStyle()));
8206   EXPECT_EQ("int* a;\n"
8207             "int* a;\n"
8208             "int* a;",
8209             format("int* a;\n"
8210                    "int* a;\n"
8211                    "int *a;",
8212                    getGoogleStyle()));
8213   EXPECT_EQ("int *a;\n"
8214             "int *a;\n"
8215             "int *a;",
8216             format("int *a;\n"
8217                    "int * a;\n"
8218                    "int *  a;",
8219                    getGoogleStyle()));
8220   EXPECT_EQ("auto x = [] {\n"
8221             "  int *a;\n"
8222             "  int *a;\n"
8223             "  int *a;\n"
8224             "};",
8225             format("auto x=[]{int *a;\n"
8226                    "int * a;\n"
8227                    "int *  a;};",
8228                    getGoogleStyle()));
8229 }
8230 
8231 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8232   verifyFormat("int f(int &&a) {}");
8233   verifyFormat("int f(int a, char &&b) {}");
8234   verifyFormat("void f() { int &&a = b; }");
8235   verifyGoogleFormat("int f(int a, char&& b) {}");
8236   verifyGoogleFormat("void f() { int&& a = b; }");
8237 
8238   verifyIndependentOfContext("A<int &&> a;");
8239   verifyIndependentOfContext("A<int &&, int &&> a;");
8240   verifyGoogleFormat("A<int&&> a;");
8241   verifyGoogleFormat("A<int&&, int&&> a;");
8242 
8243   // Not rvalue references:
8244   verifyFormat("template <bool B, bool C> class A {\n"
8245                "  static_assert(B && C, \"Something is wrong\");\n"
8246                "};");
8247   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8248   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8249   verifyFormat("#define A(a, b) (a && b)");
8250 }
8251 
8252 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8253   verifyFormat("void f() {\n"
8254                "  x[aaaaaaaaa -\n"
8255                "    b] = 23;\n"
8256                "}",
8257                getLLVMStyleWithColumns(15));
8258 }
8259 
8260 TEST_F(FormatTest, FormatsCasts) {
8261   verifyFormat("Type *A = static_cast<Type *>(P);");
8262   verifyFormat("Type *A = (Type *)P;");
8263   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8264   verifyFormat("int a = (int)(2.0f);");
8265   verifyFormat("int a = (int)2.0f;");
8266   verifyFormat("x[(int32)y];");
8267   verifyFormat("x = (int32)y;");
8268   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8269   verifyFormat("int a = (int)*b;");
8270   verifyFormat("int a = (int)2.0f;");
8271   verifyFormat("int a = (int)~0;");
8272   verifyFormat("int a = (int)++a;");
8273   verifyFormat("int a = (int)sizeof(int);");
8274   verifyFormat("int a = (int)+2;");
8275   verifyFormat("my_int a = (my_int)2.0f;");
8276   verifyFormat("my_int a = (my_int)sizeof(int);");
8277   verifyFormat("return (my_int)aaa;");
8278   verifyFormat("#define x ((int)-1)");
8279   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8280   verifyFormat("#define p(q) ((int *)&q)");
8281   verifyFormat("fn(a)(b) + 1;");
8282 
8283   verifyFormat("void f() { my_int a = (my_int)*b; }");
8284   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8285   verifyFormat("my_int a = (my_int)~0;");
8286   verifyFormat("my_int a = (my_int)++a;");
8287   verifyFormat("my_int a = (my_int)-2;");
8288   verifyFormat("my_int a = (my_int)1;");
8289   verifyFormat("my_int a = (my_int *)1;");
8290   verifyFormat("my_int a = (const my_int)-1;");
8291   verifyFormat("my_int a = (const my_int *)-1;");
8292   verifyFormat("my_int a = (my_int)(my_int)-1;");
8293   verifyFormat("my_int a = (ns::my_int)-2;");
8294   verifyFormat("case (my_int)ONE:");
8295   verifyFormat("auto x = (X)this;");
8296   // Casts in Obj-C style calls used to not be recognized as such.
8297   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8298 
8299   // FIXME: single value wrapped with paren will be treated as cast.
8300   verifyFormat("void f(int i = (kValue)*kMask) {}");
8301 
8302   verifyFormat("{ (void)F; }");
8303 
8304   // Don't break after a cast's
8305   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8306                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8307                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8308 
8309   // These are not casts.
8310   verifyFormat("void f(int *) {}");
8311   verifyFormat("f(foo)->b;");
8312   verifyFormat("f(foo).b;");
8313   verifyFormat("f(foo)(b);");
8314   verifyFormat("f(foo)[b];");
8315   verifyFormat("[](foo) { return 4; }(bar);");
8316   verifyFormat("(*funptr)(foo)[4];");
8317   verifyFormat("funptrs[4](foo)[4];");
8318   verifyFormat("void f(int *);");
8319   verifyFormat("void f(int *) = 0;");
8320   verifyFormat("void f(SmallVector<int>) {}");
8321   verifyFormat("void f(SmallVector<int>);");
8322   verifyFormat("void f(SmallVector<int>) = 0;");
8323   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8324   verifyFormat("int a = sizeof(int) * b;");
8325   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8326   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8327   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8328   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8329 
8330   // These are not casts, but at some point were confused with casts.
8331   verifyFormat("virtual void foo(int *) override;");
8332   verifyFormat("virtual void foo(char &) const;");
8333   verifyFormat("virtual void foo(int *a, char *) const;");
8334   verifyFormat("int a = sizeof(int *) + b;");
8335   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8336   verifyFormat("bool b = f(g<int>) && c;");
8337   verifyFormat("typedef void (*f)(int i) func;");
8338   verifyFormat("void operator++(int) noexcept;");
8339   verifyFormat("void operator++(int &) noexcept;");
8340   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8341                "&) noexcept;");
8342   verifyFormat(
8343       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8344   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8345   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8346   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8347   verifyFormat("void operator delete(foo &) noexcept;");
8348   verifyFormat("void operator delete(foo) noexcept;");
8349   verifyFormat("void operator delete(int) noexcept;");
8350   verifyFormat("void operator delete(int &) noexcept;");
8351   verifyFormat("void operator delete(int &) volatile noexcept;");
8352   verifyFormat("void operator delete(int &) const");
8353   verifyFormat("void operator delete(int &) = default");
8354   verifyFormat("void operator delete(int &) = delete");
8355   verifyFormat("void operator delete(int &) [[noreturn]]");
8356   verifyFormat("void operator delete(int &) throw();");
8357   verifyFormat("void operator delete(int &) throw(int);");
8358   verifyFormat("auto operator delete(int &) -> int;");
8359   verifyFormat("auto operator delete(int &) override");
8360   verifyFormat("auto operator delete(int &) final");
8361 
8362   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8363                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8364   // FIXME: The indentation here is not ideal.
8365   verifyFormat(
8366       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8367       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8368       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8369 }
8370 
8371 TEST_F(FormatTest, FormatsFunctionTypes) {
8372   verifyFormat("A<bool()> a;");
8373   verifyFormat("A<SomeType()> a;");
8374   verifyFormat("A<void (*)(int, std::string)> a;");
8375   verifyFormat("A<void *(int)>;");
8376   verifyFormat("void *(*a)(int *, SomeType *);");
8377   verifyFormat("int (*func)(void *);");
8378   verifyFormat("void f() { int (*func)(void *); }");
8379   verifyFormat("template <class CallbackClass>\n"
8380                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8381 
8382   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8383   verifyGoogleFormat("void* (*a)(int);");
8384   verifyGoogleFormat(
8385       "template <class CallbackClass>\n"
8386       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8387 
8388   // Other constructs can look somewhat like function types:
8389   verifyFormat("A<sizeof(*x)> a;");
8390   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8391   verifyFormat("some_var = function(*some_pointer_var)[0];");
8392   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8393   verifyFormat("int x = f(&h)();");
8394   verifyFormat("returnsFunction(&param1, &param2)(param);");
8395   verifyFormat("std::function<\n"
8396                "    LooooooooooongTemplatedType<\n"
8397                "        SomeType>*(\n"
8398                "        LooooooooooooooooongType type)>\n"
8399                "    function;",
8400                getGoogleStyleWithColumns(40));
8401 }
8402 
8403 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8404   verifyFormat("A (*foo_)[6];");
8405   verifyFormat("vector<int> (*foo_)[6];");
8406 }
8407 
8408 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8409   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8410                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8411   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8412                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8413   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8414                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8415 
8416   // Different ways of ()-initializiation.
8417   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8418                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8419   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8420                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8421   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8422                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8423   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8424                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8425 
8426   // Lambdas should not confuse the variable declaration heuristic.
8427   verifyFormat("LooooooooooooooooongType\n"
8428                "    variable(nullptr, [](A *a) {});",
8429                getLLVMStyleWithColumns(40));
8430 }
8431 
8432 TEST_F(FormatTest, BreaksLongDeclarations) {
8433   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8434                "    AnotherNameForTheLongType;");
8435   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8436                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8437   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8438                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8439   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8440                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8441   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8442                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8443   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8444                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8445   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8446                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8447   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8448                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8449   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8450                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8451   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8452                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8453   FormatStyle Indented = getLLVMStyle();
8454   Indented.IndentWrappedFunctionNames = true;
8455   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8456                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8457                Indented);
8458   verifyFormat(
8459       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8460       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8461       Indented);
8462   verifyFormat(
8463       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8464       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8465       Indented);
8466   verifyFormat(
8467       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8468       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8469       Indented);
8470 
8471   // FIXME: Without the comment, this breaks after "(".
8472   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8473                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8474                getGoogleStyle());
8475 
8476   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8477                "                  int LoooooooooooooooooooongParam2) {}");
8478   verifyFormat(
8479       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8480       "                                   SourceLocation L, IdentifierIn *II,\n"
8481       "                                   Type *T) {}");
8482   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8483                "ReallyReaaallyLongFunctionName(\n"
8484                "    const std::string &SomeParameter,\n"
8485                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8486                "        &ReallyReallyLongParameterName,\n"
8487                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8488                "        &AnotherLongParameterName) {}");
8489   verifyFormat("template <typename A>\n"
8490                "SomeLoooooooooooooooooooooongType<\n"
8491                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8492                "Function() {}");
8493 
8494   verifyGoogleFormat(
8495       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8496       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8497   verifyGoogleFormat(
8498       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8499       "                                   SourceLocation L) {}");
8500   verifyGoogleFormat(
8501       "some_namespace::LongReturnType\n"
8502       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8503       "    int first_long_parameter, int second_parameter) {}");
8504 
8505   verifyGoogleFormat("template <typename T>\n"
8506                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8507                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8508   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8509                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8510 
8511   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8512                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8513                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8514   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8515                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8516                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8517   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8518                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8519                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8520                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8521 
8522   verifyFormat("template <typename T> // Templates on own line.\n"
8523                "static int            // Some comment.\n"
8524                "MyFunction(int a);",
8525                getLLVMStyle());
8526 }
8527 
8528 TEST_F(FormatTest, FormatsArrays) {
8529   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8530                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8531   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8532                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8533   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8534                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8535   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8536                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8537   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8538                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8539   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8540                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8541                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8542   verifyFormat(
8543       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8544       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8545       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8546   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8547                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8548 
8549   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8550                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8551   verifyFormat(
8552       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8553       "                                  .aaaaaaa[0]\n"
8554       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8555   verifyFormat("a[::b::c];");
8556 
8557   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8558 
8559   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8560   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8561 }
8562 
8563 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8564   verifyFormat("(a)->b();");
8565   verifyFormat("--a;");
8566 }
8567 
8568 TEST_F(FormatTest, HandlesIncludeDirectives) {
8569   verifyFormat("#include <string>\n"
8570                "#include <a/b/c.h>\n"
8571                "#include \"a/b/string\"\n"
8572                "#include \"string.h\"\n"
8573                "#include \"string.h\"\n"
8574                "#include <a-a>\n"
8575                "#include < path with space >\n"
8576                "#include_next <test.h>"
8577                "#include \"abc.h\" // this is included for ABC\n"
8578                "#include \"some long include\" // with a comment\n"
8579                "#include \"some very long include path\"\n"
8580                "#include <some/very/long/include/path>\n",
8581                getLLVMStyleWithColumns(35));
8582   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8583   EXPECT_EQ("#include <a>", format("#include<a>"));
8584 
8585   verifyFormat("#import <string>");
8586   verifyFormat("#import <a/b/c.h>");
8587   verifyFormat("#import \"a/b/string\"");
8588   verifyFormat("#import \"string.h\"");
8589   verifyFormat("#import \"string.h\"");
8590   verifyFormat("#if __has_include(<strstream>)\n"
8591                "#include <strstream>\n"
8592                "#endif");
8593 
8594   verifyFormat("#define MY_IMPORT <a/b>");
8595 
8596   verifyFormat("#if __has_include(<a/b>)");
8597   verifyFormat("#if __has_include_next(<a/b>)");
8598   verifyFormat("#define F __has_include(<a/b>)");
8599   verifyFormat("#define F __has_include_next(<a/b>)");
8600 
8601   // Protocol buffer definition or missing "#".
8602   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8603                getLLVMStyleWithColumns(30));
8604 
8605   FormatStyle Style = getLLVMStyle();
8606   Style.AlwaysBreakBeforeMultilineStrings = true;
8607   Style.ColumnLimit = 0;
8608   verifyFormat("#import \"abc.h\"", Style);
8609 
8610   // But 'import' might also be a regular C++ namespace.
8611   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8612                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8613 }
8614 
8615 //===----------------------------------------------------------------------===//
8616 // Error recovery tests.
8617 //===----------------------------------------------------------------------===//
8618 
8619 TEST_F(FormatTest, IncompleteParameterLists) {
8620   FormatStyle NoBinPacking = getLLVMStyle();
8621   NoBinPacking.BinPackParameters = false;
8622   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8623                "                        double *min_x,\n"
8624                "                        double *max_x,\n"
8625                "                        double *min_y,\n"
8626                "                        double *max_y,\n"
8627                "                        double *min_z,\n"
8628                "                        double *max_z, ) {}",
8629                NoBinPacking);
8630 }
8631 
8632 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8633   verifyFormat("void f() { return; }\n42");
8634   verifyFormat("void f() {\n"
8635                "  if (0)\n"
8636                "    return;\n"
8637                "}\n"
8638                "42");
8639   verifyFormat("void f() { return }\n42");
8640   verifyFormat("void f() {\n"
8641                "  if (0)\n"
8642                "    return\n"
8643                "}\n"
8644                "42");
8645 }
8646 
8647 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
8648   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
8649   EXPECT_EQ("void f() {\n"
8650             "  if (a)\n"
8651             "    return\n"
8652             "}",
8653             format("void  f  (  )  {  if  ( a )  return  }"));
8654   EXPECT_EQ("namespace N {\n"
8655             "void f()\n"
8656             "}",
8657             format("namespace  N  {  void f()  }"));
8658   EXPECT_EQ("namespace N {\n"
8659             "void f() {}\n"
8660             "void g()\n"
8661             "} // namespace N",
8662             format("namespace N  { void f( ) { } void g( ) }"));
8663 }
8664 
8665 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
8666   verifyFormat("int aaaaaaaa =\n"
8667                "    // Overlylongcomment\n"
8668                "    b;",
8669                getLLVMStyleWithColumns(20));
8670   verifyFormat("function(\n"
8671                "    ShortArgument,\n"
8672                "    LoooooooooooongArgument);\n",
8673                getLLVMStyleWithColumns(20));
8674 }
8675 
8676 TEST_F(FormatTest, IncorrectAccessSpecifier) {
8677   verifyFormat("public:");
8678   verifyFormat("class A {\n"
8679                "public\n"
8680                "  void f() {}\n"
8681                "};");
8682   verifyFormat("public\n"
8683                "int qwerty;");
8684   verifyFormat("public\n"
8685                "B {}");
8686   verifyFormat("public\n"
8687                "{}");
8688   verifyFormat("public\n"
8689                "B { int x; }");
8690 }
8691 
8692 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
8693   verifyFormat("{");
8694   verifyFormat("#})");
8695   verifyNoCrash("(/**/[:!] ?[).");
8696 }
8697 
8698 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
8699   // Found by oss-fuzz:
8700   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
8701   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
8702   Style.ColumnLimit = 60;
8703   verifyNoCrash(
8704       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
8705       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
8706       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
8707       Style);
8708 }
8709 
8710 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
8711   verifyFormat("do {\n}");
8712   verifyFormat("do {\n}\n"
8713                "f();");
8714   verifyFormat("do {\n}\n"
8715                "wheeee(fun);");
8716   verifyFormat("do {\n"
8717                "  f();\n"
8718                "}");
8719 }
8720 
8721 TEST_F(FormatTest, IncorrectCodeMissingParens) {
8722   verifyFormat("if {\n  foo;\n  foo();\n}");
8723   verifyFormat("switch {\n  foo;\n  foo();\n}");
8724   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
8725   verifyFormat("while {\n  foo;\n  foo();\n}");
8726   verifyFormat("do {\n  foo;\n  foo();\n} while;");
8727 }
8728 
8729 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
8730   verifyIncompleteFormat("namespace {\n"
8731                          "class Foo { Foo (\n"
8732                          "};\n"
8733                          "} // namespace");
8734 }
8735 
8736 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
8737   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
8738   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
8739   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
8740   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
8741 
8742   EXPECT_EQ("{\n"
8743             "  {\n"
8744             "    breakme(\n"
8745             "        qwe);\n"
8746             "  }\n",
8747             format("{\n"
8748                    "    {\n"
8749                    " breakme(qwe);\n"
8750                    "}\n",
8751                    getLLVMStyleWithColumns(10)));
8752 }
8753 
8754 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
8755   verifyFormat("int x = {\n"
8756                "    avariable,\n"
8757                "    b(alongervariable)};",
8758                getLLVMStyleWithColumns(25));
8759 }
8760 
8761 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
8762   verifyFormat("return (a)(b){1, 2, 3};");
8763 }
8764 
8765 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
8766   verifyFormat("vector<int> x{1, 2, 3, 4};");
8767   verifyFormat("vector<int> x{\n"
8768                "    1,\n"
8769                "    2,\n"
8770                "    3,\n"
8771                "    4,\n"
8772                "};");
8773   verifyFormat("vector<T> x{{}, {}, {}, {}};");
8774   verifyFormat("f({1, 2});");
8775   verifyFormat("auto v = Foo{-1};");
8776   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
8777   verifyFormat("Class::Class : member{1, 2, 3} {}");
8778   verifyFormat("new vector<int>{1, 2, 3};");
8779   verifyFormat("new int[3]{1, 2, 3};");
8780   verifyFormat("new int{1};");
8781   verifyFormat("return {arg1, arg2};");
8782   verifyFormat("return {arg1, SomeType{parameter}};");
8783   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
8784   verifyFormat("new T{arg1, arg2};");
8785   verifyFormat("f(MyMap[{composite, key}]);");
8786   verifyFormat("class Class {\n"
8787                "  T member = {arg1, arg2};\n"
8788                "};");
8789   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
8790   verifyFormat("const struct A a = {.a = 1, .b = 2};");
8791   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
8792   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
8793   verifyFormat("int a = std::is_integral<int>{} + 0;");
8794 
8795   verifyFormat("int foo(int i) { return fo1{}(i); }");
8796   verifyFormat("int foo(int i) { return fo1{}(i); }");
8797   verifyFormat("auto i = decltype(x){};");
8798   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
8799   verifyFormat("Node n{1, Node{1000}, //\n"
8800                "       2};");
8801   verifyFormat("Aaaa aaaaaaa{\n"
8802                "    {\n"
8803                "        aaaa,\n"
8804                "    },\n"
8805                "};");
8806   verifyFormat("class C : public D {\n"
8807                "  SomeClass SC{2};\n"
8808                "};");
8809   verifyFormat("class C : public A {\n"
8810                "  class D : public B {\n"
8811                "    void f() { int i{2}; }\n"
8812                "  };\n"
8813                "};");
8814   verifyFormat("#define A {a, a},");
8815 
8816   // Avoid breaking between equal sign and opening brace
8817   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
8818   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
8819   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
8820                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
8821                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
8822                "     {\"ccccccccccccccccccccc\", 2}};",
8823                AvoidBreakingFirstArgument);
8824 
8825   // Binpacking only if there is no trailing comma
8826   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
8827                "                      cccccccccc, dddddddddd};",
8828                getLLVMStyleWithColumns(50));
8829   verifyFormat("const Aaaaaa aaaaa = {\n"
8830                "    aaaaaaaaaaa,\n"
8831                "    bbbbbbbbbbb,\n"
8832                "    ccccccccccc,\n"
8833                "    ddddddddddd,\n"
8834                "};",
8835                getLLVMStyleWithColumns(50));
8836 
8837   // Cases where distinguising braced lists and blocks is hard.
8838   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
8839   verifyFormat("void f() {\n"
8840                "  return; // comment\n"
8841                "}\n"
8842                "SomeType t;");
8843   verifyFormat("void f() {\n"
8844                "  if (a) {\n"
8845                "    f();\n"
8846                "  }\n"
8847                "}\n"
8848                "SomeType t;");
8849 
8850   // In combination with BinPackArguments = false.
8851   FormatStyle NoBinPacking = getLLVMStyle();
8852   NoBinPacking.BinPackArguments = false;
8853   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
8854                "                      bbbbb,\n"
8855                "                      ccccc,\n"
8856                "                      ddddd,\n"
8857                "                      eeeee,\n"
8858                "                      ffffff,\n"
8859                "                      ggggg,\n"
8860                "                      hhhhhh,\n"
8861                "                      iiiiii,\n"
8862                "                      jjjjjj,\n"
8863                "                      kkkkkk};",
8864                NoBinPacking);
8865   verifyFormat("const Aaaaaa aaaaa = {\n"
8866                "    aaaaa,\n"
8867                "    bbbbb,\n"
8868                "    ccccc,\n"
8869                "    ddddd,\n"
8870                "    eeeee,\n"
8871                "    ffffff,\n"
8872                "    ggggg,\n"
8873                "    hhhhhh,\n"
8874                "    iiiiii,\n"
8875                "    jjjjjj,\n"
8876                "    kkkkkk,\n"
8877                "};",
8878                NoBinPacking);
8879   verifyFormat(
8880       "const Aaaaaa aaaaa = {\n"
8881       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
8882       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
8883       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
8884       "};",
8885       NoBinPacking);
8886 
8887   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
8888   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
8889             "    CDDDP83848_BMCR_REGISTER,\n"
8890             "    CDDDP83848_BMSR_REGISTER,\n"
8891             "    CDDDP83848_RBR_REGISTER};",
8892             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
8893                    "                                CDDDP83848_BMSR_REGISTER,\n"
8894                    "                                CDDDP83848_RBR_REGISTER};",
8895                    NoBinPacking));
8896 
8897   // FIXME: The alignment of these trailing comments might be bad. Then again,
8898   // this might be utterly useless in real code.
8899   verifyFormat("Constructor::Constructor()\n"
8900                "    : some_value{         //\n"
8901                "                 aaaaaaa, //\n"
8902                "                 bbbbbbb} {}");
8903 
8904   // In braced lists, the first comment is always assumed to belong to the
8905   // first element. Thus, it can be moved to the next or previous line as
8906   // appropriate.
8907   EXPECT_EQ("function({// First element:\n"
8908             "          1,\n"
8909             "          // Second element:\n"
8910             "          2});",
8911             format("function({\n"
8912                    "    // First element:\n"
8913                    "    1,\n"
8914                    "    // Second element:\n"
8915                    "    2});"));
8916   EXPECT_EQ("std::vector<int> MyNumbers{\n"
8917             "    // First element:\n"
8918             "    1,\n"
8919             "    // Second element:\n"
8920             "    2};",
8921             format("std::vector<int> MyNumbers{// First element:\n"
8922                    "                           1,\n"
8923                    "                           // Second element:\n"
8924                    "                           2};",
8925                    getLLVMStyleWithColumns(30)));
8926   // A trailing comma should still lead to an enforced line break and no
8927   // binpacking.
8928   EXPECT_EQ("vector<int> SomeVector = {\n"
8929             "    // aaa\n"
8930             "    1,\n"
8931             "    2,\n"
8932             "};",
8933             format("vector<int> SomeVector = { // aaa\n"
8934                    "    1, 2, };"));
8935 
8936   // C++11 brace initializer list l-braces should not be treated any differently
8937   // when breaking before lambda bodies is enabled
8938   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
8939   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
8940   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
8941   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
8942   verifyFormat(
8943       "std::runtime_error{\n"
8944       "    \"Long string which will force a break onto the next line...\"};",
8945       BreakBeforeLambdaBody);
8946 
8947   FormatStyle ExtraSpaces = getLLVMStyle();
8948   ExtraSpaces.Cpp11BracedListStyle = false;
8949   ExtraSpaces.ColumnLimit = 75;
8950   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
8951   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
8952   verifyFormat("f({ 1, 2 });", ExtraSpaces);
8953   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
8954   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
8955   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
8956   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
8957   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
8958   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
8959   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
8960   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
8961   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
8962   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
8963   verifyFormat("class Class {\n"
8964                "  T member = { arg1, arg2 };\n"
8965                "};",
8966                ExtraSpaces);
8967   verifyFormat(
8968       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8969       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
8970       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
8971       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
8972       ExtraSpaces);
8973   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
8974   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
8975                ExtraSpaces);
8976   verifyFormat(
8977       "someFunction(OtherParam,\n"
8978       "             BracedList{ // comment 1 (Forcing interesting break)\n"
8979       "                         param1, param2,\n"
8980       "                         // comment 2\n"
8981       "                         param3, param4 });",
8982       ExtraSpaces);
8983   verifyFormat(
8984       "std::this_thread::sleep_for(\n"
8985       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
8986       ExtraSpaces);
8987   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
8988                "    aaaaaaa,\n"
8989                "    aaaaaaaaaa,\n"
8990                "    aaaaa,\n"
8991                "    aaaaaaaaaaaaaaa,\n"
8992                "    aaa,\n"
8993                "    aaaaaaaaaa,\n"
8994                "    a,\n"
8995                "    aaaaaaaaaaaaaaaaaaaaa,\n"
8996                "    aaaaaaaaaaaa,\n"
8997                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
8998                "    aaaaaaa,\n"
8999                "    a};");
9000   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
9001   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
9002   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
9003 
9004   // Avoid breaking between initializer/equal sign and opening brace
9005   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
9006   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
9007                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9008                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9009                "  { \"ccccccccccccccccccccc\", 2 }\n"
9010                "};",
9011                ExtraSpaces);
9012   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
9013                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9014                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9015                "  { \"ccccccccccccccccccccc\", 2 }\n"
9016                "};",
9017                ExtraSpaces);
9018 
9019   FormatStyle SpaceBeforeBrace = getLLVMStyle();
9020   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9021   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9022   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9023 
9024   FormatStyle SpaceBetweenBraces = getLLVMStyle();
9025   SpaceBetweenBraces.SpacesInAngles = true;
9026   SpaceBetweenBraces.SpacesInParentheses = true;
9027   SpaceBetweenBraces.SpacesInSquareBrackets = true;
9028   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9029   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9030   verifyFormat("vector< int > x{ // comment 1\n"
9031                "                 1, 2, 3, 4 };",
9032                SpaceBetweenBraces);
9033   SpaceBetweenBraces.ColumnLimit = 20;
9034   EXPECT_EQ("vector< int > x{\n"
9035             "    1, 2, 3, 4 };",
9036             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9037   SpaceBetweenBraces.ColumnLimit = 24;
9038   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9039             "                 3, 4 };",
9040             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9041   EXPECT_EQ("vector< int > x{\n"
9042             "    1,\n"
9043             "    2,\n"
9044             "    3,\n"
9045             "    4,\n"
9046             "};",
9047             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9048   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9049   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9050   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9051 }
9052 
9053 TEST_F(FormatTest, FormatSpacesInAngles) {
9054   FormatStyle SpaceInAngles = getLLVMStyle();
9055   SpaceInAngles.SpacesInAngles = true;
9056   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9057   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9058   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9059 
9060   SpaceInAngles.SpacesInAngles = false;
9061   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9062   verifyFormat("vector<int> x5;", SpaceInAngles);
9063   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9064   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9065 }
9066 
9067 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9068   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9069                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9070                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9071                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9072                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9073                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9074   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9075                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9076                "                 1, 22, 333, 4444, 55555, //\n"
9077                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9078                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9079   verifyFormat(
9080       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9081       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9082       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9083       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9084       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9085       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9086       "                 7777777};");
9087   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9088                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9089                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9090   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9091                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9092                "    // Separating comment.\n"
9093                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9094   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9095                "    // Leading comment\n"
9096                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9097                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9098   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9099                "                 1, 1, 1, 1};",
9100                getLLVMStyleWithColumns(39));
9101   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9102                "                 1, 1, 1, 1};",
9103                getLLVMStyleWithColumns(38));
9104   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9105                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9106                getLLVMStyleWithColumns(43));
9107   verifyFormat(
9108       "static unsigned SomeValues[10][3] = {\n"
9109       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9110       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9111   verifyFormat("static auto fields = new vector<string>{\n"
9112                "    \"aaaaaaaaaaaaa\",\n"
9113                "    \"aaaaaaaaaaaaa\",\n"
9114                "    \"aaaaaaaaaaaa\",\n"
9115                "    \"aaaaaaaaaaaaaa\",\n"
9116                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9117                "    \"aaaaaaaaaaaa\",\n"
9118                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9119                "};");
9120   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9121   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9122                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9123                "                 3, cccccccccccccccccccccc};",
9124                getLLVMStyleWithColumns(60));
9125 
9126   // Trailing commas.
9127   verifyFormat("vector<int> x = {\n"
9128                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9129                "};",
9130                getLLVMStyleWithColumns(39));
9131   verifyFormat("vector<int> x = {\n"
9132                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9133                "};",
9134                getLLVMStyleWithColumns(39));
9135   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9136                "                 1, 1, 1, 1,\n"
9137                "                 /**/ /**/};",
9138                getLLVMStyleWithColumns(39));
9139 
9140   // Trailing comment in the first line.
9141   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9142                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9143                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9144                "    11111111,   22222222,   333333333,   44444444};");
9145   // Trailing comment in the last line.
9146   verifyFormat("int aaaaa[] = {\n"
9147                "    1, 2, 3, // comment\n"
9148                "    4, 5, 6  // comment\n"
9149                "};");
9150 
9151   // With nested lists, we should either format one item per line or all nested
9152   // lists one on line.
9153   // FIXME: For some nested lists, we can do better.
9154   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9155                "        {aaaaaaaaaaaaaaaaaaa},\n"
9156                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9157                "        {aaaaaaaaaaaaaaaaa}};",
9158                getLLVMStyleWithColumns(60));
9159   verifyFormat(
9160       "SomeStruct my_struct_array = {\n"
9161       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9162       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9163       "    {aaa, aaa},\n"
9164       "    {aaa, aaa},\n"
9165       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9166       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9167       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9168 
9169   // No column layout should be used here.
9170   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9171                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9172 
9173   verifyNoCrash("a<,");
9174 
9175   // No braced initializer here.
9176   verifyFormat("void f() {\n"
9177                "  struct Dummy {};\n"
9178                "  f(v);\n"
9179                "}");
9180 
9181   // Long lists should be formatted in columns even if they are nested.
9182   verifyFormat(
9183       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9184       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9185       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9186       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9187       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9188       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9189 
9190   // Allow "single-column" layout even if that violates the column limit. There
9191   // isn't going to be a better way.
9192   verifyFormat("std::vector<int> a = {\n"
9193                "    aaaaaaaa,\n"
9194                "    aaaaaaaa,\n"
9195                "    aaaaaaaa,\n"
9196                "    aaaaaaaa,\n"
9197                "    aaaaaaaaaa,\n"
9198                "    aaaaaaaa,\n"
9199                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9200                getLLVMStyleWithColumns(30));
9201   verifyFormat("vector<int> aaaa = {\n"
9202                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9203                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9204                "    aaaaaa.aaaaaaa,\n"
9205                "    aaaaaa.aaaaaaa,\n"
9206                "    aaaaaa.aaaaaaa,\n"
9207                "    aaaaaa.aaaaaaa,\n"
9208                "};");
9209 
9210   // Don't create hanging lists.
9211   verifyFormat("someFunction(Param, {List1, List2,\n"
9212                "                     List3});",
9213                getLLVMStyleWithColumns(35));
9214   verifyFormat("someFunction(Param, Param,\n"
9215                "             {List1, List2,\n"
9216                "              List3});",
9217                getLLVMStyleWithColumns(35));
9218   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9219                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9220 }
9221 
9222 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9223   FormatStyle DoNotMerge = getLLVMStyle();
9224   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9225 
9226   verifyFormat("void f() { return 42; }");
9227   verifyFormat("void f() {\n"
9228                "  return 42;\n"
9229                "}",
9230                DoNotMerge);
9231   verifyFormat("void f() {\n"
9232                "  // Comment\n"
9233                "}");
9234   verifyFormat("{\n"
9235                "#error {\n"
9236                "  int a;\n"
9237                "}");
9238   verifyFormat("{\n"
9239                "  int a;\n"
9240                "#error {\n"
9241                "}");
9242   verifyFormat("void f() {} // comment");
9243   verifyFormat("void f() { int a; } // comment");
9244   verifyFormat("void f() {\n"
9245                "} // comment",
9246                DoNotMerge);
9247   verifyFormat("void f() {\n"
9248                "  int a;\n"
9249                "} // comment",
9250                DoNotMerge);
9251   verifyFormat("void f() {\n"
9252                "} // comment",
9253                getLLVMStyleWithColumns(15));
9254 
9255   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9256   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9257 
9258   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9259   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9260   verifyFormat("class C {\n"
9261                "  C()\n"
9262                "      : iiiiiiii(nullptr),\n"
9263                "        kkkkkkk(nullptr),\n"
9264                "        mmmmmmm(nullptr),\n"
9265                "        nnnnnnn(nullptr) {}\n"
9266                "};",
9267                getGoogleStyle());
9268 
9269   FormatStyle NoColumnLimit = getLLVMStyle();
9270   NoColumnLimit.ColumnLimit = 0;
9271   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9272   EXPECT_EQ("class C {\n"
9273             "  A() : b(0) {}\n"
9274             "};",
9275             format("class C{A():b(0){}};", NoColumnLimit));
9276   EXPECT_EQ("A()\n"
9277             "    : b(0) {\n"
9278             "}",
9279             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9280 
9281   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9282   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9283       FormatStyle::SFS_None;
9284   EXPECT_EQ("A()\n"
9285             "    : b(0) {\n"
9286             "}",
9287             format("A():b(0){}", DoNotMergeNoColumnLimit));
9288   EXPECT_EQ("A()\n"
9289             "    : b(0) {\n"
9290             "}",
9291             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9292 
9293   verifyFormat("#define A          \\\n"
9294                "  void f() {       \\\n"
9295                "    int i;         \\\n"
9296                "  }",
9297                getLLVMStyleWithColumns(20));
9298   verifyFormat("#define A           \\\n"
9299                "  void f() { int i; }",
9300                getLLVMStyleWithColumns(21));
9301   verifyFormat("#define A            \\\n"
9302                "  void f() {         \\\n"
9303                "    int i;           \\\n"
9304                "  }                  \\\n"
9305                "  int j;",
9306                getLLVMStyleWithColumns(22));
9307   verifyFormat("#define A             \\\n"
9308                "  void f() { int i; } \\\n"
9309                "  int j;",
9310                getLLVMStyleWithColumns(23));
9311 }
9312 
9313 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9314   FormatStyle MergeEmptyOnly = getLLVMStyle();
9315   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9316   verifyFormat("class C {\n"
9317                "  int f() {}\n"
9318                "};",
9319                MergeEmptyOnly);
9320   verifyFormat("class C {\n"
9321                "  int f() {\n"
9322                "    return 42;\n"
9323                "  }\n"
9324                "};",
9325                MergeEmptyOnly);
9326   verifyFormat("int f() {}", MergeEmptyOnly);
9327   verifyFormat("int f() {\n"
9328                "  return 42;\n"
9329                "}",
9330                MergeEmptyOnly);
9331 
9332   // Also verify behavior when BraceWrapping.AfterFunction = true
9333   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9334   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9335   verifyFormat("int f() {}", MergeEmptyOnly);
9336   verifyFormat("class C {\n"
9337                "  int f() {}\n"
9338                "};",
9339                MergeEmptyOnly);
9340 }
9341 
9342 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9343   FormatStyle MergeInlineOnly = getLLVMStyle();
9344   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9345   verifyFormat("class C {\n"
9346                "  int f() { return 42; }\n"
9347                "};",
9348                MergeInlineOnly);
9349   verifyFormat("int f() {\n"
9350                "  return 42;\n"
9351                "}",
9352                MergeInlineOnly);
9353 
9354   // SFS_Inline implies SFS_Empty
9355   verifyFormat("class C {\n"
9356                "  int f() {}\n"
9357                "};",
9358                MergeInlineOnly);
9359   verifyFormat("int f() {}", MergeInlineOnly);
9360 
9361   // Also verify behavior when BraceWrapping.AfterFunction = true
9362   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9363   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9364   verifyFormat("class C {\n"
9365                "  int f() { return 42; }\n"
9366                "};",
9367                MergeInlineOnly);
9368   verifyFormat("int f()\n"
9369                "{\n"
9370                "  return 42;\n"
9371                "}",
9372                MergeInlineOnly);
9373 
9374   // SFS_Inline implies SFS_Empty
9375   verifyFormat("int f() {}", MergeInlineOnly);
9376   verifyFormat("class C {\n"
9377                "  int f() {}\n"
9378                "};",
9379                MergeInlineOnly);
9380 }
9381 
9382 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9383   FormatStyle MergeInlineOnly = getLLVMStyle();
9384   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9385       FormatStyle::SFS_InlineOnly;
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_InlineOnly does not imply SFS_Empty
9396   verifyFormat("class C {\n"
9397                "  int f() {}\n"
9398                "};",
9399                MergeInlineOnly);
9400   verifyFormat("int f() {\n"
9401                "}",
9402                MergeInlineOnly);
9403 
9404   // Also verify behavior when BraceWrapping.AfterFunction = true
9405   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9406   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9407   verifyFormat("class C {\n"
9408                "  int f() { return 42; }\n"
9409                "};",
9410                MergeInlineOnly);
9411   verifyFormat("int f()\n"
9412                "{\n"
9413                "  return 42;\n"
9414                "}",
9415                MergeInlineOnly);
9416 
9417   // SFS_InlineOnly does not imply SFS_Empty
9418   verifyFormat("int f()\n"
9419                "{\n"
9420                "}",
9421                MergeInlineOnly);
9422   verifyFormat("class C {\n"
9423                "  int f() {}\n"
9424                "};",
9425                MergeInlineOnly);
9426 }
9427 
9428 TEST_F(FormatTest, SplitEmptyFunction) {
9429   FormatStyle Style = getLLVMStyle();
9430   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9431   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9432   Style.BraceWrapping.AfterFunction = true;
9433   Style.BraceWrapping.SplitEmptyFunction = false;
9434   Style.ColumnLimit = 40;
9435 
9436   verifyFormat("int f()\n"
9437                "{}",
9438                Style);
9439   verifyFormat("int f()\n"
9440                "{\n"
9441                "  return 42;\n"
9442                "}",
9443                Style);
9444   verifyFormat("int f()\n"
9445                "{\n"
9446                "  // some comment\n"
9447                "}",
9448                Style);
9449 
9450   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9451   verifyFormat("int f() {}", Style);
9452   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9453                "{}",
9454                Style);
9455   verifyFormat("int f()\n"
9456                "{\n"
9457                "  return 0;\n"
9458                "}",
9459                Style);
9460 
9461   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9462   verifyFormat("class Foo {\n"
9463                "  int f() {}\n"
9464                "};\n",
9465                Style);
9466   verifyFormat("class Foo {\n"
9467                "  int f() { return 0; }\n"
9468                "};\n",
9469                Style);
9470   verifyFormat("class Foo {\n"
9471                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9472                "  {}\n"
9473                "};\n",
9474                Style);
9475   verifyFormat("class Foo {\n"
9476                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9477                "  {\n"
9478                "    return 0;\n"
9479                "  }\n"
9480                "};\n",
9481                Style);
9482 
9483   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9484   verifyFormat("int f() {}", Style);
9485   verifyFormat("int f() { return 0; }", Style);
9486   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9487                "{}",
9488                Style);
9489   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9490                "{\n"
9491                "  return 0;\n"
9492                "}",
9493                Style);
9494 }
9495 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9496   FormatStyle Style = getLLVMStyle();
9497   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9498   verifyFormat("#ifdef A\n"
9499                "int f() {}\n"
9500                "#else\n"
9501                "int g() {}\n"
9502                "#endif",
9503                Style);
9504 }
9505 
9506 TEST_F(FormatTest, SplitEmptyClass) {
9507   FormatStyle Style = getLLVMStyle();
9508   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9509   Style.BraceWrapping.AfterClass = true;
9510   Style.BraceWrapping.SplitEmptyRecord = false;
9511 
9512   verifyFormat("class Foo\n"
9513                "{};",
9514                Style);
9515   verifyFormat("/* something */ class Foo\n"
9516                "{};",
9517                Style);
9518   verifyFormat("template <typename X> class Foo\n"
9519                "{};",
9520                Style);
9521   verifyFormat("class Foo\n"
9522                "{\n"
9523                "  Foo();\n"
9524                "};",
9525                Style);
9526   verifyFormat("typedef class Foo\n"
9527                "{\n"
9528                "} Foo_t;",
9529                Style);
9530 }
9531 
9532 TEST_F(FormatTest, SplitEmptyStruct) {
9533   FormatStyle Style = getLLVMStyle();
9534   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9535   Style.BraceWrapping.AfterStruct = true;
9536   Style.BraceWrapping.SplitEmptyRecord = false;
9537 
9538   verifyFormat("struct Foo\n"
9539                "{};",
9540                Style);
9541   verifyFormat("/* something */ struct Foo\n"
9542                "{};",
9543                Style);
9544   verifyFormat("template <typename X> struct Foo\n"
9545                "{};",
9546                Style);
9547   verifyFormat("struct Foo\n"
9548                "{\n"
9549                "  Foo();\n"
9550                "};",
9551                Style);
9552   verifyFormat("typedef struct Foo\n"
9553                "{\n"
9554                "} Foo_t;",
9555                Style);
9556   // typedef struct Bar {} Bar_t;
9557 }
9558 
9559 TEST_F(FormatTest, SplitEmptyUnion) {
9560   FormatStyle Style = getLLVMStyle();
9561   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9562   Style.BraceWrapping.AfterUnion = true;
9563   Style.BraceWrapping.SplitEmptyRecord = false;
9564 
9565   verifyFormat("union Foo\n"
9566                "{};",
9567                Style);
9568   verifyFormat("/* something */ union Foo\n"
9569                "{};",
9570                Style);
9571   verifyFormat("union Foo\n"
9572                "{\n"
9573                "  A,\n"
9574                "};",
9575                Style);
9576   verifyFormat("typedef union Foo\n"
9577                "{\n"
9578                "} Foo_t;",
9579                Style);
9580 }
9581 
9582 TEST_F(FormatTest, SplitEmptyNamespace) {
9583   FormatStyle Style = getLLVMStyle();
9584   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9585   Style.BraceWrapping.AfterNamespace = true;
9586   Style.BraceWrapping.SplitEmptyNamespace = false;
9587 
9588   verifyFormat("namespace Foo\n"
9589                "{};",
9590                Style);
9591   verifyFormat("/* something */ namespace Foo\n"
9592                "{};",
9593                Style);
9594   verifyFormat("inline namespace Foo\n"
9595                "{};",
9596                Style);
9597   verifyFormat("/* something */ inline namespace Foo\n"
9598                "{};",
9599                Style);
9600   verifyFormat("export namespace Foo\n"
9601                "{};",
9602                Style);
9603   verifyFormat("namespace Foo\n"
9604                "{\n"
9605                "void Bar();\n"
9606                "};",
9607                Style);
9608 }
9609 
9610 TEST_F(FormatTest, NeverMergeShortRecords) {
9611   FormatStyle Style = getLLVMStyle();
9612 
9613   verifyFormat("class Foo {\n"
9614                "  Foo();\n"
9615                "};",
9616                Style);
9617   verifyFormat("typedef class Foo {\n"
9618                "  Foo();\n"
9619                "} Foo_t;",
9620                Style);
9621   verifyFormat("struct Foo {\n"
9622                "  Foo();\n"
9623                "};",
9624                Style);
9625   verifyFormat("typedef struct Foo {\n"
9626                "  Foo();\n"
9627                "} Foo_t;",
9628                Style);
9629   verifyFormat("union Foo {\n"
9630                "  A,\n"
9631                "};",
9632                Style);
9633   verifyFormat("typedef union Foo {\n"
9634                "  A,\n"
9635                "} Foo_t;",
9636                Style);
9637   verifyFormat("namespace Foo {\n"
9638                "void Bar();\n"
9639                "};",
9640                Style);
9641 
9642   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9643   Style.BraceWrapping.AfterClass = true;
9644   Style.BraceWrapping.AfterStruct = true;
9645   Style.BraceWrapping.AfterUnion = true;
9646   Style.BraceWrapping.AfterNamespace = true;
9647   verifyFormat("class Foo\n"
9648                "{\n"
9649                "  Foo();\n"
9650                "};",
9651                Style);
9652   verifyFormat("typedef class Foo\n"
9653                "{\n"
9654                "  Foo();\n"
9655                "} Foo_t;",
9656                Style);
9657   verifyFormat("struct Foo\n"
9658                "{\n"
9659                "  Foo();\n"
9660                "};",
9661                Style);
9662   verifyFormat("typedef struct Foo\n"
9663                "{\n"
9664                "  Foo();\n"
9665                "} Foo_t;",
9666                Style);
9667   verifyFormat("union Foo\n"
9668                "{\n"
9669                "  A,\n"
9670                "};",
9671                Style);
9672   verifyFormat("typedef union Foo\n"
9673                "{\n"
9674                "  A,\n"
9675                "} Foo_t;",
9676                Style);
9677   verifyFormat("namespace Foo\n"
9678                "{\n"
9679                "void Bar();\n"
9680                "};",
9681                Style);
9682 }
9683 
9684 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
9685   // Elaborate type variable declarations.
9686   verifyFormat("struct foo a = {bar};\nint n;");
9687   verifyFormat("class foo a = {bar};\nint n;");
9688   verifyFormat("union foo a = {bar};\nint n;");
9689 
9690   // Elaborate types inside function definitions.
9691   verifyFormat("struct foo f() {}\nint n;");
9692   verifyFormat("class foo f() {}\nint n;");
9693   verifyFormat("union foo f() {}\nint n;");
9694 
9695   // Templates.
9696   verifyFormat("template <class X> void f() {}\nint n;");
9697   verifyFormat("template <struct X> void f() {}\nint n;");
9698   verifyFormat("template <union X> void f() {}\nint n;");
9699 
9700   // Actual definitions...
9701   verifyFormat("struct {\n} n;");
9702   verifyFormat(
9703       "template <template <class T, class Y>, class Z> class X {\n} n;");
9704   verifyFormat("union Z {\n  int n;\n} x;");
9705   verifyFormat("class MACRO Z {\n} n;");
9706   verifyFormat("class MACRO(X) Z {\n} n;");
9707   verifyFormat("class __attribute__(X) Z {\n} n;");
9708   verifyFormat("class __declspec(X) Z {\n} n;");
9709   verifyFormat("class A##B##C {\n} n;");
9710   verifyFormat("class alignas(16) Z {\n} n;");
9711   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
9712   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
9713 
9714   // Redefinition from nested context:
9715   verifyFormat("class A::B::C {\n} n;");
9716 
9717   // Template definitions.
9718   verifyFormat(
9719       "template <typename F>\n"
9720       "Matcher(const Matcher<F> &Other,\n"
9721       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
9722       "                             !is_same<F, T>::value>::type * = 0)\n"
9723       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
9724 
9725   // FIXME: This is still incorrectly handled at the formatter side.
9726   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
9727   verifyFormat("int i = SomeFunction(a<b, a> b);");
9728 
9729   // FIXME:
9730   // This now gets parsed incorrectly as class definition.
9731   // verifyFormat("class A<int> f() {\n}\nint n;");
9732 
9733   // Elaborate types where incorrectly parsing the structural element would
9734   // break the indent.
9735   verifyFormat("if (true)\n"
9736                "  class X x;\n"
9737                "else\n"
9738                "  f();\n");
9739 
9740   // This is simply incomplete. Formatting is not important, but must not crash.
9741   verifyFormat("class A:");
9742 }
9743 
9744 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
9745   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
9746             format("#error Leave     all         white!!!!! space* alone!\n"));
9747   EXPECT_EQ(
9748       "#warning Leave     all         white!!!!! space* alone!\n",
9749       format("#warning Leave     all         white!!!!! space* alone!\n"));
9750   EXPECT_EQ("#error 1", format("  #  error   1"));
9751   EXPECT_EQ("#warning 1", format("  #  warning 1"));
9752 }
9753 
9754 TEST_F(FormatTest, FormatHashIfExpressions) {
9755   verifyFormat("#if AAAA && BBBB");
9756   verifyFormat("#if (AAAA && BBBB)");
9757   verifyFormat("#elif (AAAA && BBBB)");
9758   // FIXME: Come up with a better indentation for #elif.
9759   verifyFormat(
9760       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
9761       "    defined(BBBBBBBB)\n"
9762       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
9763       "    defined(BBBBBBBB)\n"
9764       "#endif",
9765       getLLVMStyleWithColumns(65));
9766 }
9767 
9768 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
9769   FormatStyle AllowsMergedIf = getGoogleStyle();
9770   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
9771       FormatStyle::SIS_WithoutElse;
9772   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
9773   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
9774   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
9775   EXPECT_EQ("if (true) return 42;",
9776             format("if (true)\nreturn 42;", AllowsMergedIf));
9777   FormatStyle ShortMergedIf = AllowsMergedIf;
9778   ShortMergedIf.ColumnLimit = 25;
9779   verifyFormat("#define A \\\n"
9780                "  if (true) return 42;",
9781                ShortMergedIf);
9782   verifyFormat("#define A \\\n"
9783                "  f();    \\\n"
9784                "  if (true)\n"
9785                "#define B",
9786                ShortMergedIf);
9787   verifyFormat("#define A \\\n"
9788                "  f();    \\\n"
9789                "  if (true)\n"
9790                "g();",
9791                ShortMergedIf);
9792   verifyFormat("{\n"
9793                "#ifdef A\n"
9794                "  // Comment\n"
9795                "  if (true) continue;\n"
9796                "#endif\n"
9797                "  // Comment\n"
9798                "  if (true) continue;\n"
9799                "}",
9800                ShortMergedIf);
9801   ShortMergedIf.ColumnLimit = 33;
9802   verifyFormat("#define A \\\n"
9803                "  if constexpr (true) return 42;",
9804                ShortMergedIf);
9805   verifyFormat("#define A \\\n"
9806                "  if CONSTEXPR (true) return 42;",
9807                ShortMergedIf);
9808   ShortMergedIf.ColumnLimit = 29;
9809   verifyFormat("#define A                   \\\n"
9810                "  if (aaaaaaaaaa) return 1; \\\n"
9811                "  return 2;",
9812                ShortMergedIf);
9813   ShortMergedIf.ColumnLimit = 28;
9814   verifyFormat("#define A         \\\n"
9815                "  if (aaaaaaaaaa) \\\n"
9816                "    return 1;     \\\n"
9817                "  return 2;",
9818                ShortMergedIf);
9819   verifyFormat("#define A                \\\n"
9820                "  if constexpr (aaaaaaa) \\\n"
9821                "    return 1;            \\\n"
9822                "  return 2;",
9823                ShortMergedIf);
9824   verifyFormat("#define A                \\\n"
9825                "  if CONSTEXPR (aaaaaaa) \\\n"
9826                "    return 1;            \\\n"
9827                "  return 2;",
9828                ShortMergedIf);
9829 }
9830 
9831 TEST_F(FormatTest, FormatStarDependingOnContext) {
9832   verifyFormat("void f(int *a);");
9833   verifyFormat("void f() { f(fint * b); }");
9834   verifyFormat("class A {\n  void f(int *a);\n};");
9835   verifyFormat("class A {\n  int *a;\n};");
9836   verifyFormat("namespace a {\n"
9837                "namespace b {\n"
9838                "class A {\n"
9839                "  void f() {}\n"
9840                "  int *a;\n"
9841                "};\n"
9842                "} // namespace b\n"
9843                "} // namespace a");
9844 }
9845 
9846 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
9847   verifyFormat("while");
9848   verifyFormat("operator");
9849 }
9850 
9851 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
9852   // This code would be painfully slow to format if we didn't skip it.
9853   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
9854                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9855                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9856                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9857                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9858                    "A(1, 1)\n"
9859                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
9860                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9861                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9862                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9863                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9864                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9865                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9866                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9867                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9868                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
9869   // Deeply nested part is untouched, rest is formatted.
9870   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
9871             format(std::string("int    i;\n") + Code + "int    j;\n",
9872                    getLLVMStyle(), SC_ExpectIncomplete));
9873 }
9874 
9875 //===----------------------------------------------------------------------===//
9876 // Objective-C tests.
9877 //===----------------------------------------------------------------------===//
9878 
9879 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
9880   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
9881   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
9882             format("-(NSUInteger)indexOfObject:(id)anObject;"));
9883   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
9884   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
9885   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
9886             format("-(NSInteger)Method3:(id)anObject;"));
9887   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
9888             format("-(NSInteger)Method4:(id)anObject;"));
9889   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
9890             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
9891   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
9892             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
9893   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9894             "forAllCells:(BOOL)flag;",
9895             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9896                    "forAllCells:(BOOL)flag;"));
9897 
9898   // Very long objectiveC method declaration.
9899   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
9900                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
9901   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
9902                "                    inRange:(NSRange)range\n"
9903                "                   outRange:(NSRange)out_range\n"
9904                "                  outRange1:(NSRange)out_range1\n"
9905                "                  outRange2:(NSRange)out_range2\n"
9906                "                  outRange3:(NSRange)out_range3\n"
9907                "                  outRange4:(NSRange)out_range4\n"
9908                "                  outRange5:(NSRange)out_range5\n"
9909                "                  outRange6:(NSRange)out_range6\n"
9910                "                  outRange7:(NSRange)out_range7\n"
9911                "                  outRange8:(NSRange)out_range8\n"
9912                "                  outRange9:(NSRange)out_range9;");
9913 
9914   // When the function name has to be wrapped.
9915   FormatStyle Style = getLLVMStyle();
9916   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
9917   // and always indents instead.
9918   Style.IndentWrappedFunctionNames = false;
9919   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9920                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
9921                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
9922                "}",
9923                Style);
9924   Style.IndentWrappedFunctionNames = true;
9925   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9926                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
9927                "               anotherName:(NSString)dddddddddddddd {\n"
9928                "}",
9929                Style);
9930 
9931   verifyFormat("- (int)sum:(vector<int>)numbers;");
9932   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
9933   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
9934   // protocol lists (but not for template classes):
9935   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
9936 
9937   verifyFormat("- (int (*)())foo:(int (*)())f;");
9938   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
9939 
9940   // If there's no return type (very rare in practice!), LLVM and Google style
9941   // agree.
9942   verifyFormat("- foo;");
9943   verifyFormat("- foo:(int)f;");
9944   verifyGoogleFormat("- foo:(int)foo;");
9945 }
9946 
9947 TEST_F(FormatTest, BreaksStringLiterals) {
9948   EXPECT_EQ("\"some text \"\n"
9949             "\"other\";",
9950             format("\"some text other\";", getLLVMStyleWithColumns(12)));
9951   EXPECT_EQ("\"some text \"\n"
9952             "\"other\";",
9953             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
9954   EXPECT_EQ(
9955       "#define A  \\\n"
9956       "  \"some \"  \\\n"
9957       "  \"text \"  \\\n"
9958       "  \"other\";",
9959       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
9960   EXPECT_EQ(
9961       "#define A  \\\n"
9962       "  \"so \"    \\\n"
9963       "  \"text \"  \\\n"
9964       "  \"other\";",
9965       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
9966 
9967   EXPECT_EQ("\"some text\"",
9968             format("\"some text\"", getLLVMStyleWithColumns(1)));
9969   EXPECT_EQ("\"some text\"",
9970             format("\"some text\"", getLLVMStyleWithColumns(11)));
9971   EXPECT_EQ("\"some \"\n"
9972             "\"text\"",
9973             format("\"some text\"", getLLVMStyleWithColumns(10)));
9974   EXPECT_EQ("\"some \"\n"
9975             "\"text\"",
9976             format("\"some text\"", getLLVMStyleWithColumns(7)));
9977   EXPECT_EQ("\"some\"\n"
9978             "\" tex\"\n"
9979             "\"t\"",
9980             format("\"some text\"", getLLVMStyleWithColumns(6)));
9981   EXPECT_EQ("\"some\"\n"
9982             "\" tex\"\n"
9983             "\" and\"",
9984             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
9985   EXPECT_EQ("\"some\"\n"
9986             "\"/tex\"\n"
9987             "\"/and\"",
9988             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
9989 
9990   EXPECT_EQ("variable =\n"
9991             "    \"long string \"\n"
9992             "    \"literal\";",
9993             format("variable = \"long string literal\";",
9994                    getLLVMStyleWithColumns(20)));
9995 
9996   EXPECT_EQ("variable = f(\n"
9997             "    \"long string \"\n"
9998             "    \"literal\",\n"
9999             "    short,\n"
10000             "    loooooooooooooooooooong);",
10001             format("variable = f(\"long string literal\", short, "
10002                    "loooooooooooooooooooong);",
10003                    getLLVMStyleWithColumns(20)));
10004 
10005   EXPECT_EQ(
10006       "f(g(\"long string \"\n"
10007       "    \"literal\"),\n"
10008       "  b);",
10009       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
10010   EXPECT_EQ("f(g(\"long string \"\n"
10011             "    \"literal\",\n"
10012             "    a),\n"
10013             "  b);",
10014             format("f(g(\"long string literal\", a), b);",
10015                    getLLVMStyleWithColumns(20)));
10016   EXPECT_EQ(
10017       "f(\"one two\".split(\n"
10018       "    variable));",
10019       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10020   EXPECT_EQ("f(\"one two three four five six \"\n"
10021             "  \"seven\".split(\n"
10022             "      really_looooong_variable));",
10023             format("f(\"one two three four five six seven\"."
10024                    "split(really_looooong_variable));",
10025                    getLLVMStyleWithColumns(33)));
10026 
10027   EXPECT_EQ("f(\"some \"\n"
10028             "  \"text\",\n"
10029             "  other);",
10030             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10031 
10032   // Only break as a last resort.
10033   verifyFormat(
10034       "aaaaaaaaaaaaaaaaaaaa(\n"
10035       "    aaaaaaaaaaaaaaaaaaaa,\n"
10036       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10037 
10038   EXPECT_EQ("\"splitmea\"\n"
10039             "\"trandomp\"\n"
10040             "\"oint\"",
10041             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10042 
10043   EXPECT_EQ("\"split/\"\n"
10044             "\"pathat/\"\n"
10045             "\"slashes\"",
10046             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10047 
10048   EXPECT_EQ("\"split/\"\n"
10049             "\"pathat/\"\n"
10050             "\"slashes\"",
10051             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10052   EXPECT_EQ("\"split at \"\n"
10053             "\"spaces/at/\"\n"
10054             "\"slashes.at.any$\"\n"
10055             "\"non-alphanumeric%\"\n"
10056             "\"1111111111characte\"\n"
10057             "\"rs\"",
10058             format("\"split at "
10059                    "spaces/at/"
10060                    "slashes.at."
10061                    "any$non-"
10062                    "alphanumeric%"
10063                    "1111111111characte"
10064                    "rs\"",
10065                    getLLVMStyleWithColumns(20)));
10066 
10067   // Verify that splitting the strings understands
10068   // Style::AlwaysBreakBeforeMultilineStrings.
10069   EXPECT_EQ("aaaaaaaaaaaa(\n"
10070             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10071             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10072             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10073                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10074                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10075                    getGoogleStyle()));
10076   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10077             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10078             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10079                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10080                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10081                    getGoogleStyle()));
10082   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10083             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10084             format("llvm::outs() << "
10085                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10086                    "aaaaaaaaaaaaaaaaaaa\";"));
10087   EXPECT_EQ("ffff(\n"
10088             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10089             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10090             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10091                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10092                    getGoogleStyle()));
10093 
10094   FormatStyle Style = getLLVMStyleWithColumns(12);
10095   Style.BreakStringLiterals = false;
10096   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10097 
10098   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10099   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10100   EXPECT_EQ("#define A \\\n"
10101             "  \"some \" \\\n"
10102             "  \"text \" \\\n"
10103             "  \"other\";",
10104             format("#define A \"some text other\";", AlignLeft));
10105 }
10106 
10107 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10108   EXPECT_EQ("C a = \"some more \"\n"
10109             "      \"text\";",
10110             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10111 }
10112 
10113 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10114   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10115   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10116   EXPECT_EQ("int i = a(b());",
10117             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10118 }
10119 
10120 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10121   EXPECT_EQ(
10122       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10123       "(\n"
10124       "    \"x\t\");",
10125       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10126              "aaaaaaa("
10127              "\"x\t\");"));
10128 }
10129 
10130 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10131   EXPECT_EQ(
10132       "u8\"utf8 string \"\n"
10133       "u8\"literal\";",
10134       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10135   EXPECT_EQ(
10136       "u\"utf16 string \"\n"
10137       "u\"literal\";",
10138       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10139   EXPECT_EQ(
10140       "U\"utf32 string \"\n"
10141       "U\"literal\";",
10142       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10143   EXPECT_EQ("L\"wide string \"\n"
10144             "L\"literal\";",
10145             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10146   EXPECT_EQ("@\"NSString \"\n"
10147             "@\"literal\";",
10148             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10149   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10150 
10151   // This input makes clang-format try to split the incomplete unicode escape
10152   // sequence, which used to lead to a crasher.
10153   verifyNoCrash(
10154       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10155       getLLVMStyleWithColumns(60));
10156 }
10157 
10158 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10159   FormatStyle Style = getGoogleStyleWithColumns(15);
10160   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10161   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10162   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10163   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10164   EXPECT_EQ("u8R\"x(raw literal)x\";",
10165             format("u8R\"x(raw literal)x\";", Style));
10166 }
10167 
10168 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10169   FormatStyle Style = getLLVMStyleWithColumns(20);
10170   EXPECT_EQ(
10171       "_T(\"aaaaaaaaaaaaaa\")\n"
10172       "_T(\"aaaaaaaaaaaaaa\")\n"
10173       "_T(\"aaaaaaaaaaaa\")",
10174       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10175   EXPECT_EQ("f(x,\n"
10176             "  _T(\"aaaaaaaaaaaa\")\n"
10177             "  _T(\"aaa\"),\n"
10178             "  z);",
10179             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10180 
10181   // FIXME: Handle embedded spaces in one iteration.
10182   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10183   //            "_T(\"aaaaaaaaaaaaa\")\n"
10184   //            "_T(\"aaaaaaaaaaaaa\")\n"
10185   //            "_T(\"a\")",
10186   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10187   //                   getLLVMStyleWithColumns(20)));
10188   EXPECT_EQ(
10189       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10190       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10191   EXPECT_EQ("f(\n"
10192             "#if !TEST\n"
10193             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10194             "#endif\n"
10195             ");",
10196             format("f(\n"
10197                    "#if !TEST\n"
10198                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10199                    "#endif\n"
10200                    ");"));
10201   EXPECT_EQ("f(\n"
10202             "\n"
10203             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10204             format("f(\n"
10205                    "\n"
10206                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10207 }
10208 
10209 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10210   // In a function call with two operands, the second can be broken with no line
10211   // break before it.
10212   EXPECT_EQ(
10213       "func(a, \"long long \"\n"
10214       "        \"long long\");",
10215       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10216   // In a function call with three operands, the second must be broken with a
10217   // line break before it.
10218   EXPECT_EQ("func(a,\n"
10219             "     \"long long long \"\n"
10220             "     \"long\",\n"
10221             "     c);",
10222             format("func(a, \"long long long long\", c);",
10223                    getLLVMStyleWithColumns(24)));
10224   // In a function call with three operands, the third must be broken with a
10225   // line break before it.
10226   EXPECT_EQ("func(a, b,\n"
10227             "     \"long long long \"\n"
10228             "     \"long\");",
10229             format("func(a, b, \"long long long long\");",
10230                    getLLVMStyleWithColumns(24)));
10231   // In a function call with three operands, both the second and the third must
10232   // be broken with a line break before them.
10233   EXPECT_EQ("func(a,\n"
10234             "     \"long long long \"\n"
10235             "     \"long\",\n"
10236             "     \"long long long \"\n"
10237             "     \"long\");",
10238             format("func(a, \"long long long long\", \"long long long long\");",
10239                    getLLVMStyleWithColumns(24)));
10240   // In a chain of << with two operands, the second can be broken with no line
10241   // break before it.
10242   EXPECT_EQ("a << \"line line \"\n"
10243             "     \"line\";",
10244             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10245   // In a chain of << with three operands, the second can be broken with no line
10246   // break before it.
10247   EXPECT_EQ(
10248       "abcde << \"line \"\n"
10249       "         \"line line\"\n"
10250       "      << c;",
10251       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10252   // In a chain of << with three operands, the third must be broken with a line
10253   // break before it.
10254   EXPECT_EQ(
10255       "a << b\n"
10256       "  << \"line line \"\n"
10257       "     \"line\";",
10258       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10259   // In a chain of << with three operands, the second can be broken with no line
10260   // break before it and the third must be broken with a line break before it.
10261   EXPECT_EQ("abcd << \"line line \"\n"
10262             "        \"line\"\n"
10263             "     << \"line line \"\n"
10264             "        \"line\";",
10265             format("abcd << \"line line line\" << \"line line line\";",
10266                    getLLVMStyleWithColumns(20)));
10267   // In a chain of binary operators with two operands, the second can be broken
10268   // with no line break before it.
10269   EXPECT_EQ(
10270       "abcd + \"line line \"\n"
10271       "       \"line line\";",
10272       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10273   // In a chain of binary operators with three operands, the second must be
10274   // broken with a line break before it.
10275   EXPECT_EQ("abcd +\n"
10276             "    \"line line \"\n"
10277             "    \"line line\" +\n"
10278             "    e;",
10279             format("abcd + \"line line line line\" + e;",
10280                    getLLVMStyleWithColumns(20)));
10281   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10282   // the first must be broken with a line break before it.
10283   FormatStyle Style = getLLVMStyleWithColumns(25);
10284   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10285   EXPECT_EQ("someFunction(\n"
10286             "    \"long long long \"\n"
10287             "    \"long\",\n"
10288             "    a);",
10289             format("someFunction(\"long long long long\", a);", Style));
10290 }
10291 
10292 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10293   EXPECT_EQ(
10294       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10295       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10296       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10297       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10298              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10299              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10300 }
10301 
10302 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10303   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10304             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10305   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10306             "multiline raw string literal xxxxxxxxxxxxxx\n"
10307             ")x\",\n"
10308             "              a),\n"
10309             "            b);",
10310             format("fffffffffff(g(R\"x(\n"
10311                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10312                    ")x\", a), b);",
10313                    getGoogleStyleWithColumns(20)));
10314   EXPECT_EQ("fffffffffff(\n"
10315             "    g(R\"x(qqq\n"
10316             "multiline raw string literal xxxxxxxxxxxxxx\n"
10317             ")x\",\n"
10318             "      a),\n"
10319             "    b);",
10320             format("fffffffffff(g(R\"x(qqq\n"
10321                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10322                    ")x\", a), b);",
10323                    getGoogleStyleWithColumns(20)));
10324 
10325   EXPECT_EQ("fffffffffff(R\"x(\n"
10326             "multiline raw string literal xxxxxxxxxxxxxx\n"
10327             ")x\");",
10328             format("fffffffffff(R\"x(\n"
10329                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10330                    ")x\");",
10331                    getGoogleStyleWithColumns(20)));
10332   EXPECT_EQ("fffffffffff(R\"x(\n"
10333             "multiline raw string literal xxxxxxxxxxxxxx\n"
10334             ")x\" + bbbbbb);",
10335             format("fffffffffff(R\"x(\n"
10336                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10337                    ")x\" +   bbbbbb);",
10338                    getGoogleStyleWithColumns(20)));
10339   EXPECT_EQ("fffffffffff(\n"
10340             "    R\"x(\n"
10341             "multiline raw string literal xxxxxxxxxxxxxx\n"
10342             ")x\" +\n"
10343             "    bbbbbb);",
10344             format("fffffffffff(\n"
10345                    " R\"x(\n"
10346                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10347                    ")x\" + bbbbbb);",
10348                    getGoogleStyleWithColumns(20)));
10349   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10350             format("fffffffffff(\n"
10351                    " R\"(single line raw string)\" + bbbbbb);"));
10352 }
10353 
10354 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10355   verifyFormat("string a = \"unterminated;");
10356   EXPECT_EQ("function(\"unterminated,\n"
10357             "         OtherParameter);",
10358             format("function(  \"unterminated,\n"
10359                    "    OtherParameter);"));
10360 }
10361 
10362 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10363   FormatStyle Style = getLLVMStyle();
10364   Style.Standard = FormatStyle::LS_Cpp03;
10365   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10366             format("#define x(_a) printf(\"foo\"_a);", Style));
10367 }
10368 
10369 TEST_F(FormatTest, CppLexVersion) {
10370   FormatStyle Style = getLLVMStyle();
10371   // Formatting of x * y differs if x is a type.
10372   verifyFormat("void foo() { MACRO(a * b); }", Style);
10373   verifyFormat("void foo() { MACRO(int *b); }", Style);
10374 
10375   // LLVM style uses latest lexer.
10376   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10377   Style.Standard = FormatStyle::LS_Cpp17;
10378   // But in c++17, char8_t isn't a keyword.
10379   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10380 }
10381 
10382 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10383 
10384 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10385   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10386             "             \"ddeeefff\");",
10387             format("someFunction(\"aaabbbcccdddeeefff\");",
10388                    getLLVMStyleWithColumns(25)));
10389   EXPECT_EQ("someFunction1234567890(\n"
10390             "    \"aaabbbcccdddeeefff\");",
10391             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10392                    getLLVMStyleWithColumns(26)));
10393   EXPECT_EQ("someFunction1234567890(\n"
10394             "    \"aaabbbcccdddeeeff\"\n"
10395             "    \"f\");",
10396             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10397                    getLLVMStyleWithColumns(25)));
10398   EXPECT_EQ("someFunction1234567890(\n"
10399             "    \"aaabbbcccdddeeeff\"\n"
10400             "    \"f\");",
10401             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10402                    getLLVMStyleWithColumns(24)));
10403   EXPECT_EQ("someFunction(\n"
10404             "    \"aaabbbcc ddde \"\n"
10405             "    \"efff\");",
10406             format("someFunction(\"aaabbbcc ddde efff\");",
10407                    getLLVMStyleWithColumns(25)));
10408   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10409             "             \"ddeeefff\");",
10410             format("someFunction(\"aaabbbccc ddeeefff\");",
10411                    getLLVMStyleWithColumns(25)));
10412   EXPECT_EQ("someFunction1234567890(\n"
10413             "    \"aaabb \"\n"
10414             "    \"cccdddeeefff\");",
10415             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10416                    getLLVMStyleWithColumns(25)));
10417   EXPECT_EQ("#define A          \\\n"
10418             "  string s =       \\\n"
10419             "      \"123456789\"  \\\n"
10420             "      \"0\";         \\\n"
10421             "  int i;",
10422             format("#define A string s = \"1234567890\"; int i;",
10423                    getLLVMStyleWithColumns(20)));
10424   EXPECT_EQ("someFunction(\n"
10425             "    \"aaabbbcc \"\n"
10426             "    \"dddeeefff\");",
10427             format("someFunction(\"aaabbbcc dddeeefff\");",
10428                    getLLVMStyleWithColumns(25)));
10429 }
10430 
10431 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10432   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10433   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10434   EXPECT_EQ("\"test\"\n"
10435             "\"\\n\"",
10436             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10437   EXPECT_EQ("\"tes\\\\\"\n"
10438             "\"n\"",
10439             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10440   EXPECT_EQ("\"\\\\\\\\\"\n"
10441             "\"\\n\"",
10442             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10443   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10444   EXPECT_EQ("\"\\uff01\"\n"
10445             "\"test\"",
10446             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10447   EXPECT_EQ("\"\\Uff01ff02\"",
10448             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10449   EXPECT_EQ("\"\\x000000000001\"\n"
10450             "\"next\"",
10451             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10452   EXPECT_EQ("\"\\x000000000001next\"",
10453             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10454   EXPECT_EQ("\"\\x000000000001\"",
10455             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10456   EXPECT_EQ("\"test\"\n"
10457             "\"\\000000\"\n"
10458             "\"000001\"",
10459             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10460   EXPECT_EQ("\"test\\000\"\n"
10461             "\"00000000\"\n"
10462             "\"1\"",
10463             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10464 }
10465 
10466 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10467   verifyFormat("void f() {\n"
10468                "  return g() {}\n"
10469                "  void h() {}");
10470   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10471                "g();\n"
10472                "}");
10473 }
10474 
10475 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10476   verifyFormat(
10477       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10478 }
10479 
10480 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10481   verifyFormat("class X {\n"
10482                "  void f() {\n"
10483                "  }\n"
10484                "};",
10485                getLLVMStyleWithColumns(12));
10486 }
10487 
10488 TEST_F(FormatTest, ConfigurableIndentWidth) {
10489   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10490   EightIndent.IndentWidth = 8;
10491   EightIndent.ContinuationIndentWidth = 8;
10492   verifyFormat("void f() {\n"
10493                "        someFunction();\n"
10494                "        if (true) {\n"
10495                "                f();\n"
10496                "        }\n"
10497                "}",
10498                EightIndent);
10499   verifyFormat("class X {\n"
10500                "        void f() {\n"
10501                "        }\n"
10502                "};",
10503                EightIndent);
10504   verifyFormat("int x[] = {\n"
10505                "        call(),\n"
10506                "        call()};",
10507                EightIndent);
10508 }
10509 
10510 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10511   verifyFormat("double\n"
10512                "f();",
10513                getLLVMStyleWithColumns(8));
10514 }
10515 
10516 TEST_F(FormatTest, ConfigurableUseOfTab) {
10517   FormatStyle Tab = getLLVMStyleWithColumns(42);
10518   Tab.IndentWidth = 8;
10519   Tab.UseTab = FormatStyle::UT_Always;
10520   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10521 
10522   EXPECT_EQ("if (aaaaaaaa && // q\n"
10523             "    bb)\t\t// w\n"
10524             "\t;",
10525             format("if (aaaaaaaa &&// q\n"
10526                    "bb)// w\n"
10527                    ";",
10528                    Tab));
10529   EXPECT_EQ("if (aaa && bbb) // w\n"
10530             "\t;",
10531             format("if(aaa&&bbb)// w\n"
10532                    ";",
10533                    Tab));
10534 
10535   verifyFormat("class X {\n"
10536                "\tvoid f() {\n"
10537                "\t\tsomeFunction(parameter1,\n"
10538                "\t\t\t     parameter2);\n"
10539                "\t}\n"
10540                "};",
10541                Tab);
10542   verifyFormat("#define A                        \\\n"
10543                "\tvoid f() {               \\\n"
10544                "\t\tsomeFunction(    \\\n"
10545                "\t\t    parameter1,  \\\n"
10546                "\t\t    parameter2); \\\n"
10547                "\t}",
10548                Tab);
10549   verifyFormat("int a;\t      // x\n"
10550                "int bbbbbbbb; // x\n",
10551                Tab);
10552 
10553   Tab.TabWidth = 4;
10554   Tab.IndentWidth = 8;
10555   verifyFormat("class TabWidth4Indent8 {\n"
10556                "\t\tvoid f() {\n"
10557                "\t\t\t\tsomeFunction(parameter1,\n"
10558                "\t\t\t\t\t\t\t parameter2);\n"
10559                "\t\t}\n"
10560                "};",
10561                Tab);
10562 
10563   Tab.TabWidth = 4;
10564   Tab.IndentWidth = 4;
10565   verifyFormat("class TabWidth4Indent4 {\n"
10566                "\tvoid f() {\n"
10567                "\t\tsomeFunction(parameter1,\n"
10568                "\t\t\t\t\t parameter2);\n"
10569                "\t}\n"
10570                "};",
10571                Tab);
10572 
10573   Tab.TabWidth = 8;
10574   Tab.IndentWidth = 4;
10575   verifyFormat("class TabWidth8Indent4 {\n"
10576                "    void f() {\n"
10577                "\tsomeFunction(parameter1,\n"
10578                "\t\t     parameter2);\n"
10579                "    }\n"
10580                "};",
10581                Tab);
10582 
10583   Tab.TabWidth = 8;
10584   Tab.IndentWidth = 8;
10585   EXPECT_EQ("/*\n"
10586             "\t      a\t\tcomment\n"
10587             "\t      in multiple lines\n"
10588             "       */",
10589             format("   /*\t \t \n"
10590                    " \t \t a\t\tcomment\t \t\n"
10591                    " \t \t in multiple lines\t\n"
10592                    " \t  */",
10593                    Tab));
10594 
10595   Tab.UseTab = FormatStyle::UT_ForIndentation;
10596   verifyFormat("{\n"
10597                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10598                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10599                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10600                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10601                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10602                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10603                "};",
10604                Tab);
10605   verifyFormat("enum AA {\n"
10606                "\ta1, // Force multiple lines\n"
10607                "\ta2,\n"
10608                "\ta3\n"
10609                "};",
10610                Tab);
10611   EXPECT_EQ("if (aaaaaaaa && // q\n"
10612             "    bb)         // w\n"
10613             "\t;",
10614             format("if (aaaaaaaa &&// q\n"
10615                    "bb)// w\n"
10616                    ";",
10617                    Tab));
10618   verifyFormat("class X {\n"
10619                "\tvoid f() {\n"
10620                "\t\tsomeFunction(parameter1,\n"
10621                "\t\t             parameter2);\n"
10622                "\t}\n"
10623                "};",
10624                Tab);
10625   verifyFormat("{\n"
10626                "\tQ(\n"
10627                "\t    {\n"
10628                "\t\t    int a;\n"
10629                "\t\t    someFunction(aaaaaaaa,\n"
10630                "\t\t                 bbbbbbb);\n"
10631                "\t    },\n"
10632                "\t    p);\n"
10633                "}",
10634                Tab);
10635   EXPECT_EQ("{\n"
10636             "\t/* aaaa\n"
10637             "\t   bbbb */\n"
10638             "}",
10639             format("{\n"
10640                    "/* aaaa\n"
10641                    "   bbbb */\n"
10642                    "}",
10643                    Tab));
10644   EXPECT_EQ("{\n"
10645             "\t/*\n"
10646             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10647             "\t  bbbbbbbbbbbbb\n"
10648             "\t*/\n"
10649             "}",
10650             format("{\n"
10651                    "/*\n"
10652                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10653                    "*/\n"
10654                    "}",
10655                    Tab));
10656   EXPECT_EQ("{\n"
10657             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10658             "\t// bbbbbbbbbbbbb\n"
10659             "}",
10660             format("{\n"
10661                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10662                    "}",
10663                    Tab));
10664   EXPECT_EQ("{\n"
10665             "\t/*\n"
10666             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10667             "\t  bbbbbbbbbbbbb\n"
10668             "\t*/\n"
10669             "}",
10670             format("{\n"
10671                    "\t/*\n"
10672                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10673                    "\t*/\n"
10674                    "}",
10675                    Tab));
10676   EXPECT_EQ("{\n"
10677             "\t/*\n"
10678             "\n"
10679             "\t*/\n"
10680             "}",
10681             format("{\n"
10682                    "\t/*\n"
10683                    "\n"
10684                    "\t*/\n"
10685                    "}",
10686                    Tab));
10687   EXPECT_EQ("{\n"
10688             "\t/*\n"
10689             " asdf\n"
10690             "\t*/\n"
10691             "}",
10692             format("{\n"
10693                    "\t/*\n"
10694                    " asdf\n"
10695                    "\t*/\n"
10696                    "}",
10697                    Tab));
10698 
10699   Tab.UseTab = FormatStyle::UT_Never;
10700   EXPECT_EQ("/*\n"
10701             "              a\t\tcomment\n"
10702             "              in multiple lines\n"
10703             "       */",
10704             format("   /*\t \t \n"
10705                    " \t \t a\t\tcomment\t \t\n"
10706                    " \t \t in multiple lines\t\n"
10707                    " \t  */",
10708                    Tab));
10709   EXPECT_EQ("/* some\n"
10710             "   comment */",
10711             format(" \t \t /* some\n"
10712                    " \t \t    comment */",
10713                    Tab));
10714   EXPECT_EQ("int a; /* some\n"
10715             "   comment */",
10716             format(" \t \t int a; /* some\n"
10717                    " \t \t    comment */",
10718                    Tab));
10719 
10720   EXPECT_EQ("int a; /* some\n"
10721             "comment */",
10722             format(" \t \t int\ta; /* some\n"
10723                    " \t \t    comment */",
10724                    Tab));
10725   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10726             "    comment */",
10727             format(" \t \t f(\"\t\t\"); /* some\n"
10728                    " \t \t    comment */",
10729                    Tab));
10730   EXPECT_EQ("{\n"
10731             "        /*\n"
10732             "         * Comment\n"
10733             "         */\n"
10734             "        int i;\n"
10735             "}",
10736             format("{\n"
10737                    "\t/*\n"
10738                    "\t * Comment\n"
10739                    "\t */\n"
10740                    "\t int i;\n"
10741                    "}",
10742                    Tab));
10743 
10744   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
10745   Tab.TabWidth = 8;
10746   Tab.IndentWidth = 8;
10747   EXPECT_EQ("if (aaaaaaaa && // q\n"
10748             "    bb)         // w\n"
10749             "\t;",
10750             format("if (aaaaaaaa &&// q\n"
10751                    "bb)// w\n"
10752                    ";",
10753                    Tab));
10754   EXPECT_EQ("if (aaa && bbb) // w\n"
10755             "\t;",
10756             format("if(aaa&&bbb)// w\n"
10757                    ";",
10758                    Tab));
10759   verifyFormat("class X {\n"
10760                "\tvoid f() {\n"
10761                "\t\tsomeFunction(parameter1,\n"
10762                "\t\t\t     parameter2);\n"
10763                "\t}\n"
10764                "};",
10765                Tab);
10766   verifyFormat("#define A                        \\\n"
10767                "\tvoid f() {               \\\n"
10768                "\t\tsomeFunction(    \\\n"
10769                "\t\t    parameter1,  \\\n"
10770                "\t\t    parameter2); \\\n"
10771                "\t}",
10772                Tab);
10773   Tab.TabWidth = 4;
10774   Tab.IndentWidth = 8;
10775   verifyFormat("class TabWidth4Indent8 {\n"
10776                "\t\tvoid f() {\n"
10777                "\t\t\t\tsomeFunction(parameter1,\n"
10778                "\t\t\t\t\t\t\t parameter2);\n"
10779                "\t\t}\n"
10780                "};",
10781                Tab);
10782   Tab.TabWidth = 4;
10783   Tab.IndentWidth = 4;
10784   verifyFormat("class TabWidth4Indent4 {\n"
10785                "\tvoid f() {\n"
10786                "\t\tsomeFunction(parameter1,\n"
10787                "\t\t\t\t\t parameter2);\n"
10788                "\t}\n"
10789                "};",
10790                Tab);
10791   Tab.TabWidth = 8;
10792   Tab.IndentWidth = 4;
10793   verifyFormat("class TabWidth8Indent4 {\n"
10794                "    void f() {\n"
10795                "\tsomeFunction(parameter1,\n"
10796                "\t\t     parameter2);\n"
10797                "    }\n"
10798                "};",
10799                Tab);
10800   Tab.TabWidth = 8;
10801   Tab.IndentWidth = 8;
10802   EXPECT_EQ("/*\n"
10803             "\t      a\t\tcomment\n"
10804             "\t      in multiple lines\n"
10805             "       */",
10806             format("   /*\t \t \n"
10807                    " \t \t a\t\tcomment\t \t\n"
10808                    " \t \t in multiple lines\t\n"
10809                    " \t  */",
10810                    Tab));
10811   verifyFormat("{\n"
10812                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10813                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10814                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10815                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10816                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10817                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10818                "};",
10819                Tab);
10820   verifyFormat("enum AA {\n"
10821                "\ta1, // Force multiple lines\n"
10822                "\ta2,\n"
10823                "\ta3\n"
10824                "};",
10825                Tab);
10826   EXPECT_EQ("if (aaaaaaaa && // q\n"
10827             "    bb)         // w\n"
10828             "\t;",
10829             format("if (aaaaaaaa &&// q\n"
10830                    "bb)// w\n"
10831                    ";",
10832                    Tab));
10833   verifyFormat("class X {\n"
10834                "\tvoid f() {\n"
10835                "\t\tsomeFunction(parameter1,\n"
10836                "\t\t\t     parameter2);\n"
10837                "\t}\n"
10838                "};",
10839                Tab);
10840   verifyFormat("{\n"
10841                "\tQ(\n"
10842                "\t    {\n"
10843                "\t\t    int a;\n"
10844                "\t\t    someFunction(aaaaaaaa,\n"
10845                "\t\t\t\t bbbbbbb);\n"
10846                "\t    },\n"
10847                "\t    p);\n"
10848                "}",
10849                Tab);
10850   EXPECT_EQ("{\n"
10851             "\t/* aaaa\n"
10852             "\t   bbbb */\n"
10853             "}",
10854             format("{\n"
10855                    "/* aaaa\n"
10856                    "   bbbb */\n"
10857                    "}",
10858                    Tab));
10859   EXPECT_EQ("{\n"
10860             "\t/*\n"
10861             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10862             "\t  bbbbbbbbbbbbb\n"
10863             "\t*/\n"
10864             "}",
10865             format("{\n"
10866                    "/*\n"
10867                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10868                    "*/\n"
10869                    "}",
10870                    Tab));
10871   EXPECT_EQ("{\n"
10872             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10873             "\t// bbbbbbbbbbbbb\n"
10874             "}",
10875             format("{\n"
10876                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10877                    "}",
10878                    Tab));
10879   EXPECT_EQ("{\n"
10880             "\t/*\n"
10881             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10882             "\t  bbbbbbbbbbbbb\n"
10883             "\t*/\n"
10884             "}",
10885             format("{\n"
10886                    "\t/*\n"
10887                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10888                    "\t*/\n"
10889                    "}",
10890                    Tab));
10891   EXPECT_EQ("{\n"
10892             "\t/*\n"
10893             "\n"
10894             "\t*/\n"
10895             "}",
10896             format("{\n"
10897                    "\t/*\n"
10898                    "\n"
10899                    "\t*/\n"
10900                    "}",
10901                    Tab));
10902   EXPECT_EQ("{\n"
10903             "\t/*\n"
10904             " asdf\n"
10905             "\t*/\n"
10906             "}",
10907             format("{\n"
10908                    "\t/*\n"
10909                    " asdf\n"
10910                    "\t*/\n"
10911                    "}",
10912                    Tab));
10913   EXPECT_EQ("/* some\n"
10914             "   comment */",
10915             format(" \t \t /* some\n"
10916                    " \t \t    comment */",
10917                    Tab));
10918   EXPECT_EQ("int a; /* some\n"
10919             "   comment */",
10920             format(" \t \t int a; /* some\n"
10921                    " \t \t    comment */",
10922                    Tab));
10923   EXPECT_EQ("int a; /* some\n"
10924             "comment */",
10925             format(" \t \t int\ta; /* some\n"
10926                    " \t \t    comment */",
10927                    Tab));
10928   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10929             "    comment */",
10930             format(" \t \t f(\"\t\t\"); /* some\n"
10931                    " \t \t    comment */",
10932                    Tab));
10933   EXPECT_EQ("{\n"
10934             "\t/*\n"
10935             "\t * Comment\n"
10936             "\t */\n"
10937             "\tint i;\n"
10938             "}",
10939             format("{\n"
10940                    "\t/*\n"
10941                    "\t * Comment\n"
10942                    "\t */\n"
10943                    "\t int i;\n"
10944                    "}",
10945                    Tab));
10946   Tab.TabWidth = 2;
10947   Tab.IndentWidth = 2;
10948   EXPECT_EQ("{\n"
10949             "\t/* aaaa\n"
10950             "\t\t bbbb */\n"
10951             "}",
10952             format("{\n"
10953                    "/* aaaa\n"
10954                    "\t bbbb */\n"
10955                    "}",
10956                    Tab));
10957   EXPECT_EQ("{\n"
10958             "\t/*\n"
10959             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10960             "\t\tbbbbbbbbbbbbb\n"
10961             "\t*/\n"
10962             "}",
10963             format("{\n"
10964                    "/*\n"
10965                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10966                    "*/\n"
10967                    "}",
10968                    Tab));
10969   Tab.AlignConsecutiveAssignments = true;
10970   Tab.AlignConsecutiveDeclarations = true;
10971   Tab.TabWidth = 4;
10972   Tab.IndentWidth = 4;
10973   verifyFormat("class Assign {\n"
10974                "\tvoid f() {\n"
10975                "\t\tint         x      = 123;\n"
10976                "\t\tint         random = 4;\n"
10977                "\t\tstd::string alphabet =\n"
10978                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
10979                "\t}\n"
10980                "};",
10981                Tab);
10982 
10983   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
10984   Tab.TabWidth = 8;
10985   Tab.IndentWidth = 8;
10986   EXPECT_EQ("if (aaaaaaaa && // q\n"
10987             "    bb)         // w\n"
10988             "\t;",
10989             format("if (aaaaaaaa &&// q\n"
10990                    "bb)// w\n"
10991                    ";",
10992                    Tab));
10993   EXPECT_EQ("if (aaa && bbb) // w\n"
10994             "\t;",
10995             format("if(aaa&&bbb)// w\n"
10996                    ";",
10997                    Tab));
10998   verifyFormat("class X {\n"
10999                "\tvoid f() {\n"
11000                "\t\tsomeFunction(parameter1,\n"
11001                "\t\t             parameter2);\n"
11002                "\t}\n"
11003                "};",
11004                Tab);
11005   verifyFormat("#define A                        \\\n"
11006                "\tvoid f() {               \\\n"
11007                "\t\tsomeFunction(    \\\n"
11008                "\t\t    parameter1,  \\\n"
11009                "\t\t    parameter2); \\\n"
11010                "\t}",
11011                Tab);
11012   Tab.TabWidth = 4;
11013   Tab.IndentWidth = 8;
11014   verifyFormat("class TabWidth4Indent8 {\n"
11015                "\t\tvoid f() {\n"
11016                "\t\t\t\tsomeFunction(parameter1,\n"
11017                "\t\t\t\t             parameter2);\n"
11018                "\t\t}\n"
11019                "};",
11020                Tab);
11021   Tab.TabWidth = 4;
11022   Tab.IndentWidth = 4;
11023   verifyFormat("class TabWidth4Indent4 {\n"
11024                "\tvoid f() {\n"
11025                "\t\tsomeFunction(parameter1,\n"
11026                "\t\t             parameter2);\n"
11027                "\t}\n"
11028                "};",
11029                Tab);
11030   Tab.TabWidth = 8;
11031   Tab.IndentWidth = 4;
11032   verifyFormat("class TabWidth8Indent4 {\n"
11033                "    void f() {\n"
11034                "\tsomeFunction(parameter1,\n"
11035                "\t             parameter2);\n"
11036                "    }\n"
11037                "};",
11038                Tab);
11039   Tab.TabWidth = 8;
11040   Tab.IndentWidth = 8;
11041   EXPECT_EQ("/*\n"
11042             "              a\t\tcomment\n"
11043             "              in multiple lines\n"
11044             "       */",
11045             format("   /*\t \t \n"
11046                    " \t \t a\t\tcomment\t \t\n"
11047                    " \t \t in multiple lines\t\n"
11048                    " \t  */",
11049                    Tab));
11050   verifyFormat("{\n"
11051                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11052                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11053                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11054                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11055                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11056                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11057                "};",
11058                Tab);
11059   verifyFormat("enum AA {\n"
11060                "\ta1, // Force multiple lines\n"
11061                "\ta2,\n"
11062                "\ta3\n"
11063                "};",
11064                Tab);
11065   EXPECT_EQ("if (aaaaaaaa && // q\n"
11066             "    bb)         // w\n"
11067             "\t;",
11068             format("if (aaaaaaaa &&// q\n"
11069                    "bb)// w\n"
11070                    ";",
11071                    Tab));
11072   verifyFormat("class X {\n"
11073                "\tvoid f() {\n"
11074                "\t\tsomeFunction(parameter1,\n"
11075                "\t\t             parameter2);\n"
11076                "\t}\n"
11077                "};",
11078                Tab);
11079   verifyFormat("{\n"
11080                "\tQ(\n"
11081                "\t    {\n"
11082                "\t\t    int a;\n"
11083                "\t\t    someFunction(aaaaaaaa,\n"
11084                "\t\t                 bbbbbbb);\n"
11085                "\t    },\n"
11086                "\t    p);\n"
11087                "}",
11088                Tab);
11089   EXPECT_EQ("{\n"
11090             "\t/* aaaa\n"
11091             "\t   bbbb */\n"
11092             "}",
11093             format("{\n"
11094                    "/* aaaa\n"
11095                    "   bbbb */\n"
11096                    "}",
11097                    Tab));
11098   EXPECT_EQ("{\n"
11099             "\t/*\n"
11100             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11101             "\t  bbbbbbbbbbbbb\n"
11102             "\t*/\n"
11103             "}",
11104             format("{\n"
11105                    "/*\n"
11106                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11107                    "*/\n"
11108                    "}",
11109                    Tab));
11110   EXPECT_EQ("{\n"
11111             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11112             "\t// bbbbbbbbbbbbb\n"
11113             "}",
11114             format("{\n"
11115                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11116                    "}",
11117                    Tab));
11118   EXPECT_EQ("{\n"
11119             "\t/*\n"
11120             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11121             "\t  bbbbbbbbbbbbb\n"
11122             "\t*/\n"
11123             "}",
11124             format("{\n"
11125                    "\t/*\n"
11126                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11127                    "\t*/\n"
11128                    "}",
11129                    Tab));
11130   EXPECT_EQ("{\n"
11131             "\t/*\n"
11132             "\n"
11133             "\t*/\n"
11134             "}",
11135             format("{\n"
11136                    "\t/*\n"
11137                    "\n"
11138                    "\t*/\n"
11139                    "}",
11140                    Tab));
11141   EXPECT_EQ("{\n"
11142             "\t/*\n"
11143             " asdf\n"
11144             "\t*/\n"
11145             "}",
11146             format("{\n"
11147                    "\t/*\n"
11148                    " asdf\n"
11149                    "\t*/\n"
11150                    "}",
11151                    Tab));
11152   EXPECT_EQ("/* some\n"
11153             "   comment */",
11154             format(" \t \t /* some\n"
11155                    " \t \t    comment */",
11156                    Tab));
11157   EXPECT_EQ("int a; /* some\n"
11158             "   comment */",
11159             format(" \t \t int a; /* some\n"
11160                    " \t \t    comment */",
11161                    Tab));
11162   EXPECT_EQ("int a; /* some\n"
11163             "comment */",
11164             format(" \t \t int\ta; /* some\n"
11165                    " \t \t    comment */",
11166                    Tab));
11167   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11168             "    comment */",
11169             format(" \t \t f(\"\t\t\"); /* some\n"
11170                    " \t \t    comment */",
11171                    Tab));
11172   EXPECT_EQ("{\n"
11173             "\t/*\n"
11174             "\t * Comment\n"
11175             "\t */\n"
11176             "\tint i;\n"
11177             "}",
11178             format("{\n"
11179                    "\t/*\n"
11180                    "\t * Comment\n"
11181                    "\t */\n"
11182                    "\t int i;\n"
11183                    "}",
11184                    Tab));
11185   Tab.TabWidth = 2;
11186   Tab.IndentWidth = 2;
11187   EXPECT_EQ("{\n"
11188             "\t/* aaaa\n"
11189             "\t   bbbb */\n"
11190             "}",
11191             format("{\n"
11192                    "/* aaaa\n"
11193                    "   bbbb */\n"
11194                    "}",
11195                    Tab));
11196   EXPECT_EQ("{\n"
11197             "\t/*\n"
11198             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11199             "\t  bbbbbbbbbbbbb\n"
11200             "\t*/\n"
11201             "}",
11202             format("{\n"
11203                    "/*\n"
11204                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11205                    "*/\n"
11206                    "}",
11207                    Tab));
11208   Tab.AlignConsecutiveAssignments = true;
11209   Tab.AlignConsecutiveDeclarations = true;
11210   Tab.TabWidth = 4;
11211   Tab.IndentWidth = 4;
11212   verifyFormat("class Assign {\n"
11213                "\tvoid f() {\n"
11214                "\t\tint         x      = 123;\n"
11215                "\t\tint         random = 4;\n"
11216                "\t\tstd::string alphabet =\n"
11217                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11218                "\t}\n"
11219                "};",
11220                Tab);
11221 }
11222 
11223 TEST_F(FormatTest, ZeroTabWidth) {
11224   FormatStyle Tab = getLLVMStyleWithColumns(42);
11225   Tab.IndentWidth = 8;
11226   Tab.UseTab = FormatStyle::UT_Never;
11227   Tab.TabWidth = 0;
11228   EXPECT_EQ("void a(){\n"
11229             "    // line starts with '\t'\n"
11230             "};",
11231             format("void a(){\n"
11232                    "\t// line starts with '\t'\n"
11233                    "};",
11234                    Tab));
11235 
11236   EXPECT_EQ("void a(){\n"
11237             "    // line starts with '\t'\n"
11238             "};",
11239             format("void a(){\n"
11240                    "\t\t// line starts with '\t'\n"
11241                    "};",
11242                    Tab));
11243 
11244   Tab.UseTab = FormatStyle::UT_ForIndentation;
11245   EXPECT_EQ("void a(){\n"
11246             "    // line starts with '\t'\n"
11247             "};",
11248             format("void a(){\n"
11249                    "\t// line starts with '\t'\n"
11250                    "};",
11251                    Tab));
11252 
11253   EXPECT_EQ("void a(){\n"
11254             "    // line starts with '\t'\n"
11255             "};",
11256             format("void a(){\n"
11257                    "\t\t// line starts with '\t'\n"
11258                    "};",
11259                    Tab));
11260 
11261   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11262   EXPECT_EQ("void a(){\n"
11263             "    // line starts with '\t'\n"
11264             "};",
11265             format("void a(){\n"
11266                    "\t// line starts with '\t'\n"
11267                    "};",
11268                    Tab));
11269 
11270   EXPECT_EQ("void a(){\n"
11271             "    // line starts with '\t'\n"
11272             "};",
11273             format("void a(){\n"
11274                    "\t\t// line starts with '\t'\n"
11275                    "};",
11276                    Tab));
11277 
11278   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11279   EXPECT_EQ("void a(){\n"
11280             "    // line starts with '\t'\n"
11281             "};",
11282             format("void a(){\n"
11283                    "\t// line starts with '\t'\n"
11284                    "};",
11285                    Tab));
11286 
11287   EXPECT_EQ("void a(){\n"
11288             "    // line starts with '\t'\n"
11289             "};",
11290             format("void a(){\n"
11291                    "\t\t// line starts with '\t'\n"
11292                    "};",
11293                    Tab));
11294 
11295   Tab.UseTab = FormatStyle::UT_Always;
11296   EXPECT_EQ("void a(){\n"
11297             "// line starts with '\t'\n"
11298             "};",
11299             format("void a(){\n"
11300                    "\t// line starts with '\t'\n"
11301                    "};",
11302                    Tab));
11303 
11304   EXPECT_EQ("void a(){\n"
11305             "// line starts with '\t'\n"
11306             "};",
11307             format("void a(){\n"
11308                    "\t\t// line starts with '\t'\n"
11309                    "};",
11310                    Tab));
11311 }
11312 
11313 TEST_F(FormatTest, CalculatesOriginalColumn) {
11314   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11315             "q\"; /* some\n"
11316             "       comment */",
11317             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11318                    "q\"; /* some\n"
11319                    "       comment */",
11320                    getLLVMStyle()));
11321   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11322             "/* some\n"
11323             "   comment */",
11324             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11325                    " /* some\n"
11326                    "    comment */",
11327                    getLLVMStyle()));
11328   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11329             "qqq\n"
11330             "/* some\n"
11331             "   comment */",
11332             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11333                    "qqq\n"
11334                    " /* some\n"
11335                    "    comment */",
11336                    getLLVMStyle()));
11337   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11338             "wwww; /* some\n"
11339             "         comment */",
11340             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11341                    "wwww; /* some\n"
11342                    "         comment */",
11343                    getLLVMStyle()));
11344 }
11345 
11346 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11347   FormatStyle NoSpace = getLLVMStyle();
11348   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11349 
11350   verifyFormat("while(true)\n"
11351                "  continue;",
11352                NoSpace);
11353   verifyFormat("for(;;)\n"
11354                "  continue;",
11355                NoSpace);
11356   verifyFormat("if(true)\n"
11357                "  f();\n"
11358                "else if(true)\n"
11359                "  f();",
11360                NoSpace);
11361   verifyFormat("do {\n"
11362                "  do_something();\n"
11363                "} while(something());",
11364                NoSpace);
11365   verifyFormat("switch(x) {\n"
11366                "default:\n"
11367                "  break;\n"
11368                "}",
11369                NoSpace);
11370   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11371   verifyFormat("size_t x = sizeof(x);", NoSpace);
11372   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11373   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11374   verifyFormat("alignas(128) char a[128];", NoSpace);
11375   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11376   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11377   verifyFormat("int f() throw(Deprecated);", NoSpace);
11378   verifyFormat("typedef void (*cb)(int);", NoSpace);
11379   verifyFormat("T A::operator()();", NoSpace);
11380   verifyFormat("X A::operator++(T);", NoSpace);
11381   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11382 
11383   FormatStyle Space = getLLVMStyle();
11384   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11385 
11386   verifyFormat("int f ();", Space);
11387   verifyFormat("void f (int a, T b) {\n"
11388                "  while (true)\n"
11389                "    continue;\n"
11390                "}",
11391                Space);
11392   verifyFormat("if (true)\n"
11393                "  f ();\n"
11394                "else if (true)\n"
11395                "  f ();",
11396                Space);
11397   verifyFormat("do {\n"
11398                "  do_something ();\n"
11399                "} while (something ());",
11400                Space);
11401   verifyFormat("switch (x) {\n"
11402                "default:\n"
11403                "  break;\n"
11404                "}",
11405                Space);
11406   verifyFormat("A::A () : a (1) {}", Space);
11407   verifyFormat("void f () __attribute__ ((asdf));", Space);
11408   verifyFormat("*(&a + 1);\n"
11409                "&((&a)[1]);\n"
11410                "a[(b + c) * d];\n"
11411                "(((a + 1) * 2) + 3) * 4;",
11412                Space);
11413   verifyFormat("#define A(x) x", Space);
11414   verifyFormat("#define A (x) x", Space);
11415   verifyFormat("#if defined(x)\n"
11416                "#endif",
11417                Space);
11418   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11419   verifyFormat("size_t x = sizeof (x);", Space);
11420   verifyFormat("auto f (int x) -> decltype (x);", Space);
11421   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11422   verifyFormat("alignas (128) char a[128];", Space);
11423   verifyFormat("size_t x = alignof (MyType);", Space);
11424   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11425   verifyFormat("int f () throw (Deprecated);", Space);
11426   verifyFormat("typedef void (*cb) (int);", Space);
11427   verifyFormat("T A::operator() ();", Space);
11428   verifyFormat("X A::operator++ (T);", Space);
11429   verifyFormat("auto lambda = [] () { return 0; };", Space);
11430   verifyFormat("int x = int (y);", Space);
11431 
11432   FormatStyle SomeSpace = getLLVMStyle();
11433   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11434 
11435   verifyFormat("[]() -> float {}", SomeSpace);
11436   verifyFormat("[] (auto foo) {}", SomeSpace);
11437   verifyFormat("[foo]() -> int {}", SomeSpace);
11438   verifyFormat("int f();", SomeSpace);
11439   verifyFormat("void f (int a, T b) {\n"
11440                "  while (true)\n"
11441                "    continue;\n"
11442                "}",
11443                SomeSpace);
11444   verifyFormat("if (true)\n"
11445                "  f();\n"
11446                "else if (true)\n"
11447                "  f();",
11448                SomeSpace);
11449   verifyFormat("do {\n"
11450                "  do_something();\n"
11451                "} while (something());",
11452                SomeSpace);
11453   verifyFormat("switch (x) {\n"
11454                "default:\n"
11455                "  break;\n"
11456                "}",
11457                SomeSpace);
11458   verifyFormat("A::A() : a (1) {}", SomeSpace);
11459   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11460   verifyFormat("*(&a + 1);\n"
11461                "&((&a)[1]);\n"
11462                "a[(b + c) * d];\n"
11463                "(((a + 1) * 2) + 3) * 4;",
11464                SomeSpace);
11465   verifyFormat("#define A(x) x", SomeSpace);
11466   verifyFormat("#define A (x) x", SomeSpace);
11467   verifyFormat("#if defined(x)\n"
11468                "#endif",
11469                SomeSpace);
11470   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11471   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11472   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11473   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11474   verifyFormat("alignas (128) char a[128];", SomeSpace);
11475   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11476   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11477                SomeSpace);
11478   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11479   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11480   verifyFormat("T A::operator()();", SomeSpace);
11481   verifyFormat("X A::operator++ (T);", SomeSpace);
11482   verifyFormat("int x = int (y);", SomeSpace);
11483   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11484 }
11485 
11486 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11487   FormatStyle Spaces = getLLVMStyle();
11488   Spaces.SpaceAfterLogicalNot = true;
11489 
11490   verifyFormat("bool x = ! y", Spaces);
11491   verifyFormat("if (! isFailure())", Spaces);
11492   verifyFormat("if (! (a && b))", Spaces);
11493   verifyFormat("\"Error!\"", Spaces);
11494   verifyFormat("! ! x", Spaces);
11495 }
11496 
11497 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11498   FormatStyle Spaces = getLLVMStyle();
11499 
11500   Spaces.SpacesInParentheses = true;
11501   verifyFormat("do_something( ::globalVar );", Spaces);
11502   verifyFormat("call( x, y, z );", Spaces);
11503   verifyFormat("call();", Spaces);
11504   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11505   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11506                Spaces);
11507   verifyFormat("while ( (bool)1 )\n"
11508                "  continue;",
11509                Spaces);
11510   verifyFormat("for ( ;; )\n"
11511                "  continue;",
11512                Spaces);
11513   verifyFormat("if ( true )\n"
11514                "  f();\n"
11515                "else if ( true )\n"
11516                "  f();",
11517                Spaces);
11518   verifyFormat("do {\n"
11519                "  do_something( (int)i );\n"
11520                "} while ( something() );",
11521                Spaces);
11522   verifyFormat("switch ( x ) {\n"
11523                "default:\n"
11524                "  break;\n"
11525                "}",
11526                Spaces);
11527 
11528   Spaces.SpacesInParentheses = false;
11529   Spaces.SpacesInCStyleCastParentheses = true;
11530   verifyFormat("Type *A = ( Type * )P;", Spaces);
11531   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11532   verifyFormat("x = ( int32 )y;", Spaces);
11533   verifyFormat("int a = ( int )(2.0f);", Spaces);
11534   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11535   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11536   verifyFormat("#define x (( int )-1)", Spaces);
11537 
11538   // Run the first set of tests again with:
11539   Spaces.SpacesInParentheses = false;
11540   Spaces.SpaceInEmptyParentheses = true;
11541   Spaces.SpacesInCStyleCastParentheses = true;
11542   verifyFormat("call(x, y, z);", Spaces);
11543   verifyFormat("call( );", Spaces);
11544   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11545   verifyFormat("while (( bool )1)\n"
11546                "  continue;",
11547                Spaces);
11548   verifyFormat("for (;;)\n"
11549                "  continue;",
11550                Spaces);
11551   verifyFormat("if (true)\n"
11552                "  f( );\n"
11553                "else if (true)\n"
11554                "  f( );",
11555                Spaces);
11556   verifyFormat("do {\n"
11557                "  do_something(( int )i);\n"
11558                "} while (something( ));",
11559                Spaces);
11560   verifyFormat("switch (x) {\n"
11561                "default:\n"
11562                "  break;\n"
11563                "}",
11564                Spaces);
11565 
11566   // Run the first set of tests again with:
11567   Spaces.SpaceAfterCStyleCast = true;
11568   verifyFormat("call(x, y, z);", Spaces);
11569   verifyFormat("call( );", Spaces);
11570   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11571   verifyFormat("while (( bool ) 1)\n"
11572                "  continue;",
11573                Spaces);
11574   verifyFormat("for (;;)\n"
11575                "  continue;",
11576                Spaces);
11577   verifyFormat("if (true)\n"
11578                "  f( );\n"
11579                "else if (true)\n"
11580                "  f( );",
11581                Spaces);
11582   verifyFormat("do {\n"
11583                "  do_something(( int ) i);\n"
11584                "} while (something( ));",
11585                Spaces);
11586   verifyFormat("switch (x) {\n"
11587                "default:\n"
11588                "  break;\n"
11589                "}",
11590                Spaces);
11591 
11592   // Run subset of tests again with:
11593   Spaces.SpacesInCStyleCastParentheses = false;
11594   Spaces.SpaceAfterCStyleCast = true;
11595   verifyFormat("while ((bool) 1)\n"
11596                "  continue;",
11597                Spaces);
11598   verifyFormat("do {\n"
11599                "  do_something((int) i);\n"
11600                "} while (something( ));",
11601                Spaces);
11602 }
11603 
11604 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
11605   verifyFormat("int a[5];");
11606   verifyFormat("a[3] += 42;");
11607 
11608   FormatStyle Spaces = getLLVMStyle();
11609   Spaces.SpacesInSquareBrackets = true;
11610   // Not lambdas.
11611   verifyFormat("int a[ 5 ];", Spaces);
11612   verifyFormat("a[ 3 ] += 42;", Spaces);
11613   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
11614   verifyFormat("double &operator[](int i) { return 0; }\n"
11615                "int i;",
11616                Spaces);
11617   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
11618   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
11619   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
11620   // Lambdas.
11621   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
11622   verifyFormat("return [ i, args... ] {};", Spaces);
11623   verifyFormat("int foo = [ &bar ]() {};", Spaces);
11624   verifyFormat("int foo = [ = ]() {};", Spaces);
11625   verifyFormat("int foo = [ & ]() {};", Spaces);
11626   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
11627   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
11628 }
11629 
11630 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
11631   FormatStyle NoSpaceStyle = getLLVMStyle();
11632   verifyFormat("int a[5];", NoSpaceStyle);
11633   verifyFormat("a[3] += 42;", NoSpaceStyle);
11634 
11635   verifyFormat("int a[1];", NoSpaceStyle);
11636   verifyFormat("int 1 [a];", NoSpaceStyle);
11637   verifyFormat("int a[1][2];", NoSpaceStyle);
11638   verifyFormat("a[7] = 5;", NoSpaceStyle);
11639   verifyFormat("int a = (f())[23];", NoSpaceStyle);
11640   verifyFormat("f([] {})", NoSpaceStyle);
11641 
11642   FormatStyle Space = getLLVMStyle();
11643   Space.SpaceBeforeSquareBrackets = true;
11644   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
11645   verifyFormat("return [i, args...] {};", Space);
11646 
11647   verifyFormat("int a [5];", Space);
11648   verifyFormat("a [3] += 42;", Space);
11649   verifyFormat("constexpr char hello []{\"hello\"};", Space);
11650   verifyFormat("double &operator[](int i) { return 0; }\n"
11651                "int i;",
11652                Space);
11653   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
11654   verifyFormat("int i = a [a][a]->f();", Space);
11655   verifyFormat("int i = (*b) [a]->f();", Space);
11656 
11657   verifyFormat("int a [1];", Space);
11658   verifyFormat("int 1 [a];", Space);
11659   verifyFormat("int a [1][2];", Space);
11660   verifyFormat("a [7] = 5;", Space);
11661   verifyFormat("int a = (f()) [23];", Space);
11662   verifyFormat("f([] {})", Space);
11663 }
11664 
11665 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
11666   verifyFormat("int a = 5;");
11667   verifyFormat("a += 42;");
11668   verifyFormat("a or_eq 8;");
11669 
11670   FormatStyle Spaces = getLLVMStyle();
11671   Spaces.SpaceBeforeAssignmentOperators = false;
11672   verifyFormat("int a= 5;", Spaces);
11673   verifyFormat("a+= 42;", Spaces);
11674   verifyFormat("a or_eq 8;", Spaces);
11675 }
11676 
11677 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
11678   verifyFormat("class Foo : public Bar {};");
11679   verifyFormat("Foo::Foo() : foo(1) {}");
11680   verifyFormat("for (auto a : b) {\n}");
11681   verifyFormat("int x = a ? b : c;");
11682   verifyFormat("{\n"
11683                "label0:\n"
11684                "  int x = 0;\n"
11685                "}");
11686   verifyFormat("switch (x) {\n"
11687                "case 1:\n"
11688                "default:\n"
11689                "}");
11690 
11691   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
11692   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
11693   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
11694   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
11695   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
11696   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
11697   verifyFormat("{\n"
11698                "label1:\n"
11699                "  int x = 0;\n"
11700                "}",
11701                CtorInitializerStyle);
11702   verifyFormat("switch (x) {\n"
11703                "case 1:\n"
11704                "default:\n"
11705                "}",
11706                CtorInitializerStyle);
11707   CtorInitializerStyle.BreakConstructorInitializers =
11708       FormatStyle::BCIS_AfterColon;
11709   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
11710                "    aaaaaaaaaaaaaaaa(1),\n"
11711                "    bbbbbbbbbbbbbbbb(2) {}",
11712                CtorInitializerStyle);
11713   CtorInitializerStyle.BreakConstructorInitializers =
11714       FormatStyle::BCIS_BeforeComma;
11715   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11716                "    : aaaaaaaaaaaaaaaa(1)\n"
11717                "    , bbbbbbbbbbbbbbbb(2) {}",
11718                CtorInitializerStyle);
11719   CtorInitializerStyle.BreakConstructorInitializers =
11720       FormatStyle::BCIS_BeforeColon;
11721   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11722                "    : aaaaaaaaaaaaaaaa(1),\n"
11723                "      bbbbbbbbbbbbbbbb(2) {}",
11724                CtorInitializerStyle);
11725   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
11726   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11727                ": aaaaaaaaaaaaaaaa(1),\n"
11728                "  bbbbbbbbbbbbbbbb(2) {}",
11729                CtorInitializerStyle);
11730 
11731   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
11732   InheritanceStyle.SpaceBeforeInheritanceColon = false;
11733   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
11734   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
11735   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
11736   verifyFormat("int x = a ? b : c;", InheritanceStyle);
11737   verifyFormat("{\n"
11738                "label2:\n"
11739                "  int x = 0;\n"
11740                "}",
11741                InheritanceStyle);
11742   verifyFormat("switch (x) {\n"
11743                "case 1:\n"
11744                "default:\n"
11745                "}",
11746                InheritanceStyle);
11747   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
11748   verifyFormat("class Foooooooooooooooooooooo:\n"
11749                "    public aaaaaaaaaaaaaaaaaa,\n"
11750                "    public bbbbbbbbbbbbbbbbbb {\n"
11751                "}",
11752                InheritanceStyle);
11753   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
11754   verifyFormat("class Foooooooooooooooooooooo\n"
11755                "    : public aaaaaaaaaaaaaaaaaa\n"
11756                "    , public bbbbbbbbbbbbbbbbbb {\n"
11757                "}",
11758                InheritanceStyle);
11759   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
11760   verifyFormat("class Foooooooooooooooooooooo\n"
11761                "    : public aaaaaaaaaaaaaaaaaa,\n"
11762                "      public bbbbbbbbbbbbbbbbbb {\n"
11763                "}",
11764                InheritanceStyle);
11765   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
11766   verifyFormat("class Foooooooooooooooooooooo\n"
11767                ": public aaaaaaaaaaaaaaaaaa,\n"
11768                "  public bbbbbbbbbbbbbbbbbb {}",
11769                InheritanceStyle);
11770 
11771   FormatStyle ForLoopStyle = getLLVMStyle();
11772   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
11773   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
11774   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
11775   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
11776   verifyFormat("int x = a ? b : c;", ForLoopStyle);
11777   verifyFormat("{\n"
11778                "label2:\n"
11779                "  int x = 0;\n"
11780                "}",
11781                ForLoopStyle);
11782   verifyFormat("switch (x) {\n"
11783                "case 1:\n"
11784                "default:\n"
11785                "}",
11786                ForLoopStyle);
11787 
11788   FormatStyle NoSpaceStyle = getLLVMStyle();
11789   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
11790   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
11791   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
11792   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
11793   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
11794   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
11795   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
11796   verifyFormat("{\n"
11797                "label3:\n"
11798                "  int x = 0;\n"
11799                "}",
11800                NoSpaceStyle);
11801   verifyFormat("switch (x) {\n"
11802                "case 1:\n"
11803                "default:\n"
11804                "}",
11805                NoSpaceStyle);
11806 }
11807 
11808 TEST_F(FormatTest, AlignConsecutiveMacros) {
11809   FormatStyle Style = getLLVMStyle();
11810   Style.AlignConsecutiveAssignments = true;
11811   Style.AlignConsecutiveDeclarations = true;
11812   Style.AlignConsecutiveMacros = false;
11813 
11814   verifyFormat("#define a 3\n"
11815                "#define bbbb 4\n"
11816                "#define ccc (5)",
11817                Style);
11818 
11819   verifyFormat("#define f(x) (x * x)\n"
11820                "#define fff(x, y, z) (x * y + z)\n"
11821                "#define ffff(x, y) (x - y)",
11822                Style);
11823 
11824   verifyFormat("#define foo(x, y) (x + y)\n"
11825                "#define bar (5, 6)(2 + 2)",
11826                Style);
11827 
11828   verifyFormat("#define a 3\n"
11829                "#define bbbb 4\n"
11830                "#define ccc (5)\n"
11831                "#define f(x) (x * x)\n"
11832                "#define fff(x, y, z) (x * y + z)\n"
11833                "#define ffff(x, y) (x - y)",
11834                Style);
11835 
11836   Style.AlignConsecutiveMacros = true;
11837   verifyFormat("#define a    3\n"
11838                "#define bbbb 4\n"
11839                "#define ccc  (5)",
11840                Style);
11841 
11842   verifyFormat("#define f(x)         (x * x)\n"
11843                "#define fff(x, y, z) (x * y + z)\n"
11844                "#define ffff(x, y)   (x - y)",
11845                Style);
11846 
11847   verifyFormat("#define foo(x, y) (x + y)\n"
11848                "#define bar       (5, 6)(2 + 2)",
11849                Style);
11850 
11851   verifyFormat("#define a            3\n"
11852                "#define bbbb         4\n"
11853                "#define ccc          (5)\n"
11854                "#define f(x)         (x * x)\n"
11855                "#define fff(x, y, z) (x * y + z)\n"
11856                "#define ffff(x, y)   (x - y)",
11857                Style);
11858 
11859   verifyFormat("#define a         5\n"
11860                "#define foo(x, y) (x + y)\n"
11861                "#define CCC       (6)\n"
11862                "auto lambda = []() {\n"
11863                "  auto  ii = 0;\n"
11864                "  float j  = 0;\n"
11865                "  return 0;\n"
11866                "};\n"
11867                "int   i  = 0;\n"
11868                "float i2 = 0;\n"
11869                "auto  v  = type{\n"
11870                "    i = 1,   //\n"
11871                "    (i = 2), //\n"
11872                "    i = 3    //\n"
11873                "};",
11874                Style);
11875 
11876   Style.AlignConsecutiveMacros = false;
11877   Style.ColumnLimit = 20;
11878 
11879   verifyFormat("#define a          \\\n"
11880                "  \"aabbbbbbbbbbbb\"\n"
11881                "#define D          \\\n"
11882                "  \"aabbbbbbbbbbbb\" \\\n"
11883                "  \"ccddeeeeeeeee\"\n"
11884                "#define B          \\\n"
11885                "  \"QQQQQQQQQQQQQ\"  \\\n"
11886                "  \"FFFFFFFFFFFFF\"  \\\n"
11887                "  \"LLLLLLLL\"\n",
11888                Style);
11889 
11890   Style.AlignConsecutiveMacros = true;
11891   verifyFormat("#define a          \\\n"
11892                "  \"aabbbbbbbbbbbb\"\n"
11893                "#define D          \\\n"
11894                "  \"aabbbbbbbbbbbb\" \\\n"
11895                "  \"ccddeeeeeeeee\"\n"
11896                "#define B          \\\n"
11897                "  \"QQQQQQQQQQQQQ\"  \\\n"
11898                "  \"FFFFFFFFFFFFF\"  \\\n"
11899                "  \"LLLLLLLL\"\n",
11900                Style);
11901 }
11902 
11903 TEST_F(FormatTest, AlignConsecutiveAssignments) {
11904   FormatStyle Alignment = getLLVMStyle();
11905   Alignment.AlignConsecutiveMacros = true;
11906   Alignment.AlignConsecutiveAssignments = false;
11907   verifyFormat("int a = 5;\n"
11908                "int oneTwoThree = 123;",
11909                Alignment);
11910   verifyFormat("int a = 5;\n"
11911                "int oneTwoThree = 123;",
11912                Alignment);
11913 
11914   Alignment.AlignConsecutiveAssignments = true;
11915   verifyFormat("int a           = 5;\n"
11916                "int oneTwoThree = 123;",
11917                Alignment);
11918   verifyFormat("int a           = method();\n"
11919                "int oneTwoThree = 133;",
11920                Alignment);
11921   verifyFormat("a &= 5;\n"
11922                "bcd *= 5;\n"
11923                "ghtyf += 5;\n"
11924                "dvfvdb -= 5;\n"
11925                "a /= 5;\n"
11926                "vdsvsv %= 5;\n"
11927                "sfdbddfbdfbb ^= 5;\n"
11928                "dvsdsv |= 5;\n"
11929                "int dsvvdvsdvvv = 123;",
11930                Alignment);
11931   verifyFormat("int i = 1, j = 10;\n"
11932                "something = 2000;",
11933                Alignment);
11934   verifyFormat("something = 2000;\n"
11935                "int i = 1, j = 10;\n",
11936                Alignment);
11937   verifyFormat("something = 2000;\n"
11938                "another   = 911;\n"
11939                "int i = 1, j = 10;\n"
11940                "oneMore = 1;\n"
11941                "i       = 2;",
11942                Alignment);
11943   verifyFormat("int a   = 5;\n"
11944                "int one = 1;\n"
11945                "method();\n"
11946                "int oneTwoThree = 123;\n"
11947                "int oneTwo      = 12;",
11948                Alignment);
11949   verifyFormat("int oneTwoThree = 123;\n"
11950                "int oneTwo      = 12;\n"
11951                "method();\n",
11952                Alignment);
11953   verifyFormat("int oneTwoThree = 123; // comment\n"
11954                "int oneTwo      = 12;  // comment",
11955                Alignment);
11956 
11957   // Bug 25167
11958   verifyFormat("#if A\n"
11959                "#else\n"
11960                "int aaaaaaaa = 12;\n"
11961                "#endif\n"
11962                "#if B\n"
11963                "#else\n"
11964                "int a = 12;\n"
11965                "#endif\n",
11966                Alignment);
11967   verifyFormat("enum foo {\n"
11968                "#if A\n"
11969                "#else\n"
11970                "  aaaaaaaa = 12;\n"
11971                "#endif\n"
11972                "#if B\n"
11973                "#else\n"
11974                "  a = 12;\n"
11975                "#endif\n"
11976                "};\n",
11977                Alignment);
11978 
11979   EXPECT_EQ("int a = 5;\n"
11980             "\n"
11981             "int oneTwoThree = 123;",
11982             format("int a       = 5;\n"
11983                    "\n"
11984                    "int oneTwoThree= 123;",
11985                    Alignment));
11986   EXPECT_EQ("int a   = 5;\n"
11987             "int one = 1;\n"
11988             "\n"
11989             "int oneTwoThree = 123;",
11990             format("int a = 5;\n"
11991                    "int one = 1;\n"
11992                    "\n"
11993                    "int oneTwoThree = 123;",
11994                    Alignment));
11995   EXPECT_EQ("int a   = 5;\n"
11996             "int one = 1;\n"
11997             "\n"
11998             "int oneTwoThree = 123;\n"
11999             "int oneTwo      = 12;",
12000             format("int a = 5;\n"
12001                    "int one = 1;\n"
12002                    "\n"
12003                    "int oneTwoThree = 123;\n"
12004                    "int oneTwo = 12;",
12005                    Alignment));
12006   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12007   verifyFormat("#define A \\\n"
12008                "  int aaaa       = 12; \\\n"
12009                "  int b          = 23; \\\n"
12010                "  int ccc        = 234; \\\n"
12011                "  int dddddddddd = 2345;",
12012                Alignment);
12013   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12014   verifyFormat("#define A               \\\n"
12015                "  int aaaa       = 12;  \\\n"
12016                "  int b          = 23;  \\\n"
12017                "  int ccc        = 234; \\\n"
12018                "  int dddddddddd = 2345;",
12019                Alignment);
12020   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12021   verifyFormat("#define A                                                      "
12022                "                \\\n"
12023                "  int aaaa       = 12;                                         "
12024                "                \\\n"
12025                "  int b          = 23;                                         "
12026                "                \\\n"
12027                "  int ccc        = 234;                                        "
12028                "                \\\n"
12029                "  int dddddddddd = 2345;",
12030                Alignment);
12031   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12032                "k = 4, int l = 5,\n"
12033                "                  int m = 6) {\n"
12034                "  int j      = 10;\n"
12035                "  otherThing = 1;\n"
12036                "}",
12037                Alignment);
12038   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12039                "  int i   = 1;\n"
12040                "  int j   = 2;\n"
12041                "  int big = 10000;\n"
12042                "}",
12043                Alignment);
12044   verifyFormat("class C {\n"
12045                "public:\n"
12046                "  int i            = 1;\n"
12047                "  virtual void f() = 0;\n"
12048                "};",
12049                Alignment);
12050   verifyFormat("int i = 1;\n"
12051                "if (SomeType t = getSomething()) {\n"
12052                "}\n"
12053                "int j   = 2;\n"
12054                "int big = 10000;",
12055                Alignment);
12056   verifyFormat("int j = 7;\n"
12057                "for (int k = 0; k < N; ++k) {\n"
12058                "}\n"
12059                "int j   = 2;\n"
12060                "int big = 10000;\n"
12061                "}",
12062                Alignment);
12063   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12064   verifyFormat("int i = 1;\n"
12065                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12066                "    = someLooooooooooooooooongFunction();\n"
12067                "int j = 2;",
12068                Alignment);
12069   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12070   verifyFormat("int i = 1;\n"
12071                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12072                "    someLooooooooooooooooongFunction();\n"
12073                "int j = 2;",
12074                Alignment);
12075 
12076   verifyFormat("auto lambda = []() {\n"
12077                "  auto i = 0;\n"
12078                "  return 0;\n"
12079                "};\n"
12080                "int i  = 0;\n"
12081                "auto v = type{\n"
12082                "    i = 1,   //\n"
12083                "    (i = 2), //\n"
12084                "    i = 3    //\n"
12085                "};",
12086                Alignment);
12087 
12088   verifyFormat(
12089       "int i      = 1;\n"
12090       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12091       "                          loooooooooooooooooooooongParameterB);\n"
12092       "int j      = 2;",
12093       Alignment);
12094 
12095   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12096                "          typename B   = very_long_type_name_1,\n"
12097                "          typename T_2 = very_long_type_name_2>\n"
12098                "auto foo() {}\n",
12099                Alignment);
12100   verifyFormat("int a, b = 1;\n"
12101                "int c  = 2;\n"
12102                "int dd = 3;\n",
12103                Alignment);
12104   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12105                "float b[1][] = {{3.f}};\n",
12106                Alignment);
12107   verifyFormat("for (int i = 0; i < 1; i++)\n"
12108                "  int x = 1;\n",
12109                Alignment);
12110   verifyFormat("for (i = 0; i < 1; i++)\n"
12111                "  x = 1;\n"
12112                "y = 1;\n",
12113                Alignment);
12114 
12115   Alignment.ReflowComments = true;
12116   Alignment.ColumnLimit = 50;
12117   EXPECT_EQ("int x   = 0;\n"
12118             "int yy  = 1; /// specificlennospace\n"
12119             "int zzz = 2;\n",
12120             format("int x   = 0;\n"
12121                    "int yy  = 1; ///specificlennospace\n"
12122                    "int zzz = 2;\n",
12123                    Alignment));
12124 }
12125 
12126 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12127   FormatStyle Alignment = getLLVMStyle();
12128   Alignment.AlignConsecutiveBitFields = true;
12129   verifyFormat("int const a     : 5;\n"
12130                "int oneTwoThree : 23;",
12131                Alignment);
12132 
12133   // Initializers are allowed starting with c++2a
12134   verifyFormat("int const a     : 5 = 1;\n"
12135                "int oneTwoThree : 23 = 0;",
12136                Alignment);
12137 
12138   Alignment.AlignConsecutiveDeclarations = true;
12139   verifyFormat("int const a           : 5;\n"
12140                "int       oneTwoThree : 23;",
12141                Alignment);
12142 
12143   verifyFormat("int const a           : 5;  // comment\n"
12144                "int       oneTwoThree : 23; // comment",
12145                Alignment);
12146 
12147   verifyFormat("int const a           : 5 = 1;\n"
12148                "int       oneTwoThree : 23 = 0;",
12149                Alignment);
12150 
12151   Alignment.AlignConsecutiveAssignments = true;
12152   verifyFormat("int const a           : 5  = 1;\n"
12153                "int       oneTwoThree : 23 = 0;",
12154                Alignment);
12155   verifyFormat("int const a           : 5  = {1};\n"
12156                "int       oneTwoThree : 23 = 0;",
12157                Alignment);
12158 
12159   // Known limitations: ':' is only recognized as a bitfield colon when
12160   // followed by a number.
12161   /*
12162   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12163                "int a           : 5;",
12164                Alignment);
12165   */
12166 }
12167 
12168 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12169   FormatStyle Alignment = getLLVMStyle();
12170   Alignment.AlignConsecutiveMacros = true;
12171   Alignment.AlignConsecutiveDeclarations = false;
12172   verifyFormat("float const a = 5;\n"
12173                "int oneTwoThree = 123;",
12174                Alignment);
12175   verifyFormat("int a = 5;\n"
12176                "float const oneTwoThree = 123;",
12177                Alignment);
12178 
12179   Alignment.AlignConsecutiveDeclarations = true;
12180   verifyFormat("float const a = 5;\n"
12181                "int         oneTwoThree = 123;",
12182                Alignment);
12183   verifyFormat("int         a = method();\n"
12184                "float const oneTwoThree = 133;",
12185                Alignment);
12186   verifyFormat("int i = 1, j = 10;\n"
12187                "something = 2000;",
12188                Alignment);
12189   verifyFormat("something = 2000;\n"
12190                "int i = 1, j = 10;\n",
12191                Alignment);
12192   verifyFormat("float      something = 2000;\n"
12193                "double     another = 911;\n"
12194                "int        i = 1, j = 10;\n"
12195                "const int *oneMore = 1;\n"
12196                "unsigned   i = 2;",
12197                Alignment);
12198   verifyFormat("float a = 5;\n"
12199                "int   one = 1;\n"
12200                "method();\n"
12201                "const double       oneTwoThree = 123;\n"
12202                "const unsigned int oneTwo = 12;",
12203                Alignment);
12204   verifyFormat("int      oneTwoThree{0}; // comment\n"
12205                "unsigned oneTwo;         // comment",
12206                Alignment);
12207   EXPECT_EQ("float const a = 5;\n"
12208             "\n"
12209             "int oneTwoThree = 123;",
12210             format("float const   a = 5;\n"
12211                    "\n"
12212                    "int           oneTwoThree= 123;",
12213                    Alignment));
12214   EXPECT_EQ("float a = 5;\n"
12215             "int   one = 1;\n"
12216             "\n"
12217             "unsigned oneTwoThree = 123;",
12218             format("float    a = 5;\n"
12219                    "int      one = 1;\n"
12220                    "\n"
12221                    "unsigned oneTwoThree = 123;",
12222                    Alignment));
12223   EXPECT_EQ("float a = 5;\n"
12224             "int   one = 1;\n"
12225             "\n"
12226             "unsigned oneTwoThree = 123;\n"
12227             "int      oneTwo = 12;",
12228             format("float    a = 5;\n"
12229                    "int one = 1;\n"
12230                    "\n"
12231                    "unsigned oneTwoThree = 123;\n"
12232                    "int oneTwo = 12;",
12233                    Alignment));
12234   // Function prototype alignment
12235   verifyFormat("int    a();\n"
12236                "double b();",
12237                Alignment);
12238   verifyFormat("int    a(int x);\n"
12239                "double b();",
12240                Alignment);
12241   unsigned OldColumnLimit = Alignment.ColumnLimit;
12242   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12243   // otherwise the function parameters will be re-flowed onto a single line.
12244   Alignment.ColumnLimit = 0;
12245   EXPECT_EQ("int    a(int   x,\n"
12246             "         float y);\n"
12247             "double b(int    x,\n"
12248             "         double y);",
12249             format("int a(int x,\n"
12250                    " float y);\n"
12251                    "double b(int x,\n"
12252                    " double y);",
12253                    Alignment));
12254   // This ensures that function parameters of function declarations are
12255   // correctly indented when their owning functions are indented.
12256   // The failure case here is for 'double y' to not be indented enough.
12257   EXPECT_EQ("double a(int x);\n"
12258             "int    b(int    y,\n"
12259             "         double z);",
12260             format("double a(int x);\n"
12261                    "int b(int y,\n"
12262                    " double z);",
12263                    Alignment));
12264   // Set ColumnLimit low so that we induce wrapping immediately after
12265   // the function name and opening paren.
12266   Alignment.ColumnLimit = 13;
12267   verifyFormat("int function(\n"
12268                "    int  x,\n"
12269                "    bool y);",
12270                Alignment);
12271   Alignment.ColumnLimit = OldColumnLimit;
12272   // Ensure function pointers don't screw up recursive alignment
12273   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12274                "double b();",
12275                Alignment);
12276   Alignment.AlignConsecutiveAssignments = true;
12277   // Ensure recursive alignment is broken by function braces, so that the
12278   // "a = 1" does not align with subsequent assignments inside the function
12279   // body.
12280   verifyFormat("int func(int a = 1) {\n"
12281                "  int b  = 2;\n"
12282                "  int cc = 3;\n"
12283                "}",
12284                Alignment);
12285   verifyFormat("float      something = 2000;\n"
12286                "double     another   = 911;\n"
12287                "int        i = 1, j = 10;\n"
12288                "const int *oneMore = 1;\n"
12289                "unsigned   i       = 2;",
12290                Alignment);
12291   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12292                "unsigned oneTwo      = 0;   // comment",
12293                Alignment);
12294   // Make sure that scope is correctly tracked, in the absence of braces
12295   verifyFormat("for (int i = 0; i < n; i++)\n"
12296                "  j = i;\n"
12297                "double x = 1;\n",
12298                Alignment);
12299   verifyFormat("if (int i = 0)\n"
12300                "  j = i;\n"
12301                "double x = 1;\n",
12302                Alignment);
12303   // Ensure operator[] and operator() are comprehended
12304   verifyFormat("struct test {\n"
12305                "  long long int foo();\n"
12306                "  int           operator[](int a);\n"
12307                "  double        bar();\n"
12308                "};\n",
12309                Alignment);
12310   verifyFormat("struct test {\n"
12311                "  long long int foo();\n"
12312                "  int           operator()(int a);\n"
12313                "  double        bar();\n"
12314                "};\n",
12315                Alignment);
12316   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12317             "  int const i   = 1;\n"
12318             "  int *     j   = 2;\n"
12319             "  int       big = 10000;\n"
12320             "\n"
12321             "  unsigned oneTwoThree = 123;\n"
12322             "  int      oneTwo      = 12;\n"
12323             "  method();\n"
12324             "  float k  = 2;\n"
12325             "  int   ll = 10000;\n"
12326             "}",
12327             format("void SomeFunction(int parameter= 0) {\n"
12328                    " int const  i= 1;\n"
12329                    "  int *j=2;\n"
12330                    " int big  =  10000;\n"
12331                    "\n"
12332                    "unsigned oneTwoThree  =123;\n"
12333                    "int oneTwo = 12;\n"
12334                    "  method();\n"
12335                    "float k= 2;\n"
12336                    "int ll=10000;\n"
12337                    "}",
12338                    Alignment));
12339   Alignment.AlignConsecutiveAssignments = false;
12340   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12341   verifyFormat("#define A \\\n"
12342                "  int       aaaa = 12; \\\n"
12343                "  float     b = 23; \\\n"
12344                "  const int ccc = 234; \\\n"
12345                "  unsigned  dddddddddd = 2345;",
12346                Alignment);
12347   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12348   verifyFormat("#define A              \\\n"
12349                "  int       aaaa = 12; \\\n"
12350                "  float     b = 23;    \\\n"
12351                "  const int ccc = 234; \\\n"
12352                "  unsigned  dddddddddd = 2345;",
12353                Alignment);
12354   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12355   Alignment.ColumnLimit = 30;
12356   verifyFormat("#define A                    \\\n"
12357                "  int       aaaa = 12;       \\\n"
12358                "  float     b = 23;          \\\n"
12359                "  const int ccc = 234;       \\\n"
12360                "  int       dddddddddd = 2345;",
12361                Alignment);
12362   Alignment.ColumnLimit = 80;
12363   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12364                "k = 4, int l = 5,\n"
12365                "                  int m = 6) {\n"
12366                "  const int j = 10;\n"
12367                "  otherThing = 1;\n"
12368                "}",
12369                Alignment);
12370   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12371                "  int const i = 1;\n"
12372                "  int *     j = 2;\n"
12373                "  int       big = 10000;\n"
12374                "}",
12375                Alignment);
12376   verifyFormat("class C {\n"
12377                "public:\n"
12378                "  int          i = 1;\n"
12379                "  virtual void f() = 0;\n"
12380                "};",
12381                Alignment);
12382   verifyFormat("float i = 1;\n"
12383                "if (SomeType t = getSomething()) {\n"
12384                "}\n"
12385                "const unsigned j = 2;\n"
12386                "int            big = 10000;",
12387                Alignment);
12388   verifyFormat("float j = 7;\n"
12389                "for (int k = 0; k < N; ++k) {\n"
12390                "}\n"
12391                "unsigned j = 2;\n"
12392                "int      big = 10000;\n"
12393                "}",
12394                Alignment);
12395   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12396   verifyFormat("float              i = 1;\n"
12397                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12398                "    = someLooooooooooooooooongFunction();\n"
12399                "int j = 2;",
12400                Alignment);
12401   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12402   verifyFormat("int                i = 1;\n"
12403                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12404                "    someLooooooooooooooooongFunction();\n"
12405                "int j = 2;",
12406                Alignment);
12407 
12408   Alignment.AlignConsecutiveAssignments = true;
12409   verifyFormat("auto lambda = []() {\n"
12410                "  auto  ii = 0;\n"
12411                "  float j  = 0;\n"
12412                "  return 0;\n"
12413                "};\n"
12414                "int   i  = 0;\n"
12415                "float i2 = 0;\n"
12416                "auto  v  = type{\n"
12417                "    i = 1,   //\n"
12418                "    (i = 2), //\n"
12419                "    i = 3    //\n"
12420                "};",
12421                Alignment);
12422   Alignment.AlignConsecutiveAssignments = false;
12423 
12424   verifyFormat(
12425       "int      i = 1;\n"
12426       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12427       "                          loooooooooooooooooooooongParameterB);\n"
12428       "int      j = 2;",
12429       Alignment);
12430 
12431   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12432   // We expect declarations and assignments to align, as long as it doesn't
12433   // exceed the column limit, starting a new alignment sequence whenever it
12434   // happens.
12435   Alignment.AlignConsecutiveAssignments = true;
12436   Alignment.ColumnLimit = 30;
12437   verifyFormat("float    ii              = 1;\n"
12438                "unsigned j               = 2;\n"
12439                "int someVerylongVariable = 1;\n"
12440                "AnotherLongType  ll = 123456;\n"
12441                "VeryVeryLongType k  = 2;\n"
12442                "int              myvar = 1;",
12443                Alignment);
12444   Alignment.ColumnLimit = 80;
12445   Alignment.AlignConsecutiveAssignments = false;
12446 
12447   verifyFormat(
12448       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12449       "          typename LongType, typename B>\n"
12450       "auto foo() {}\n",
12451       Alignment);
12452   verifyFormat("float a, b = 1;\n"
12453                "int   c = 2;\n"
12454                "int   dd = 3;\n",
12455                Alignment);
12456   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12457                "float b[1][] = {{3.f}};\n",
12458                Alignment);
12459   Alignment.AlignConsecutiveAssignments = true;
12460   verifyFormat("float a, b = 1;\n"
12461                "int   c  = 2;\n"
12462                "int   dd = 3;\n",
12463                Alignment);
12464   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12465                "float b[1][] = {{3.f}};\n",
12466                Alignment);
12467   Alignment.AlignConsecutiveAssignments = false;
12468 
12469   Alignment.ColumnLimit = 30;
12470   Alignment.BinPackParameters = false;
12471   verifyFormat("void foo(float     a,\n"
12472                "         float     b,\n"
12473                "         int       c,\n"
12474                "         uint32_t *d) {\n"
12475                "  int *  e = 0;\n"
12476                "  float  f = 0;\n"
12477                "  double g = 0;\n"
12478                "}\n"
12479                "void bar(ino_t     a,\n"
12480                "         int       b,\n"
12481                "         uint32_t *c,\n"
12482                "         bool      d) {}\n",
12483                Alignment);
12484   Alignment.BinPackParameters = true;
12485   Alignment.ColumnLimit = 80;
12486 
12487   // Bug 33507
12488   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12489   verifyFormat(
12490       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12491       "  static const Version verVs2017;\n"
12492       "  return true;\n"
12493       "});\n",
12494       Alignment);
12495   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12496 
12497   // See llvm.org/PR35641
12498   Alignment.AlignConsecutiveDeclarations = true;
12499   verifyFormat("int func() { //\n"
12500                "  int      b;\n"
12501                "  unsigned c;\n"
12502                "}",
12503                Alignment);
12504 
12505   // See PR37175
12506   FormatStyle Style = getMozillaStyle();
12507   Style.AlignConsecutiveDeclarations = true;
12508   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12509             "foo(int a);",
12510             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12511 }
12512 
12513 TEST_F(FormatTest, LinuxBraceBreaking) {
12514   FormatStyle LinuxBraceStyle = getLLVMStyle();
12515   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12516   verifyFormat("namespace a\n"
12517                "{\n"
12518                "class A\n"
12519                "{\n"
12520                "  void f()\n"
12521                "  {\n"
12522                "    if (true) {\n"
12523                "      a();\n"
12524                "      b();\n"
12525                "    } else {\n"
12526                "      a();\n"
12527                "    }\n"
12528                "  }\n"
12529                "  void g() { return; }\n"
12530                "};\n"
12531                "struct B {\n"
12532                "  int x;\n"
12533                "};\n"
12534                "} // namespace a\n",
12535                LinuxBraceStyle);
12536   verifyFormat("enum X {\n"
12537                "  Y = 0,\n"
12538                "}\n",
12539                LinuxBraceStyle);
12540   verifyFormat("struct S {\n"
12541                "  int Type;\n"
12542                "  union {\n"
12543                "    int x;\n"
12544                "    double y;\n"
12545                "  } Value;\n"
12546                "  class C\n"
12547                "  {\n"
12548                "    MyFavoriteType Value;\n"
12549                "  } Class;\n"
12550                "}\n",
12551                LinuxBraceStyle);
12552 }
12553 
12554 TEST_F(FormatTest, MozillaBraceBreaking) {
12555   FormatStyle MozillaBraceStyle = getLLVMStyle();
12556   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
12557   MozillaBraceStyle.FixNamespaceComments = false;
12558   verifyFormat("namespace a {\n"
12559                "class A\n"
12560                "{\n"
12561                "  void f()\n"
12562                "  {\n"
12563                "    if (true) {\n"
12564                "      a();\n"
12565                "      b();\n"
12566                "    }\n"
12567                "  }\n"
12568                "  void g() { return; }\n"
12569                "};\n"
12570                "enum E\n"
12571                "{\n"
12572                "  A,\n"
12573                "  // foo\n"
12574                "  B,\n"
12575                "  C\n"
12576                "};\n"
12577                "struct B\n"
12578                "{\n"
12579                "  int x;\n"
12580                "};\n"
12581                "}\n",
12582                MozillaBraceStyle);
12583   verifyFormat("struct S\n"
12584                "{\n"
12585                "  int Type;\n"
12586                "  union\n"
12587                "  {\n"
12588                "    int x;\n"
12589                "    double y;\n"
12590                "  } Value;\n"
12591                "  class C\n"
12592                "  {\n"
12593                "    MyFavoriteType Value;\n"
12594                "  } Class;\n"
12595                "}\n",
12596                MozillaBraceStyle);
12597 }
12598 
12599 TEST_F(FormatTest, StroustrupBraceBreaking) {
12600   FormatStyle StroustrupBraceStyle = getLLVMStyle();
12601   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12602   verifyFormat("namespace a {\n"
12603                "class A {\n"
12604                "  void f()\n"
12605                "  {\n"
12606                "    if (true) {\n"
12607                "      a();\n"
12608                "      b();\n"
12609                "    }\n"
12610                "  }\n"
12611                "  void g() { return; }\n"
12612                "};\n"
12613                "struct B {\n"
12614                "  int x;\n"
12615                "};\n"
12616                "} // namespace a\n",
12617                StroustrupBraceStyle);
12618 
12619   verifyFormat("void foo()\n"
12620                "{\n"
12621                "  if (a) {\n"
12622                "    a();\n"
12623                "  }\n"
12624                "  else {\n"
12625                "    b();\n"
12626                "  }\n"
12627                "}\n",
12628                StroustrupBraceStyle);
12629 
12630   verifyFormat("#ifdef _DEBUG\n"
12631                "int foo(int i = 0)\n"
12632                "#else\n"
12633                "int foo(int i = 5)\n"
12634                "#endif\n"
12635                "{\n"
12636                "  return i;\n"
12637                "}",
12638                StroustrupBraceStyle);
12639 
12640   verifyFormat("void foo() {}\n"
12641                "void bar()\n"
12642                "#ifdef _DEBUG\n"
12643                "{\n"
12644                "  foo();\n"
12645                "}\n"
12646                "#else\n"
12647                "{\n"
12648                "}\n"
12649                "#endif",
12650                StroustrupBraceStyle);
12651 
12652   verifyFormat("void foobar() { int i = 5; }\n"
12653                "#ifdef _DEBUG\n"
12654                "void bar() {}\n"
12655                "#else\n"
12656                "void bar() { foobar(); }\n"
12657                "#endif",
12658                StroustrupBraceStyle);
12659 }
12660 
12661 TEST_F(FormatTest, AllmanBraceBreaking) {
12662   FormatStyle AllmanBraceStyle = getLLVMStyle();
12663   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
12664 
12665   EXPECT_EQ("namespace a\n"
12666             "{\n"
12667             "void f();\n"
12668             "void g();\n"
12669             "} // namespace a\n",
12670             format("namespace a\n"
12671                    "{\n"
12672                    "void f();\n"
12673                    "void g();\n"
12674                    "}\n",
12675                    AllmanBraceStyle));
12676 
12677   verifyFormat("namespace a\n"
12678                "{\n"
12679                "class A\n"
12680                "{\n"
12681                "  void f()\n"
12682                "  {\n"
12683                "    if (true)\n"
12684                "    {\n"
12685                "      a();\n"
12686                "      b();\n"
12687                "    }\n"
12688                "  }\n"
12689                "  void g() { return; }\n"
12690                "};\n"
12691                "struct B\n"
12692                "{\n"
12693                "  int x;\n"
12694                "};\n"
12695                "union C\n"
12696                "{\n"
12697                "};\n"
12698                "} // namespace a",
12699                AllmanBraceStyle);
12700 
12701   verifyFormat("void f()\n"
12702                "{\n"
12703                "  if (true)\n"
12704                "  {\n"
12705                "    a();\n"
12706                "  }\n"
12707                "  else if (false)\n"
12708                "  {\n"
12709                "    b();\n"
12710                "  }\n"
12711                "  else\n"
12712                "  {\n"
12713                "    c();\n"
12714                "  }\n"
12715                "}\n",
12716                AllmanBraceStyle);
12717 
12718   verifyFormat("void f()\n"
12719                "{\n"
12720                "  for (int i = 0; i < 10; ++i)\n"
12721                "  {\n"
12722                "    a();\n"
12723                "  }\n"
12724                "  while (false)\n"
12725                "  {\n"
12726                "    b();\n"
12727                "  }\n"
12728                "  do\n"
12729                "  {\n"
12730                "    c();\n"
12731                "  } while (false)\n"
12732                "}\n",
12733                AllmanBraceStyle);
12734 
12735   verifyFormat("void f(int a)\n"
12736                "{\n"
12737                "  switch (a)\n"
12738                "  {\n"
12739                "  case 0:\n"
12740                "    break;\n"
12741                "  case 1:\n"
12742                "  {\n"
12743                "    break;\n"
12744                "  }\n"
12745                "  case 2:\n"
12746                "  {\n"
12747                "  }\n"
12748                "  break;\n"
12749                "  default:\n"
12750                "    break;\n"
12751                "  }\n"
12752                "}\n",
12753                AllmanBraceStyle);
12754 
12755   verifyFormat("enum X\n"
12756                "{\n"
12757                "  Y = 0,\n"
12758                "}\n",
12759                AllmanBraceStyle);
12760   verifyFormat("enum X\n"
12761                "{\n"
12762                "  Y = 0\n"
12763                "}\n",
12764                AllmanBraceStyle);
12765 
12766   verifyFormat("@interface BSApplicationController ()\n"
12767                "{\n"
12768                "@private\n"
12769                "  id _extraIvar;\n"
12770                "}\n"
12771                "@end\n",
12772                AllmanBraceStyle);
12773 
12774   verifyFormat("#ifdef _DEBUG\n"
12775                "int foo(int i = 0)\n"
12776                "#else\n"
12777                "int foo(int i = 5)\n"
12778                "#endif\n"
12779                "{\n"
12780                "  return i;\n"
12781                "}",
12782                AllmanBraceStyle);
12783 
12784   verifyFormat("void foo() {}\n"
12785                "void bar()\n"
12786                "#ifdef _DEBUG\n"
12787                "{\n"
12788                "  foo();\n"
12789                "}\n"
12790                "#else\n"
12791                "{\n"
12792                "}\n"
12793                "#endif",
12794                AllmanBraceStyle);
12795 
12796   verifyFormat("void foobar() { int i = 5; }\n"
12797                "#ifdef _DEBUG\n"
12798                "void bar() {}\n"
12799                "#else\n"
12800                "void bar() { foobar(); }\n"
12801                "#endif",
12802                AllmanBraceStyle);
12803 
12804   // This shouldn't affect ObjC blocks..
12805   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
12806                "  // ...\n"
12807                "  int i;\n"
12808                "}];",
12809                AllmanBraceStyle);
12810   verifyFormat("void (^block)(void) = ^{\n"
12811                "  // ...\n"
12812                "  int i;\n"
12813                "};",
12814                AllmanBraceStyle);
12815   // .. or dict literals.
12816   verifyFormat("void f()\n"
12817                "{\n"
12818                "  // ...\n"
12819                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
12820                "}",
12821                AllmanBraceStyle);
12822   verifyFormat("void f()\n"
12823                "{\n"
12824                "  // ...\n"
12825                "  [object someMethod:@{a : @\"b\"}];\n"
12826                "}",
12827                AllmanBraceStyle);
12828   verifyFormat("int f()\n"
12829                "{ // comment\n"
12830                "  return 42;\n"
12831                "}",
12832                AllmanBraceStyle);
12833 
12834   AllmanBraceStyle.ColumnLimit = 19;
12835   verifyFormat("void f() { int i; }", AllmanBraceStyle);
12836   AllmanBraceStyle.ColumnLimit = 18;
12837   verifyFormat("void f()\n"
12838                "{\n"
12839                "  int i;\n"
12840                "}",
12841                AllmanBraceStyle);
12842   AllmanBraceStyle.ColumnLimit = 80;
12843 
12844   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
12845   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
12846       FormatStyle::SIS_WithoutElse;
12847   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
12848   verifyFormat("void f(bool b)\n"
12849                "{\n"
12850                "  if (b)\n"
12851                "  {\n"
12852                "    return;\n"
12853                "  }\n"
12854                "}\n",
12855                BreakBeforeBraceShortIfs);
12856   verifyFormat("void f(bool b)\n"
12857                "{\n"
12858                "  if constexpr (b)\n"
12859                "  {\n"
12860                "    return;\n"
12861                "  }\n"
12862                "}\n",
12863                BreakBeforeBraceShortIfs);
12864   verifyFormat("void f(bool b)\n"
12865                "{\n"
12866                "  if CONSTEXPR (b)\n"
12867                "  {\n"
12868                "    return;\n"
12869                "  }\n"
12870                "}\n",
12871                BreakBeforeBraceShortIfs);
12872   verifyFormat("void f(bool b)\n"
12873                "{\n"
12874                "  if (b) return;\n"
12875                "}\n",
12876                BreakBeforeBraceShortIfs);
12877   verifyFormat("void f(bool b)\n"
12878                "{\n"
12879                "  if constexpr (b) return;\n"
12880                "}\n",
12881                BreakBeforeBraceShortIfs);
12882   verifyFormat("void f(bool b)\n"
12883                "{\n"
12884                "  if CONSTEXPR (b) return;\n"
12885                "}\n",
12886                BreakBeforeBraceShortIfs);
12887   verifyFormat("void f(bool b)\n"
12888                "{\n"
12889                "  while (b)\n"
12890                "  {\n"
12891                "    return;\n"
12892                "  }\n"
12893                "}\n",
12894                BreakBeforeBraceShortIfs);
12895 }
12896 
12897 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
12898   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
12899   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
12900 
12901   // Make a few changes to the style for testing purposes
12902   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
12903       FormatStyle::SFS_Empty;
12904   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
12905   WhitesmithsBraceStyle.ColumnLimit = 0;
12906 
12907   // FIXME: this test case can't decide whether there should be a blank line
12908   // after the ~D() line or not. It adds one if one doesn't exist in the test
12909   // and it removes the line if one exists.
12910   /*
12911   verifyFormat("class A;\n"
12912                "namespace B\n"
12913                "  {\n"
12914                "class C;\n"
12915                "// Comment\n"
12916                "class D\n"
12917                "  {\n"
12918                "public:\n"
12919                "  D();\n"
12920                "  ~D() {}\n"
12921                "private:\n"
12922                "  enum E\n"
12923                "    {\n"
12924                "    F\n"
12925                "    }\n"
12926                "  };\n"
12927                "  } // namespace B\n",
12928                WhitesmithsBraceStyle);
12929   */
12930 
12931   verifyFormat("namespace a\n"
12932                "  {\n"
12933                "class A\n"
12934                "  {\n"
12935                "  void f()\n"
12936                "    {\n"
12937                "    if (true)\n"
12938                "      {\n"
12939                "      a();\n"
12940                "      b();\n"
12941                "      }\n"
12942                "    }\n"
12943                "  void g()\n"
12944                "    {\n"
12945                "    return;\n"
12946                "    }\n"
12947                "  };\n"
12948                "struct B\n"
12949                "  {\n"
12950                "  int x;\n"
12951                "  };\n"
12952                "  } // namespace a",
12953                WhitesmithsBraceStyle);
12954 
12955   verifyFormat("void f()\n"
12956                "  {\n"
12957                "  if (true)\n"
12958                "    {\n"
12959                "    a();\n"
12960                "    }\n"
12961                "  else if (false)\n"
12962                "    {\n"
12963                "    b();\n"
12964                "    }\n"
12965                "  else\n"
12966                "    {\n"
12967                "    c();\n"
12968                "    }\n"
12969                "  }\n",
12970                WhitesmithsBraceStyle);
12971 
12972   verifyFormat("void f()\n"
12973                "  {\n"
12974                "  for (int i = 0; i < 10; ++i)\n"
12975                "    {\n"
12976                "    a();\n"
12977                "    }\n"
12978                "  while (false)\n"
12979                "    {\n"
12980                "    b();\n"
12981                "    }\n"
12982                "  do\n"
12983                "    {\n"
12984                "    c();\n"
12985                "    } while (false)\n"
12986                "  }\n",
12987                WhitesmithsBraceStyle);
12988 
12989   WhitesmithsBraceStyle.IndentCaseBlocks = true;
12990   verifyFormat("void switchTest1(int a)\n"
12991                "  {\n"
12992                "  switch (a)\n"
12993                "    {\n"
12994                "    case 2:\n"
12995                "      {\n"
12996                "      }\n"
12997                "    break;\n"
12998                "    }\n"
12999                "  }\n",
13000                WhitesmithsBraceStyle);
13001 
13002   verifyFormat("void switchTest2(int a)\n"
13003                "  {\n"
13004                "  switch (a)\n"
13005                "    {\n"
13006                "    case 0:\n"
13007                "    break;\n"
13008                "    case 1:\n"
13009                "      {\n"
13010                "      break;\n"
13011                "      }\n"
13012                "    case 2:\n"
13013                "      {\n"
13014                "      }\n"
13015                "    break;\n"
13016                "    default:\n"
13017                "    break;\n"
13018                "    }\n"
13019                "  }\n",
13020                WhitesmithsBraceStyle);
13021 
13022   verifyFormat("void switchTest3(int a)\n"
13023                "  {\n"
13024                "  switch (a)\n"
13025                "    {\n"
13026                "    case 0:\n"
13027                "      {\n"
13028                "      foo(x);\n"
13029                "      }\n"
13030                "    break;\n"
13031                "    default:\n"
13032                "      {\n"
13033                "      foo(1);\n"
13034                "      }\n"
13035                "    break;\n"
13036                "    }\n"
13037                "  }\n",
13038                WhitesmithsBraceStyle);
13039 
13040   WhitesmithsBraceStyle.IndentCaseBlocks = false;
13041 
13042   verifyFormat("void switchTest4(int a)\n"
13043                "  {\n"
13044                "  switch (a)\n"
13045                "    {\n"
13046                "    case 2:\n"
13047                "    {\n"
13048                "    }\n"
13049                "    break;\n"
13050                "    }\n"
13051                "  }\n",
13052                WhitesmithsBraceStyle);
13053 
13054   verifyFormat("void switchTest5(int a)\n"
13055                "  {\n"
13056                "  switch (a)\n"
13057                "    {\n"
13058                "    case 0:\n"
13059                "    break;\n"
13060                "    case 1:\n"
13061                "    {\n"
13062                "    foo();\n"
13063                "    break;\n"
13064                "    }\n"
13065                "    case 2:\n"
13066                "    {\n"
13067                "    }\n"
13068                "    break;\n"
13069                "    default:\n"
13070                "    break;\n"
13071                "    }\n"
13072                "  }\n",
13073                WhitesmithsBraceStyle);
13074 
13075   verifyFormat("void switchTest6(int a)\n"
13076                "  {\n"
13077                "  switch (a)\n"
13078                "    {\n"
13079                "    case 0:\n"
13080                "    {\n"
13081                "    foo(x);\n"
13082                "    }\n"
13083                "    break;\n"
13084                "    default:\n"
13085                "    {\n"
13086                "    foo(1);\n"
13087                "    }\n"
13088                "    break;\n"
13089                "    }\n"
13090                "  }\n",
13091                WhitesmithsBraceStyle);
13092 
13093   verifyFormat("enum X\n"
13094                "  {\n"
13095                "  Y = 0, // testing\n"
13096                "  }\n",
13097                WhitesmithsBraceStyle);
13098 
13099   verifyFormat("enum X\n"
13100                "  {\n"
13101                "  Y = 0\n"
13102                "  }\n",
13103                WhitesmithsBraceStyle);
13104   verifyFormat("enum X\n"
13105                "  {\n"
13106                "  Y = 0,\n"
13107                "  Z = 1\n"
13108                "  };\n",
13109                WhitesmithsBraceStyle);
13110 
13111   verifyFormat("@interface BSApplicationController ()\n"
13112                "  {\n"
13113                "@private\n"
13114                "  id _extraIvar;\n"
13115                "  }\n"
13116                "@end\n",
13117                WhitesmithsBraceStyle);
13118 
13119   verifyFormat("#ifdef _DEBUG\n"
13120                "int foo(int i = 0)\n"
13121                "#else\n"
13122                "int foo(int i = 5)\n"
13123                "#endif\n"
13124                "  {\n"
13125                "  return i;\n"
13126                "  }",
13127                WhitesmithsBraceStyle);
13128 
13129   verifyFormat("void foo() {}\n"
13130                "void bar()\n"
13131                "#ifdef _DEBUG\n"
13132                "  {\n"
13133                "  foo();\n"
13134                "  }\n"
13135                "#else\n"
13136                "  {\n"
13137                "  }\n"
13138                "#endif",
13139                WhitesmithsBraceStyle);
13140 
13141   verifyFormat("void foobar()\n"
13142                "  {\n"
13143                "  int i = 5;\n"
13144                "  }\n"
13145                "#ifdef _DEBUG\n"
13146                "void bar()\n"
13147                "  {\n"
13148                "  }\n"
13149                "#else\n"
13150                "void bar()\n"
13151                "  {\n"
13152                "  foobar();\n"
13153                "  }\n"
13154                "#endif",
13155                WhitesmithsBraceStyle);
13156 
13157   // This shouldn't affect ObjC blocks..
13158   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13159                "  // ...\n"
13160                "  int i;\n"
13161                "}];",
13162                WhitesmithsBraceStyle);
13163   verifyFormat("void (^block)(void) = ^{\n"
13164                "  // ...\n"
13165                "  int i;\n"
13166                "};",
13167                WhitesmithsBraceStyle);
13168   // .. or dict literals.
13169   verifyFormat("void f()\n"
13170                "  {\n"
13171                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13172                "  }",
13173                WhitesmithsBraceStyle);
13174 
13175   verifyFormat("int f()\n"
13176                "  { // comment\n"
13177                "  return 42;\n"
13178                "  }",
13179                WhitesmithsBraceStyle);
13180 
13181   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13182   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13183       FormatStyle::SIS_Always;
13184   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13185   verifyFormat("void f(bool b)\n"
13186                "  {\n"
13187                "  if (b)\n"
13188                "    {\n"
13189                "    return;\n"
13190                "    }\n"
13191                "  }\n",
13192                BreakBeforeBraceShortIfs);
13193   verifyFormat("void f(bool b)\n"
13194                "  {\n"
13195                "  if (b) return;\n"
13196                "  }\n",
13197                BreakBeforeBraceShortIfs);
13198   verifyFormat("void f(bool b)\n"
13199                "  {\n"
13200                "  while (b)\n"
13201                "    {\n"
13202                "    return;\n"
13203                "    }\n"
13204                "  }\n",
13205                BreakBeforeBraceShortIfs);
13206 }
13207 
13208 TEST_F(FormatTest, GNUBraceBreaking) {
13209   FormatStyle GNUBraceStyle = getLLVMStyle();
13210   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13211   verifyFormat("namespace a\n"
13212                "{\n"
13213                "class A\n"
13214                "{\n"
13215                "  void f()\n"
13216                "  {\n"
13217                "    int a;\n"
13218                "    {\n"
13219                "      int b;\n"
13220                "    }\n"
13221                "    if (true)\n"
13222                "      {\n"
13223                "        a();\n"
13224                "        b();\n"
13225                "      }\n"
13226                "  }\n"
13227                "  void g() { return; }\n"
13228                "}\n"
13229                "} // namespace a",
13230                GNUBraceStyle);
13231 
13232   verifyFormat("void f()\n"
13233                "{\n"
13234                "  if (true)\n"
13235                "    {\n"
13236                "      a();\n"
13237                "    }\n"
13238                "  else if (false)\n"
13239                "    {\n"
13240                "      b();\n"
13241                "    }\n"
13242                "  else\n"
13243                "    {\n"
13244                "      c();\n"
13245                "    }\n"
13246                "}\n",
13247                GNUBraceStyle);
13248 
13249   verifyFormat("void f()\n"
13250                "{\n"
13251                "  for (int i = 0; i < 10; ++i)\n"
13252                "    {\n"
13253                "      a();\n"
13254                "    }\n"
13255                "  while (false)\n"
13256                "    {\n"
13257                "      b();\n"
13258                "    }\n"
13259                "  do\n"
13260                "    {\n"
13261                "      c();\n"
13262                "    }\n"
13263                "  while (false);\n"
13264                "}\n",
13265                GNUBraceStyle);
13266 
13267   verifyFormat("void f(int a)\n"
13268                "{\n"
13269                "  switch (a)\n"
13270                "    {\n"
13271                "    case 0:\n"
13272                "      break;\n"
13273                "    case 1:\n"
13274                "      {\n"
13275                "        break;\n"
13276                "      }\n"
13277                "    case 2:\n"
13278                "      {\n"
13279                "      }\n"
13280                "      break;\n"
13281                "    default:\n"
13282                "      break;\n"
13283                "    }\n"
13284                "}\n",
13285                GNUBraceStyle);
13286 
13287   verifyFormat("enum X\n"
13288                "{\n"
13289                "  Y = 0,\n"
13290                "}\n",
13291                GNUBraceStyle);
13292 
13293   verifyFormat("@interface BSApplicationController ()\n"
13294                "{\n"
13295                "@private\n"
13296                "  id _extraIvar;\n"
13297                "}\n"
13298                "@end\n",
13299                GNUBraceStyle);
13300 
13301   verifyFormat("#ifdef _DEBUG\n"
13302                "int foo(int i = 0)\n"
13303                "#else\n"
13304                "int foo(int i = 5)\n"
13305                "#endif\n"
13306                "{\n"
13307                "  return i;\n"
13308                "}",
13309                GNUBraceStyle);
13310 
13311   verifyFormat("void foo() {}\n"
13312                "void bar()\n"
13313                "#ifdef _DEBUG\n"
13314                "{\n"
13315                "  foo();\n"
13316                "}\n"
13317                "#else\n"
13318                "{\n"
13319                "}\n"
13320                "#endif",
13321                GNUBraceStyle);
13322 
13323   verifyFormat("void foobar() { int i = 5; }\n"
13324                "#ifdef _DEBUG\n"
13325                "void bar() {}\n"
13326                "#else\n"
13327                "void bar() { foobar(); }\n"
13328                "#endif",
13329                GNUBraceStyle);
13330 }
13331 
13332 TEST_F(FormatTest, WebKitBraceBreaking) {
13333   FormatStyle WebKitBraceStyle = getLLVMStyle();
13334   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13335   WebKitBraceStyle.FixNamespaceComments = false;
13336   verifyFormat("namespace a {\n"
13337                "class A {\n"
13338                "  void f()\n"
13339                "  {\n"
13340                "    if (true) {\n"
13341                "      a();\n"
13342                "      b();\n"
13343                "    }\n"
13344                "  }\n"
13345                "  void g() { return; }\n"
13346                "};\n"
13347                "enum E {\n"
13348                "  A,\n"
13349                "  // foo\n"
13350                "  B,\n"
13351                "  C\n"
13352                "};\n"
13353                "struct B {\n"
13354                "  int x;\n"
13355                "};\n"
13356                "}\n",
13357                WebKitBraceStyle);
13358   verifyFormat("struct S {\n"
13359                "  int Type;\n"
13360                "  union {\n"
13361                "    int x;\n"
13362                "    double y;\n"
13363                "  } Value;\n"
13364                "  class C {\n"
13365                "    MyFavoriteType Value;\n"
13366                "  } Class;\n"
13367                "};\n",
13368                WebKitBraceStyle);
13369 }
13370 
13371 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13372   verifyFormat("void f() {\n"
13373                "  try {\n"
13374                "  } catch (const Exception &e) {\n"
13375                "  }\n"
13376                "}\n",
13377                getLLVMStyle());
13378 }
13379 
13380 TEST_F(FormatTest, UnderstandsPragmas) {
13381   verifyFormat("#pragma omp reduction(| : var)");
13382   verifyFormat("#pragma omp reduction(+ : var)");
13383 
13384   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13385             "(including parentheses).",
13386             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13387                    "(including parentheses)."));
13388 }
13389 
13390 TEST_F(FormatTest, UnderstandPragmaOption) {
13391   verifyFormat("#pragma option -C -A");
13392 
13393   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13394 }
13395 
13396 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13397   FormatStyle Style = getLLVMStyle();
13398   Style.ColumnLimit = 20;
13399 
13400   // See PR41213
13401   EXPECT_EQ("/*\n"
13402             " *\t9012345\n"
13403             " * /8901\n"
13404             " */",
13405             format("/*\n"
13406                    " *\t9012345 /8901\n"
13407                    " */",
13408                    Style));
13409   EXPECT_EQ("/*\n"
13410             " *345678\n"
13411             " *\t/8901\n"
13412             " */",
13413             format("/*\n"
13414                    " *345678\t/8901\n"
13415                    " */",
13416                    Style));
13417 
13418   verifyFormat("int a; // the\n"
13419                "       // comment",
13420                Style);
13421   EXPECT_EQ("int a; /* first line\n"
13422             "        * second\n"
13423             "        * line third\n"
13424             "        * line\n"
13425             "        */",
13426             format("int a; /* first line\n"
13427                    "        * second\n"
13428                    "        * line third\n"
13429                    "        * line\n"
13430                    "        */",
13431                    Style));
13432   EXPECT_EQ("int a; // first line\n"
13433             "       // second\n"
13434             "       // line third\n"
13435             "       // line",
13436             format("int a; // first line\n"
13437                    "       // second line\n"
13438                    "       // third line",
13439                    Style));
13440 
13441   Style.PenaltyExcessCharacter = 90;
13442   verifyFormat("int a; // the comment", Style);
13443   EXPECT_EQ("int a; // the comment\n"
13444             "       // aaa",
13445             format("int a; // the comment aaa", Style));
13446   EXPECT_EQ("int a; /* first line\n"
13447             "        * second line\n"
13448             "        * third line\n"
13449             "        */",
13450             format("int a; /* first line\n"
13451                    "        * second line\n"
13452                    "        * third line\n"
13453                    "        */",
13454                    Style));
13455   EXPECT_EQ("int a; // first line\n"
13456             "       // second line\n"
13457             "       // third line",
13458             format("int a; // first line\n"
13459                    "       // second line\n"
13460                    "       // third line",
13461                    Style));
13462   // FIXME: Investigate why this is not getting the same layout as the test
13463   // above.
13464   EXPECT_EQ("int a; /* first line\n"
13465             "        * second line\n"
13466             "        * third line\n"
13467             "        */",
13468             format("int a; /* first line second line third line"
13469                    "\n*/",
13470                    Style));
13471 
13472   EXPECT_EQ("// foo bar baz bazfoo\n"
13473             "// foo bar foo bar\n",
13474             format("// foo bar baz bazfoo\n"
13475                    "// foo bar foo           bar\n",
13476                    Style));
13477   EXPECT_EQ("// foo bar baz bazfoo\n"
13478             "// foo bar foo bar\n",
13479             format("// foo bar baz      bazfoo\n"
13480                    "// foo            bar foo bar\n",
13481                    Style));
13482 
13483   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13484   // next one.
13485   EXPECT_EQ("// foo bar baz bazfoo\n"
13486             "// bar foo bar\n",
13487             format("// foo bar baz      bazfoo bar\n"
13488                    "// foo            bar\n",
13489                    Style));
13490 
13491   EXPECT_EQ("// foo bar baz bazfoo\n"
13492             "// foo bar baz bazfoo\n"
13493             "// bar foo bar\n",
13494             format("// foo bar baz      bazfoo\n"
13495                    "// foo bar baz      bazfoo bar\n"
13496                    "// foo bar\n",
13497                    Style));
13498 
13499   EXPECT_EQ("// foo bar baz bazfoo\n"
13500             "// foo bar baz bazfoo\n"
13501             "// bar foo bar\n",
13502             format("// foo bar baz      bazfoo\n"
13503                    "// foo bar baz      bazfoo bar\n"
13504                    "// foo           bar\n",
13505                    Style));
13506 
13507   // Make sure we do not keep protruding characters if strict mode reflow is
13508   // cheaper than keeping protruding characters.
13509   Style.ColumnLimit = 21;
13510   EXPECT_EQ(
13511       "// foo foo foo foo\n"
13512       "// foo foo foo foo\n"
13513       "// foo foo foo foo\n",
13514       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13515 
13516   EXPECT_EQ("int a = /* long block\n"
13517             "           comment */\n"
13518             "    42;",
13519             format("int a = /* long block comment */ 42;", Style));
13520 }
13521 
13522 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13523   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13524   EXPECT_EQ(Styles[0], Styles[i])                                              \
13525       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13526 
13527 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13528   SmallVector<FormatStyle, 3> Styles;
13529   Styles.resize(3);
13530 
13531   Styles[0] = getLLVMStyle();
13532   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13533   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13534   EXPECT_ALL_STYLES_EQUAL(Styles);
13535 
13536   Styles[0] = getGoogleStyle();
13537   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13538   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13539   EXPECT_ALL_STYLES_EQUAL(Styles);
13540 
13541   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13542   EXPECT_TRUE(
13543       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13544   EXPECT_TRUE(
13545       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13546   EXPECT_ALL_STYLES_EQUAL(Styles);
13547 
13548   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13549   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13550   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
13551   EXPECT_ALL_STYLES_EQUAL(Styles);
13552 
13553   Styles[0] = getMozillaStyle();
13554   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
13555   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
13556   EXPECT_ALL_STYLES_EQUAL(Styles);
13557 
13558   Styles[0] = getWebKitStyle();
13559   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
13560   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
13561   EXPECT_ALL_STYLES_EQUAL(Styles);
13562 
13563   Styles[0] = getGNUStyle();
13564   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
13565   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
13566   EXPECT_ALL_STYLES_EQUAL(Styles);
13567 
13568   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
13569 }
13570 
13571 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
13572   SmallVector<FormatStyle, 8> Styles;
13573   Styles.resize(2);
13574 
13575   Styles[0] = getGoogleStyle();
13576   Styles[1] = getLLVMStyle();
13577   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13578   EXPECT_ALL_STYLES_EQUAL(Styles);
13579 
13580   Styles.resize(5);
13581   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13582   Styles[1] = getLLVMStyle();
13583   Styles[1].Language = FormatStyle::LK_JavaScript;
13584   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13585 
13586   Styles[2] = getLLVMStyle();
13587   Styles[2].Language = FormatStyle::LK_JavaScript;
13588   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
13589                                   "BasedOnStyle: Google",
13590                                   &Styles[2])
13591                    .value());
13592 
13593   Styles[3] = getLLVMStyle();
13594   Styles[3].Language = FormatStyle::LK_JavaScript;
13595   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
13596                                   "Language: JavaScript",
13597                                   &Styles[3])
13598                    .value());
13599 
13600   Styles[4] = getLLVMStyle();
13601   Styles[4].Language = FormatStyle::LK_JavaScript;
13602   EXPECT_EQ(0, parseConfiguration("---\n"
13603                                   "BasedOnStyle: LLVM\n"
13604                                   "IndentWidth: 123\n"
13605                                   "---\n"
13606                                   "BasedOnStyle: Google\n"
13607                                   "Language: JavaScript",
13608                                   &Styles[4])
13609                    .value());
13610   EXPECT_ALL_STYLES_EQUAL(Styles);
13611 }
13612 
13613 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
13614   Style.FIELD = false;                                                         \
13615   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
13616   EXPECT_TRUE(Style.FIELD);                                                    \
13617   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
13618   EXPECT_FALSE(Style.FIELD);
13619 
13620 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
13621 
13622 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
13623   Style.STRUCT.FIELD = false;                                                  \
13624   EXPECT_EQ(0,                                                                 \
13625             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
13626                 .value());                                                     \
13627   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
13628   EXPECT_EQ(0,                                                                 \
13629             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
13630                 .value());                                                     \
13631   EXPECT_FALSE(Style.STRUCT.FIELD);
13632 
13633 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
13634   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
13635 
13636 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
13637   EXPECT_NE(VALUE, Style.FIELD);                                               \
13638   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
13639   EXPECT_EQ(VALUE, Style.FIELD)
13640 
13641 TEST_F(FormatTest, ParsesConfigurationBools) {
13642   FormatStyle Style = {};
13643   Style.Language = FormatStyle::LK_Cpp;
13644   CHECK_PARSE_BOOL(AlignTrailingComments);
13645   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
13646   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
13647   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
13648   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
13649   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
13650   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
13651   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
13652   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
13653   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
13654   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
13655   CHECK_PARSE_BOOL(BinPackArguments);
13656   CHECK_PARSE_BOOL(BinPackParameters);
13657   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
13658   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
13659   CHECK_PARSE_BOOL(BreakStringLiterals);
13660   CHECK_PARSE_BOOL(CompactNamespaces);
13661   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
13662   CHECK_PARSE_BOOL(DeriveLineEnding);
13663   CHECK_PARSE_BOOL(DerivePointerAlignment);
13664   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
13665   CHECK_PARSE_BOOL(DisableFormat);
13666   CHECK_PARSE_BOOL(IndentCaseLabels);
13667   CHECK_PARSE_BOOL(IndentCaseBlocks);
13668   CHECK_PARSE_BOOL(IndentGotoLabels);
13669   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
13670   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
13671   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
13672   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
13673   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
13674   CHECK_PARSE_BOOL(ReflowComments);
13675   CHECK_PARSE_BOOL(SortIncludes);
13676   CHECK_PARSE_BOOL(SortUsingDeclarations);
13677   CHECK_PARSE_BOOL(SpacesInParentheses);
13678   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
13679   CHECK_PARSE_BOOL(SpacesInAngles);
13680   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
13681   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
13682   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
13683   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
13684   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
13685   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
13686   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
13687   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
13688   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
13689   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
13690   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
13691   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
13692   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
13693   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
13694   CHECK_PARSE_BOOL(UseCRLF);
13695 
13696   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
13697   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
13698   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
13699   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
13700   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
13701   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
13702   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
13703   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
13704   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
13705   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
13706   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
13707   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
13708   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
13709   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
13710   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
13711   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
13712   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
13713 }
13714 
13715 #undef CHECK_PARSE_BOOL
13716 
13717 TEST_F(FormatTest, ParsesConfiguration) {
13718   FormatStyle Style = {};
13719   Style.Language = FormatStyle::LK_Cpp;
13720   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
13721   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
13722               ConstructorInitializerIndentWidth, 1234u);
13723   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
13724   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
13725   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
13726   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
13727   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
13728               PenaltyBreakBeforeFirstCallParameter, 1234u);
13729   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
13730               PenaltyBreakTemplateDeclaration, 1234u);
13731   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
13732   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
13733               PenaltyReturnTypeOnItsOwnLine, 1234u);
13734   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
13735               SpacesBeforeTrailingComments, 1234u);
13736   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
13737   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
13738   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
13739 
13740   Style.PointerAlignment = FormatStyle::PAS_Middle;
13741   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
13742               FormatStyle::PAS_Left);
13743   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
13744               FormatStyle::PAS_Right);
13745   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
13746               FormatStyle::PAS_Middle);
13747   // For backward compatibility:
13748   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
13749               FormatStyle::PAS_Left);
13750   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
13751               FormatStyle::PAS_Right);
13752   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
13753               FormatStyle::PAS_Middle);
13754 
13755   Style.Standard = FormatStyle::LS_Auto;
13756   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
13757   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
13758   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
13759   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
13760   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
13761   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
13762   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
13763   // Legacy aliases:
13764   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
13765   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
13766   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
13767   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
13768 
13769   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13770   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
13771               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
13772   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
13773               FormatStyle::BOS_None);
13774   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
13775               FormatStyle::BOS_All);
13776   // For backward compatibility:
13777   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
13778               FormatStyle::BOS_None);
13779   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
13780               FormatStyle::BOS_All);
13781 
13782   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
13783   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
13784               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13785   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
13786               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
13787   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
13788               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
13789   // For backward compatibility:
13790   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
13791               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13792 
13793   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
13794   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
13795               FormatStyle::BILS_BeforeComma);
13796   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
13797               FormatStyle::BILS_AfterColon);
13798   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
13799               FormatStyle::BILS_BeforeColon);
13800   // For backward compatibility:
13801   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
13802               FormatStyle::BILS_BeforeComma);
13803 
13804   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
13805   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
13806               FormatStyle::BAS_Align);
13807   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
13808               FormatStyle::BAS_DontAlign);
13809   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
13810               FormatStyle::BAS_AlwaysBreak);
13811   // For backward compatibility:
13812   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
13813               FormatStyle::BAS_DontAlign);
13814   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
13815               FormatStyle::BAS_Align);
13816 
13817   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13818   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
13819               FormatStyle::ENAS_DontAlign);
13820   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
13821               FormatStyle::ENAS_Left);
13822   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
13823               FormatStyle::ENAS_Right);
13824   // For backward compatibility:
13825   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
13826               FormatStyle::ENAS_Left);
13827   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
13828               FormatStyle::ENAS_Right);
13829 
13830   Style.AlignOperands = FormatStyle::OAS_Align;
13831   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
13832               FormatStyle::OAS_DontAlign);
13833   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
13834   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
13835               FormatStyle::OAS_AlignAfterOperator);
13836   // For backward compatibility:
13837   CHECK_PARSE("AlignOperands: false", AlignOperands,
13838               FormatStyle::OAS_DontAlign);
13839   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
13840 
13841   Style.UseTab = FormatStyle::UT_ForIndentation;
13842   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
13843   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
13844   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
13845   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
13846               FormatStyle::UT_ForContinuationAndIndentation);
13847   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
13848               FormatStyle::UT_AlignWithSpaces);
13849   // For backward compatibility:
13850   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
13851   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
13852 
13853   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
13854   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
13855               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13856   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
13857               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
13858   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
13859               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13860   // For backward compatibility:
13861   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
13862               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13863   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
13864               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13865 
13866   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
13867   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
13868               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13869   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
13870               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
13871   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
13872               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
13873   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
13874               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13875   // For backward compatibility:
13876   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
13877               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13878   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
13879               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13880 
13881   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
13882   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
13883               FormatStyle::SBPO_Never);
13884   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
13885               FormatStyle::SBPO_Always);
13886   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
13887               FormatStyle::SBPO_ControlStatements);
13888   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
13889               FormatStyle::SBPO_NonEmptyParentheses);
13890   // For backward compatibility:
13891   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
13892               FormatStyle::SBPO_Never);
13893   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
13894               FormatStyle::SBPO_ControlStatements);
13895 
13896   Style.ColumnLimit = 123;
13897   FormatStyle BaseStyle = getLLVMStyle();
13898   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
13899   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
13900 
13901   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
13902   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
13903               FormatStyle::BS_Attach);
13904   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
13905               FormatStyle::BS_Linux);
13906   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
13907               FormatStyle::BS_Mozilla);
13908   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
13909               FormatStyle::BS_Stroustrup);
13910   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
13911               FormatStyle::BS_Allman);
13912   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
13913               FormatStyle::BS_Whitesmiths);
13914   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
13915   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
13916               FormatStyle::BS_WebKit);
13917   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
13918               FormatStyle::BS_Custom);
13919 
13920   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
13921   CHECK_PARSE("BraceWrapping:\n"
13922               "  AfterControlStatement: MultiLine",
13923               BraceWrapping.AfterControlStatement,
13924               FormatStyle::BWACS_MultiLine);
13925   CHECK_PARSE("BraceWrapping:\n"
13926               "  AfterControlStatement: Always",
13927               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13928   CHECK_PARSE("BraceWrapping:\n"
13929               "  AfterControlStatement: Never",
13930               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13931   // For backward compatibility:
13932   CHECK_PARSE("BraceWrapping:\n"
13933               "  AfterControlStatement: true",
13934               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13935   CHECK_PARSE("BraceWrapping:\n"
13936               "  AfterControlStatement: false",
13937               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13938 
13939   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
13940   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
13941               FormatStyle::RTBS_None);
13942   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
13943               FormatStyle::RTBS_All);
13944   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
13945               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
13946   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
13947               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
13948   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
13949               AlwaysBreakAfterReturnType,
13950               FormatStyle::RTBS_TopLevelDefinitions);
13951 
13952   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
13953   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
13954               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
13955   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
13956               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
13957   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
13958               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
13959   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
13960               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
13961   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
13962               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
13963 
13964   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
13965   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
13966               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
13967   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
13968               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
13969   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
13970               AlwaysBreakAfterDefinitionReturnType,
13971               FormatStyle::DRTBS_TopLevel);
13972 
13973   Style.NamespaceIndentation = FormatStyle::NI_All;
13974   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
13975               FormatStyle::NI_None);
13976   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
13977               FormatStyle::NI_Inner);
13978   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
13979               FormatStyle::NI_All);
13980 
13981   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
13982   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
13983               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
13984   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
13985               AllowShortIfStatementsOnASingleLine,
13986               FormatStyle::SIS_WithoutElse);
13987   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
13988               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
13989   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
13990               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
13991   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
13992               AllowShortIfStatementsOnASingleLine,
13993               FormatStyle::SIS_WithoutElse);
13994 
13995   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
13996   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
13997               FormatStyle::IEBS_AfterExternBlock);
13998   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
13999               FormatStyle::IEBS_Indent);
14000   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
14001               FormatStyle::IEBS_NoIndent);
14002   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
14003               FormatStyle::IEBS_Indent);
14004   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
14005               FormatStyle::IEBS_NoIndent);
14006 
14007   // FIXME: This is required because parsing a configuration simply overwrites
14008   // the first N elements of the list instead of resetting it.
14009   Style.ForEachMacros.clear();
14010   std::vector<std::string> BoostForeach;
14011   BoostForeach.push_back("BOOST_FOREACH");
14012   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
14013   std::vector<std::string> BoostAndQForeach;
14014   BoostAndQForeach.push_back("BOOST_FOREACH");
14015   BoostAndQForeach.push_back("Q_FOREACH");
14016   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
14017               BoostAndQForeach);
14018 
14019   Style.StatementMacros.clear();
14020   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
14021               std::vector<std::string>{"QUNUSED"});
14022   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
14023               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
14024 
14025   Style.NamespaceMacros.clear();
14026   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
14027               std::vector<std::string>{"TESTSUITE"});
14028   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
14029               std::vector<std::string>({"TESTSUITE", "SUITE"}));
14030 
14031   Style.WhitespaceSensitiveMacros.clear();
14032   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
14033               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14034   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
14035               WhitespaceSensitiveMacros,
14036               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14037   Style.WhitespaceSensitiveMacros.clear();
14038   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
14039               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14040   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
14041               WhitespaceSensitiveMacros,
14042               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14043 
14044   Style.IncludeStyle.IncludeCategories.clear();
14045   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
14046       {"abc/.*", 2, 0}, {".*", 1, 0}};
14047   CHECK_PARSE("IncludeCategories:\n"
14048               "  - Regex: abc/.*\n"
14049               "    Priority: 2\n"
14050               "  - Regex: .*\n"
14051               "    Priority: 1",
14052               IncludeStyle.IncludeCategories, ExpectedCategories);
14053   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
14054               "abc$");
14055   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
14056               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
14057 
14058   Style.RawStringFormats.clear();
14059   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
14060       {
14061           FormatStyle::LK_TextProto,
14062           {"pb", "proto"},
14063           {"PARSE_TEXT_PROTO"},
14064           /*CanonicalDelimiter=*/"",
14065           "llvm",
14066       },
14067       {
14068           FormatStyle::LK_Cpp,
14069           {"cc", "cpp"},
14070           {"C_CODEBLOCK", "CPPEVAL"},
14071           /*CanonicalDelimiter=*/"cc",
14072           /*BasedOnStyle=*/"",
14073       },
14074   };
14075 
14076   CHECK_PARSE("RawStringFormats:\n"
14077               "  - Language: TextProto\n"
14078               "    Delimiters:\n"
14079               "      - 'pb'\n"
14080               "      - 'proto'\n"
14081               "    EnclosingFunctions:\n"
14082               "      - 'PARSE_TEXT_PROTO'\n"
14083               "    BasedOnStyle: llvm\n"
14084               "  - Language: Cpp\n"
14085               "    Delimiters:\n"
14086               "      - 'cc'\n"
14087               "      - 'cpp'\n"
14088               "    EnclosingFunctions:\n"
14089               "      - 'C_CODEBLOCK'\n"
14090               "      - 'CPPEVAL'\n"
14091               "    CanonicalDelimiter: 'cc'",
14092               RawStringFormats, ExpectedRawStringFormats);
14093 }
14094 
14095 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
14096   FormatStyle Style = {};
14097   Style.Language = FormatStyle::LK_Cpp;
14098   CHECK_PARSE("Language: Cpp\n"
14099               "IndentWidth: 12",
14100               IndentWidth, 12u);
14101   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
14102                                "IndentWidth: 34",
14103                                &Style),
14104             ParseError::Unsuitable);
14105   FormatStyle BinPackedTCS = {};
14106   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
14107   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
14108                                "InsertTrailingCommas: Wrapped",
14109                                &BinPackedTCS),
14110             ParseError::BinPackTrailingCommaConflict);
14111   EXPECT_EQ(12u, Style.IndentWidth);
14112   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14113   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14114 
14115   Style.Language = FormatStyle::LK_JavaScript;
14116   CHECK_PARSE("Language: JavaScript\n"
14117               "IndentWidth: 12",
14118               IndentWidth, 12u);
14119   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14120   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14121                                "IndentWidth: 34",
14122                                &Style),
14123             ParseError::Unsuitable);
14124   EXPECT_EQ(23u, Style.IndentWidth);
14125   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14126   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14127 
14128   CHECK_PARSE("BasedOnStyle: LLVM\n"
14129               "IndentWidth: 67",
14130               IndentWidth, 67u);
14131 
14132   CHECK_PARSE("---\n"
14133               "Language: JavaScript\n"
14134               "IndentWidth: 12\n"
14135               "---\n"
14136               "Language: Cpp\n"
14137               "IndentWidth: 34\n"
14138               "...\n",
14139               IndentWidth, 12u);
14140 
14141   Style.Language = FormatStyle::LK_Cpp;
14142   CHECK_PARSE("---\n"
14143               "Language: JavaScript\n"
14144               "IndentWidth: 12\n"
14145               "---\n"
14146               "Language: Cpp\n"
14147               "IndentWidth: 34\n"
14148               "...\n",
14149               IndentWidth, 34u);
14150   CHECK_PARSE("---\n"
14151               "IndentWidth: 78\n"
14152               "---\n"
14153               "Language: JavaScript\n"
14154               "IndentWidth: 56\n"
14155               "...\n",
14156               IndentWidth, 78u);
14157 
14158   Style.ColumnLimit = 123;
14159   Style.IndentWidth = 234;
14160   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14161   Style.TabWidth = 345;
14162   EXPECT_FALSE(parseConfiguration("---\n"
14163                                   "IndentWidth: 456\n"
14164                                   "BreakBeforeBraces: Allman\n"
14165                                   "---\n"
14166                                   "Language: JavaScript\n"
14167                                   "IndentWidth: 111\n"
14168                                   "TabWidth: 111\n"
14169                                   "---\n"
14170                                   "Language: Cpp\n"
14171                                   "BreakBeforeBraces: Stroustrup\n"
14172                                   "TabWidth: 789\n"
14173                                   "...\n",
14174                                   &Style));
14175   EXPECT_EQ(123u, Style.ColumnLimit);
14176   EXPECT_EQ(456u, Style.IndentWidth);
14177   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14178   EXPECT_EQ(789u, Style.TabWidth);
14179 
14180   EXPECT_EQ(parseConfiguration("---\n"
14181                                "Language: JavaScript\n"
14182                                "IndentWidth: 56\n"
14183                                "---\n"
14184                                "IndentWidth: 78\n"
14185                                "...\n",
14186                                &Style),
14187             ParseError::Error);
14188   EXPECT_EQ(parseConfiguration("---\n"
14189                                "Language: JavaScript\n"
14190                                "IndentWidth: 56\n"
14191                                "---\n"
14192                                "Language: JavaScript\n"
14193                                "IndentWidth: 78\n"
14194                                "...\n",
14195                                &Style),
14196             ParseError::Error);
14197 
14198   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14199 }
14200 
14201 #undef CHECK_PARSE
14202 
14203 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14204   FormatStyle Style = {};
14205   Style.Language = FormatStyle::LK_JavaScript;
14206   Style.BreakBeforeTernaryOperators = true;
14207   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14208   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14209 
14210   Style.BreakBeforeTernaryOperators = true;
14211   EXPECT_EQ(0, parseConfiguration("---\n"
14212                                   "BasedOnStyle: Google\n"
14213                                   "---\n"
14214                                   "Language: JavaScript\n"
14215                                   "IndentWidth: 76\n"
14216                                   "...\n",
14217                                   &Style)
14218                    .value());
14219   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14220   EXPECT_EQ(76u, Style.IndentWidth);
14221   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14222 }
14223 
14224 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14225   FormatStyle Style = getLLVMStyle();
14226   std::string YAML = configurationAsText(Style);
14227   FormatStyle ParsedStyle = {};
14228   ParsedStyle.Language = FormatStyle::LK_Cpp;
14229   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14230   EXPECT_EQ(Style, ParsedStyle);
14231 }
14232 
14233 TEST_F(FormatTest, WorksFor8bitEncodings) {
14234   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14235             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14236             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14237             "\"\xef\xee\xf0\xf3...\"",
14238             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14239                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14240                    "\xef\xee\xf0\xf3...\"",
14241                    getLLVMStyleWithColumns(12)));
14242 }
14243 
14244 TEST_F(FormatTest, HandlesUTF8BOM) {
14245   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14246   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14247             format("\xef\xbb\xbf#include <iostream>"));
14248   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14249             format("\xef\xbb\xbf\n#include <iostream>"));
14250 }
14251 
14252 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14253 #if !defined(_MSC_VER)
14254 
14255 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14256   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14257                getLLVMStyleWithColumns(35));
14258   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14259                getLLVMStyleWithColumns(31));
14260   verifyFormat("// Однажды в студёную зимнюю пору...",
14261                getLLVMStyleWithColumns(36));
14262   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14263   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14264                getLLVMStyleWithColumns(39));
14265   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14266                getLLVMStyleWithColumns(35));
14267 }
14268 
14269 TEST_F(FormatTest, SplitsUTF8Strings) {
14270   // Non-printable characters' width is currently considered to be the length in
14271   // bytes in UTF8. The characters can be displayed in very different manner
14272   // (zero-width, single width with a substitution glyph, expanded to their code
14273   // (e.g. "<8d>"), so there's no single correct way to handle them.
14274   EXPECT_EQ("\"aaaaÄ\"\n"
14275             "\"\xc2\x8d\";",
14276             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14277   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14278             "\"\xc2\x8d\";",
14279             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14280   EXPECT_EQ("\"Однажды, в \"\n"
14281             "\"студёную \"\n"
14282             "\"зимнюю \"\n"
14283             "\"пору,\"",
14284             format("\"Однажды, в студёную зимнюю пору,\"",
14285                    getLLVMStyleWithColumns(13)));
14286   EXPECT_EQ(
14287       "\"一 二 三 \"\n"
14288       "\"四 五六 \"\n"
14289       "\"七 八 九 \"\n"
14290       "\"十\"",
14291       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14292   EXPECT_EQ("\"一\t\"\n"
14293             "\"二 \t\"\n"
14294             "\"三 四 \"\n"
14295             "\"五\t\"\n"
14296             "\"六 \t\"\n"
14297             "\"七 \"\n"
14298             "\"八九十\tqq\"",
14299             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14300                    getLLVMStyleWithColumns(11)));
14301 
14302   // UTF8 character in an escape sequence.
14303   EXPECT_EQ("\"aaaaaa\"\n"
14304             "\"\\\xC2\x8D\"",
14305             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14306 }
14307 
14308 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14309   EXPECT_EQ("const char *sssss =\n"
14310             "    \"一二三四五六七八\\\n"
14311             " 九 十\";",
14312             format("const char *sssss = \"一二三四五六七八\\\n"
14313                    " 九 十\";",
14314                    getLLVMStyleWithColumns(30)));
14315 }
14316 
14317 TEST_F(FormatTest, SplitsUTF8LineComments) {
14318   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14319             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14320   EXPECT_EQ("// Я из лесу\n"
14321             "// вышел; был\n"
14322             "// сильный\n"
14323             "// мороз.",
14324             format("// Я из лесу вышел; был сильный мороз.",
14325                    getLLVMStyleWithColumns(13)));
14326   EXPECT_EQ("// 一二三\n"
14327             "// 四五六七\n"
14328             "// 八  九\n"
14329             "// 十",
14330             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14331 }
14332 
14333 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14334   EXPECT_EQ("/* Гляжу,\n"
14335             " * поднимается\n"
14336             " * медленно в\n"
14337             " * гору\n"
14338             " * Лошадка,\n"
14339             " * везущая\n"
14340             " * хворосту\n"
14341             " * воз. */",
14342             format("/* Гляжу, поднимается медленно в гору\n"
14343                    " * Лошадка, везущая хворосту воз. */",
14344                    getLLVMStyleWithColumns(13)));
14345   EXPECT_EQ(
14346       "/* 一二三\n"
14347       " * 四五六七\n"
14348       " * 八  九\n"
14349       " * 十  */",
14350       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14351   EXPECT_EQ("/* �������� ��������\n"
14352             " * ��������\n"
14353             " * ������-�� */",
14354             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14355 }
14356 
14357 #endif // _MSC_VER
14358 
14359 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14360   FormatStyle Style = getLLVMStyle();
14361 
14362   Style.ConstructorInitializerIndentWidth = 4;
14363   verifyFormat(
14364       "SomeClass::Constructor()\n"
14365       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14366       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14367       Style);
14368 
14369   Style.ConstructorInitializerIndentWidth = 2;
14370   verifyFormat(
14371       "SomeClass::Constructor()\n"
14372       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14373       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14374       Style);
14375 
14376   Style.ConstructorInitializerIndentWidth = 0;
14377   verifyFormat(
14378       "SomeClass::Constructor()\n"
14379       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14380       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14381       Style);
14382   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14383   verifyFormat(
14384       "SomeLongTemplateVariableName<\n"
14385       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14386       Style);
14387   verifyFormat("bool smaller = 1 < "
14388                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14389                "                       "
14390                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14391                Style);
14392 
14393   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14394   verifyFormat("SomeClass::Constructor() :\n"
14395                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14396                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14397                Style);
14398 }
14399 
14400 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14401   FormatStyle Style = getLLVMStyle();
14402   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14403   Style.ConstructorInitializerIndentWidth = 4;
14404   verifyFormat("SomeClass::Constructor()\n"
14405                "    : a(a)\n"
14406                "    , b(b)\n"
14407                "    , c(c) {}",
14408                Style);
14409   verifyFormat("SomeClass::Constructor()\n"
14410                "    : a(a) {}",
14411                Style);
14412 
14413   Style.ColumnLimit = 0;
14414   verifyFormat("SomeClass::Constructor()\n"
14415                "    : a(a) {}",
14416                Style);
14417   verifyFormat("SomeClass::Constructor() noexcept\n"
14418                "    : a(a) {}",
14419                Style);
14420   verifyFormat("SomeClass::Constructor()\n"
14421                "    : a(a)\n"
14422                "    , b(b)\n"
14423                "    , c(c) {}",
14424                Style);
14425   verifyFormat("SomeClass::Constructor()\n"
14426                "    : a(a) {\n"
14427                "  foo();\n"
14428                "  bar();\n"
14429                "}",
14430                Style);
14431 
14432   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14433   verifyFormat("SomeClass::Constructor()\n"
14434                "    : a(a)\n"
14435                "    , b(b)\n"
14436                "    , c(c) {\n}",
14437                Style);
14438   verifyFormat("SomeClass::Constructor()\n"
14439                "    : a(a) {\n}",
14440                Style);
14441 
14442   Style.ColumnLimit = 80;
14443   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14444   Style.ConstructorInitializerIndentWidth = 2;
14445   verifyFormat("SomeClass::Constructor()\n"
14446                "  : a(a)\n"
14447                "  , b(b)\n"
14448                "  , c(c) {}",
14449                Style);
14450 
14451   Style.ConstructorInitializerIndentWidth = 0;
14452   verifyFormat("SomeClass::Constructor()\n"
14453                ": a(a)\n"
14454                ", b(b)\n"
14455                ", c(c) {}",
14456                Style);
14457 
14458   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14459   Style.ConstructorInitializerIndentWidth = 4;
14460   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14461   verifyFormat(
14462       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14463       Style);
14464   verifyFormat(
14465       "SomeClass::Constructor()\n"
14466       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14467       Style);
14468   Style.ConstructorInitializerIndentWidth = 4;
14469   Style.ColumnLimit = 60;
14470   verifyFormat("SomeClass::Constructor()\n"
14471                "    : aaaaaaaa(aaaaaaaa)\n"
14472                "    , aaaaaaaa(aaaaaaaa)\n"
14473                "    , aaaaaaaa(aaaaaaaa) {}",
14474                Style);
14475 }
14476 
14477 TEST_F(FormatTest, Destructors) {
14478   verifyFormat("void F(int &i) { i.~int(); }");
14479   verifyFormat("void F(int &i) { i->~int(); }");
14480 }
14481 
14482 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14483   FormatStyle Style = getWebKitStyle();
14484 
14485   // Don't indent in outer namespaces.
14486   verifyFormat("namespace outer {\n"
14487                "int i;\n"
14488                "namespace inner {\n"
14489                "    int i;\n"
14490                "} // namespace inner\n"
14491                "} // namespace outer\n"
14492                "namespace other_outer {\n"
14493                "int i;\n"
14494                "}",
14495                Style);
14496 
14497   // Don't indent case labels.
14498   verifyFormat("switch (variable) {\n"
14499                "case 1:\n"
14500                "case 2:\n"
14501                "    doSomething();\n"
14502                "    break;\n"
14503                "default:\n"
14504                "    ++variable;\n"
14505                "}",
14506                Style);
14507 
14508   // Wrap before binary operators.
14509   EXPECT_EQ("void f()\n"
14510             "{\n"
14511             "    if (aaaaaaaaaaaaaaaa\n"
14512             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14513             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14514             "        return;\n"
14515             "}",
14516             format("void f() {\n"
14517                    "if (aaaaaaaaaaaaaaaa\n"
14518                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
14519                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14520                    "return;\n"
14521                    "}",
14522                    Style));
14523 
14524   // Allow functions on a single line.
14525   verifyFormat("void f() { return; }", Style);
14526 
14527   // Allow empty blocks on a single line and insert a space in empty blocks.
14528   EXPECT_EQ("void f() { }", format("void f() {}", Style));
14529   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
14530   // However, don't merge non-empty short loops.
14531   EXPECT_EQ("while (true) {\n"
14532             "    continue;\n"
14533             "}",
14534             format("while (true) { continue; }", Style));
14535 
14536   // Constructor initializers are formatted one per line with the "," on the
14537   // new line.
14538   verifyFormat("Constructor()\n"
14539                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
14540                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
14541                "          aaaaaaaaaaaaaa)\n"
14542                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
14543                "{\n"
14544                "}",
14545                Style);
14546   verifyFormat("SomeClass::Constructor()\n"
14547                "    : a(a)\n"
14548                "{\n"
14549                "}",
14550                Style);
14551   EXPECT_EQ("SomeClass::Constructor()\n"
14552             "    : a(a)\n"
14553             "{\n"
14554             "}",
14555             format("SomeClass::Constructor():a(a){}", Style));
14556   verifyFormat("SomeClass::Constructor()\n"
14557                "    : a(a)\n"
14558                "    , b(b)\n"
14559                "    , c(c)\n"
14560                "{\n"
14561                "}",
14562                Style);
14563   verifyFormat("SomeClass::Constructor()\n"
14564                "    : a(a)\n"
14565                "{\n"
14566                "    foo();\n"
14567                "    bar();\n"
14568                "}",
14569                Style);
14570 
14571   // Access specifiers should be aligned left.
14572   verifyFormat("class C {\n"
14573                "public:\n"
14574                "    int i;\n"
14575                "};",
14576                Style);
14577 
14578   // Do not align comments.
14579   verifyFormat("int a; // Do not\n"
14580                "double b; // align comments.",
14581                Style);
14582 
14583   // Do not align operands.
14584   EXPECT_EQ("ASSERT(aaaa\n"
14585             "    || bbbb);",
14586             format("ASSERT ( aaaa\n||bbbb);", Style));
14587 
14588   // Accept input's line breaks.
14589   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
14590             "    || bbbbbbbbbbbbbbb) {\n"
14591             "    i++;\n"
14592             "}",
14593             format("if (aaaaaaaaaaaaaaa\n"
14594                    "|| bbbbbbbbbbbbbbb) { i++; }",
14595                    Style));
14596   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
14597             "    i++;\n"
14598             "}",
14599             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
14600 
14601   // Don't automatically break all macro definitions (llvm.org/PR17842).
14602   verifyFormat("#define aNumber 10", Style);
14603   // However, generally keep the line breaks that the user authored.
14604   EXPECT_EQ("#define aNumber \\\n"
14605             "    10",
14606             format("#define aNumber \\\n"
14607                    " 10",
14608                    Style));
14609 
14610   // Keep empty and one-element array literals on a single line.
14611   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
14612             "                                  copyItems:YES];",
14613             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
14614                    "copyItems:YES];",
14615                    Style));
14616   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
14617             "                                  copyItems:YES];",
14618             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
14619                    "             copyItems:YES];",
14620                    Style));
14621   // FIXME: This does not seem right, there should be more indentation before
14622   // the array literal's entries. Nested blocks have the same problem.
14623   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14624             "    @\"a\",\n"
14625             "    @\"a\"\n"
14626             "]\n"
14627             "                                  copyItems:YES];",
14628             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14629                    "     @\"a\",\n"
14630                    "     @\"a\"\n"
14631                    "     ]\n"
14632                    "       copyItems:YES];",
14633                    Style));
14634   EXPECT_EQ(
14635       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14636       "                                  copyItems:YES];",
14637       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14638              "   copyItems:YES];",
14639              Style));
14640 
14641   verifyFormat("[self.a b:c c:d];", Style);
14642   EXPECT_EQ("[self.a b:c\n"
14643             "        c:d];",
14644             format("[self.a b:c\n"
14645                    "c:d];",
14646                    Style));
14647 }
14648 
14649 TEST_F(FormatTest, FormatsLambdas) {
14650   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
14651   verifyFormat(
14652       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
14653   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
14654   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
14655   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
14656   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
14657   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
14658   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
14659   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
14660   verifyFormat("int x = f(*+[] {});");
14661   verifyFormat("void f() {\n"
14662                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
14663                "}\n");
14664   verifyFormat("void f() {\n"
14665                "  other(x.begin(), //\n"
14666                "        x.end(),   //\n"
14667                "        [&](int, int) { return 1; });\n"
14668                "}\n");
14669   verifyFormat("void f() {\n"
14670                "  other.other.other.other.other(\n"
14671                "      x.begin(), x.end(),\n"
14672                "      [something, rather](int, int, int, int, int, int, int) { "
14673                "return 1; });\n"
14674                "}\n");
14675   verifyFormat(
14676       "void f() {\n"
14677       "  other.other.other.other.other(\n"
14678       "      x.begin(), x.end(),\n"
14679       "      [something, rather](int, int, int, int, int, int, int) {\n"
14680       "        //\n"
14681       "      });\n"
14682       "}\n");
14683   verifyFormat("SomeFunction([]() { // A cool function...\n"
14684                "  return 43;\n"
14685                "});");
14686   EXPECT_EQ("SomeFunction([]() {\n"
14687             "#define A a\n"
14688             "  return 43;\n"
14689             "});",
14690             format("SomeFunction([](){\n"
14691                    "#define A a\n"
14692                    "return 43;\n"
14693                    "});"));
14694   verifyFormat("void f() {\n"
14695                "  SomeFunction([](decltype(x), A *a) {});\n"
14696                "}");
14697   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14698                "    [](const aaaaaaaaaa &a) { return a; });");
14699   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
14700                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
14701                "});");
14702   verifyFormat("Constructor()\n"
14703                "    : Field([] { // comment\n"
14704                "        int i;\n"
14705                "      }) {}");
14706   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
14707                "  return some_parameter.size();\n"
14708                "};");
14709   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
14710                "    [](const string &s) { return s; };");
14711   verifyFormat("int i = aaaaaa ? 1 //\n"
14712                "               : [] {\n"
14713                "                   return 2; //\n"
14714                "                 }();");
14715   verifyFormat("llvm::errs() << \"number of twos is \"\n"
14716                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
14717                "                  return x == 2; // force break\n"
14718                "                });");
14719   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14720                "    [=](int iiiiiiiiiiii) {\n"
14721                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
14722                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
14723                "    });",
14724                getLLVMStyleWithColumns(60));
14725   verifyFormat("SomeFunction({[&] {\n"
14726                "                // comment\n"
14727                "              },\n"
14728                "              [&] {\n"
14729                "                // comment\n"
14730                "              }});");
14731   verifyFormat("SomeFunction({[&] {\n"
14732                "  // comment\n"
14733                "}});");
14734   verifyFormat(
14735       "virtual aaaaaaaaaaaaaaaa(\n"
14736       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
14737       "    aaaaa aaaaaaaaa);");
14738 
14739   // Lambdas with return types.
14740   verifyFormat("int c = []() -> int { return 2; }();\n");
14741   verifyFormat("int c = []() -> int * { return 2; }();\n");
14742   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
14743   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
14744   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
14745   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
14746   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
14747   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
14748   verifyFormat("[a, a]() -> a<1> {};");
14749   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
14750   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
14751   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
14752   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
14753   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
14754   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
14755   verifyFormat("[]() -> foo<!5> { return {}; };");
14756   verifyFormat("[]() -> foo<~5> { return {}; };");
14757   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
14758   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
14759   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
14760   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
14761   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
14762   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
14763   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
14764   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
14765   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
14766   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
14767   verifyFormat("namespace bar {\n"
14768                "// broken:\n"
14769                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
14770                "} // namespace bar");
14771   verifyFormat("namespace bar {\n"
14772                "// broken:\n"
14773                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
14774                "} // namespace bar");
14775   verifyFormat("namespace bar {\n"
14776                "// broken:\n"
14777                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
14778                "} // namespace bar");
14779   verifyFormat("namespace bar {\n"
14780                "// broken:\n"
14781                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
14782                "} // namespace bar");
14783   verifyFormat("namespace bar {\n"
14784                "// broken:\n"
14785                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
14786                "} // namespace bar");
14787   verifyFormat("namespace bar {\n"
14788                "// broken:\n"
14789                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
14790                "} // namespace bar");
14791   verifyFormat("namespace bar {\n"
14792                "// broken:\n"
14793                "auto foo{[]() -> foo<!5> { return {}; }};\n"
14794                "} // namespace bar");
14795   verifyFormat("namespace bar {\n"
14796                "// broken:\n"
14797                "auto foo{[]() -> foo<~5> { return {}; }};\n"
14798                "} // namespace bar");
14799   verifyFormat("namespace bar {\n"
14800                "// broken:\n"
14801                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
14802                "} // namespace bar");
14803   verifyFormat("namespace bar {\n"
14804                "// broken:\n"
14805                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
14806                "} // namespace bar");
14807   verifyFormat("namespace bar {\n"
14808                "// broken:\n"
14809                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
14810                "} // namespace bar");
14811   verifyFormat("namespace bar {\n"
14812                "// broken:\n"
14813                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
14814                "} // namespace bar");
14815   verifyFormat("namespace bar {\n"
14816                "// broken:\n"
14817                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
14818                "} // namespace bar");
14819   verifyFormat("namespace bar {\n"
14820                "// broken:\n"
14821                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
14822                "} // namespace bar");
14823   verifyFormat("namespace bar {\n"
14824                "// broken:\n"
14825                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
14826                "} // namespace bar");
14827   verifyFormat("namespace bar {\n"
14828                "// broken:\n"
14829                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
14830                "} // namespace bar");
14831   verifyFormat("namespace bar {\n"
14832                "// broken:\n"
14833                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
14834                "} // namespace bar");
14835   verifyFormat("namespace bar {\n"
14836                "// broken:\n"
14837                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
14838                "} // namespace bar");
14839   verifyFormat("[]() -> a<1> {};");
14840   verifyFormat("[]() -> a<1> { ; };");
14841   verifyFormat("[]() -> a<1> { ; }();");
14842   verifyFormat("[a, a]() -> a<true> {};");
14843   verifyFormat("[]() -> a<true> {};");
14844   verifyFormat("[]() -> a<true> { ; };");
14845   verifyFormat("[]() -> a<true> { ; }();");
14846   verifyFormat("[a, a]() -> a<false> {};");
14847   verifyFormat("[]() -> a<false> {};");
14848   verifyFormat("[]() -> a<false> { ; };");
14849   verifyFormat("[]() -> a<false> { ; }();");
14850   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
14851   verifyFormat("namespace bar {\n"
14852                "auto foo{[]() -> foo<false> { ; }};\n"
14853                "} // namespace bar");
14854   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
14855                "                   int j) -> int {\n"
14856                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
14857                "};");
14858   verifyFormat(
14859       "aaaaaaaaaaaaaaaaaaaaaa(\n"
14860       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
14861       "      return aaaaaaaaaaaaaaaaa;\n"
14862       "    });",
14863       getLLVMStyleWithColumns(70));
14864   verifyFormat("[]() //\n"
14865                "    -> int {\n"
14866                "  return 1; //\n"
14867                "};");
14868   verifyFormat("[]() -> Void<T...> {};");
14869   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
14870 
14871   // Lambdas with explicit template argument lists.
14872   verifyFormat(
14873       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
14874 
14875   // Multiple lambdas in the same parentheses change indentation rules. These
14876   // lambdas are forced to start on new lines.
14877   verifyFormat("SomeFunction(\n"
14878                "    []() {\n"
14879                "      //\n"
14880                "    },\n"
14881                "    []() {\n"
14882                "      //\n"
14883                "    });");
14884 
14885   // A lambda passed as arg0 is always pushed to the next line.
14886   verifyFormat("SomeFunction(\n"
14887                "    [this] {\n"
14888                "      //\n"
14889                "    },\n"
14890                "    1);\n");
14891 
14892   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
14893   // the arg0 case above.
14894   auto Style = getGoogleStyle();
14895   Style.BinPackArguments = false;
14896   verifyFormat("SomeFunction(\n"
14897                "    a,\n"
14898                "    [this] {\n"
14899                "      //\n"
14900                "    },\n"
14901                "    b);\n",
14902                Style);
14903   verifyFormat("SomeFunction(\n"
14904                "    a,\n"
14905                "    [this] {\n"
14906                "      //\n"
14907                "    },\n"
14908                "    b);\n");
14909 
14910   // A lambda with a very long line forces arg0 to be pushed out irrespective of
14911   // the BinPackArguments value (as long as the code is wide enough).
14912   verifyFormat(
14913       "something->SomeFunction(\n"
14914       "    a,\n"
14915       "    [this] {\n"
14916       "      "
14917       "D0000000000000000000000000000000000000000000000000000000000001();\n"
14918       "    },\n"
14919       "    b);\n");
14920 
14921   // A multi-line lambda is pulled up as long as the introducer fits on the
14922   // previous line and there are no further args.
14923   verifyFormat("function(1, [this, that] {\n"
14924                "  //\n"
14925                "});\n");
14926   verifyFormat("function([this, that] {\n"
14927                "  //\n"
14928                "});\n");
14929   // FIXME: this format is not ideal and we should consider forcing the first
14930   // arg onto its own line.
14931   verifyFormat("function(a, b, c, //\n"
14932                "         d, [this, that] {\n"
14933                "           //\n"
14934                "         });\n");
14935 
14936   // Multiple lambdas are treated correctly even when there is a short arg0.
14937   verifyFormat("SomeFunction(\n"
14938                "    1,\n"
14939                "    [this] {\n"
14940                "      //\n"
14941                "    },\n"
14942                "    [this] {\n"
14943                "      //\n"
14944                "    },\n"
14945                "    1);\n");
14946 
14947   // More complex introducers.
14948   verifyFormat("return [i, args...] {};");
14949 
14950   // Not lambdas.
14951   verifyFormat("constexpr char hello[]{\"hello\"};");
14952   verifyFormat("double &operator[](int i) { return 0; }\n"
14953                "int i;");
14954   verifyFormat("std::unique_ptr<int[]> foo() {}");
14955   verifyFormat("int i = a[a][a]->f();");
14956   verifyFormat("int i = (*b)[a]->f();");
14957 
14958   // Other corner cases.
14959   verifyFormat("void f() {\n"
14960                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
14961                "  );\n"
14962                "}");
14963 
14964   // Lambdas created through weird macros.
14965   verifyFormat("void f() {\n"
14966                "  MACRO((const AA &a) { return 1; });\n"
14967                "  MACRO((AA &a) { return 1; });\n"
14968                "}");
14969 
14970   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
14971                "      doo_dah();\n"
14972                "      doo_dah();\n"
14973                "    })) {\n"
14974                "}");
14975   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
14976                "                doo_dah();\n"
14977                "                doo_dah();\n"
14978                "              })) {\n"
14979                "}");
14980   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
14981                "                doo_dah();\n"
14982                "                doo_dah();\n"
14983                "              })) {\n"
14984                "}");
14985   verifyFormat("auto lambda = []() {\n"
14986                "  int a = 2\n"
14987                "#if A\n"
14988                "          + 2\n"
14989                "#endif\n"
14990                "      ;\n"
14991                "};");
14992 
14993   // Lambdas with complex multiline introducers.
14994   verifyFormat(
14995       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14996       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
14997       "        -> ::std::unordered_set<\n"
14998       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
14999       "      //\n"
15000       "    });");
15001 
15002   FormatStyle DoNotMerge = getLLVMStyle();
15003   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
15004   verifyFormat("auto c = []() {\n"
15005                "  return b;\n"
15006                "};",
15007                "auto c = []() { return b; };", DoNotMerge);
15008   verifyFormat("auto c = []() {\n"
15009                "};",
15010                " auto c = []() {};", DoNotMerge);
15011 
15012   FormatStyle MergeEmptyOnly = getLLVMStyle();
15013   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
15014   verifyFormat("auto c = []() {\n"
15015                "  return b;\n"
15016                "};",
15017                "auto c = []() {\n"
15018                "  return b;\n"
15019                " };",
15020                MergeEmptyOnly);
15021   verifyFormat("auto c = []() {};",
15022                "auto c = []() {\n"
15023                "};",
15024                MergeEmptyOnly);
15025 
15026   FormatStyle MergeInline = getLLVMStyle();
15027   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
15028   verifyFormat("auto c = []() {\n"
15029                "  return b;\n"
15030                "};",
15031                "auto c = []() { return b; };", MergeInline);
15032   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
15033                MergeInline);
15034   verifyFormat("function([]() { return b; }, a)",
15035                "function([]() { return b; }, a)", MergeInline);
15036   verifyFormat("function(a, []() { return b; })",
15037                "function(a, []() { return b; })", MergeInline);
15038 
15039   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
15040   // AllowShortLambdasOnASingleLine
15041   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15042   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15043   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15044   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15045       FormatStyle::ShortLambdaStyle::SLS_None;
15046   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
15047                "    []()\n"
15048                "    {\n"
15049                "      return 17;\n"
15050                "    });",
15051                LLVMWithBeforeLambdaBody);
15052   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
15053                "    []()\n"
15054                "    {\n"
15055                "    });",
15056                LLVMWithBeforeLambdaBody);
15057   verifyFormat("auto fct_SLS_None = []()\n"
15058                "{\n"
15059                "  return 17;\n"
15060                "};",
15061                LLVMWithBeforeLambdaBody);
15062   verifyFormat("TwoNestedLambdas_SLS_None(\n"
15063                "    []()\n"
15064                "    {\n"
15065                "      return Call(\n"
15066                "          []()\n"
15067                "          {\n"
15068                "            return 17;\n"
15069                "          });\n"
15070                "    });",
15071                LLVMWithBeforeLambdaBody);
15072   verifyFormat("void Fct()\n"
15073                "{\n"
15074                "  return {[]()\n"
15075                "          {\n"
15076                "            return 17;\n"
15077                "          }};\n"
15078                "}",
15079                LLVMWithBeforeLambdaBody);
15080 
15081   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15082       FormatStyle::ShortLambdaStyle::SLS_Empty;
15083   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
15084                "    []()\n"
15085                "    {\n"
15086                "      return 17;\n"
15087                "    });",
15088                LLVMWithBeforeLambdaBody);
15089   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
15090                LLVMWithBeforeLambdaBody);
15091   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
15092                "ongFunctionName_SLS_Empty(\n"
15093                "    []() {});",
15094                LLVMWithBeforeLambdaBody);
15095   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
15096                "                                []()\n"
15097                "                                {\n"
15098                "                                  return 17;\n"
15099                "                                });",
15100                LLVMWithBeforeLambdaBody);
15101   verifyFormat("auto fct_SLS_Empty = []()\n"
15102                "{\n"
15103                "  return 17;\n"
15104                "};",
15105                LLVMWithBeforeLambdaBody);
15106   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
15107                "    []()\n"
15108                "    {\n"
15109                "      return Call([]() {});\n"
15110                "    });",
15111                LLVMWithBeforeLambdaBody);
15112   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15113                "                           []()\n"
15114                "                           {\n"
15115                "                             return Call([]() {});\n"
15116                "                           });",
15117                LLVMWithBeforeLambdaBody);
15118   verifyFormat(
15119       "FctWithLongLineInLambda_SLS_Empty(\n"
15120       "    []()\n"
15121       "    {\n"
15122       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15123       "                               AndShouldNotBeConsiderAsInline,\n"
15124       "                               LambdaBodyMustBeBreak);\n"
15125       "    });",
15126       LLVMWithBeforeLambdaBody);
15127 
15128   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15129       FormatStyle::ShortLambdaStyle::SLS_Inline;
15130   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15131                LLVMWithBeforeLambdaBody);
15132   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15133                LLVMWithBeforeLambdaBody);
15134   verifyFormat("auto fct_SLS_Inline = []()\n"
15135                "{\n"
15136                "  return 17;\n"
15137                "};",
15138                LLVMWithBeforeLambdaBody);
15139   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15140                "17; }); });",
15141                LLVMWithBeforeLambdaBody);
15142   verifyFormat(
15143       "FctWithLongLineInLambda_SLS_Inline(\n"
15144       "    []()\n"
15145       "    {\n"
15146       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15147       "                               AndShouldNotBeConsiderAsInline,\n"
15148       "                               LambdaBodyMustBeBreak);\n"
15149       "    });",
15150       LLVMWithBeforeLambdaBody);
15151   verifyFormat("FctWithMultipleParams_SLS_Inline("
15152                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15153                "                                 []() { return 17; });",
15154                LLVMWithBeforeLambdaBody);
15155   verifyFormat(
15156       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15157       LLVMWithBeforeLambdaBody);
15158 
15159   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15160       FormatStyle::ShortLambdaStyle::SLS_All;
15161   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15162                LLVMWithBeforeLambdaBody);
15163   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15164                LLVMWithBeforeLambdaBody);
15165   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15166                LLVMWithBeforeLambdaBody);
15167   verifyFormat("FctWithOneParam_SLS_All(\n"
15168                "    []()\n"
15169                "    {\n"
15170                "      // A cool function...\n"
15171                "      return 43;\n"
15172                "    });",
15173                LLVMWithBeforeLambdaBody);
15174   verifyFormat("FctWithMultipleParams_SLS_All("
15175                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15176                "                              []() { return 17; });",
15177                LLVMWithBeforeLambdaBody);
15178   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15179                LLVMWithBeforeLambdaBody);
15180   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15181                LLVMWithBeforeLambdaBody);
15182   verifyFormat(
15183       "FctWithLongLineInLambda_SLS_All(\n"
15184       "    []()\n"
15185       "    {\n"
15186       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15187       "                               AndShouldNotBeConsiderAsInline,\n"
15188       "                               LambdaBodyMustBeBreak);\n"
15189       "    });",
15190       LLVMWithBeforeLambdaBody);
15191   verifyFormat(
15192       "auto fct_SLS_All = []()\n"
15193       "{\n"
15194       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15195       "                           AndShouldNotBeConsiderAsInline,\n"
15196       "                           LambdaBodyMustBeBreak);\n"
15197       "};",
15198       LLVMWithBeforeLambdaBody);
15199   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15200   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15201                LLVMWithBeforeLambdaBody);
15202   verifyFormat(
15203       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15204       "                                FirstParam,\n"
15205       "                                SecondParam,\n"
15206       "                                ThirdParam,\n"
15207       "                                FourthParam);",
15208       LLVMWithBeforeLambdaBody);
15209   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15210                "    []() { return "
15211                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15212                "    FirstParam,\n"
15213                "    SecondParam,\n"
15214                "    ThirdParam,\n"
15215                "    FourthParam);",
15216                LLVMWithBeforeLambdaBody);
15217   verifyFormat(
15218       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15219       "                                SecondParam,\n"
15220       "                                ThirdParam,\n"
15221       "                                FourthParam,\n"
15222       "                                []() { return SomeValueNotSoLong; });",
15223       LLVMWithBeforeLambdaBody);
15224   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15225                "    []()\n"
15226                "    {\n"
15227                "      return "
15228                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15229                "eConsiderAsInline;\n"
15230                "    });",
15231                LLVMWithBeforeLambdaBody);
15232   verifyFormat(
15233       "FctWithLongLineInLambda_SLS_All(\n"
15234       "    []()\n"
15235       "    {\n"
15236       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15237       "                               AndShouldNotBeConsiderAsInline,\n"
15238       "                               LambdaBodyMustBeBreak);\n"
15239       "    });",
15240       LLVMWithBeforeLambdaBody);
15241   verifyFormat("FctWithTwoParams_SLS_All(\n"
15242                "    []()\n"
15243                "    {\n"
15244                "      // A cool function...\n"
15245                "      return 43;\n"
15246                "    },\n"
15247                "    87);",
15248                LLVMWithBeforeLambdaBody);
15249   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15250                LLVMWithBeforeLambdaBody);
15251   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15252                LLVMWithBeforeLambdaBody);
15253   verifyFormat(
15254       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15255       LLVMWithBeforeLambdaBody);
15256   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15257                "}); }, x);",
15258                LLVMWithBeforeLambdaBody);
15259   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15260                "    []()\n"
15261                "    {\n"
15262                "      // A cool function...\n"
15263                "      return Call([]() { return 17; });\n"
15264                "    });",
15265                LLVMWithBeforeLambdaBody);
15266   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15267                "    []()\n"
15268                "    {\n"
15269                "      return Call(\n"
15270                "          []()\n"
15271                "          {\n"
15272                "            // A cool function...\n"
15273                "            return 17;\n"
15274                "          });\n"
15275                "    });",
15276                LLVMWithBeforeLambdaBody);
15277 }
15278 
15279 TEST_F(FormatTest, LambdaWithLineComments) {
15280   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15281   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15282   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15283   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15284       FormatStyle::ShortLambdaStyle::SLS_All;
15285 
15286   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15287   verifyFormat("auto k = []() // comment\n"
15288                "{ return; }",
15289                LLVMWithBeforeLambdaBody);
15290   verifyFormat("auto k = []() /* comment */ { return; }",
15291                LLVMWithBeforeLambdaBody);
15292   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15293                LLVMWithBeforeLambdaBody);
15294   verifyFormat("auto k = []() // X\n"
15295                "{ return; }",
15296                LLVMWithBeforeLambdaBody);
15297   verifyFormat(
15298       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15299       "{ return; }",
15300       LLVMWithBeforeLambdaBody);
15301 }
15302 
15303 TEST_F(FormatTest, EmptyLinesInLambdas) {
15304   verifyFormat("auto lambda = []() {\n"
15305                "  x(); //\n"
15306                "};",
15307                "auto lambda = []() {\n"
15308                "\n"
15309                "  x(); //\n"
15310                "\n"
15311                "};");
15312 }
15313 
15314 TEST_F(FormatTest, FormatsBlocks) {
15315   FormatStyle ShortBlocks = getLLVMStyle();
15316   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15317   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15318   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15319   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15320   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15321   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15322   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15323 
15324   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15325   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15326   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15327 
15328   verifyFormat("[operation setCompletionBlock:^{\n"
15329                "  [self onOperationDone];\n"
15330                "}];");
15331   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15332                "  [self onOperationDone];\n"
15333                "}]};");
15334   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15335                "  f();\n"
15336                "}];");
15337   verifyFormat("int a = [operation block:^int(int *i) {\n"
15338                "  return 1;\n"
15339                "}];");
15340   verifyFormat("[myObject doSomethingWith:arg1\n"
15341                "                      aaa:^int(int *a) {\n"
15342                "                        return 1;\n"
15343                "                      }\n"
15344                "                      bbb:f(a * bbbbbbbb)];");
15345 
15346   verifyFormat("[operation setCompletionBlock:^{\n"
15347                "  [self.delegate newDataAvailable];\n"
15348                "}];",
15349                getLLVMStyleWithColumns(60));
15350   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15351                "  NSString *path = [self sessionFilePath];\n"
15352                "  if (path) {\n"
15353                "    // ...\n"
15354                "  }\n"
15355                "});");
15356   verifyFormat("[[SessionService sharedService]\n"
15357                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15358                "      if (window) {\n"
15359                "        [self windowDidLoad:window];\n"
15360                "      } else {\n"
15361                "        [self errorLoadingWindow];\n"
15362                "      }\n"
15363                "    }];");
15364   verifyFormat("void (^largeBlock)(void) = ^{\n"
15365                "  // ...\n"
15366                "};\n",
15367                getLLVMStyleWithColumns(40));
15368   verifyFormat("[[SessionService sharedService]\n"
15369                "    loadWindowWithCompletionBlock: //\n"
15370                "        ^(SessionWindow *window) {\n"
15371                "          if (window) {\n"
15372                "            [self windowDidLoad:window];\n"
15373                "          } else {\n"
15374                "            [self errorLoadingWindow];\n"
15375                "          }\n"
15376                "        }];",
15377                getLLVMStyleWithColumns(60));
15378   verifyFormat("[myObject doSomethingWith:arg1\n"
15379                "    firstBlock:^(Foo *a) {\n"
15380                "      // ...\n"
15381                "      int i;\n"
15382                "    }\n"
15383                "    secondBlock:^(Bar *b) {\n"
15384                "      // ...\n"
15385                "      int i;\n"
15386                "    }\n"
15387                "    thirdBlock:^Foo(Bar *b) {\n"
15388                "      // ...\n"
15389                "      int i;\n"
15390                "    }];");
15391   verifyFormat("[myObject doSomethingWith:arg1\n"
15392                "               firstBlock:-1\n"
15393                "              secondBlock:^(Bar *b) {\n"
15394                "                // ...\n"
15395                "                int i;\n"
15396                "              }];");
15397 
15398   verifyFormat("f(^{\n"
15399                "  @autoreleasepool {\n"
15400                "    if (a) {\n"
15401                "      g();\n"
15402                "    }\n"
15403                "  }\n"
15404                "});");
15405   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15406   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15407                "};");
15408 
15409   FormatStyle FourIndent = getLLVMStyle();
15410   FourIndent.ObjCBlockIndentWidth = 4;
15411   verifyFormat("[operation setCompletionBlock:^{\n"
15412                "    [self onOperationDone];\n"
15413                "}];",
15414                FourIndent);
15415 }
15416 
15417 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15418   FormatStyle ZeroColumn = getLLVMStyle();
15419   ZeroColumn.ColumnLimit = 0;
15420 
15421   verifyFormat("[[SessionService sharedService] "
15422                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15423                "  if (window) {\n"
15424                "    [self windowDidLoad:window];\n"
15425                "  } else {\n"
15426                "    [self errorLoadingWindow];\n"
15427                "  }\n"
15428                "}];",
15429                ZeroColumn);
15430   EXPECT_EQ("[[SessionService sharedService]\n"
15431             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15432             "      if (window) {\n"
15433             "        [self windowDidLoad:window];\n"
15434             "      } else {\n"
15435             "        [self errorLoadingWindow];\n"
15436             "      }\n"
15437             "    }];",
15438             format("[[SessionService sharedService]\n"
15439                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15440                    "                if (window) {\n"
15441                    "    [self windowDidLoad:window];\n"
15442                    "  } else {\n"
15443                    "    [self errorLoadingWindow];\n"
15444                    "  }\n"
15445                    "}];",
15446                    ZeroColumn));
15447   verifyFormat("[myObject doSomethingWith:arg1\n"
15448                "    firstBlock:^(Foo *a) {\n"
15449                "      // ...\n"
15450                "      int i;\n"
15451                "    }\n"
15452                "    secondBlock:^(Bar *b) {\n"
15453                "      // ...\n"
15454                "      int i;\n"
15455                "    }\n"
15456                "    thirdBlock:^Foo(Bar *b) {\n"
15457                "      // ...\n"
15458                "      int i;\n"
15459                "    }];",
15460                ZeroColumn);
15461   verifyFormat("f(^{\n"
15462                "  @autoreleasepool {\n"
15463                "    if (a) {\n"
15464                "      g();\n"
15465                "    }\n"
15466                "  }\n"
15467                "});",
15468                ZeroColumn);
15469   verifyFormat("void (^largeBlock)(void) = ^{\n"
15470                "  // ...\n"
15471                "};",
15472                ZeroColumn);
15473 
15474   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15475   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15476             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15477   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15478   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15479             "  int i;\n"
15480             "};",
15481             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15482 }
15483 
15484 TEST_F(FormatTest, SupportsCRLF) {
15485   EXPECT_EQ("int a;\r\n"
15486             "int b;\r\n"
15487             "int c;\r\n",
15488             format("int a;\r\n"
15489                    "  int b;\r\n"
15490                    "    int c;\r\n",
15491                    getLLVMStyle()));
15492   EXPECT_EQ("int a;\r\n"
15493             "int b;\r\n"
15494             "int c;\r\n",
15495             format("int a;\r\n"
15496                    "  int b;\n"
15497                    "    int c;\r\n",
15498                    getLLVMStyle()));
15499   EXPECT_EQ("int a;\n"
15500             "int b;\n"
15501             "int c;\n",
15502             format("int a;\r\n"
15503                    "  int b;\n"
15504                    "    int c;\n",
15505                    getLLVMStyle()));
15506   EXPECT_EQ("\"aaaaaaa \"\r\n"
15507             "\"bbbbbbb\";\r\n",
15508             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15509   EXPECT_EQ("#define A \\\r\n"
15510             "  b;      \\\r\n"
15511             "  c;      \\\r\n"
15512             "  d;\r\n",
15513             format("#define A \\\r\n"
15514                    "  b; \\\r\n"
15515                    "  c; d; \r\n",
15516                    getGoogleStyle()));
15517 
15518   EXPECT_EQ("/*\r\n"
15519             "multi line block comments\r\n"
15520             "should not introduce\r\n"
15521             "an extra carriage return\r\n"
15522             "*/\r\n",
15523             format("/*\r\n"
15524                    "multi line block comments\r\n"
15525                    "should not introduce\r\n"
15526                    "an extra carriage return\r\n"
15527                    "*/\r\n"));
15528   EXPECT_EQ("/*\r\n"
15529             "\r\n"
15530             "*/",
15531             format("/*\r\n"
15532                    "    \r\r\r\n"
15533                    "*/"));
15534 
15535   FormatStyle style = getLLVMStyle();
15536 
15537   style.DeriveLineEnding = true;
15538   style.UseCRLF = false;
15539   EXPECT_EQ("union FooBarBazQux {\n"
15540             "  int foo;\n"
15541             "  int bar;\n"
15542             "  int baz;\n"
15543             "};",
15544             format("union FooBarBazQux {\r\n"
15545                    "  int foo;\n"
15546                    "  int bar;\r\n"
15547                    "  int baz;\n"
15548                    "};",
15549                    style));
15550   style.UseCRLF = true;
15551   EXPECT_EQ("union FooBarBazQux {\r\n"
15552             "  int foo;\r\n"
15553             "  int bar;\r\n"
15554             "  int baz;\r\n"
15555             "};",
15556             format("union FooBarBazQux {\r\n"
15557                    "  int foo;\n"
15558                    "  int bar;\r\n"
15559                    "  int baz;\n"
15560                    "};",
15561                    style));
15562 
15563   style.DeriveLineEnding = false;
15564   style.UseCRLF = false;
15565   EXPECT_EQ("union FooBarBazQux {\n"
15566             "  int foo;\n"
15567             "  int bar;\n"
15568             "  int baz;\n"
15569             "  int qux;\n"
15570             "};",
15571             format("union FooBarBazQux {\r\n"
15572                    "  int foo;\n"
15573                    "  int bar;\r\n"
15574                    "  int baz;\n"
15575                    "  int qux;\r\n"
15576                    "};",
15577                    style));
15578   style.UseCRLF = true;
15579   EXPECT_EQ("union FooBarBazQux {\r\n"
15580             "  int foo;\r\n"
15581             "  int bar;\r\n"
15582             "  int baz;\r\n"
15583             "  int qux;\r\n"
15584             "};",
15585             format("union FooBarBazQux {\r\n"
15586                    "  int foo;\n"
15587                    "  int bar;\r\n"
15588                    "  int baz;\n"
15589                    "  int qux;\n"
15590                    "};",
15591                    style));
15592 
15593   style.DeriveLineEnding = true;
15594   style.UseCRLF = false;
15595   EXPECT_EQ("union FooBarBazQux {\r\n"
15596             "  int foo;\r\n"
15597             "  int bar;\r\n"
15598             "  int baz;\r\n"
15599             "  int qux;\r\n"
15600             "};",
15601             format("union FooBarBazQux {\r\n"
15602                    "  int foo;\n"
15603                    "  int bar;\r\n"
15604                    "  int baz;\n"
15605                    "  int qux;\r\n"
15606                    "};",
15607                    style));
15608   style.UseCRLF = true;
15609   EXPECT_EQ("union FooBarBazQux {\n"
15610             "  int foo;\n"
15611             "  int bar;\n"
15612             "  int baz;\n"
15613             "  int qux;\n"
15614             "};",
15615             format("union FooBarBazQux {\r\n"
15616                    "  int foo;\n"
15617                    "  int bar;\r\n"
15618                    "  int baz;\n"
15619                    "  int qux;\n"
15620                    "};",
15621                    style));
15622 }
15623 
15624 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
15625   verifyFormat("MY_CLASS(C) {\n"
15626                "  int i;\n"
15627                "  int j;\n"
15628                "};");
15629 }
15630 
15631 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
15632   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
15633   TwoIndent.ContinuationIndentWidth = 2;
15634 
15635   EXPECT_EQ("int i =\n"
15636             "  longFunction(\n"
15637             "    arg);",
15638             format("int i = longFunction(arg);", TwoIndent));
15639 
15640   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
15641   SixIndent.ContinuationIndentWidth = 6;
15642 
15643   EXPECT_EQ("int i =\n"
15644             "      longFunction(\n"
15645             "            arg);",
15646             format("int i = longFunction(arg);", SixIndent));
15647 }
15648 
15649 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
15650   FormatStyle Style = getLLVMStyle();
15651   verifyFormat("int Foo::getter(\n"
15652                "    //\n"
15653                ") const {\n"
15654                "  return foo;\n"
15655                "}",
15656                Style);
15657   verifyFormat("void Foo::setter(\n"
15658                "    //\n"
15659                ") {\n"
15660                "  foo = 1;\n"
15661                "}",
15662                Style);
15663 }
15664 
15665 TEST_F(FormatTest, SpacesInAngles) {
15666   FormatStyle Spaces = getLLVMStyle();
15667   Spaces.SpacesInAngles = true;
15668 
15669   verifyFormat("static_cast< int >(arg);", Spaces);
15670   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
15671   verifyFormat("f< int, float >();", Spaces);
15672   verifyFormat("template <> g() {}", Spaces);
15673   verifyFormat("template < std::vector< int > > f() {}", Spaces);
15674   verifyFormat("std::function< void(int, int) > fct;", Spaces);
15675   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
15676                Spaces);
15677 
15678   Spaces.Standard = FormatStyle::LS_Cpp03;
15679   Spaces.SpacesInAngles = true;
15680   verifyFormat("A< A< int > >();", Spaces);
15681 
15682   Spaces.SpacesInAngles = false;
15683   verifyFormat("A<A<int> >();", Spaces);
15684 
15685   Spaces.Standard = FormatStyle::LS_Cpp11;
15686   Spaces.SpacesInAngles = true;
15687   verifyFormat("A< A< int > >();", Spaces);
15688 
15689   Spaces.SpacesInAngles = false;
15690   verifyFormat("A<A<int>>();", Spaces);
15691 }
15692 
15693 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
15694   FormatStyle Style = getLLVMStyle();
15695   Style.SpaceAfterTemplateKeyword = false;
15696   verifyFormat("template<int> void foo();", Style);
15697 }
15698 
15699 TEST_F(FormatTest, TripleAngleBrackets) {
15700   verifyFormat("f<<<1, 1>>>();");
15701   verifyFormat("f<<<1, 1, 1, s>>>();");
15702   verifyFormat("f<<<a, b, c, d>>>();");
15703   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
15704   verifyFormat("f<param><<<1, 1>>>();");
15705   verifyFormat("f<1><<<1, 1>>>();");
15706   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
15707   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15708                "aaaaaaaaaaa<<<\n    1, 1>>>();");
15709   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
15710                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
15711 }
15712 
15713 TEST_F(FormatTest, MergeLessLessAtEnd) {
15714   verifyFormat("<<");
15715   EXPECT_EQ("< < <", format("\\\n<<<"));
15716   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15717                "aaallvm::outs() <<");
15718   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15719                "aaaallvm::outs()\n    <<");
15720 }
15721 
15722 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
15723   std::string code = "#if A\n"
15724                      "#if B\n"
15725                      "a.\n"
15726                      "#endif\n"
15727                      "    a = 1;\n"
15728                      "#else\n"
15729                      "#endif\n"
15730                      "#if C\n"
15731                      "#else\n"
15732                      "#endif\n";
15733   EXPECT_EQ(code, format(code));
15734 }
15735 
15736 TEST_F(FormatTest, HandleConflictMarkers) {
15737   // Git/SVN conflict markers.
15738   EXPECT_EQ("int a;\n"
15739             "void f() {\n"
15740             "  callme(some(parameter1,\n"
15741             "<<<<<<< text by the vcs\n"
15742             "              parameter2),\n"
15743             "||||||| text by the vcs\n"
15744             "              parameter2),\n"
15745             "         parameter3,\n"
15746             "======= text by the vcs\n"
15747             "              parameter2, parameter3),\n"
15748             ">>>>>>> text by the vcs\n"
15749             "         otherparameter);\n",
15750             format("int a;\n"
15751                    "void f() {\n"
15752                    "  callme(some(parameter1,\n"
15753                    "<<<<<<< text by the vcs\n"
15754                    "  parameter2),\n"
15755                    "||||||| text by the vcs\n"
15756                    "  parameter2),\n"
15757                    "  parameter3,\n"
15758                    "======= text by the vcs\n"
15759                    "  parameter2,\n"
15760                    "  parameter3),\n"
15761                    ">>>>>>> text by the vcs\n"
15762                    "  otherparameter);\n"));
15763 
15764   // Perforce markers.
15765   EXPECT_EQ("void f() {\n"
15766             "  function(\n"
15767             ">>>> text by the vcs\n"
15768             "      parameter,\n"
15769             "==== text by the vcs\n"
15770             "      parameter,\n"
15771             "==== text by the vcs\n"
15772             "      parameter,\n"
15773             "<<<< text by the vcs\n"
15774             "      parameter);\n",
15775             format("void f() {\n"
15776                    "  function(\n"
15777                    ">>>> text by the vcs\n"
15778                    "  parameter,\n"
15779                    "==== text by the vcs\n"
15780                    "  parameter,\n"
15781                    "==== text by the vcs\n"
15782                    "  parameter,\n"
15783                    "<<<< text by the vcs\n"
15784                    "  parameter);\n"));
15785 
15786   EXPECT_EQ("<<<<<<<\n"
15787             "|||||||\n"
15788             "=======\n"
15789             ">>>>>>>",
15790             format("<<<<<<<\n"
15791                    "|||||||\n"
15792                    "=======\n"
15793                    ">>>>>>>"));
15794 
15795   EXPECT_EQ("<<<<<<<\n"
15796             "|||||||\n"
15797             "int i;\n"
15798             "=======\n"
15799             ">>>>>>>",
15800             format("<<<<<<<\n"
15801                    "|||||||\n"
15802                    "int i;\n"
15803                    "=======\n"
15804                    ">>>>>>>"));
15805 
15806   // FIXME: Handle parsing of macros around conflict markers correctly:
15807   EXPECT_EQ("#define Macro \\\n"
15808             "<<<<<<<\n"
15809             "Something \\\n"
15810             "|||||||\n"
15811             "Else \\\n"
15812             "=======\n"
15813             "Other \\\n"
15814             ">>>>>>>\n"
15815             "    End int i;\n",
15816             format("#define Macro \\\n"
15817                    "<<<<<<<\n"
15818                    "  Something \\\n"
15819                    "|||||||\n"
15820                    "  Else \\\n"
15821                    "=======\n"
15822                    "  Other \\\n"
15823                    ">>>>>>>\n"
15824                    "  End\n"
15825                    "int i;\n"));
15826 }
15827 
15828 TEST_F(FormatTest, DisableRegions) {
15829   EXPECT_EQ("int i;\n"
15830             "// clang-format off\n"
15831             "  int j;\n"
15832             "// clang-format on\n"
15833             "int k;",
15834             format(" int  i;\n"
15835                    "   // clang-format off\n"
15836                    "  int j;\n"
15837                    " // clang-format on\n"
15838                    "   int   k;"));
15839   EXPECT_EQ("int i;\n"
15840             "/* clang-format off */\n"
15841             "  int j;\n"
15842             "/* clang-format on */\n"
15843             "int k;",
15844             format(" int  i;\n"
15845                    "   /* clang-format off */\n"
15846                    "  int j;\n"
15847                    " /* clang-format on */\n"
15848                    "   int   k;"));
15849 
15850   // Don't reflow comments within disabled regions.
15851   EXPECT_EQ("// clang-format off\n"
15852             "// long long long long long long line\n"
15853             "/* clang-format on */\n"
15854             "/* long long long\n"
15855             " * long long long\n"
15856             " * line */\n"
15857             "int i;\n"
15858             "/* clang-format off */\n"
15859             "/* long long long long long long line */\n",
15860             format("// clang-format off\n"
15861                    "// long long long long long long line\n"
15862                    "/* clang-format on */\n"
15863                    "/* long long long long long long line */\n"
15864                    "int i;\n"
15865                    "/* clang-format off */\n"
15866                    "/* long long long long long long line */\n",
15867                    getLLVMStyleWithColumns(20)));
15868 }
15869 
15870 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
15871   format("? ) =");
15872   verifyNoCrash("#define a\\\n /**/}");
15873 }
15874 
15875 TEST_F(FormatTest, FormatsTableGenCode) {
15876   FormatStyle Style = getLLVMStyle();
15877   Style.Language = FormatStyle::LK_TableGen;
15878   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
15879 }
15880 
15881 TEST_F(FormatTest, ArrayOfTemplates) {
15882   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
15883             format("auto a = new unique_ptr<int > [ 10];"));
15884 
15885   FormatStyle Spaces = getLLVMStyle();
15886   Spaces.SpacesInSquareBrackets = true;
15887   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
15888             format("auto a = new unique_ptr<int > [10];", Spaces));
15889 }
15890 
15891 TEST_F(FormatTest, ArrayAsTemplateType) {
15892   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
15893             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
15894 
15895   FormatStyle Spaces = getLLVMStyle();
15896   Spaces.SpacesInSquareBrackets = true;
15897   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
15898             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
15899 }
15900 
15901 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
15902 
15903 TEST(FormatStyle, GetStyleWithEmptyFileName) {
15904   llvm::vfs::InMemoryFileSystem FS;
15905   auto Style1 = getStyle("file", "", "Google", "", &FS);
15906   ASSERT_TRUE((bool)Style1);
15907   ASSERT_EQ(*Style1, getGoogleStyle());
15908 }
15909 
15910 TEST(FormatStyle, GetStyleOfFile) {
15911   llvm::vfs::InMemoryFileSystem FS;
15912   // Test 1: format file in the same directory.
15913   ASSERT_TRUE(
15914       FS.addFile("/a/.clang-format", 0,
15915                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
15916   ASSERT_TRUE(
15917       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15918   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
15919   ASSERT_TRUE((bool)Style1);
15920   ASSERT_EQ(*Style1, getLLVMStyle());
15921 
15922   // Test 2.1: fallback to default.
15923   ASSERT_TRUE(
15924       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15925   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
15926   ASSERT_TRUE((bool)Style2);
15927   ASSERT_EQ(*Style2, getMozillaStyle());
15928 
15929   // Test 2.2: no format on 'none' fallback style.
15930   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
15931   ASSERT_TRUE((bool)Style2);
15932   ASSERT_EQ(*Style2, getNoStyle());
15933 
15934   // Test 2.3: format if config is found with no based style while fallback is
15935   // 'none'.
15936   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
15937                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
15938   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
15939   ASSERT_TRUE((bool)Style2);
15940   ASSERT_EQ(*Style2, getLLVMStyle());
15941 
15942   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
15943   Style2 = getStyle("{}", "a.h", "none", "", &FS);
15944   ASSERT_TRUE((bool)Style2);
15945   ASSERT_EQ(*Style2, getLLVMStyle());
15946 
15947   // Test 3: format file in parent directory.
15948   ASSERT_TRUE(
15949       FS.addFile("/c/.clang-format", 0,
15950                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
15951   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
15952                          llvm::MemoryBuffer::getMemBuffer("int i;")));
15953   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
15954   ASSERT_TRUE((bool)Style3);
15955   ASSERT_EQ(*Style3, getGoogleStyle());
15956 
15957   // Test 4: error on invalid fallback style
15958   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
15959   ASSERT_FALSE((bool)Style4);
15960   llvm::consumeError(Style4.takeError());
15961 
15962   // Test 5: error on invalid yaml on command line
15963   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
15964   ASSERT_FALSE((bool)Style5);
15965   llvm::consumeError(Style5.takeError());
15966 
15967   // Test 6: error on invalid style
15968   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
15969   ASSERT_FALSE((bool)Style6);
15970   llvm::consumeError(Style6.takeError());
15971 
15972   // Test 7: found config file, error on parsing it
15973   ASSERT_TRUE(
15974       FS.addFile("/d/.clang-format", 0,
15975                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
15976                                                   "InvalidKey: InvalidValue")));
15977   ASSERT_TRUE(
15978       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15979   auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
15980   ASSERT_FALSE((bool)Style7);
15981   llvm::consumeError(Style7.takeError());
15982 
15983   // Test 8: inferred per-language defaults apply.
15984   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
15985   ASSERT_TRUE((bool)StyleTd);
15986   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
15987 }
15988 
15989 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
15990   // Column limit is 20.
15991   std::string Code = "Type *a =\n"
15992                      "    new Type();\n"
15993                      "g(iiiii, 0, jjjjj,\n"
15994                      "  0, kkkkk, 0, mm);\n"
15995                      "int  bad     = format   ;";
15996   std::string Expected = "auto a = new Type();\n"
15997                          "g(iiiii, nullptr,\n"
15998                          "  jjjjj, nullptr,\n"
15999                          "  kkkkk, nullptr,\n"
16000                          "  mm);\n"
16001                          "int  bad     = format   ;";
16002   FileID ID = Context.createInMemoryFile("format.cpp", Code);
16003   tooling::Replacements Replaces = toReplacements(
16004       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
16005                             "auto "),
16006        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
16007                             "nullptr"),
16008        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
16009                             "nullptr"),
16010        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
16011                             "nullptr")});
16012 
16013   format::FormatStyle Style = format::getLLVMStyle();
16014   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
16015   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16016   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16017       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16018   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16019   EXPECT_TRUE(static_cast<bool>(Result));
16020   EXPECT_EQ(Expected, *Result);
16021 }
16022 
16023 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
16024   std::string Code = "#include \"a.h\"\n"
16025                      "#include \"c.h\"\n"
16026                      "\n"
16027                      "int main() {\n"
16028                      "  return 0;\n"
16029                      "}";
16030   std::string Expected = "#include \"a.h\"\n"
16031                          "#include \"b.h\"\n"
16032                          "#include \"c.h\"\n"
16033                          "\n"
16034                          "int main() {\n"
16035                          "  return 0;\n"
16036                          "}";
16037   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
16038   tooling::Replacements Replaces = toReplacements(
16039       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
16040                             "#include \"b.h\"\n")});
16041 
16042   format::FormatStyle Style = format::getLLVMStyle();
16043   Style.SortIncludes = true;
16044   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16045   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16046       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16047   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16048   EXPECT_TRUE(static_cast<bool>(Result));
16049   EXPECT_EQ(Expected, *Result);
16050 }
16051 
16052 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
16053   EXPECT_EQ("using std::cin;\n"
16054             "using std::cout;",
16055             format("using std::cout;\n"
16056                    "using std::cin;",
16057                    getGoogleStyle()));
16058 }
16059 
16060 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
16061   format::FormatStyle Style = format::getLLVMStyle();
16062   Style.Standard = FormatStyle::LS_Cpp03;
16063   // cpp03 recognize this string as identifier u8 and literal character 'a'
16064   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
16065 }
16066 
16067 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
16068   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
16069   // all modes, including C++11, C++14 and C++17
16070   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
16071 }
16072 
16073 TEST_F(FormatTest, DoNotFormatLikelyXml) {
16074   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
16075   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
16076 }
16077 
16078 TEST_F(FormatTest, StructuredBindings) {
16079   // Structured bindings is a C++17 feature.
16080   // all modes, including C++11, C++14 and C++17
16081   verifyFormat("auto [a, b] = f();");
16082   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
16083   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
16084   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
16085   EXPECT_EQ("auto const volatile [a, b] = f();",
16086             format("auto  const   volatile[a, b] = f();"));
16087   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
16088   EXPECT_EQ("auto &[a, b, c] = f();",
16089             format("auto   &[  a  ,  b,c   ] = f();"));
16090   EXPECT_EQ("auto &&[a, b, c] = f();",
16091             format("auto   &&[  a  ,  b,c   ] = f();"));
16092   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
16093   EXPECT_EQ("auto const volatile &&[a, b] = f();",
16094             format("auto  const  volatile  &&[a, b] = f();"));
16095   EXPECT_EQ("auto const &&[a, b] = f();",
16096             format("auto  const   &&  [a, b] = f();"));
16097   EXPECT_EQ("const auto &[a, b] = f();",
16098             format("const  auto  &  [a, b] = f();"));
16099   EXPECT_EQ("const auto volatile &&[a, b] = f();",
16100             format("const  auto   volatile  &&[a, b] = f();"));
16101   EXPECT_EQ("volatile const auto &&[a, b] = f();",
16102             format("volatile  const  auto   &&[a, b] = f();"));
16103   EXPECT_EQ("const auto &&[a, b] = f();",
16104             format("const  auto  &&  [a, b] = f();"));
16105 
16106   // Make sure we don't mistake structured bindings for lambdas.
16107   FormatStyle PointerMiddle = getLLVMStyle();
16108   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16109   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16110   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16111   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16112   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16113   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16114   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16115   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16116   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16117   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16118   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16119   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16120   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16121 
16122   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16123             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16124   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16125             format("for (const auto   &   [a, b] : some_range) {\n}"));
16126   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16127             format("for (const auto[a, b] : some_range) {\n}"));
16128   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16129   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16130   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16131   EXPECT_EQ("auto const &[x, y](expr);",
16132             format("auto  const  &  [x,y]  (expr);"));
16133   EXPECT_EQ("auto const &&[x, y](expr);",
16134             format("auto  const  &&  [x,y]  (expr);"));
16135   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16136   EXPECT_EQ("auto const &[x, y]{expr};",
16137             format("auto  const  &  [x,y]  {expr};"));
16138   EXPECT_EQ("auto const &&[x, y]{expr};",
16139             format("auto  const  &&  [x,y]  {expr};"));
16140 
16141   format::FormatStyle Spaces = format::getLLVMStyle();
16142   Spaces.SpacesInSquareBrackets = true;
16143   verifyFormat("auto [ a, b ] = f();", Spaces);
16144   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16145   verifyFormat("auto &[ a, b ] = f();", Spaces);
16146   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16147   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16148 }
16149 
16150 TEST_F(FormatTest, FileAndCode) {
16151   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16152   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16153   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16154   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16155   EXPECT_EQ(FormatStyle::LK_ObjC,
16156             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16157   EXPECT_EQ(
16158       FormatStyle::LK_ObjC,
16159       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16160   EXPECT_EQ(FormatStyle::LK_ObjC,
16161             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16162   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16163   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16164   EXPECT_EQ(FormatStyle::LK_ObjC,
16165             guessLanguage("foo", "@interface Foo\n@end\n"));
16166   EXPECT_EQ(FormatStyle::LK_ObjC,
16167             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16168   EXPECT_EQ(
16169       FormatStyle::LK_ObjC,
16170       guessLanguage("foo.h",
16171                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16172   EXPECT_EQ(
16173       FormatStyle::LK_Cpp,
16174       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16175 }
16176 
16177 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16178   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16179   EXPECT_EQ(FormatStyle::LK_ObjC,
16180             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16181   EXPECT_EQ(FormatStyle::LK_Cpp,
16182             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16183   EXPECT_EQ(
16184       FormatStyle::LK_Cpp,
16185       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16186   EXPECT_EQ(FormatStyle::LK_ObjC,
16187             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16188   EXPECT_EQ(FormatStyle::LK_Cpp,
16189             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16190   EXPECT_EQ(FormatStyle::LK_ObjC,
16191             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16192   EXPECT_EQ(FormatStyle::LK_Cpp,
16193             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16194   EXPECT_EQ(FormatStyle::LK_Cpp,
16195             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16196   EXPECT_EQ(FormatStyle::LK_ObjC,
16197             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16198   EXPECT_EQ(FormatStyle::LK_Cpp,
16199             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16200   EXPECT_EQ(
16201       FormatStyle::LK_Cpp,
16202       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16203   EXPECT_EQ(
16204       FormatStyle::LK_Cpp,
16205       guessLanguage("foo.h",
16206                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16207   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16208 }
16209 
16210 TEST_F(FormatTest, GuessLanguageWithCaret) {
16211   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16212   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16213   EXPECT_EQ(FormatStyle::LK_ObjC,
16214             guessLanguage("foo.h", "int(^)(char, float);"));
16215   EXPECT_EQ(FormatStyle::LK_ObjC,
16216             guessLanguage("foo.h", "int(^foo)(char, float);"));
16217   EXPECT_EQ(FormatStyle::LK_ObjC,
16218             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16219   EXPECT_EQ(FormatStyle::LK_ObjC,
16220             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16221   EXPECT_EQ(
16222       FormatStyle::LK_ObjC,
16223       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16224 }
16225 
16226 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16227   // ASM symbolic names are identifiers that must be surrounded by [] without
16228   // space in between:
16229   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16230 
16231   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16232   verifyFormat(R"(//
16233 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16234 )");
16235 
16236   // A list of several ASM symbolic names.
16237   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16238 
16239   // ASM symbolic names in inline ASM with inputs and outputs.
16240   verifyFormat(R"(//
16241 asm("cmoveq %1, %2, %[result]"
16242     : [result] "=r"(result)
16243     : "r"(test), "r"(new), "[result]"(old));
16244 )");
16245 
16246   // ASM symbolic names in inline ASM with no outputs.
16247   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16248 }
16249 
16250 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
16251   EXPECT_EQ(FormatStyle::LK_Cpp,
16252             guessLanguage("foo.h", "void f() {\n"
16253                                    "  asm (\"mov %[e], %[d]\"\n"
16254                                    "     : [d] \"=rm\" (d)\n"
16255                                    "       [e] \"rm\" (*e));\n"
16256                                    "}"));
16257   EXPECT_EQ(FormatStyle::LK_Cpp,
16258             guessLanguage("foo.h", "void f() {\n"
16259                                    "  _asm (\"mov %[e], %[d]\"\n"
16260                                    "     : [d] \"=rm\" (d)\n"
16261                                    "       [e] \"rm\" (*e));\n"
16262                                    "}"));
16263   EXPECT_EQ(FormatStyle::LK_Cpp,
16264             guessLanguage("foo.h", "void f() {\n"
16265                                    "  __asm (\"mov %[e], %[d]\"\n"
16266                                    "     : [d] \"=rm\" (d)\n"
16267                                    "       [e] \"rm\" (*e));\n"
16268                                    "}"));
16269   EXPECT_EQ(FormatStyle::LK_Cpp,
16270             guessLanguage("foo.h", "void f() {\n"
16271                                    "  __asm__ (\"mov %[e], %[d]\"\n"
16272                                    "     : [d] \"=rm\" (d)\n"
16273                                    "       [e] \"rm\" (*e));\n"
16274                                    "}"));
16275   EXPECT_EQ(FormatStyle::LK_Cpp,
16276             guessLanguage("foo.h", "void f() {\n"
16277                                    "  asm (\"mov %[e], %[d]\"\n"
16278                                    "     : [d] \"=rm\" (d),\n"
16279                                    "       [e] \"rm\" (*e));\n"
16280                                    "}"));
16281   EXPECT_EQ(FormatStyle::LK_Cpp,
16282             guessLanguage("foo.h", "void f() {\n"
16283                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16284                                    "     : [d] \"=rm\" (d)\n"
16285                                    "       [e] \"rm\" (*e));\n"
16286                                    "}"));
16287 }
16288 
16289 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16290   EXPECT_EQ(FormatStyle::LK_Cpp,
16291             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16292   EXPECT_EQ(FormatStyle::LK_ObjC,
16293             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16294   EXPECT_EQ(
16295       FormatStyle::LK_Cpp,
16296       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16297   EXPECT_EQ(
16298       FormatStyle::LK_ObjC,
16299       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16300 }
16301 
16302 TEST_F(FormatTest, TypenameMacros) {
16303   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16304 
16305   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16306   FormatStyle Google = getGoogleStyleWithColumns(0);
16307   Google.TypenameMacros = TypenameMacros;
16308   verifyFormat("struct foo {\n"
16309                "  int bar;\n"
16310                "  TAILQ_ENTRY(a) bleh;\n"
16311                "};",
16312                Google);
16313 
16314   FormatStyle Macros = getLLVMStyle();
16315   Macros.TypenameMacros = TypenameMacros;
16316 
16317   verifyFormat("STACK_OF(int) a;", Macros);
16318   verifyFormat("STACK_OF(int) *a;", Macros);
16319   verifyFormat("STACK_OF(int const *) *a;", Macros);
16320   verifyFormat("STACK_OF(int *const) *a;", Macros);
16321   verifyFormat("STACK_OF(int, string) a;", Macros);
16322   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16323   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16324   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16325   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16326 
16327   Macros.PointerAlignment = FormatStyle::PAS_Left;
16328   verifyFormat("STACK_OF(int)* a;", Macros);
16329   verifyFormat("STACK_OF(int*)* a;", Macros);
16330 }
16331 
16332 TEST_F(FormatTest, AmbersandInLamda) {
16333   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16334   FormatStyle AlignStyle = getLLVMStyle();
16335   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16336   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16337   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16338   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16339 }
16340 
16341 TEST_F(FormatTest, SpacesInConditionalStatement) {
16342   FormatStyle Spaces = getLLVMStyle();
16343   Spaces.SpacesInConditionalStatement = true;
16344   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16345   verifyFormat("if ( !a )\n  return;", Spaces);
16346   verifyFormat("if ( a )\n  return;", Spaces);
16347   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16348   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16349   verifyFormat("while ( a )\n  return;", Spaces);
16350   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16351   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16352   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16353   // Check that space on the left of "::" is inserted as expected at beginning
16354   // of condition.
16355   verifyFormat("while ( ::func() )\n  return;", Spaces);
16356 }
16357 
16358 TEST_F(FormatTest, AlternativeOperators) {
16359   // Test case for ensuring alternate operators are not
16360   // combined with their right most neighbour.
16361   verifyFormat("int a and b;");
16362   verifyFormat("int a and_eq b;");
16363   verifyFormat("int a bitand b;");
16364   verifyFormat("int a bitor b;");
16365   verifyFormat("int a compl b;");
16366   verifyFormat("int a not b;");
16367   verifyFormat("int a not_eq b;");
16368   verifyFormat("int a or b;");
16369   verifyFormat("int a xor b;");
16370   verifyFormat("int a xor_eq b;");
16371   verifyFormat("return this not_eq bitand other;");
16372   verifyFormat("bool operator not_eq(const X bitand other)");
16373 
16374   verifyFormat("int a and 5;");
16375   verifyFormat("int a and_eq 5;");
16376   verifyFormat("int a bitand 5;");
16377   verifyFormat("int a bitor 5;");
16378   verifyFormat("int a compl 5;");
16379   verifyFormat("int a not 5;");
16380   verifyFormat("int a not_eq 5;");
16381   verifyFormat("int a or 5;");
16382   verifyFormat("int a xor 5;");
16383   verifyFormat("int a xor_eq 5;");
16384 
16385   verifyFormat("int a compl(5);");
16386   verifyFormat("int a not(5);");
16387 
16388   /* FIXME handle alternate tokens
16389    * https://en.cppreference.com/w/cpp/language/operator_alternative
16390   // alternative tokens
16391   verifyFormat("compl foo();");     //  ~foo();
16392   verifyFormat("foo() <%%>;");      // foo();
16393   verifyFormat("void foo() <%%>;"); // void foo(){}
16394   verifyFormat("int a <:1:>;");     // int a[1];[
16395   verifyFormat("%:define ABC abc"); // #define ABC abc
16396   verifyFormat("%:%:");             // ##
16397   */
16398 }
16399 
16400 TEST_F(FormatTest, STLWhileNotDefineChed) {
16401   verifyFormat("#if defined(while)\n"
16402                "#define while EMIT WARNING C4005\n"
16403                "#endif // while");
16404 }
16405 
16406 TEST_F(FormatTest, OperatorSpacing) {
16407   FormatStyle Style = getLLVMStyle();
16408   Style.PointerAlignment = FormatStyle::PAS_Right;
16409   verifyFormat("Foo::operator*();", Style);
16410   verifyFormat("Foo::operator void *();", Style);
16411   verifyFormat("Foo::operator void **();", Style);
16412   verifyFormat("Foo::operator void *&();", Style);
16413   verifyFormat("Foo::operator void *&&();", Style);
16414   verifyFormat("Foo::operator()(void *);", Style);
16415   verifyFormat("Foo::operator*(void *);", Style);
16416   verifyFormat("Foo::operator*();", Style);
16417   verifyFormat("Foo::operator**();", Style);
16418   verifyFormat("Foo::operator&();", Style);
16419   verifyFormat("Foo::operator<int> *();", Style);
16420   verifyFormat("Foo::operator<Foo> *();", Style);
16421   verifyFormat("Foo::operator<int> **();", Style);
16422   verifyFormat("Foo::operator<Foo> **();", Style);
16423   verifyFormat("Foo::operator<int> &();", Style);
16424   verifyFormat("Foo::operator<Foo> &();", Style);
16425   verifyFormat("Foo::operator<int> &&();", Style);
16426   verifyFormat("Foo::operator<Foo> &&();", Style);
16427   verifyFormat("Foo::operator<int> *&();", Style);
16428   verifyFormat("Foo::operator<Foo> *&();", Style);
16429   verifyFormat("Foo::operator<int> *&&();", Style);
16430   verifyFormat("Foo::operator<Foo> *&&();", Style);
16431   verifyFormat("operator*(int (*)(), class Foo);", Style);
16432 
16433   verifyFormat("Foo::operator&();", Style);
16434   verifyFormat("Foo::operator void &();", Style);
16435   verifyFormat("Foo::operator()(void &);", Style);
16436   verifyFormat("Foo::operator&(void &);", Style);
16437   verifyFormat("Foo::operator&();", Style);
16438   verifyFormat("operator&(int (&)(), class Foo);", Style);
16439 
16440   verifyFormat("Foo::operator&&();", Style);
16441   verifyFormat("Foo::operator**();", Style);
16442   verifyFormat("Foo::operator void &&();", Style);
16443   verifyFormat("Foo::operator()(void &&);", Style);
16444   verifyFormat("Foo::operator&&(void &&);", Style);
16445   verifyFormat("Foo::operator&&();", Style);
16446   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16447   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16448   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16449                Style);
16450   verifyFormat("operator void **()", Style);
16451   verifyFormat("operator const FooRight<Object> &()", Style);
16452   verifyFormat("operator const FooRight<Object> *()", Style);
16453   verifyFormat("operator const FooRight<Object> **()", Style);
16454   verifyFormat("operator const FooRight<Object> *&()", Style);
16455   verifyFormat("operator const FooRight<Object> *&&()", Style);
16456 
16457   Style.PointerAlignment = FormatStyle::PAS_Left;
16458   verifyFormat("Foo::operator*();", Style);
16459   verifyFormat("Foo::operator**();", Style);
16460   verifyFormat("Foo::operator void*();", Style);
16461   verifyFormat("Foo::operator void**();", Style);
16462   verifyFormat("Foo::operator void*&();", Style);
16463   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16464   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16465   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16466   verifyFormat("Foo::operator()(void*);", Style);
16467   verifyFormat("Foo::operator*(void*);", Style);
16468   verifyFormat("Foo::operator*();", Style);
16469   verifyFormat("Foo::operator<int>*();", Style);
16470   verifyFormat("Foo::operator<Foo>*();", Style);
16471   verifyFormat("Foo::operator<int>**();", Style);
16472   verifyFormat("Foo::operator<Foo>**();", Style);
16473   verifyFormat("Foo::operator<Foo>*&();", Style);
16474   verifyFormat("Foo::operator<int>&();", Style);
16475   verifyFormat("Foo::operator<Foo>&();", Style);
16476   verifyFormat("Foo::operator<int>&&();", Style);
16477   verifyFormat("Foo::operator<Foo>&&();", Style);
16478   verifyFormat("Foo::operator<int>*&();", Style);
16479   verifyFormat("Foo::operator<Foo>*&();", Style);
16480   verifyFormat("operator*(int (*)(), class Foo);", Style);
16481 
16482   verifyFormat("Foo::operator&();", Style);
16483   verifyFormat("Foo::operator void&();", Style);
16484   verifyFormat("Foo::operator/*comment*/ void&();", Style);
16485   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
16486   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
16487   verifyFormat("Foo::operator()(void&);", Style);
16488   verifyFormat("Foo::operator&(void&);", Style);
16489   verifyFormat("Foo::operator&();", Style);
16490   verifyFormat("operator&(int (&)(), class Foo);", Style);
16491 
16492   verifyFormat("Foo::operator&&();", Style);
16493   verifyFormat("Foo::operator void&&();", Style);
16494   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
16495   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
16496   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
16497   verifyFormat("Foo::operator()(void&&);", Style);
16498   verifyFormat("Foo::operator&&(void&&);", Style);
16499   verifyFormat("Foo::operator&&();", Style);
16500   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16501   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
16502   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
16503                Style);
16504   verifyFormat("operator void**()", Style);
16505   verifyFormat("operator const FooLeft<Object>&()", Style);
16506   verifyFormat("operator const FooLeft<Object>*()", Style);
16507   verifyFormat("operator const FooLeft<Object>**()", Style);
16508   verifyFormat("operator const FooLeft<Object>*&()", Style);
16509   verifyFormat("operator const FooLeft<Object>*&&()", Style);
16510 
16511   // PR45107
16512   verifyFormat("operator Vector<String>&();", Style);
16513   verifyFormat("operator const Vector<String>&();", Style);
16514   verifyFormat("operator foo::Bar*();", Style);
16515   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
16516   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
16517                Style);
16518 
16519   Style.PointerAlignment = FormatStyle::PAS_Middle;
16520   verifyFormat("Foo::operator*();", Style);
16521   verifyFormat("Foo::operator void *();", Style);
16522   verifyFormat("Foo::operator()(void *);", Style);
16523   verifyFormat("Foo::operator*(void *);", Style);
16524   verifyFormat("Foo::operator*();", Style);
16525   verifyFormat("operator*(int (*)(), class Foo);", Style);
16526 
16527   verifyFormat("Foo::operator&();", Style);
16528   verifyFormat("Foo::operator void &();", Style);
16529   verifyFormat("Foo::operator()(void &);", Style);
16530   verifyFormat("Foo::operator&(void &);", Style);
16531   verifyFormat("Foo::operator&();", Style);
16532   verifyFormat("operator&(int (&)(), class Foo);", Style);
16533 
16534   verifyFormat("Foo::operator&&();", Style);
16535   verifyFormat("Foo::operator void &&();", Style);
16536   verifyFormat("Foo::operator()(void &&);", Style);
16537   verifyFormat("Foo::operator&&(void &&);", Style);
16538   verifyFormat("Foo::operator&&();", Style);
16539   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16540 }
16541 
16542 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
16543   FormatStyle Style = getLLVMStyle();
16544   // PR46157
16545   verifyFormat("foo(operator+, -42);", Style);
16546   verifyFormat("foo(operator++, -42);", Style);
16547   verifyFormat("foo(operator--, -42);", Style);
16548   verifyFormat("foo(-42, operator--);", Style);
16549   verifyFormat("foo(-42, operator, );", Style);
16550   verifyFormat("foo(operator, , -42);", Style);
16551 }
16552 
16553 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
16554   FormatStyle Style = getLLVMStyle();
16555   Style.WhitespaceSensitiveMacros.push_back("FOO");
16556 
16557   // Don't use the helpers here, since 'mess up' will change the whitespace
16558   // and these are all whitespace sensitive by definition
16559   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
16560             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
16561   EXPECT_EQ(
16562       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
16563       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
16564   EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
16565             format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
16566   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
16567             "       Still=Intentional);",
16568             format("FOO(String-ized&Messy+But,: :\n"
16569                    "       Still=Intentional);",
16570                    Style));
16571   Style.AlignConsecutiveAssignments = true;
16572   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
16573             "       Still=Intentional);",
16574             format("FOO(String-ized=&Messy+But,: :\n"
16575                    "       Still=Intentional);",
16576                    Style));
16577 
16578   Style.ColumnLimit = 21;
16579   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
16580             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
16581 }
16582 
16583 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
16584   // These tests are not in NamespaceFixer because that doesn't
16585   // test its interaction with line wrapping
16586   FormatStyle Style = getLLVMStyle();
16587   Style.ColumnLimit = 80;
16588   verifyFormat("namespace {\n"
16589                "int i;\n"
16590                "int j;\n"
16591                "} // namespace",
16592                Style);
16593 
16594   verifyFormat("namespace AAA {\n"
16595                "int i;\n"
16596                "int j;\n"
16597                "} // namespace AAA",
16598                Style);
16599 
16600   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
16601             "int i;\n"
16602             "int j;\n"
16603             "} // namespace Averyveryveryverylongnamespace",
16604             format("namespace Averyveryveryverylongnamespace {\n"
16605                    "int i;\n"
16606                    "int j;\n"
16607                    "}",
16608                    Style));
16609 
16610   EXPECT_EQ(
16611       "namespace "
16612       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16613       "    went::mad::now {\n"
16614       "int i;\n"
16615       "int j;\n"
16616       "} // namespace\n"
16617       "  // "
16618       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16619       "went::mad::now",
16620       format("namespace "
16621              "would::it::save::you::a::lot::of::time::if_::i::"
16622              "just::gave::up::and_::went::mad::now {\n"
16623              "int i;\n"
16624              "int j;\n"
16625              "}",
16626              Style));
16627 
16628   // This used to duplicate the comment again and again on subsequent runs
16629   EXPECT_EQ(
16630       "namespace "
16631       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16632       "    went::mad::now {\n"
16633       "int i;\n"
16634       "int j;\n"
16635       "} // namespace\n"
16636       "  // "
16637       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16638       "went::mad::now",
16639       format("namespace "
16640              "would::it::save::you::a::lot::of::time::if_::i::"
16641              "just::gave::up::and_::went::mad::now {\n"
16642              "int i;\n"
16643              "int j;\n"
16644              "} // namespace\n"
16645              "  // "
16646              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
16647              "and_::went::mad::now",
16648              Style));
16649 }
16650 
16651 TEST_F(FormatTest, LikelyUnlikely) {
16652   FormatStyle Style = getLLVMStyle();
16653 
16654   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16655                "  return 29;\n"
16656                "}",
16657                Style);
16658 
16659   verifyFormat("if (argc > 5) [[likely]] {\n"
16660                "  return 29;\n"
16661                "}",
16662                Style);
16663 
16664   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16665                "  return 29;\n"
16666                "} else [[likely]] {\n"
16667                "  return 42;\n"
16668                "}\n",
16669                Style);
16670 
16671   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16672                "  return 29;\n"
16673                "} else if (argc > 10) [[likely]] {\n"
16674                "  return 99;\n"
16675                "} else {\n"
16676                "  return 42;\n"
16677                "}\n",
16678                Style);
16679 
16680   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
16681                "  return 29;\n"
16682                "}",
16683                Style);
16684 }
16685 
16686 TEST_F(FormatTest, LLVMDefaultStyle) {
16687   FormatStyle Style = getLLVMStyle();
16688   verifyFormat("extern \"C\" {\n"
16689                "int foo();\n"
16690                "}",
16691                Style);
16692 }
16693 TEST_F(FormatTest, GNUDefaultStyle) {
16694   FormatStyle Style = getGNUStyle();
16695   verifyFormat("extern \"C\"\n"
16696                "{\n"
16697                "  int foo ();\n"
16698                "}",
16699                Style);
16700 }
16701 TEST_F(FormatTest, MozillaDefaultStyle) {
16702   FormatStyle Style = getMozillaStyle();
16703   verifyFormat("extern \"C\"\n"
16704                "{\n"
16705                "  int foo();\n"
16706                "}",
16707                Style);
16708 }
16709 TEST_F(FormatTest, GoogleDefaultStyle) {
16710   FormatStyle Style = getGoogleStyle();
16711   verifyFormat("extern \"C\" {\n"
16712                "int foo();\n"
16713                "}",
16714                Style);
16715 }
16716 TEST_F(FormatTest, ChromiumDefaultStyle) {
16717   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
16718   verifyFormat("extern \"C\" {\n"
16719                "int foo();\n"
16720                "}",
16721                Style);
16722 }
16723 TEST_F(FormatTest, MicrosoftDefaultStyle) {
16724   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
16725   verifyFormat("extern \"C\"\n"
16726                "{\n"
16727                "    int foo();\n"
16728                "}",
16729                Style);
16730 }
16731 TEST_F(FormatTest, WebKitDefaultStyle) {
16732   FormatStyle Style = getWebKitStyle();
16733   verifyFormat("extern \"C\" {\n"
16734                "int foo();\n"
16735                "}",
16736                Style);
16737 }
16738 } // namespace
16739 } // namespace format
16740 } // namespace clang
16741