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   verifyFormat("int printf(const char *fmt, ...);");
8183   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8184   verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
8185 
8186   FormatStyle PointersLeft = getLLVMStyle();
8187   PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
8188   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
8189 }
8190 
8191 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8192   EXPECT_EQ("int *a;\n"
8193             "int *a;\n"
8194             "int *a;",
8195             format("int *a;\n"
8196                    "int* a;\n"
8197                    "int *a;",
8198                    getGoogleStyle()));
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("auto x = [] {\n"
8214             "  int *a;\n"
8215             "  int *a;\n"
8216             "  int *a;\n"
8217             "};",
8218             format("auto x=[]{int *a;\n"
8219                    "int * a;\n"
8220                    "int *  a;};",
8221                    getGoogleStyle()));
8222 }
8223 
8224 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8225   verifyFormat("int f(int &&a) {}");
8226   verifyFormat("int f(int a, char &&b) {}");
8227   verifyFormat("void f() { int &&a = b; }");
8228   verifyGoogleFormat("int f(int a, char&& b) {}");
8229   verifyGoogleFormat("void f() { int&& a = b; }");
8230 
8231   verifyIndependentOfContext("A<int &&> a;");
8232   verifyIndependentOfContext("A<int &&, int &&> a;");
8233   verifyGoogleFormat("A<int&&> a;");
8234   verifyGoogleFormat("A<int&&, int&&> a;");
8235 
8236   // Not rvalue references:
8237   verifyFormat("template <bool B, bool C> class A {\n"
8238                "  static_assert(B && C, \"Something is wrong\");\n"
8239                "};");
8240   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8241   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8242   verifyFormat("#define A(a, b) (a && b)");
8243 }
8244 
8245 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8246   verifyFormat("void f() {\n"
8247                "  x[aaaaaaaaa -\n"
8248                "    b] = 23;\n"
8249                "}",
8250                getLLVMStyleWithColumns(15));
8251 }
8252 
8253 TEST_F(FormatTest, FormatsCasts) {
8254   verifyFormat("Type *A = static_cast<Type *>(P);");
8255   verifyFormat("Type *A = (Type *)P;");
8256   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8257   verifyFormat("int a = (int)(2.0f);");
8258   verifyFormat("int a = (int)2.0f;");
8259   verifyFormat("x[(int32)y];");
8260   verifyFormat("x = (int32)y;");
8261   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8262   verifyFormat("int a = (int)*b;");
8263   verifyFormat("int a = (int)2.0f;");
8264   verifyFormat("int a = (int)~0;");
8265   verifyFormat("int a = (int)++a;");
8266   verifyFormat("int a = (int)sizeof(int);");
8267   verifyFormat("int a = (int)+2;");
8268   verifyFormat("my_int a = (my_int)2.0f;");
8269   verifyFormat("my_int a = (my_int)sizeof(int);");
8270   verifyFormat("return (my_int)aaa;");
8271   verifyFormat("#define x ((int)-1)");
8272   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8273   verifyFormat("#define p(q) ((int *)&q)");
8274   verifyFormat("fn(a)(b) + 1;");
8275 
8276   verifyFormat("void f() { my_int a = (my_int)*b; }");
8277   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8278   verifyFormat("my_int a = (my_int)~0;");
8279   verifyFormat("my_int a = (my_int)++a;");
8280   verifyFormat("my_int a = (my_int)-2;");
8281   verifyFormat("my_int a = (my_int)1;");
8282   verifyFormat("my_int a = (my_int *)1;");
8283   verifyFormat("my_int a = (const my_int)-1;");
8284   verifyFormat("my_int a = (const my_int *)-1;");
8285   verifyFormat("my_int a = (my_int)(my_int)-1;");
8286   verifyFormat("my_int a = (ns::my_int)-2;");
8287   verifyFormat("case (my_int)ONE:");
8288   verifyFormat("auto x = (X)this;");
8289   // Casts in Obj-C style calls used to not be recognized as such.
8290   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8291 
8292   // FIXME: single value wrapped with paren will be treated as cast.
8293   verifyFormat("void f(int i = (kValue)*kMask) {}");
8294 
8295   verifyFormat("{ (void)F; }");
8296 
8297   // Don't break after a cast's
8298   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8299                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8300                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8301 
8302   // These are not casts.
8303   verifyFormat("void f(int *) {}");
8304   verifyFormat("f(foo)->b;");
8305   verifyFormat("f(foo).b;");
8306   verifyFormat("f(foo)(b);");
8307   verifyFormat("f(foo)[b];");
8308   verifyFormat("[](foo) { return 4; }(bar);");
8309   verifyFormat("(*funptr)(foo)[4];");
8310   verifyFormat("funptrs[4](foo)[4];");
8311   verifyFormat("void f(int *);");
8312   verifyFormat("void f(int *) = 0;");
8313   verifyFormat("void f(SmallVector<int>) {}");
8314   verifyFormat("void f(SmallVector<int>);");
8315   verifyFormat("void f(SmallVector<int>) = 0;");
8316   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8317   verifyFormat("int a = sizeof(int) * b;");
8318   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8319   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8320   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8321   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8322 
8323   // These are not casts, but at some point were confused with casts.
8324   verifyFormat("virtual void foo(int *) override;");
8325   verifyFormat("virtual void foo(char &) const;");
8326   verifyFormat("virtual void foo(int *a, char *) const;");
8327   verifyFormat("int a = sizeof(int *) + b;");
8328   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8329   verifyFormat("bool b = f(g<int>) && c;");
8330   verifyFormat("typedef void (*f)(int i) func;");
8331   verifyFormat("void operator++(int) noexcept;");
8332   verifyFormat("void operator++(int &) noexcept;");
8333   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8334                "&) noexcept;");
8335   verifyFormat(
8336       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8337   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8338   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8339   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8340   verifyFormat("void operator delete(foo &) noexcept;");
8341   verifyFormat("void operator delete(foo) noexcept;");
8342   verifyFormat("void operator delete(int) noexcept;");
8343   verifyFormat("void operator delete(int &) noexcept;");
8344   verifyFormat("void operator delete(int &) volatile noexcept;");
8345   verifyFormat("void operator delete(int &) const");
8346   verifyFormat("void operator delete(int &) = default");
8347   verifyFormat("void operator delete(int &) = delete");
8348   verifyFormat("void operator delete(int &) [[noreturn]]");
8349   verifyFormat("void operator delete(int &) throw();");
8350   verifyFormat("void operator delete(int &) throw(int);");
8351   verifyFormat("auto operator delete(int &) -> int;");
8352   verifyFormat("auto operator delete(int &) override");
8353   verifyFormat("auto operator delete(int &) final");
8354 
8355   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8356                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8357   // FIXME: The indentation here is not ideal.
8358   verifyFormat(
8359       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8360       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8361       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8362 }
8363 
8364 TEST_F(FormatTest, FormatsFunctionTypes) {
8365   verifyFormat("A<bool()> a;");
8366   verifyFormat("A<SomeType()> a;");
8367   verifyFormat("A<void (*)(int, std::string)> a;");
8368   verifyFormat("A<void *(int)>;");
8369   verifyFormat("void *(*a)(int *, SomeType *);");
8370   verifyFormat("int (*func)(void *);");
8371   verifyFormat("void f() { int (*func)(void *); }");
8372   verifyFormat("template <class CallbackClass>\n"
8373                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8374 
8375   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8376   verifyGoogleFormat("void* (*a)(int);");
8377   verifyGoogleFormat(
8378       "template <class CallbackClass>\n"
8379       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8380 
8381   // Other constructs can look somewhat like function types:
8382   verifyFormat("A<sizeof(*x)> a;");
8383   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8384   verifyFormat("some_var = function(*some_pointer_var)[0];");
8385   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8386   verifyFormat("int x = f(&h)();");
8387   verifyFormat("returnsFunction(&param1, &param2)(param);");
8388   verifyFormat("std::function<\n"
8389                "    LooooooooooongTemplatedType<\n"
8390                "        SomeType>*(\n"
8391                "        LooooooooooooooooongType type)>\n"
8392                "    function;",
8393                getGoogleStyleWithColumns(40));
8394 }
8395 
8396 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8397   verifyFormat("A (*foo_)[6];");
8398   verifyFormat("vector<int> (*foo_)[6];");
8399 }
8400 
8401 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8402   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8403                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8404   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8405                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8406   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8407                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8408 
8409   // Different ways of ()-initializiation.
8410   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8411                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8412   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8413                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8414   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8415                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8416   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8417                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8418 
8419   // Lambdas should not confuse the variable declaration heuristic.
8420   verifyFormat("LooooooooooooooooongType\n"
8421                "    variable(nullptr, [](A *a) {});",
8422                getLLVMStyleWithColumns(40));
8423 }
8424 
8425 TEST_F(FormatTest, BreaksLongDeclarations) {
8426   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8427                "    AnotherNameForTheLongType;");
8428   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8429                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8430   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8431                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8432   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8433                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8434   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8435                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8436   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8437                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8438   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8439                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8440   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8441                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8442   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8443                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8444   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8445                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8446   FormatStyle Indented = getLLVMStyle();
8447   Indented.IndentWrappedFunctionNames = true;
8448   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8449                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8450                Indented);
8451   verifyFormat(
8452       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8453       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8454       Indented);
8455   verifyFormat(
8456       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8457       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8458       Indented);
8459   verifyFormat(
8460       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8461       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8462       Indented);
8463 
8464   // FIXME: Without the comment, this breaks after "(".
8465   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8466                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8467                getGoogleStyle());
8468 
8469   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8470                "                  int LoooooooooooooooooooongParam2) {}");
8471   verifyFormat(
8472       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8473       "                                   SourceLocation L, IdentifierIn *II,\n"
8474       "                                   Type *T) {}");
8475   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8476                "ReallyReaaallyLongFunctionName(\n"
8477                "    const std::string &SomeParameter,\n"
8478                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8479                "        &ReallyReallyLongParameterName,\n"
8480                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8481                "        &AnotherLongParameterName) {}");
8482   verifyFormat("template <typename A>\n"
8483                "SomeLoooooooooooooooooooooongType<\n"
8484                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8485                "Function() {}");
8486 
8487   verifyGoogleFormat(
8488       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8489       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8490   verifyGoogleFormat(
8491       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8492       "                                   SourceLocation L) {}");
8493   verifyGoogleFormat(
8494       "some_namespace::LongReturnType\n"
8495       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8496       "    int first_long_parameter, int second_parameter) {}");
8497 
8498   verifyGoogleFormat("template <typename T>\n"
8499                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8500                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8501   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8502                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8503 
8504   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8505                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8506                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8507   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8508                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8509                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8510   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8511                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8512                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8513                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8514 
8515   verifyFormat("template <typename T> // Templates on own line.\n"
8516                "static int            // Some comment.\n"
8517                "MyFunction(int a);",
8518                getLLVMStyle());
8519 }
8520 
8521 TEST_F(FormatTest, FormatsArrays) {
8522   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8523                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8524   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8525                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8526   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8527                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8528   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8529                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8530   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8531                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8532   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8533                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8534                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8535   verifyFormat(
8536       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8537       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8538       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8539   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8540                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8541 
8542   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8543                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8544   verifyFormat(
8545       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8546       "                                  .aaaaaaa[0]\n"
8547       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8548   verifyFormat("a[::b::c];");
8549 
8550   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8551 
8552   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8553   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8554 }
8555 
8556 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8557   verifyFormat("(a)->b();");
8558   verifyFormat("--a;");
8559 }
8560 
8561 TEST_F(FormatTest, HandlesIncludeDirectives) {
8562   verifyFormat("#include <string>\n"
8563                "#include <a/b/c.h>\n"
8564                "#include \"a/b/string\"\n"
8565                "#include \"string.h\"\n"
8566                "#include \"string.h\"\n"
8567                "#include <a-a>\n"
8568                "#include < path with space >\n"
8569                "#include_next <test.h>"
8570                "#include \"abc.h\" // this is included for ABC\n"
8571                "#include \"some long include\" // with a comment\n"
8572                "#include \"some very long include path\"\n"
8573                "#include <some/very/long/include/path>\n",
8574                getLLVMStyleWithColumns(35));
8575   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8576   EXPECT_EQ("#include <a>", format("#include<a>"));
8577 
8578   verifyFormat("#import <string>");
8579   verifyFormat("#import <a/b/c.h>");
8580   verifyFormat("#import \"a/b/string\"");
8581   verifyFormat("#import \"string.h\"");
8582   verifyFormat("#import \"string.h\"");
8583   verifyFormat("#if __has_include(<strstream>)\n"
8584                "#include <strstream>\n"
8585                "#endif");
8586 
8587   verifyFormat("#define MY_IMPORT <a/b>");
8588 
8589   verifyFormat("#if __has_include(<a/b>)");
8590   verifyFormat("#if __has_include_next(<a/b>)");
8591   verifyFormat("#define F __has_include(<a/b>)");
8592   verifyFormat("#define F __has_include_next(<a/b>)");
8593 
8594   // Protocol buffer definition or missing "#".
8595   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8596                getLLVMStyleWithColumns(30));
8597 
8598   FormatStyle Style = getLLVMStyle();
8599   Style.AlwaysBreakBeforeMultilineStrings = true;
8600   Style.ColumnLimit = 0;
8601   verifyFormat("#import \"abc.h\"", Style);
8602 
8603   // But 'import' might also be a regular C++ namespace.
8604   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8605                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8606 }
8607 
8608 //===----------------------------------------------------------------------===//
8609 // Error recovery tests.
8610 //===----------------------------------------------------------------------===//
8611 
8612 TEST_F(FormatTest, IncompleteParameterLists) {
8613   FormatStyle NoBinPacking = getLLVMStyle();
8614   NoBinPacking.BinPackParameters = false;
8615   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8616                "                        double *min_x,\n"
8617                "                        double *max_x,\n"
8618                "                        double *min_y,\n"
8619                "                        double *max_y,\n"
8620                "                        double *min_z,\n"
8621                "                        double *max_z, ) {}",
8622                NoBinPacking);
8623 }
8624 
8625 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8626   verifyFormat("void f() { return; }\n42");
8627   verifyFormat("void f() {\n"
8628                "  if (0)\n"
8629                "    return;\n"
8630                "}\n"
8631                "42");
8632   verifyFormat("void f() { return }\n42");
8633   verifyFormat("void f() {\n"
8634                "  if (0)\n"
8635                "    return\n"
8636                "}\n"
8637                "42");
8638 }
8639 
8640 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
8641   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
8642   EXPECT_EQ("void f() {\n"
8643             "  if (a)\n"
8644             "    return\n"
8645             "}",
8646             format("void  f  (  )  {  if  ( a )  return  }"));
8647   EXPECT_EQ("namespace N {\n"
8648             "void f()\n"
8649             "}",
8650             format("namespace  N  {  void f()  }"));
8651   EXPECT_EQ("namespace N {\n"
8652             "void f() {}\n"
8653             "void g()\n"
8654             "} // namespace N",
8655             format("namespace N  { void f( ) { } void g( ) }"));
8656 }
8657 
8658 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
8659   verifyFormat("int aaaaaaaa =\n"
8660                "    // Overlylongcomment\n"
8661                "    b;",
8662                getLLVMStyleWithColumns(20));
8663   verifyFormat("function(\n"
8664                "    ShortArgument,\n"
8665                "    LoooooooooooongArgument);\n",
8666                getLLVMStyleWithColumns(20));
8667 }
8668 
8669 TEST_F(FormatTest, IncorrectAccessSpecifier) {
8670   verifyFormat("public:");
8671   verifyFormat("class A {\n"
8672                "public\n"
8673                "  void f() {}\n"
8674                "};");
8675   verifyFormat("public\n"
8676                "int qwerty;");
8677   verifyFormat("public\n"
8678                "B {}");
8679   verifyFormat("public\n"
8680                "{}");
8681   verifyFormat("public\n"
8682                "B { int x; }");
8683 }
8684 
8685 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
8686   verifyFormat("{");
8687   verifyFormat("#})");
8688   verifyNoCrash("(/**/[:!] ?[).");
8689 }
8690 
8691 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
8692   // Found by oss-fuzz:
8693   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
8694   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
8695   Style.ColumnLimit = 60;
8696   verifyNoCrash(
8697       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
8698       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
8699       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
8700       Style);
8701 }
8702 
8703 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
8704   verifyFormat("do {\n}");
8705   verifyFormat("do {\n}\n"
8706                "f();");
8707   verifyFormat("do {\n}\n"
8708                "wheeee(fun);");
8709   verifyFormat("do {\n"
8710                "  f();\n"
8711                "}");
8712 }
8713 
8714 TEST_F(FormatTest, IncorrectCodeMissingParens) {
8715   verifyFormat("if {\n  foo;\n  foo();\n}");
8716   verifyFormat("switch {\n  foo;\n  foo();\n}");
8717   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
8718   verifyFormat("while {\n  foo;\n  foo();\n}");
8719   verifyFormat("do {\n  foo;\n  foo();\n} while;");
8720 }
8721 
8722 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
8723   verifyIncompleteFormat("namespace {\n"
8724                          "class Foo { Foo (\n"
8725                          "};\n"
8726                          "} // namespace");
8727 }
8728 
8729 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
8730   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
8731   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
8732   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
8733   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
8734 
8735   EXPECT_EQ("{\n"
8736             "  {\n"
8737             "    breakme(\n"
8738             "        qwe);\n"
8739             "  }\n",
8740             format("{\n"
8741                    "    {\n"
8742                    " breakme(qwe);\n"
8743                    "}\n",
8744                    getLLVMStyleWithColumns(10)));
8745 }
8746 
8747 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
8748   verifyFormat("int x = {\n"
8749                "    avariable,\n"
8750                "    b(alongervariable)};",
8751                getLLVMStyleWithColumns(25));
8752 }
8753 
8754 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
8755   verifyFormat("return (a)(b){1, 2, 3};");
8756 }
8757 
8758 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
8759   verifyFormat("vector<int> x{1, 2, 3, 4};");
8760   verifyFormat("vector<int> x{\n"
8761                "    1,\n"
8762                "    2,\n"
8763                "    3,\n"
8764                "    4,\n"
8765                "};");
8766   verifyFormat("vector<T> x{{}, {}, {}, {}};");
8767   verifyFormat("f({1, 2});");
8768   verifyFormat("auto v = Foo{-1};");
8769   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
8770   verifyFormat("Class::Class : member{1, 2, 3} {}");
8771   verifyFormat("new vector<int>{1, 2, 3};");
8772   verifyFormat("new int[3]{1, 2, 3};");
8773   verifyFormat("new int{1};");
8774   verifyFormat("return {arg1, arg2};");
8775   verifyFormat("return {arg1, SomeType{parameter}};");
8776   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
8777   verifyFormat("new T{arg1, arg2};");
8778   verifyFormat("f(MyMap[{composite, key}]);");
8779   verifyFormat("class Class {\n"
8780                "  T member = {arg1, arg2};\n"
8781                "};");
8782   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
8783   verifyFormat("const struct A a = {.a = 1, .b = 2};");
8784   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
8785   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
8786   verifyFormat("int a = std::is_integral<int>{} + 0;");
8787 
8788   verifyFormat("int foo(int i) { return fo1{}(i); }");
8789   verifyFormat("int foo(int i) { return fo1{}(i); }");
8790   verifyFormat("auto i = decltype(x){};");
8791   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
8792   verifyFormat("Node n{1, Node{1000}, //\n"
8793                "       2};");
8794   verifyFormat("Aaaa aaaaaaa{\n"
8795                "    {\n"
8796                "        aaaa,\n"
8797                "    },\n"
8798                "};");
8799   verifyFormat("class C : public D {\n"
8800                "  SomeClass SC{2};\n"
8801                "};");
8802   verifyFormat("class C : public A {\n"
8803                "  class D : public B {\n"
8804                "    void f() { int i{2}; }\n"
8805                "  };\n"
8806                "};");
8807   verifyFormat("#define A {a, a},");
8808 
8809   // Avoid breaking between equal sign and opening brace
8810   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
8811   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
8812   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
8813                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
8814                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
8815                "     {\"ccccccccccccccccccccc\", 2}};",
8816                AvoidBreakingFirstArgument);
8817 
8818   // Binpacking only if there is no trailing comma
8819   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
8820                "                      cccccccccc, dddddddddd};",
8821                getLLVMStyleWithColumns(50));
8822   verifyFormat("const Aaaaaa aaaaa = {\n"
8823                "    aaaaaaaaaaa,\n"
8824                "    bbbbbbbbbbb,\n"
8825                "    ccccccccccc,\n"
8826                "    ddddddddddd,\n"
8827                "};",
8828                getLLVMStyleWithColumns(50));
8829 
8830   // Cases where distinguising braced lists and blocks is hard.
8831   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
8832   verifyFormat("void f() {\n"
8833                "  return; // comment\n"
8834                "}\n"
8835                "SomeType t;");
8836   verifyFormat("void f() {\n"
8837                "  if (a) {\n"
8838                "    f();\n"
8839                "  }\n"
8840                "}\n"
8841                "SomeType t;");
8842 
8843   // In combination with BinPackArguments = false.
8844   FormatStyle NoBinPacking = getLLVMStyle();
8845   NoBinPacking.BinPackArguments = false;
8846   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
8847                "                      bbbbb,\n"
8848                "                      ccccc,\n"
8849                "                      ddddd,\n"
8850                "                      eeeee,\n"
8851                "                      ffffff,\n"
8852                "                      ggggg,\n"
8853                "                      hhhhhh,\n"
8854                "                      iiiiii,\n"
8855                "                      jjjjjj,\n"
8856                "                      kkkkkk};",
8857                NoBinPacking);
8858   verifyFormat("const Aaaaaa aaaaa = {\n"
8859                "    aaaaa,\n"
8860                "    bbbbb,\n"
8861                "    ccccc,\n"
8862                "    ddddd,\n"
8863                "    eeeee,\n"
8864                "    ffffff,\n"
8865                "    ggggg,\n"
8866                "    hhhhhh,\n"
8867                "    iiiiii,\n"
8868                "    jjjjjj,\n"
8869                "    kkkkkk,\n"
8870                "};",
8871                NoBinPacking);
8872   verifyFormat(
8873       "const Aaaaaa aaaaa = {\n"
8874       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
8875       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
8876       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
8877       "};",
8878       NoBinPacking);
8879 
8880   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
8881   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
8882             "    CDDDP83848_BMCR_REGISTER,\n"
8883             "    CDDDP83848_BMSR_REGISTER,\n"
8884             "    CDDDP83848_RBR_REGISTER};",
8885             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
8886                    "                                CDDDP83848_BMSR_REGISTER,\n"
8887                    "                                CDDDP83848_RBR_REGISTER};",
8888                    NoBinPacking));
8889 
8890   // FIXME: The alignment of these trailing comments might be bad. Then again,
8891   // this might be utterly useless in real code.
8892   verifyFormat("Constructor::Constructor()\n"
8893                "    : some_value{         //\n"
8894                "                 aaaaaaa, //\n"
8895                "                 bbbbbbb} {}");
8896 
8897   // In braced lists, the first comment is always assumed to belong to the
8898   // first element. Thus, it can be moved to the next or previous line as
8899   // appropriate.
8900   EXPECT_EQ("function({// First element:\n"
8901             "          1,\n"
8902             "          // Second element:\n"
8903             "          2});",
8904             format("function({\n"
8905                    "    // First element:\n"
8906                    "    1,\n"
8907                    "    // Second element:\n"
8908                    "    2});"));
8909   EXPECT_EQ("std::vector<int> MyNumbers{\n"
8910             "    // First element:\n"
8911             "    1,\n"
8912             "    // Second element:\n"
8913             "    2};",
8914             format("std::vector<int> MyNumbers{// First element:\n"
8915                    "                           1,\n"
8916                    "                           // Second element:\n"
8917                    "                           2};",
8918                    getLLVMStyleWithColumns(30)));
8919   // A trailing comma should still lead to an enforced line break and no
8920   // binpacking.
8921   EXPECT_EQ("vector<int> SomeVector = {\n"
8922             "    // aaa\n"
8923             "    1,\n"
8924             "    2,\n"
8925             "};",
8926             format("vector<int> SomeVector = { // aaa\n"
8927                    "    1, 2, };"));
8928 
8929   // C++11 brace initializer list l-braces should not be treated any differently
8930   // when breaking before lambda bodies is enabled
8931   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
8932   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
8933   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
8934   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
8935   verifyFormat(
8936       "std::runtime_error{\n"
8937       "    \"Long string which will force a break onto the next line...\"};",
8938       BreakBeforeLambdaBody);
8939 
8940   FormatStyle ExtraSpaces = getLLVMStyle();
8941   ExtraSpaces.Cpp11BracedListStyle = false;
8942   ExtraSpaces.ColumnLimit = 75;
8943   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
8944   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
8945   verifyFormat("f({ 1, 2 });", ExtraSpaces);
8946   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
8947   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
8948   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
8949   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
8950   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
8951   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
8952   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
8953   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
8954   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
8955   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
8956   verifyFormat("class Class {\n"
8957                "  T member = { arg1, arg2 };\n"
8958                "};",
8959                ExtraSpaces);
8960   verifyFormat(
8961       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8962       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
8963       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
8964       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
8965       ExtraSpaces);
8966   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
8967   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
8968                ExtraSpaces);
8969   verifyFormat(
8970       "someFunction(OtherParam,\n"
8971       "             BracedList{ // comment 1 (Forcing interesting break)\n"
8972       "                         param1, param2,\n"
8973       "                         // comment 2\n"
8974       "                         param3, param4 });",
8975       ExtraSpaces);
8976   verifyFormat(
8977       "std::this_thread::sleep_for(\n"
8978       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
8979       ExtraSpaces);
8980   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
8981                "    aaaaaaa,\n"
8982                "    aaaaaaaaaa,\n"
8983                "    aaaaa,\n"
8984                "    aaaaaaaaaaaaaaa,\n"
8985                "    aaa,\n"
8986                "    aaaaaaaaaa,\n"
8987                "    a,\n"
8988                "    aaaaaaaaaaaaaaaaaaaaa,\n"
8989                "    aaaaaaaaaaaa,\n"
8990                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
8991                "    aaaaaaa,\n"
8992                "    a};");
8993   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
8994   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
8995   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
8996 
8997   // Avoid breaking between initializer/equal sign and opening brace
8998   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
8999   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
9000                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9001                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9002                "  { \"ccccccccccccccccccccc\", 2 }\n"
9003                "};",
9004                ExtraSpaces);
9005   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
9006                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9007                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9008                "  { \"ccccccccccccccccccccc\", 2 }\n"
9009                "};",
9010                ExtraSpaces);
9011 
9012   FormatStyle SpaceBeforeBrace = getLLVMStyle();
9013   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9014   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9015   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9016 
9017   FormatStyle SpaceBetweenBraces = getLLVMStyle();
9018   SpaceBetweenBraces.SpacesInAngles = true;
9019   SpaceBetweenBraces.SpacesInParentheses = true;
9020   SpaceBetweenBraces.SpacesInSquareBrackets = true;
9021   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9022   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9023   verifyFormat("vector< int > x{ // comment 1\n"
9024                "                 1, 2, 3, 4 };",
9025                SpaceBetweenBraces);
9026   SpaceBetweenBraces.ColumnLimit = 20;
9027   EXPECT_EQ("vector< int > x{\n"
9028             "    1, 2, 3, 4 };",
9029             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9030   SpaceBetweenBraces.ColumnLimit = 24;
9031   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9032             "                 3, 4 };",
9033             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9034   EXPECT_EQ("vector< int > x{\n"
9035             "    1,\n"
9036             "    2,\n"
9037             "    3,\n"
9038             "    4,\n"
9039             "};",
9040             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9041   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9042   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9043   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9044 }
9045 
9046 TEST_F(FormatTest, FormatSpacesInAngles) {
9047   FormatStyle SpaceInAngles = getLLVMStyle();
9048   SpaceInAngles.SpacesInAngles = true;
9049   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9050   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9051   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9052 
9053   SpaceInAngles.SpacesInAngles = false;
9054   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9055   verifyFormat("vector<int> x5;", SpaceInAngles);
9056   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9057   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9058 }
9059 
9060 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9061   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9062                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9063                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9064                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9065                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9066                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9067   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9068                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9069                "                 1, 22, 333, 4444, 55555, //\n"
9070                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9071                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9072   verifyFormat(
9073       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9074       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9075       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9076       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9077       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9078       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9079       "                 7777777};");
9080   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9081                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9082                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9083   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9084                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9085                "    // Separating comment.\n"
9086                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9087   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9088                "    // Leading comment\n"
9089                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9090                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9091   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9092                "                 1, 1, 1, 1};",
9093                getLLVMStyleWithColumns(39));
9094   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9095                "                 1, 1, 1, 1};",
9096                getLLVMStyleWithColumns(38));
9097   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9098                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9099                getLLVMStyleWithColumns(43));
9100   verifyFormat(
9101       "static unsigned SomeValues[10][3] = {\n"
9102       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9103       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9104   verifyFormat("static auto fields = new vector<string>{\n"
9105                "    \"aaaaaaaaaaaaa\",\n"
9106                "    \"aaaaaaaaaaaaa\",\n"
9107                "    \"aaaaaaaaaaaa\",\n"
9108                "    \"aaaaaaaaaaaaaa\",\n"
9109                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9110                "    \"aaaaaaaaaaaa\",\n"
9111                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9112                "};");
9113   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9114   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9115                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9116                "                 3, cccccccccccccccccccccc};",
9117                getLLVMStyleWithColumns(60));
9118 
9119   // Trailing commas.
9120   verifyFormat("vector<int> x = {\n"
9121                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9122                "};",
9123                getLLVMStyleWithColumns(39));
9124   verifyFormat("vector<int> x = {\n"
9125                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9126                "};",
9127                getLLVMStyleWithColumns(39));
9128   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9129                "                 1, 1, 1, 1,\n"
9130                "                 /**/ /**/};",
9131                getLLVMStyleWithColumns(39));
9132 
9133   // Trailing comment in the first line.
9134   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9135                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9136                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9137                "    11111111,   22222222,   333333333,   44444444};");
9138   // Trailing comment in the last line.
9139   verifyFormat("int aaaaa[] = {\n"
9140                "    1, 2, 3, // comment\n"
9141                "    4, 5, 6  // comment\n"
9142                "};");
9143 
9144   // With nested lists, we should either format one item per line or all nested
9145   // lists one on line.
9146   // FIXME: For some nested lists, we can do better.
9147   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9148                "        {aaaaaaaaaaaaaaaaaaa},\n"
9149                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9150                "        {aaaaaaaaaaaaaaaaa}};",
9151                getLLVMStyleWithColumns(60));
9152   verifyFormat(
9153       "SomeStruct my_struct_array = {\n"
9154       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9155       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9156       "    {aaa, aaa},\n"
9157       "    {aaa, aaa},\n"
9158       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9159       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9160       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9161 
9162   // No column layout should be used here.
9163   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9164                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9165 
9166   verifyNoCrash("a<,");
9167 
9168   // No braced initializer here.
9169   verifyFormat("void f() {\n"
9170                "  struct Dummy {};\n"
9171                "  f(v);\n"
9172                "}");
9173 
9174   // Long lists should be formatted in columns even if they are nested.
9175   verifyFormat(
9176       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9177       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9178       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9179       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9180       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9181       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9182 
9183   // Allow "single-column" layout even if that violates the column limit. There
9184   // isn't going to be a better way.
9185   verifyFormat("std::vector<int> a = {\n"
9186                "    aaaaaaaa,\n"
9187                "    aaaaaaaa,\n"
9188                "    aaaaaaaa,\n"
9189                "    aaaaaaaa,\n"
9190                "    aaaaaaaaaa,\n"
9191                "    aaaaaaaa,\n"
9192                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9193                getLLVMStyleWithColumns(30));
9194   verifyFormat("vector<int> aaaa = {\n"
9195                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9196                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9197                "    aaaaaa.aaaaaaa,\n"
9198                "    aaaaaa.aaaaaaa,\n"
9199                "    aaaaaa.aaaaaaa,\n"
9200                "    aaaaaa.aaaaaaa,\n"
9201                "};");
9202 
9203   // Don't create hanging lists.
9204   verifyFormat("someFunction(Param, {List1, List2,\n"
9205                "                     List3});",
9206                getLLVMStyleWithColumns(35));
9207   verifyFormat("someFunction(Param, Param,\n"
9208                "             {List1, List2,\n"
9209                "              List3});",
9210                getLLVMStyleWithColumns(35));
9211   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9212                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9213 }
9214 
9215 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9216   FormatStyle DoNotMerge = getLLVMStyle();
9217   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9218 
9219   verifyFormat("void f() { return 42; }");
9220   verifyFormat("void f() {\n"
9221                "  return 42;\n"
9222                "}",
9223                DoNotMerge);
9224   verifyFormat("void f() {\n"
9225                "  // Comment\n"
9226                "}");
9227   verifyFormat("{\n"
9228                "#error {\n"
9229                "  int a;\n"
9230                "}");
9231   verifyFormat("{\n"
9232                "  int a;\n"
9233                "#error {\n"
9234                "}");
9235   verifyFormat("void f() {} // comment");
9236   verifyFormat("void f() { int a; } // comment");
9237   verifyFormat("void f() {\n"
9238                "} // comment",
9239                DoNotMerge);
9240   verifyFormat("void f() {\n"
9241                "  int a;\n"
9242                "} // comment",
9243                DoNotMerge);
9244   verifyFormat("void f() {\n"
9245                "} // comment",
9246                getLLVMStyleWithColumns(15));
9247 
9248   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9249   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9250 
9251   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9252   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9253   verifyFormat("class C {\n"
9254                "  C()\n"
9255                "      : iiiiiiii(nullptr),\n"
9256                "        kkkkkkk(nullptr),\n"
9257                "        mmmmmmm(nullptr),\n"
9258                "        nnnnnnn(nullptr) {}\n"
9259                "};",
9260                getGoogleStyle());
9261 
9262   FormatStyle NoColumnLimit = getLLVMStyle();
9263   NoColumnLimit.ColumnLimit = 0;
9264   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9265   EXPECT_EQ("class C {\n"
9266             "  A() : b(0) {}\n"
9267             "};",
9268             format("class C{A():b(0){}};", NoColumnLimit));
9269   EXPECT_EQ("A()\n"
9270             "    : b(0) {\n"
9271             "}",
9272             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9273 
9274   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9275   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9276       FormatStyle::SFS_None;
9277   EXPECT_EQ("A()\n"
9278             "    : b(0) {\n"
9279             "}",
9280             format("A():b(0){}", DoNotMergeNoColumnLimit));
9281   EXPECT_EQ("A()\n"
9282             "    : b(0) {\n"
9283             "}",
9284             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9285 
9286   verifyFormat("#define A          \\\n"
9287                "  void f() {       \\\n"
9288                "    int i;         \\\n"
9289                "  }",
9290                getLLVMStyleWithColumns(20));
9291   verifyFormat("#define A           \\\n"
9292                "  void f() { int i; }",
9293                getLLVMStyleWithColumns(21));
9294   verifyFormat("#define A            \\\n"
9295                "  void f() {         \\\n"
9296                "    int i;           \\\n"
9297                "  }                  \\\n"
9298                "  int j;",
9299                getLLVMStyleWithColumns(22));
9300   verifyFormat("#define A             \\\n"
9301                "  void f() { int i; } \\\n"
9302                "  int j;",
9303                getLLVMStyleWithColumns(23));
9304 }
9305 
9306 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9307   FormatStyle MergeEmptyOnly = getLLVMStyle();
9308   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9309   verifyFormat("class C {\n"
9310                "  int f() {}\n"
9311                "};",
9312                MergeEmptyOnly);
9313   verifyFormat("class C {\n"
9314                "  int f() {\n"
9315                "    return 42;\n"
9316                "  }\n"
9317                "};",
9318                MergeEmptyOnly);
9319   verifyFormat("int f() {}", MergeEmptyOnly);
9320   verifyFormat("int f() {\n"
9321                "  return 42;\n"
9322                "}",
9323                MergeEmptyOnly);
9324 
9325   // Also verify behavior when BraceWrapping.AfterFunction = true
9326   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9327   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9328   verifyFormat("int f() {}", MergeEmptyOnly);
9329   verifyFormat("class C {\n"
9330                "  int f() {}\n"
9331                "};",
9332                MergeEmptyOnly);
9333 }
9334 
9335 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9336   FormatStyle MergeInlineOnly = getLLVMStyle();
9337   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9338   verifyFormat("class C {\n"
9339                "  int f() { return 42; }\n"
9340                "};",
9341                MergeInlineOnly);
9342   verifyFormat("int f() {\n"
9343                "  return 42;\n"
9344                "}",
9345                MergeInlineOnly);
9346 
9347   // SFS_Inline implies SFS_Empty
9348   verifyFormat("class C {\n"
9349                "  int f() {}\n"
9350                "};",
9351                MergeInlineOnly);
9352   verifyFormat("int f() {}", MergeInlineOnly);
9353 
9354   // Also verify behavior when BraceWrapping.AfterFunction = true
9355   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9356   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9357   verifyFormat("class C {\n"
9358                "  int f() { return 42; }\n"
9359                "};",
9360                MergeInlineOnly);
9361   verifyFormat("int f()\n"
9362                "{\n"
9363                "  return 42;\n"
9364                "}",
9365                MergeInlineOnly);
9366 
9367   // SFS_Inline implies SFS_Empty
9368   verifyFormat("int f() {}", MergeInlineOnly);
9369   verifyFormat("class C {\n"
9370                "  int f() {}\n"
9371                "};",
9372                MergeInlineOnly);
9373 }
9374 
9375 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9376   FormatStyle MergeInlineOnly = getLLVMStyle();
9377   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9378       FormatStyle::SFS_InlineOnly;
9379   verifyFormat("class C {\n"
9380                "  int f() { return 42; }\n"
9381                "};",
9382                MergeInlineOnly);
9383   verifyFormat("int f() {\n"
9384                "  return 42;\n"
9385                "}",
9386                MergeInlineOnly);
9387 
9388   // SFS_InlineOnly does not imply SFS_Empty
9389   verifyFormat("class C {\n"
9390                "  int f() {}\n"
9391                "};",
9392                MergeInlineOnly);
9393   verifyFormat("int f() {\n"
9394                "}",
9395                MergeInlineOnly);
9396 
9397   // Also verify behavior when BraceWrapping.AfterFunction = true
9398   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9399   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9400   verifyFormat("class C {\n"
9401                "  int f() { return 42; }\n"
9402                "};",
9403                MergeInlineOnly);
9404   verifyFormat("int f()\n"
9405                "{\n"
9406                "  return 42;\n"
9407                "}",
9408                MergeInlineOnly);
9409 
9410   // SFS_InlineOnly does not imply SFS_Empty
9411   verifyFormat("int f()\n"
9412                "{\n"
9413                "}",
9414                MergeInlineOnly);
9415   verifyFormat("class C {\n"
9416                "  int f() {}\n"
9417                "};",
9418                MergeInlineOnly);
9419 }
9420 
9421 TEST_F(FormatTest, SplitEmptyFunction) {
9422   FormatStyle Style = getLLVMStyle();
9423   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9424   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9425   Style.BraceWrapping.AfterFunction = true;
9426   Style.BraceWrapping.SplitEmptyFunction = false;
9427   Style.ColumnLimit = 40;
9428 
9429   verifyFormat("int f()\n"
9430                "{}",
9431                Style);
9432   verifyFormat("int f()\n"
9433                "{\n"
9434                "  return 42;\n"
9435                "}",
9436                Style);
9437   verifyFormat("int f()\n"
9438                "{\n"
9439                "  // some comment\n"
9440                "}",
9441                Style);
9442 
9443   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9444   verifyFormat("int f() {}", Style);
9445   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9446                "{}",
9447                Style);
9448   verifyFormat("int f()\n"
9449                "{\n"
9450                "  return 0;\n"
9451                "}",
9452                Style);
9453 
9454   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9455   verifyFormat("class Foo {\n"
9456                "  int f() {}\n"
9457                "};\n",
9458                Style);
9459   verifyFormat("class Foo {\n"
9460                "  int f() { return 0; }\n"
9461                "};\n",
9462                Style);
9463   verifyFormat("class Foo {\n"
9464                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9465                "  {}\n"
9466                "};\n",
9467                Style);
9468   verifyFormat("class Foo {\n"
9469                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9470                "  {\n"
9471                "    return 0;\n"
9472                "  }\n"
9473                "};\n",
9474                Style);
9475 
9476   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9477   verifyFormat("int f() {}", Style);
9478   verifyFormat("int f() { return 0; }", Style);
9479   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9480                "{}",
9481                Style);
9482   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9483                "{\n"
9484                "  return 0;\n"
9485                "}",
9486                Style);
9487 }
9488 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9489   FormatStyle Style = getLLVMStyle();
9490   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9491   verifyFormat("#ifdef A\n"
9492                "int f() {}\n"
9493                "#else\n"
9494                "int g() {}\n"
9495                "#endif",
9496                Style);
9497 }
9498 
9499 TEST_F(FormatTest, SplitEmptyClass) {
9500   FormatStyle Style = getLLVMStyle();
9501   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9502   Style.BraceWrapping.AfterClass = true;
9503   Style.BraceWrapping.SplitEmptyRecord = false;
9504 
9505   verifyFormat("class Foo\n"
9506                "{};",
9507                Style);
9508   verifyFormat("/* something */ class Foo\n"
9509                "{};",
9510                Style);
9511   verifyFormat("template <typename X> class Foo\n"
9512                "{};",
9513                Style);
9514   verifyFormat("class Foo\n"
9515                "{\n"
9516                "  Foo();\n"
9517                "};",
9518                Style);
9519   verifyFormat("typedef class Foo\n"
9520                "{\n"
9521                "} Foo_t;",
9522                Style);
9523 }
9524 
9525 TEST_F(FormatTest, SplitEmptyStruct) {
9526   FormatStyle Style = getLLVMStyle();
9527   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9528   Style.BraceWrapping.AfterStruct = true;
9529   Style.BraceWrapping.SplitEmptyRecord = false;
9530 
9531   verifyFormat("struct Foo\n"
9532                "{};",
9533                Style);
9534   verifyFormat("/* something */ struct Foo\n"
9535                "{};",
9536                Style);
9537   verifyFormat("template <typename X> struct Foo\n"
9538                "{};",
9539                Style);
9540   verifyFormat("struct Foo\n"
9541                "{\n"
9542                "  Foo();\n"
9543                "};",
9544                Style);
9545   verifyFormat("typedef struct Foo\n"
9546                "{\n"
9547                "} Foo_t;",
9548                Style);
9549   // typedef struct Bar {} Bar_t;
9550 }
9551 
9552 TEST_F(FormatTest, SplitEmptyUnion) {
9553   FormatStyle Style = getLLVMStyle();
9554   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9555   Style.BraceWrapping.AfterUnion = true;
9556   Style.BraceWrapping.SplitEmptyRecord = false;
9557 
9558   verifyFormat("union Foo\n"
9559                "{};",
9560                Style);
9561   verifyFormat("/* something */ union Foo\n"
9562                "{};",
9563                Style);
9564   verifyFormat("union Foo\n"
9565                "{\n"
9566                "  A,\n"
9567                "};",
9568                Style);
9569   verifyFormat("typedef union Foo\n"
9570                "{\n"
9571                "} Foo_t;",
9572                Style);
9573 }
9574 
9575 TEST_F(FormatTest, SplitEmptyNamespace) {
9576   FormatStyle Style = getLLVMStyle();
9577   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9578   Style.BraceWrapping.AfterNamespace = true;
9579   Style.BraceWrapping.SplitEmptyNamespace = false;
9580 
9581   verifyFormat("namespace Foo\n"
9582                "{};",
9583                Style);
9584   verifyFormat("/* something */ namespace Foo\n"
9585                "{};",
9586                Style);
9587   verifyFormat("inline namespace Foo\n"
9588                "{};",
9589                Style);
9590   verifyFormat("/* something */ inline namespace Foo\n"
9591                "{};",
9592                Style);
9593   verifyFormat("export namespace Foo\n"
9594                "{};",
9595                Style);
9596   verifyFormat("namespace Foo\n"
9597                "{\n"
9598                "void Bar();\n"
9599                "};",
9600                Style);
9601 }
9602 
9603 TEST_F(FormatTest, NeverMergeShortRecords) {
9604   FormatStyle Style = getLLVMStyle();
9605 
9606   verifyFormat("class Foo {\n"
9607                "  Foo();\n"
9608                "};",
9609                Style);
9610   verifyFormat("typedef class Foo {\n"
9611                "  Foo();\n"
9612                "} Foo_t;",
9613                Style);
9614   verifyFormat("struct Foo {\n"
9615                "  Foo();\n"
9616                "};",
9617                Style);
9618   verifyFormat("typedef struct Foo {\n"
9619                "  Foo();\n"
9620                "} Foo_t;",
9621                Style);
9622   verifyFormat("union Foo {\n"
9623                "  A,\n"
9624                "};",
9625                Style);
9626   verifyFormat("typedef union Foo {\n"
9627                "  A,\n"
9628                "} Foo_t;",
9629                Style);
9630   verifyFormat("namespace Foo {\n"
9631                "void Bar();\n"
9632                "};",
9633                Style);
9634 
9635   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9636   Style.BraceWrapping.AfterClass = true;
9637   Style.BraceWrapping.AfterStruct = true;
9638   Style.BraceWrapping.AfterUnion = true;
9639   Style.BraceWrapping.AfterNamespace = true;
9640   verifyFormat("class Foo\n"
9641                "{\n"
9642                "  Foo();\n"
9643                "};",
9644                Style);
9645   verifyFormat("typedef class Foo\n"
9646                "{\n"
9647                "  Foo();\n"
9648                "} Foo_t;",
9649                Style);
9650   verifyFormat("struct Foo\n"
9651                "{\n"
9652                "  Foo();\n"
9653                "};",
9654                Style);
9655   verifyFormat("typedef struct Foo\n"
9656                "{\n"
9657                "  Foo();\n"
9658                "} Foo_t;",
9659                Style);
9660   verifyFormat("union Foo\n"
9661                "{\n"
9662                "  A,\n"
9663                "};",
9664                Style);
9665   verifyFormat("typedef union Foo\n"
9666                "{\n"
9667                "  A,\n"
9668                "} Foo_t;",
9669                Style);
9670   verifyFormat("namespace Foo\n"
9671                "{\n"
9672                "void Bar();\n"
9673                "};",
9674                Style);
9675 }
9676 
9677 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
9678   // Elaborate type variable declarations.
9679   verifyFormat("struct foo a = {bar};\nint n;");
9680   verifyFormat("class foo a = {bar};\nint n;");
9681   verifyFormat("union foo a = {bar};\nint n;");
9682 
9683   // Elaborate types inside function definitions.
9684   verifyFormat("struct foo f() {}\nint n;");
9685   verifyFormat("class foo f() {}\nint n;");
9686   verifyFormat("union foo f() {}\nint n;");
9687 
9688   // Templates.
9689   verifyFormat("template <class X> void f() {}\nint n;");
9690   verifyFormat("template <struct X> void f() {}\nint n;");
9691   verifyFormat("template <union X> void f() {}\nint n;");
9692 
9693   // Actual definitions...
9694   verifyFormat("struct {\n} n;");
9695   verifyFormat(
9696       "template <template <class T, class Y>, class Z> class X {\n} n;");
9697   verifyFormat("union Z {\n  int n;\n} x;");
9698   verifyFormat("class MACRO Z {\n} n;");
9699   verifyFormat("class MACRO(X) Z {\n} n;");
9700   verifyFormat("class __attribute__(X) Z {\n} n;");
9701   verifyFormat("class __declspec(X) Z {\n} n;");
9702   verifyFormat("class A##B##C {\n} n;");
9703   verifyFormat("class alignas(16) Z {\n} n;");
9704   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
9705   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
9706 
9707   // Redefinition from nested context:
9708   verifyFormat("class A::B::C {\n} n;");
9709 
9710   // Template definitions.
9711   verifyFormat(
9712       "template <typename F>\n"
9713       "Matcher(const Matcher<F> &Other,\n"
9714       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
9715       "                             !is_same<F, T>::value>::type * = 0)\n"
9716       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
9717 
9718   // FIXME: This is still incorrectly handled at the formatter side.
9719   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
9720   verifyFormat("int i = SomeFunction(a<b, a> b);");
9721 
9722   // FIXME:
9723   // This now gets parsed incorrectly as class definition.
9724   // verifyFormat("class A<int> f() {\n}\nint n;");
9725 
9726   // Elaborate types where incorrectly parsing the structural element would
9727   // break the indent.
9728   verifyFormat("if (true)\n"
9729                "  class X x;\n"
9730                "else\n"
9731                "  f();\n");
9732 
9733   // This is simply incomplete. Formatting is not important, but must not crash.
9734   verifyFormat("class A:");
9735 }
9736 
9737 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
9738   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
9739             format("#error Leave     all         white!!!!! space* alone!\n"));
9740   EXPECT_EQ(
9741       "#warning Leave     all         white!!!!! space* alone!\n",
9742       format("#warning Leave     all         white!!!!! space* alone!\n"));
9743   EXPECT_EQ("#error 1", format("  #  error   1"));
9744   EXPECT_EQ("#warning 1", format("  #  warning 1"));
9745 }
9746 
9747 TEST_F(FormatTest, FormatHashIfExpressions) {
9748   verifyFormat("#if AAAA && BBBB");
9749   verifyFormat("#if (AAAA && BBBB)");
9750   verifyFormat("#elif (AAAA && BBBB)");
9751   // FIXME: Come up with a better indentation for #elif.
9752   verifyFormat(
9753       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
9754       "    defined(BBBBBBBB)\n"
9755       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
9756       "    defined(BBBBBBBB)\n"
9757       "#endif",
9758       getLLVMStyleWithColumns(65));
9759 }
9760 
9761 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
9762   FormatStyle AllowsMergedIf = getGoogleStyle();
9763   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
9764       FormatStyle::SIS_WithoutElse;
9765   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
9766   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
9767   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
9768   EXPECT_EQ("if (true) return 42;",
9769             format("if (true)\nreturn 42;", AllowsMergedIf));
9770   FormatStyle ShortMergedIf = AllowsMergedIf;
9771   ShortMergedIf.ColumnLimit = 25;
9772   verifyFormat("#define A \\\n"
9773                "  if (true) return 42;",
9774                ShortMergedIf);
9775   verifyFormat("#define A \\\n"
9776                "  f();    \\\n"
9777                "  if (true)\n"
9778                "#define B",
9779                ShortMergedIf);
9780   verifyFormat("#define A \\\n"
9781                "  f();    \\\n"
9782                "  if (true)\n"
9783                "g();",
9784                ShortMergedIf);
9785   verifyFormat("{\n"
9786                "#ifdef A\n"
9787                "  // Comment\n"
9788                "  if (true) continue;\n"
9789                "#endif\n"
9790                "  // Comment\n"
9791                "  if (true) continue;\n"
9792                "}",
9793                ShortMergedIf);
9794   ShortMergedIf.ColumnLimit = 33;
9795   verifyFormat("#define A \\\n"
9796                "  if constexpr (true) return 42;",
9797                ShortMergedIf);
9798   verifyFormat("#define A \\\n"
9799                "  if CONSTEXPR (true) return 42;",
9800                ShortMergedIf);
9801   ShortMergedIf.ColumnLimit = 29;
9802   verifyFormat("#define A                   \\\n"
9803                "  if (aaaaaaaaaa) return 1; \\\n"
9804                "  return 2;",
9805                ShortMergedIf);
9806   ShortMergedIf.ColumnLimit = 28;
9807   verifyFormat("#define A         \\\n"
9808                "  if (aaaaaaaaaa) \\\n"
9809                "    return 1;     \\\n"
9810                "  return 2;",
9811                ShortMergedIf);
9812   verifyFormat("#define A                \\\n"
9813                "  if constexpr (aaaaaaa) \\\n"
9814                "    return 1;            \\\n"
9815                "  return 2;",
9816                ShortMergedIf);
9817   verifyFormat("#define A                \\\n"
9818                "  if CONSTEXPR (aaaaaaa) \\\n"
9819                "    return 1;            \\\n"
9820                "  return 2;",
9821                ShortMergedIf);
9822 }
9823 
9824 TEST_F(FormatTest, FormatStarDependingOnContext) {
9825   verifyFormat("void f(int *a);");
9826   verifyFormat("void f() { f(fint * b); }");
9827   verifyFormat("class A {\n  void f(int *a);\n};");
9828   verifyFormat("class A {\n  int *a;\n};");
9829   verifyFormat("namespace a {\n"
9830                "namespace b {\n"
9831                "class A {\n"
9832                "  void f() {}\n"
9833                "  int *a;\n"
9834                "};\n"
9835                "} // namespace b\n"
9836                "} // namespace a");
9837 }
9838 
9839 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
9840   verifyFormat("while");
9841   verifyFormat("operator");
9842 }
9843 
9844 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
9845   // This code would be painfully slow to format if we didn't skip it.
9846   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
9847                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9848                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9849                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9850                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9851                    "A(1, 1)\n"
9852                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
9853                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9854                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9855                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9856                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9857                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9858                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9859                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
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   // Deeply nested part is untouched, rest is formatted.
9863   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
9864             format(std::string("int    i;\n") + Code + "int    j;\n",
9865                    getLLVMStyle(), SC_ExpectIncomplete));
9866 }
9867 
9868 //===----------------------------------------------------------------------===//
9869 // Objective-C tests.
9870 //===----------------------------------------------------------------------===//
9871 
9872 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
9873   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
9874   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
9875             format("-(NSUInteger)indexOfObject:(id)anObject;"));
9876   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
9877   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
9878   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
9879             format("-(NSInteger)Method3:(id)anObject;"));
9880   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
9881             format("-(NSInteger)Method4:(id)anObject;"));
9882   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
9883             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
9884   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
9885             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
9886   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9887             "forAllCells:(BOOL)flag;",
9888             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9889                    "forAllCells:(BOOL)flag;"));
9890 
9891   // Very long objectiveC method declaration.
9892   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
9893                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
9894   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
9895                "                    inRange:(NSRange)range\n"
9896                "                   outRange:(NSRange)out_range\n"
9897                "                  outRange1:(NSRange)out_range1\n"
9898                "                  outRange2:(NSRange)out_range2\n"
9899                "                  outRange3:(NSRange)out_range3\n"
9900                "                  outRange4:(NSRange)out_range4\n"
9901                "                  outRange5:(NSRange)out_range5\n"
9902                "                  outRange6:(NSRange)out_range6\n"
9903                "                  outRange7:(NSRange)out_range7\n"
9904                "                  outRange8:(NSRange)out_range8\n"
9905                "                  outRange9:(NSRange)out_range9;");
9906 
9907   // When the function name has to be wrapped.
9908   FormatStyle Style = getLLVMStyle();
9909   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
9910   // and always indents instead.
9911   Style.IndentWrappedFunctionNames = false;
9912   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9913                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
9914                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
9915                "}",
9916                Style);
9917   Style.IndentWrappedFunctionNames = true;
9918   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9919                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
9920                "               anotherName:(NSString)dddddddddddddd {\n"
9921                "}",
9922                Style);
9923 
9924   verifyFormat("- (int)sum:(vector<int>)numbers;");
9925   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
9926   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
9927   // protocol lists (but not for template classes):
9928   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
9929 
9930   verifyFormat("- (int (*)())foo:(int (*)())f;");
9931   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
9932 
9933   // If there's no return type (very rare in practice!), LLVM and Google style
9934   // agree.
9935   verifyFormat("- foo;");
9936   verifyFormat("- foo:(int)f;");
9937   verifyGoogleFormat("- foo:(int)foo;");
9938 }
9939 
9940 TEST_F(FormatTest, BreaksStringLiterals) {
9941   EXPECT_EQ("\"some text \"\n"
9942             "\"other\";",
9943             format("\"some text other\";", getLLVMStyleWithColumns(12)));
9944   EXPECT_EQ("\"some text \"\n"
9945             "\"other\";",
9946             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
9947   EXPECT_EQ(
9948       "#define A  \\\n"
9949       "  \"some \"  \\\n"
9950       "  \"text \"  \\\n"
9951       "  \"other\";",
9952       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
9953   EXPECT_EQ(
9954       "#define A  \\\n"
9955       "  \"so \"    \\\n"
9956       "  \"text \"  \\\n"
9957       "  \"other\";",
9958       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
9959 
9960   EXPECT_EQ("\"some text\"",
9961             format("\"some text\"", getLLVMStyleWithColumns(1)));
9962   EXPECT_EQ("\"some text\"",
9963             format("\"some text\"", getLLVMStyleWithColumns(11)));
9964   EXPECT_EQ("\"some \"\n"
9965             "\"text\"",
9966             format("\"some text\"", getLLVMStyleWithColumns(10)));
9967   EXPECT_EQ("\"some \"\n"
9968             "\"text\"",
9969             format("\"some text\"", getLLVMStyleWithColumns(7)));
9970   EXPECT_EQ("\"some\"\n"
9971             "\" tex\"\n"
9972             "\"t\"",
9973             format("\"some text\"", getLLVMStyleWithColumns(6)));
9974   EXPECT_EQ("\"some\"\n"
9975             "\" tex\"\n"
9976             "\" and\"",
9977             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
9978   EXPECT_EQ("\"some\"\n"
9979             "\"/tex\"\n"
9980             "\"/and\"",
9981             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
9982 
9983   EXPECT_EQ("variable =\n"
9984             "    \"long string \"\n"
9985             "    \"literal\";",
9986             format("variable = \"long string literal\";",
9987                    getLLVMStyleWithColumns(20)));
9988 
9989   EXPECT_EQ("variable = f(\n"
9990             "    \"long string \"\n"
9991             "    \"literal\",\n"
9992             "    short,\n"
9993             "    loooooooooooooooooooong);",
9994             format("variable = f(\"long string literal\", short, "
9995                    "loooooooooooooooooooong);",
9996                    getLLVMStyleWithColumns(20)));
9997 
9998   EXPECT_EQ(
9999       "f(g(\"long string \"\n"
10000       "    \"literal\"),\n"
10001       "  b);",
10002       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
10003   EXPECT_EQ("f(g(\"long string \"\n"
10004             "    \"literal\",\n"
10005             "    a),\n"
10006             "  b);",
10007             format("f(g(\"long string literal\", a), b);",
10008                    getLLVMStyleWithColumns(20)));
10009   EXPECT_EQ(
10010       "f(\"one two\".split(\n"
10011       "    variable));",
10012       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10013   EXPECT_EQ("f(\"one two three four five six \"\n"
10014             "  \"seven\".split(\n"
10015             "      really_looooong_variable));",
10016             format("f(\"one two three four five six seven\"."
10017                    "split(really_looooong_variable));",
10018                    getLLVMStyleWithColumns(33)));
10019 
10020   EXPECT_EQ("f(\"some \"\n"
10021             "  \"text\",\n"
10022             "  other);",
10023             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10024 
10025   // Only break as a last resort.
10026   verifyFormat(
10027       "aaaaaaaaaaaaaaaaaaaa(\n"
10028       "    aaaaaaaaaaaaaaaaaaaa,\n"
10029       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10030 
10031   EXPECT_EQ("\"splitmea\"\n"
10032             "\"trandomp\"\n"
10033             "\"oint\"",
10034             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10035 
10036   EXPECT_EQ("\"split/\"\n"
10037             "\"pathat/\"\n"
10038             "\"slashes\"",
10039             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10040 
10041   EXPECT_EQ("\"split/\"\n"
10042             "\"pathat/\"\n"
10043             "\"slashes\"",
10044             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10045   EXPECT_EQ("\"split at \"\n"
10046             "\"spaces/at/\"\n"
10047             "\"slashes.at.any$\"\n"
10048             "\"non-alphanumeric%\"\n"
10049             "\"1111111111characte\"\n"
10050             "\"rs\"",
10051             format("\"split at "
10052                    "spaces/at/"
10053                    "slashes.at."
10054                    "any$non-"
10055                    "alphanumeric%"
10056                    "1111111111characte"
10057                    "rs\"",
10058                    getLLVMStyleWithColumns(20)));
10059 
10060   // Verify that splitting the strings understands
10061   // Style::AlwaysBreakBeforeMultilineStrings.
10062   EXPECT_EQ("aaaaaaaaaaaa(\n"
10063             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10064             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10065             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10066                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10067                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10068                    getGoogleStyle()));
10069   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10070             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10071             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10072                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10073                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10074                    getGoogleStyle()));
10075   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10076             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10077             format("llvm::outs() << "
10078                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10079                    "aaaaaaaaaaaaaaaaaaa\";"));
10080   EXPECT_EQ("ffff(\n"
10081             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10082             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10083             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10084                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10085                    getGoogleStyle()));
10086 
10087   FormatStyle Style = getLLVMStyleWithColumns(12);
10088   Style.BreakStringLiterals = false;
10089   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10090 
10091   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10092   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10093   EXPECT_EQ("#define A \\\n"
10094             "  \"some \" \\\n"
10095             "  \"text \" \\\n"
10096             "  \"other\";",
10097             format("#define A \"some text other\";", AlignLeft));
10098 }
10099 
10100 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10101   EXPECT_EQ("C a = \"some more \"\n"
10102             "      \"text\";",
10103             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10104 }
10105 
10106 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10107   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10108   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10109   EXPECT_EQ("int i = a(b());",
10110             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10111 }
10112 
10113 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10114   EXPECT_EQ(
10115       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10116       "(\n"
10117       "    \"x\t\");",
10118       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10119              "aaaaaaa("
10120              "\"x\t\");"));
10121 }
10122 
10123 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10124   EXPECT_EQ(
10125       "u8\"utf8 string \"\n"
10126       "u8\"literal\";",
10127       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10128   EXPECT_EQ(
10129       "u\"utf16 string \"\n"
10130       "u\"literal\";",
10131       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10132   EXPECT_EQ(
10133       "U\"utf32 string \"\n"
10134       "U\"literal\";",
10135       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10136   EXPECT_EQ("L\"wide string \"\n"
10137             "L\"literal\";",
10138             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10139   EXPECT_EQ("@\"NSString \"\n"
10140             "@\"literal\";",
10141             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10142   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10143 
10144   // This input makes clang-format try to split the incomplete unicode escape
10145   // sequence, which used to lead to a crasher.
10146   verifyNoCrash(
10147       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10148       getLLVMStyleWithColumns(60));
10149 }
10150 
10151 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10152   FormatStyle Style = getGoogleStyleWithColumns(15);
10153   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10154   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10155   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10156   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10157   EXPECT_EQ("u8R\"x(raw literal)x\";",
10158             format("u8R\"x(raw literal)x\";", Style));
10159 }
10160 
10161 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10162   FormatStyle Style = getLLVMStyleWithColumns(20);
10163   EXPECT_EQ(
10164       "_T(\"aaaaaaaaaaaaaa\")\n"
10165       "_T(\"aaaaaaaaaaaaaa\")\n"
10166       "_T(\"aaaaaaaaaaaa\")",
10167       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10168   EXPECT_EQ("f(x,\n"
10169             "  _T(\"aaaaaaaaaaaa\")\n"
10170             "  _T(\"aaa\"),\n"
10171             "  z);",
10172             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10173 
10174   // FIXME: Handle embedded spaces in one iteration.
10175   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10176   //            "_T(\"aaaaaaaaaaaaa\")\n"
10177   //            "_T(\"aaaaaaaaaaaaa\")\n"
10178   //            "_T(\"a\")",
10179   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10180   //                   getLLVMStyleWithColumns(20)));
10181   EXPECT_EQ(
10182       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10183       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10184   EXPECT_EQ("f(\n"
10185             "#if !TEST\n"
10186             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10187             "#endif\n"
10188             ");",
10189             format("f(\n"
10190                    "#if !TEST\n"
10191                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10192                    "#endif\n"
10193                    ");"));
10194   EXPECT_EQ("f(\n"
10195             "\n"
10196             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10197             format("f(\n"
10198                    "\n"
10199                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10200 }
10201 
10202 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10203   // In a function call with two operands, the second can be broken with no line
10204   // break before it.
10205   EXPECT_EQ(
10206       "func(a, \"long long \"\n"
10207       "        \"long long\");",
10208       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10209   // In a function call with three operands, the second must be broken with a
10210   // line break before it.
10211   EXPECT_EQ("func(a,\n"
10212             "     \"long long long \"\n"
10213             "     \"long\",\n"
10214             "     c);",
10215             format("func(a, \"long long long long\", c);",
10216                    getLLVMStyleWithColumns(24)));
10217   // In a function call with three operands, the third must be broken with a
10218   // line break before it.
10219   EXPECT_EQ("func(a, b,\n"
10220             "     \"long long long \"\n"
10221             "     \"long\");",
10222             format("func(a, b, \"long long long long\");",
10223                    getLLVMStyleWithColumns(24)));
10224   // In a function call with three operands, both the second and the third must
10225   // be broken with a line break before them.
10226   EXPECT_EQ("func(a,\n"
10227             "     \"long long long \"\n"
10228             "     \"long\",\n"
10229             "     \"long long long \"\n"
10230             "     \"long\");",
10231             format("func(a, \"long long long long\", \"long long long long\");",
10232                    getLLVMStyleWithColumns(24)));
10233   // In a chain of << with two operands, the second can be broken with no line
10234   // break before it.
10235   EXPECT_EQ("a << \"line line \"\n"
10236             "     \"line\";",
10237             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10238   // In a chain of << with three operands, the second can be broken with no line
10239   // break before it.
10240   EXPECT_EQ(
10241       "abcde << \"line \"\n"
10242       "         \"line line\"\n"
10243       "      << c;",
10244       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10245   // In a chain of << with three operands, the third must be broken with a line
10246   // break before it.
10247   EXPECT_EQ(
10248       "a << b\n"
10249       "  << \"line line \"\n"
10250       "     \"line\";",
10251       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10252   // In a chain of << with three operands, the second can be broken with no line
10253   // break before it and the third must be broken with a line break before it.
10254   EXPECT_EQ("abcd << \"line line \"\n"
10255             "        \"line\"\n"
10256             "     << \"line line \"\n"
10257             "        \"line\";",
10258             format("abcd << \"line line line\" << \"line line line\";",
10259                    getLLVMStyleWithColumns(20)));
10260   // In a chain of binary operators with two operands, the second can be broken
10261   // with no line break before it.
10262   EXPECT_EQ(
10263       "abcd + \"line line \"\n"
10264       "       \"line line\";",
10265       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10266   // In a chain of binary operators with three operands, the second must be
10267   // broken with a line break before it.
10268   EXPECT_EQ("abcd +\n"
10269             "    \"line line \"\n"
10270             "    \"line line\" +\n"
10271             "    e;",
10272             format("abcd + \"line line line line\" + e;",
10273                    getLLVMStyleWithColumns(20)));
10274   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10275   // the first must be broken with a line break before it.
10276   FormatStyle Style = getLLVMStyleWithColumns(25);
10277   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10278   EXPECT_EQ("someFunction(\n"
10279             "    \"long long long \"\n"
10280             "    \"long\",\n"
10281             "    a);",
10282             format("someFunction(\"long long long long\", a);", Style));
10283 }
10284 
10285 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10286   EXPECT_EQ(
10287       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10288       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10289       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10290       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10291              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10292              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10293 }
10294 
10295 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10296   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10297             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10298   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10299             "multiline raw string literal xxxxxxxxxxxxxx\n"
10300             ")x\",\n"
10301             "              a),\n"
10302             "            b);",
10303             format("fffffffffff(g(R\"x(\n"
10304                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10305                    ")x\", a), b);",
10306                    getGoogleStyleWithColumns(20)));
10307   EXPECT_EQ("fffffffffff(\n"
10308             "    g(R\"x(qqq\n"
10309             "multiline raw string literal xxxxxxxxxxxxxx\n"
10310             ")x\",\n"
10311             "      a),\n"
10312             "    b);",
10313             format("fffffffffff(g(R\"x(qqq\n"
10314                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10315                    ")x\", a), b);",
10316                    getGoogleStyleWithColumns(20)));
10317 
10318   EXPECT_EQ("fffffffffff(R\"x(\n"
10319             "multiline raw string literal xxxxxxxxxxxxxx\n"
10320             ")x\");",
10321             format("fffffffffff(R\"x(\n"
10322                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10323                    ")x\");",
10324                    getGoogleStyleWithColumns(20)));
10325   EXPECT_EQ("fffffffffff(R\"x(\n"
10326             "multiline raw string literal xxxxxxxxxxxxxx\n"
10327             ")x\" + bbbbbb);",
10328             format("fffffffffff(R\"x(\n"
10329                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10330                    ")x\" +   bbbbbb);",
10331                    getGoogleStyleWithColumns(20)));
10332   EXPECT_EQ("fffffffffff(\n"
10333             "    R\"x(\n"
10334             "multiline raw string literal xxxxxxxxxxxxxx\n"
10335             ")x\" +\n"
10336             "    bbbbbb);",
10337             format("fffffffffff(\n"
10338                    " R\"x(\n"
10339                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10340                    ")x\" + bbbbbb);",
10341                    getGoogleStyleWithColumns(20)));
10342   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10343             format("fffffffffff(\n"
10344                    " R\"(single line raw string)\" + bbbbbb);"));
10345 }
10346 
10347 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10348   verifyFormat("string a = \"unterminated;");
10349   EXPECT_EQ("function(\"unterminated,\n"
10350             "         OtherParameter);",
10351             format("function(  \"unterminated,\n"
10352                    "    OtherParameter);"));
10353 }
10354 
10355 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10356   FormatStyle Style = getLLVMStyle();
10357   Style.Standard = FormatStyle::LS_Cpp03;
10358   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10359             format("#define x(_a) printf(\"foo\"_a);", Style));
10360 }
10361 
10362 TEST_F(FormatTest, CppLexVersion) {
10363   FormatStyle Style = getLLVMStyle();
10364   // Formatting of x * y differs if x is a type.
10365   verifyFormat("void foo() { MACRO(a * b); }", Style);
10366   verifyFormat("void foo() { MACRO(int *b); }", Style);
10367 
10368   // LLVM style uses latest lexer.
10369   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10370   Style.Standard = FormatStyle::LS_Cpp17;
10371   // But in c++17, char8_t isn't a keyword.
10372   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10373 }
10374 
10375 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10376 
10377 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10378   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10379             "             \"ddeeefff\");",
10380             format("someFunction(\"aaabbbcccdddeeefff\");",
10381                    getLLVMStyleWithColumns(25)));
10382   EXPECT_EQ("someFunction1234567890(\n"
10383             "    \"aaabbbcccdddeeefff\");",
10384             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10385                    getLLVMStyleWithColumns(26)));
10386   EXPECT_EQ("someFunction1234567890(\n"
10387             "    \"aaabbbcccdddeeeff\"\n"
10388             "    \"f\");",
10389             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10390                    getLLVMStyleWithColumns(25)));
10391   EXPECT_EQ("someFunction1234567890(\n"
10392             "    \"aaabbbcccdddeeeff\"\n"
10393             "    \"f\");",
10394             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10395                    getLLVMStyleWithColumns(24)));
10396   EXPECT_EQ("someFunction(\n"
10397             "    \"aaabbbcc ddde \"\n"
10398             "    \"efff\");",
10399             format("someFunction(\"aaabbbcc ddde efff\");",
10400                    getLLVMStyleWithColumns(25)));
10401   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10402             "             \"ddeeefff\");",
10403             format("someFunction(\"aaabbbccc ddeeefff\");",
10404                    getLLVMStyleWithColumns(25)));
10405   EXPECT_EQ("someFunction1234567890(\n"
10406             "    \"aaabb \"\n"
10407             "    \"cccdddeeefff\");",
10408             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10409                    getLLVMStyleWithColumns(25)));
10410   EXPECT_EQ("#define A          \\\n"
10411             "  string s =       \\\n"
10412             "      \"123456789\"  \\\n"
10413             "      \"0\";         \\\n"
10414             "  int i;",
10415             format("#define A string s = \"1234567890\"; int i;",
10416                    getLLVMStyleWithColumns(20)));
10417   EXPECT_EQ("someFunction(\n"
10418             "    \"aaabbbcc \"\n"
10419             "    \"dddeeefff\");",
10420             format("someFunction(\"aaabbbcc dddeeefff\");",
10421                    getLLVMStyleWithColumns(25)));
10422 }
10423 
10424 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10425   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10426   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10427   EXPECT_EQ("\"test\"\n"
10428             "\"\\n\"",
10429             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10430   EXPECT_EQ("\"tes\\\\\"\n"
10431             "\"n\"",
10432             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10433   EXPECT_EQ("\"\\\\\\\\\"\n"
10434             "\"\\n\"",
10435             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10436   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10437   EXPECT_EQ("\"\\uff01\"\n"
10438             "\"test\"",
10439             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10440   EXPECT_EQ("\"\\Uff01ff02\"",
10441             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10442   EXPECT_EQ("\"\\x000000000001\"\n"
10443             "\"next\"",
10444             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10445   EXPECT_EQ("\"\\x000000000001next\"",
10446             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10447   EXPECT_EQ("\"\\x000000000001\"",
10448             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10449   EXPECT_EQ("\"test\"\n"
10450             "\"\\000000\"\n"
10451             "\"000001\"",
10452             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10453   EXPECT_EQ("\"test\\000\"\n"
10454             "\"00000000\"\n"
10455             "\"1\"",
10456             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10457 }
10458 
10459 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10460   verifyFormat("void f() {\n"
10461                "  return g() {}\n"
10462                "  void h() {}");
10463   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10464                "g();\n"
10465                "}");
10466 }
10467 
10468 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10469   verifyFormat(
10470       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10471 }
10472 
10473 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10474   verifyFormat("class X {\n"
10475                "  void f() {\n"
10476                "  }\n"
10477                "};",
10478                getLLVMStyleWithColumns(12));
10479 }
10480 
10481 TEST_F(FormatTest, ConfigurableIndentWidth) {
10482   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10483   EightIndent.IndentWidth = 8;
10484   EightIndent.ContinuationIndentWidth = 8;
10485   verifyFormat("void f() {\n"
10486                "        someFunction();\n"
10487                "        if (true) {\n"
10488                "                f();\n"
10489                "        }\n"
10490                "}",
10491                EightIndent);
10492   verifyFormat("class X {\n"
10493                "        void f() {\n"
10494                "        }\n"
10495                "};",
10496                EightIndent);
10497   verifyFormat("int x[] = {\n"
10498                "        call(),\n"
10499                "        call()};",
10500                EightIndent);
10501 }
10502 
10503 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10504   verifyFormat("double\n"
10505                "f();",
10506                getLLVMStyleWithColumns(8));
10507 }
10508 
10509 TEST_F(FormatTest, ConfigurableUseOfTab) {
10510   FormatStyle Tab = getLLVMStyleWithColumns(42);
10511   Tab.IndentWidth = 8;
10512   Tab.UseTab = FormatStyle::UT_Always;
10513   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10514 
10515   EXPECT_EQ("if (aaaaaaaa && // q\n"
10516             "    bb)\t\t// w\n"
10517             "\t;",
10518             format("if (aaaaaaaa &&// q\n"
10519                    "bb)// w\n"
10520                    ";",
10521                    Tab));
10522   EXPECT_EQ("if (aaa && bbb) // w\n"
10523             "\t;",
10524             format("if(aaa&&bbb)// w\n"
10525                    ";",
10526                    Tab));
10527 
10528   verifyFormat("class X {\n"
10529                "\tvoid f() {\n"
10530                "\t\tsomeFunction(parameter1,\n"
10531                "\t\t\t     parameter2);\n"
10532                "\t}\n"
10533                "};",
10534                Tab);
10535   verifyFormat("#define A                        \\\n"
10536                "\tvoid f() {               \\\n"
10537                "\t\tsomeFunction(    \\\n"
10538                "\t\t    parameter1,  \\\n"
10539                "\t\t    parameter2); \\\n"
10540                "\t}",
10541                Tab);
10542   verifyFormat("int a;\t      // x\n"
10543                "int bbbbbbbb; // x\n",
10544                Tab);
10545 
10546   Tab.TabWidth = 4;
10547   Tab.IndentWidth = 8;
10548   verifyFormat("class TabWidth4Indent8 {\n"
10549                "\t\tvoid f() {\n"
10550                "\t\t\t\tsomeFunction(parameter1,\n"
10551                "\t\t\t\t\t\t\t parameter2);\n"
10552                "\t\t}\n"
10553                "};",
10554                Tab);
10555 
10556   Tab.TabWidth = 4;
10557   Tab.IndentWidth = 4;
10558   verifyFormat("class TabWidth4Indent4 {\n"
10559                "\tvoid f() {\n"
10560                "\t\tsomeFunction(parameter1,\n"
10561                "\t\t\t\t\t parameter2);\n"
10562                "\t}\n"
10563                "};",
10564                Tab);
10565 
10566   Tab.TabWidth = 8;
10567   Tab.IndentWidth = 4;
10568   verifyFormat("class TabWidth8Indent4 {\n"
10569                "    void f() {\n"
10570                "\tsomeFunction(parameter1,\n"
10571                "\t\t     parameter2);\n"
10572                "    }\n"
10573                "};",
10574                Tab);
10575 
10576   Tab.TabWidth = 8;
10577   Tab.IndentWidth = 8;
10578   EXPECT_EQ("/*\n"
10579             "\t      a\t\tcomment\n"
10580             "\t      in multiple lines\n"
10581             "       */",
10582             format("   /*\t \t \n"
10583                    " \t \t a\t\tcomment\t \t\n"
10584                    " \t \t in multiple lines\t\n"
10585                    " \t  */",
10586                    Tab));
10587 
10588   Tab.UseTab = FormatStyle::UT_ForIndentation;
10589   verifyFormat("{\n"
10590                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10591                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10592                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10593                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10594                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10595                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10596                "};",
10597                Tab);
10598   verifyFormat("enum AA {\n"
10599                "\ta1, // Force multiple lines\n"
10600                "\ta2,\n"
10601                "\ta3\n"
10602                "};",
10603                Tab);
10604   EXPECT_EQ("if (aaaaaaaa && // q\n"
10605             "    bb)         // w\n"
10606             "\t;",
10607             format("if (aaaaaaaa &&// q\n"
10608                    "bb)// w\n"
10609                    ";",
10610                    Tab));
10611   verifyFormat("class X {\n"
10612                "\tvoid f() {\n"
10613                "\t\tsomeFunction(parameter1,\n"
10614                "\t\t             parameter2);\n"
10615                "\t}\n"
10616                "};",
10617                Tab);
10618   verifyFormat("{\n"
10619                "\tQ(\n"
10620                "\t    {\n"
10621                "\t\t    int a;\n"
10622                "\t\t    someFunction(aaaaaaaa,\n"
10623                "\t\t                 bbbbbbb);\n"
10624                "\t    },\n"
10625                "\t    p);\n"
10626                "}",
10627                Tab);
10628   EXPECT_EQ("{\n"
10629             "\t/* aaaa\n"
10630             "\t   bbbb */\n"
10631             "}",
10632             format("{\n"
10633                    "/* aaaa\n"
10634                    "   bbbb */\n"
10635                    "}",
10636                    Tab));
10637   EXPECT_EQ("{\n"
10638             "\t/*\n"
10639             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10640             "\t  bbbbbbbbbbbbb\n"
10641             "\t*/\n"
10642             "}",
10643             format("{\n"
10644                    "/*\n"
10645                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10646                    "*/\n"
10647                    "}",
10648                    Tab));
10649   EXPECT_EQ("{\n"
10650             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10651             "\t// bbbbbbbbbbbbb\n"
10652             "}",
10653             format("{\n"
10654                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10655                    "}",
10656                    Tab));
10657   EXPECT_EQ("{\n"
10658             "\t/*\n"
10659             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10660             "\t  bbbbbbbbbbbbb\n"
10661             "\t*/\n"
10662             "}",
10663             format("{\n"
10664                    "\t/*\n"
10665                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10666                    "\t*/\n"
10667                    "}",
10668                    Tab));
10669   EXPECT_EQ("{\n"
10670             "\t/*\n"
10671             "\n"
10672             "\t*/\n"
10673             "}",
10674             format("{\n"
10675                    "\t/*\n"
10676                    "\n"
10677                    "\t*/\n"
10678                    "}",
10679                    Tab));
10680   EXPECT_EQ("{\n"
10681             "\t/*\n"
10682             " asdf\n"
10683             "\t*/\n"
10684             "}",
10685             format("{\n"
10686                    "\t/*\n"
10687                    " asdf\n"
10688                    "\t*/\n"
10689                    "}",
10690                    Tab));
10691 
10692   Tab.UseTab = FormatStyle::UT_Never;
10693   EXPECT_EQ("/*\n"
10694             "              a\t\tcomment\n"
10695             "              in multiple lines\n"
10696             "       */",
10697             format("   /*\t \t \n"
10698                    " \t \t a\t\tcomment\t \t\n"
10699                    " \t \t in multiple lines\t\n"
10700                    " \t  */",
10701                    Tab));
10702   EXPECT_EQ("/* some\n"
10703             "   comment */",
10704             format(" \t \t /* some\n"
10705                    " \t \t    comment */",
10706                    Tab));
10707   EXPECT_EQ("int a; /* some\n"
10708             "   comment */",
10709             format(" \t \t int a; /* some\n"
10710                    " \t \t    comment */",
10711                    Tab));
10712 
10713   EXPECT_EQ("int a; /* some\n"
10714             "comment */",
10715             format(" \t \t int\ta; /* some\n"
10716                    " \t \t    comment */",
10717                    Tab));
10718   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10719             "    comment */",
10720             format(" \t \t f(\"\t\t\"); /* some\n"
10721                    " \t \t    comment */",
10722                    Tab));
10723   EXPECT_EQ("{\n"
10724             "        /*\n"
10725             "         * Comment\n"
10726             "         */\n"
10727             "        int i;\n"
10728             "}",
10729             format("{\n"
10730                    "\t/*\n"
10731                    "\t * Comment\n"
10732                    "\t */\n"
10733                    "\t int i;\n"
10734                    "}",
10735                    Tab));
10736 
10737   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
10738   Tab.TabWidth = 8;
10739   Tab.IndentWidth = 8;
10740   EXPECT_EQ("if (aaaaaaaa && // q\n"
10741             "    bb)         // w\n"
10742             "\t;",
10743             format("if (aaaaaaaa &&// q\n"
10744                    "bb)// w\n"
10745                    ";",
10746                    Tab));
10747   EXPECT_EQ("if (aaa && bbb) // w\n"
10748             "\t;",
10749             format("if(aaa&&bbb)// w\n"
10750                    ";",
10751                    Tab));
10752   verifyFormat("class X {\n"
10753                "\tvoid f() {\n"
10754                "\t\tsomeFunction(parameter1,\n"
10755                "\t\t\t     parameter2);\n"
10756                "\t}\n"
10757                "};",
10758                Tab);
10759   verifyFormat("#define A                        \\\n"
10760                "\tvoid f() {               \\\n"
10761                "\t\tsomeFunction(    \\\n"
10762                "\t\t    parameter1,  \\\n"
10763                "\t\t    parameter2); \\\n"
10764                "\t}",
10765                Tab);
10766   Tab.TabWidth = 4;
10767   Tab.IndentWidth = 8;
10768   verifyFormat("class TabWidth4Indent8 {\n"
10769                "\t\tvoid f() {\n"
10770                "\t\t\t\tsomeFunction(parameter1,\n"
10771                "\t\t\t\t\t\t\t parameter2);\n"
10772                "\t\t}\n"
10773                "};",
10774                Tab);
10775   Tab.TabWidth = 4;
10776   Tab.IndentWidth = 4;
10777   verifyFormat("class TabWidth4Indent4 {\n"
10778                "\tvoid f() {\n"
10779                "\t\tsomeFunction(parameter1,\n"
10780                "\t\t\t\t\t parameter2);\n"
10781                "\t}\n"
10782                "};",
10783                Tab);
10784   Tab.TabWidth = 8;
10785   Tab.IndentWidth = 4;
10786   verifyFormat("class TabWidth8Indent4 {\n"
10787                "    void f() {\n"
10788                "\tsomeFunction(parameter1,\n"
10789                "\t\t     parameter2);\n"
10790                "    }\n"
10791                "};",
10792                Tab);
10793   Tab.TabWidth = 8;
10794   Tab.IndentWidth = 8;
10795   EXPECT_EQ("/*\n"
10796             "\t      a\t\tcomment\n"
10797             "\t      in multiple lines\n"
10798             "       */",
10799             format("   /*\t \t \n"
10800                    " \t \t a\t\tcomment\t \t\n"
10801                    " \t \t in multiple lines\t\n"
10802                    " \t  */",
10803                    Tab));
10804   verifyFormat("{\n"
10805                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10806                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10807                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10808                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10809                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10810                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10811                "};",
10812                Tab);
10813   verifyFormat("enum AA {\n"
10814                "\ta1, // Force multiple lines\n"
10815                "\ta2,\n"
10816                "\ta3\n"
10817                "};",
10818                Tab);
10819   EXPECT_EQ("if (aaaaaaaa && // q\n"
10820             "    bb)         // w\n"
10821             "\t;",
10822             format("if (aaaaaaaa &&// q\n"
10823                    "bb)// w\n"
10824                    ";",
10825                    Tab));
10826   verifyFormat("class X {\n"
10827                "\tvoid f() {\n"
10828                "\t\tsomeFunction(parameter1,\n"
10829                "\t\t\t     parameter2);\n"
10830                "\t}\n"
10831                "};",
10832                Tab);
10833   verifyFormat("{\n"
10834                "\tQ(\n"
10835                "\t    {\n"
10836                "\t\t    int a;\n"
10837                "\t\t    someFunction(aaaaaaaa,\n"
10838                "\t\t\t\t bbbbbbb);\n"
10839                "\t    },\n"
10840                "\t    p);\n"
10841                "}",
10842                Tab);
10843   EXPECT_EQ("{\n"
10844             "\t/* aaaa\n"
10845             "\t   bbbb */\n"
10846             "}",
10847             format("{\n"
10848                    "/* aaaa\n"
10849                    "   bbbb */\n"
10850                    "}",
10851                    Tab));
10852   EXPECT_EQ("{\n"
10853             "\t/*\n"
10854             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10855             "\t  bbbbbbbbbbbbb\n"
10856             "\t*/\n"
10857             "}",
10858             format("{\n"
10859                    "/*\n"
10860                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10861                    "*/\n"
10862                    "}",
10863                    Tab));
10864   EXPECT_EQ("{\n"
10865             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10866             "\t// bbbbbbbbbbbbb\n"
10867             "}",
10868             format("{\n"
10869                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10870                    "}",
10871                    Tab));
10872   EXPECT_EQ("{\n"
10873             "\t/*\n"
10874             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10875             "\t  bbbbbbbbbbbbb\n"
10876             "\t*/\n"
10877             "}",
10878             format("{\n"
10879                    "\t/*\n"
10880                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10881                    "\t*/\n"
10882                    "}",
10883                    Tab));
10884   EXPECT_EQ("{\n"
10885             "\t/*\n"
10886             "\n"
10887             "\t*/\n"
10888             "}",
10889             format("{\n"
10890                    "\t/*\n"
10891                    "\n"
10892                    "\t*/\n"
10893                    "}",
10894                    Tab));
10895   EXPECT_EQ("{\n"
10896             "\t/*\n"
10897             " asdf\n"
10898             "\t*/\n"
10899             "}",
10900             format("{\n"
10901                    "\t/*\n"
10902                    " asdf\n"
10903                    "\t*/\n"
10904                    "}",
10905                    Tab));
10906   EXPECT_EQ("/* some\n"
10907             "   comment */",
10908             format(" \t \t /* some\n"
10909                    " \t \t    comment */",
10910                    Tab));
10911   EXPECT_EQ("int a; /* some\n"
10912             "   comment */",
10913             format(" \t \t int a; /* some\n"
10914                    " \t \t    comment */",
10915                    Tab));
10916   EXPECT_EQ("int a; /* some\n"
10917             "comment */",
10918             format(" \t \t int\ta; /* some\n"
10919                    " \t \t    comment */",
10920                    Tab));
10921   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10922             "    comment */",
10923             format(" \t \t f(\"\t\t\"); /* some\n"
10924                    " \t \t    comment */",
10925                    Tab));
10926   EXPECT_EQ("{\n"
10927             "\t/*\n"
10928             "\t * Comment\n"
10929             "\t */\n"
10930             "\tint i;\n"
10931             "}",
10932             format("{\n"
10933                    "\t/*\n"
10934                    "\t * Comment\n"
10935                    "\t */\n"
10936                    "\t int i;\n"
10937                    "}",
10938                    Tab));
10939   Tab.TabWidth = 2;
10940   Tab.IndentWidth = 2;
10941   EXPECT_EQ("{\n"
10942             "\t/* aaaa\n"
10943             "\t\t bbbb */\n"
10944             "}",
10945             format("{\n"
10946                    "/* aaaa\n"
10947                    "\t bbbb */\n"
10948                    "}",
10949                    Tab));
10950   EXPECT_EQ("{\n"
10951             "\t/*\n"
10952             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10953             "\t\tbbbbbbbbbbbbb\n"
10954             "\t*/\n"
10955             "}",
10956             format("{\n"
10957                    "/*\n"
10958                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10959                    "*/\n"
10960                    "}",
10961                    Tab));
10962   Tab.AlignConsecutiveAssignments = true;
10963   Tab.AlignConsecutiveDeclarations = true;
10964   Tab.TabWidth = 4;
10965   Tab.IndentWidth = 4;
10966   verifyFormat("class Assign {\n"
10967                "\tvoid f() {\n"
10968                "\t\tint         x      = 123;\n"
10969                "\t\tint         random = 4;\n"
10970                "\t\tstd::string alphabet =\n"
10971                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
10972                "\t}\n"
10973                "};",
10974                Tab);
10975 
10976   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
10977   Tab.TabWidth = 8;
10978   Tab.IndentWidth = 8;
10979   EXPECT_EQ("if (aaaaaaaa && // q\n"
10980             "    bb)         // w\n"
10981             "\t;",
10982             format("if (aaaaaaaa &&// q\n"
10983                    "bb)// w\n"
10984                    ";",
10985                    Tab));
10986   EXPECT_EQ("if (aaa && bbb) // w\n"
10987             "\t;",
10988             format("if(aaa&&bbb)// w\n"
10989                    ";",
10990                    Tab));
10991   verifyFormat("class X {\n"
10992                "\tvoid f() {\n"
10993                "\t\tsomeFunction(parameter1,\n"
10994                "\t\t             parameter2);\n"
10995                "\t}\n"
10996                "};",
10997                Tab);
10998   verifyFormat("#define A                        \\\n"
10999                "\tvoid f() {               \\\n"
11000                "\t\tsomeFunction(    \\\n"
11001                "\t\t    parameter1,  \\\n"
11002                "\t\t    parameter2); \\\n"
11003                "\t}",
11004                Tab);
11005   Tab.TabWidth = 4;
11006   Tab.IndentWidth = 8;
11007   verifyFormat("class TabWidth4Indent8 {\n"
11008                "\t\tvoid f() {\n"
11009                "\t\t\t\tsomeFunction(parameter1,\n"
11010                "\t\t\t\t             parameter2);\n"
11011                "\t\t}\n"
11012                "};",
11013                Tab);
11014   Tab.TabWidth = 4;
11015   Tab.IndentWidth = 4;
11016   verifyFormat("class TabWidth4Indent4 {\n"
11017                "\tvoid f() {\n"
11018                "\t\tsomeFunction(parameter1,\n"
11019                "\t\t             parameter2);\n"
11020                "\t}\n"
11021                "};",
11022                Tab);
11023   Tab.TabWidth = 8;
11024   Tab.IndentWidth = 4;
11025   verifyFormat("class TabWidth8Indent4 {\n"
11026                "    void f() {\n"
11027                "\tsomeFunction(parameter1,\n"
11028                "\t             parameter2);\n"
11029                "    }\n"
11030                "};",
11031                Tab);
11032   Tab.TabWidth = 8;
11033   Tab.IndentWidth = 8;
11034   EXPECT_EQ("/*\n"
11035             "              a\t\tcomment\n"
11036             "              in multiple lines\n"
11037             "       */",
11038             format("   /*\t \t \n"
11039                    " \t \t a\t\tcomment\t \t\n"
11040                    " \t \t in multiple lines\t\n"
11041                    " \t  */",
11042                    Tab));
11043   verifyFormat("{\n"
11044                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11045                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11046                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11047                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11048                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11049                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11050                "};",
11051                Tab);
11052   verifyFormat("enum AA {\n"
11053                "\ta1, // Force multiple lines\n"
11054                "\ta2,\n"
11055                "\ta3\n"
11056                "};",
11057                Tab);
11058   EXPECT_EQ("if (aaaaaaaa && // q\n"
11059             "    bb)         // w\n"
11060             "\t;",
11061             format("if (aaaaaaaa &&// q\n"
11062                    "bb)// w\n"
11063                    ";",
11064                    Tab));
11065   verifyFormat("class X {\n"
11066                "\tvoid f() {\n"
11067                "\t\tsomeFunction(parameter1,\n"
11068                "\t\t             parameter2);\n"
11069                "\t}\n"
11070                "};",
11071                Tab);
11072   verifyFormat("{\n"
11073                "\tQ(\n"
11074                "\t    {\n"
11075                "\t\t    int a;\n"
11076                "\t\t    someFunction(aaaaaaaa,\n"
11077                "\t\t                 bbbbbbb);\n"
11078                "\t    },\n"
11079                "\t    p);\n"
11080                "}",
11081                Tab);
11082   EXPECT_EQ("{\n"
11083             "\t/* aaaa\n"
11084             "\t   bbbb */\n"
11085             "}",
11086             format("{\n"
11087                    "/* aaaa\n"
11088                    "   bbbb */\n"
11089                    "}",
11090                    Tab));
11091   EXPECT_EQ("{\n"
11092             "\t/*\n"
11093             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11094             "\t  bbbbbbbbbbbbb\n"
11095             "\t*/\n"
11096             "}",
11097             format("{\n"
11098                    "/*\n"
11099                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11100                    "*/\n"
11101                    "}",
11102                    Tab));
11103   EXPECT_EQ("{\n"
11104             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11105             "\t// bbbbbbbbbbbbb\n"
11106             "}",
11107             format("{\n"
11108                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11109                    "}",
11110                    Tab));
11111   EXPECT_EQ("{\n"
11112             "\t/*\n"
11113             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11114             "\t  bbbbbbbbbbbbb\n"
11115             "\t*/\n"
11116             "}",
11117             format("{\n"
11118                    "\t/*\n"
11119                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11120                    "\t*/\n"
11121                    "}",
11122                    Tab));
11123   EXPECT_EQ("{\n"
11124             "\t/*\n"
11125             "\n"
11126             "\t*/\n"
11127             "}",
11128             format("{\n"
11129                    "\t/*\n"
11130                    "\n"
11131                    "\t*/\n"
11132                    "}",
11133                    Tab));
11134   EXPECT_EQ("{\n"
11135             "\t/*\n"
11136             " asdf\n"
11137             "\t*/\n"
11138             "}",
11139             format("{\n"
11140                    "\t/*\n"
11141                    " asdf\n"
11142                    "\t*/\n"
11143                    "}",
11144                    Tab));
11145   EXPECT_EQ("/* some\n"
11146             "   comment */",
11147             format(" \t \t /* some\n"
11148                    " \t \t    comment */",
11149                    Tab));
11150   EXPECT_EQ("int a; /* some\n"
11151             "   comment */",
11152             format(" \t \t int a; /* some\n"
11153                    " \t \t    comment */",
11154                    Tab));
11155   EXPECT_EQ("int a; /* some\n"
11156             "comment */",
11157             format(" \t \t int\ta; /* some\n"
11158                    " \t \t    comment */",
11159                    Tab));
11160   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11161             "    comment */",
11162             format(" \t \t f(\"\t\t\"); /* some\n"
11163                    " \t \t    comment */",
11164                    Tab));
11165   EXPECT_EQ("{\n"
11166             "\t/*\n"
11167             "\t * Comment\n"
11168             "\t */\n"
11169             "\tint i;\n"
11170             "}",
11171             format("{\n"
11172                    "\t/*\n"
11173                    "\t * Comment\n"
11174                    "\t */\n"
11175                    "\t int i;\n"
11176                    "}",
11177                    Tab));
11178   Tab.TabWidth = 2;
11179   Tab.IndentWidth = 2;
11180   EXPECT_EQ("{\n"
11181             "\t/* aaaa\n"
11182             "\t   bbbb */\n"
11183             "}",
11184             format("{\n"
11185                    "/* aaaa\n"
11186                    "   bbbb */\n"
11187                    "}",
11188                    Tab));
11189   EXPECT_EQ("{\n"
11190             "\t/*\n"
11191             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11192             "\t  bbbbbbbbbbbbb\n"
11193             "\t*/\n"
11194             "}",
11195             format("{\n"
11196                    "/*\n"
11197                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11198                    "*/\n"
11199                    "}",
11200                    Tab));
11201   Tab.AlignConsecutiveAssignments = true;
11202   Tab.AlignConsecutiveDeclarations = true;
11203   Tab.TabWidth = 4;
11204   Tab.IndentWidth = 4;
11205   verifyFormat("class Assign {\n"
11206                "\tvoid f() {\n"
11207                "\t\tint         x      = 123;\n"
11208                "\t\tint         random = 4;\n"
11209                "\t\tstd::string alphabet =\n"
11210                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11211                "\t}\n"
11212                "};",
11213                Tab);
11214 }
11215 
11216 TEST_F(FormatTest, ZeroTabWidth) {
11217   FormatStyle Tab = getLLVMStyleWithColumns(42);
11218   Tab.IndentWidth = 8;
11219   Tab.UseTab = FormatStyle::UT_Never;
11220   Tab.TabWidth = 0;
11221   EXPECT_EQ("void a(){\n"
11222             "    // line starts with '\t'\n"
11223             "};",
11224             format("void a(){\n"
11225                    "\t// line starts with '\t'\n"
11226                    "};",
11227                    Tab));
11228 
11229   EXPECT_EQ("void a(){\n"
11230             "    // line starts with '\t'\n"
11231             "};",
11232             format("void a(){\n"
11233                    "\t\t// line starts with '\t'\n"
11234                    "};",
11235                    Tab));
11236 
11237   Tab.UseTab = FormatStyle::UT_ForIndentation;
11238   EXPECT_EQ("void a(){\n"
11239             "    // line starts with '\t'\n"
11240             "};",
11241             format("void a(){\n"
11242                    "\t// line starts with '\t'\n"
11243                    "};",
11244                    Tab));
11245 
11246   EXPECT_EQ("void a(){\n"
11247             "    // line starts with '\t'\n"
11248             "};",
11249             format("void a(){\n"
11250                    "\t\t// line starts with '\t'\n"
11251                    "};",
11252                    Tab));
11253 
11254   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11255   EXPECT_EQ("void a(){\n"
11256             "    // line starts with '\t'\n"
11257             "};",
11258             format("void a(){\n"
11259                    "\t// line starts with '\t'\n"
11260                    "};",
11261                    Tab));
11262 
11263   EXPECT_EQ("void a(){\n"
11264             "    // line starts with '\t'\n"
11265             "};",
11266             format("void a(){\n"
11267                    "\t\t// line starts with '\t'\n"
11268                    "};",
11269                    Tab));
11270 
11271   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11272   EXPECT_EQ("void a(){\n"
11273             "    // line starts with '\t'\n"
11274             "};",
11275             format("void a(){\n"
11276                    "\t// line starts with '\t'\n"
11277                    "};",
11278                    Tab));
11279 
11280   EXPECT_EQ("void a(){\n"
11281             "    // line starts with '\t'\n"
11282             "};",
11283             format("void a(){\n"
11284                    "\t\t// line starts with '\t'\n"
11285                    "};",
11286                    Tab));
11287 
11288   Tab.UseTab = FormatStyle::UT_Always;
11289   EXPECT_EQ("void a(){\n"
11290             "// line starts with '\t'\n"
11291             "};",
11292             format("void a(){\n"
11293                    "\t// line starts with '\t'\n"
11294                    "};",
11295                    Tab));
11296 
11297   EXPECT_EQ("void a(){\n"
11298             "// line starts with '\t'\n"
11299             "};",
11300             format("void a(){\n"
11301                    "\t\t// line starts with '\t'\n"
11302                    "};",
11303                    Tab));
11304 }
11305 
11306 TEST_F(FormatTest, CalculatesOriginalColumn) {
11307   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11308             "q\"; /* some\n"
11309             "       comment */",
11310             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11311                    "q\"; /* some\n"
11312                    "       comment */",
11313                    getLLVMStyle()));
11314   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11315             "/* some\n"
11316             "   comment */",
11317             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11318                    " /* some\n"
11319                    "    comment */",
11320                    getLLVMStyle()));
11321   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11322             "qqq\n"
11323             "/* some\n"
11324             "   comment */",
11325             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11326                    "qqq\n"
11327                    " /* some\n"
11328                    "    comment */",
11329                    getLLVMStyle()));
11330   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11331             "wwww; /* some\n"
11332             "         comment */",
11333             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11334                    "wwww; /* some\n"
11335                    "         comment */",
11336                    getLLVMStyle()));
11337 }
11338 
11339 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11340   FormatStyle NoSpace = getLLVMStyle();
11341   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11342 
11343   verifyFormat("while(true)\n"
11344                "  continue;",
11345                NoSpace);
11346   verifyFormat("for(;;)\n"
11347                "  continue;",
11348                NoSpace);
11349   verifyFormat("if(true)\n"
11350                "  f();\n"
11351                "else if(true)\n"
11352                "  f();",
11353                NoSpace);
11354   verifyFormat("do {\n"
11355                "  do_something();\n"
11356                "} while(something());",
11357                NoSpace);
11358   verifyFormat("switch(x) {\n"
11359                "default:\n"
11360                "  break;\n"
11361                "}",
11362                NoSpace);
11363   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11364   verifyFormat("size_t x = sizeof(x);", NoSpace);
11365   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11366   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11367   verifyFormat("alignas(128) char a[128];", NoSpace);
11368   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11369   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11370   verifyFormat("int f() throw(Deprecated);", NoSpace);
11371   verifyFormat("typedef void (*cb)(int);", NoSpace);
11372   verifyFormat("T A::operator()();", NoSpace);
11373   verifyFormat("X A::operator++(T);", NoSpace);
11374   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11375 
11376   FormatStyle Space = getLLVMStyle();
11377   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11378 
11379   verifyFormat("int f ();", Space);
11380   verifyFormat("void f (int a, T b) {\n"
11381                "  while (true)\n"
11382                "    continue;\n"
11383                "}",
11384                Space);
11385   verifyFormat("if (true)\n"
11386                "  f ();\n"
11387                "else if (true)\n"
11388                "  f ();",
11389                Space);
11390   verifyFormat("do {\n"
11391                "  do_something ();\n"
11392                "} while (something ());",
11393                Space);
11394   verifyFormat("switch (x) {\n"
11395                "default:\n"
11396                "  break;\n"
11397                "}",
11398                Space);
11399   verifyFormat("A::A () : a (1) {}", Space);
11400   verifyFormat("void f () __attribute__ ((asdf));", Space);
11401   verifyFormat("*(&a + 1);\n"
11402                "&((&a)[1]);\n"
11403                "a[(b + c) * d];\n"
11404                "(((a + 1) * 2) + 3) * 4;",
11405                Space);
11406   verifyFormat("#define A(x) x", Space);
11407   verifyFormat("#define A (x) x", Space);
11408   verifyFormat("#if defined(x)\n"
11409                "#endif",
11410                Space);
11411   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11412   verifyFormat("size_t x = sizeof (x);", Space);
11413   verifyFormat("auto f (int x) -> decltype (x);", Space);
11414   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11415   verifyFormat("alignas (128) char a[128];", Space);
11416   verifyFormat("size_t x = alignof (MyType);", Space);
11417   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11418   verifyFormat("int f () throw (Deprecated);", Space);
11419   verifyFormat("typedef void (*cb) (int);", Space);
11420   verifyFormat("T A::operator() ();", Space);
11421   verifyFormat("X A::operator++ (T);", Space);
11422   verifyFormat("auto lambda = [] () { return 0; };", Space);
11423   verifyFormat("int x = int (y);", Space);
11424 
11425   FormatStyle SomeSpace = getLLVMStyle();
11426   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11427 
11428   verifyFormat("[]() -> float {}", SomeSpace);
11429   verifyFormat("[] (auto foo) {}", SomeSpace);
11430   verifyFormat("[foo]() -> int {}", SomeSpace);
11431   verifyFormat("int f();", SomeSpace);
11432   verifyFormat("void f (int a, T b) {\n"
11433                "  while (true)\n"
11434                "    continue;\n"
11435                "}",
11436                SomeSpace);
11437   verifyFormat("if (true)\n"
11438                "  f();\n"
11439                "else if (true)\n"
11440                "  f();",
11441                SomeSpace);
11442   verifyFormat("do {\n"
11443                "  do_something();\n"
11444                "} while (something());",
11445                SomeSpace);
11446   verifyFormat("switch (x) {\n"
11447                "default:\n"
11448                "  break;\n"
11449                "}",
11450                SomeSpace);
11451   verifyFormat("A::A() : a (1) {}", SomeSpace);
11452   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11453   verifyFormat("*(&a + 1);\n"
11454                "&((&a)[1]);\n"
11455                "a[(b + c) * d];\n"
11456                "(((a + 1) * 2) + 3) * 4;",
11457                SomeSpace);
11458   verifyFormat("#define A(x) x", SomeSpace);
11459   verifyFormat("#define A (x) x", SomeSpace);
11460   verifyFormat("#if defined(x)\n"
11461                "#endif",
11462                SomeSpace);
11463   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11464   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11465   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11466   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11467   verifyFormat("alignas (128) char a[128];", SomeSpace);
11468   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11469   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11470                SomeSpace);
11471   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11472   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11473   verifyFormat("T A::operator()();", SomeSpace);
11474   verifyFormat("X A::operator++ (T);", SomeSpace);
11475   verifyFormat("int x = int (y);", SomeSpace);
11476   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11477 }
11478 
11479 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11480   FormatStyle Spaces = getLLVMStyle();
11481   Spaces.SpaceAfterLogicalNot = true;
11482 
11483   verifyFormat("bool x = ! y", Spaces);
11484   verifyFormat("if (! isFailure())", Spaces);
11485   verifyFormat("if (! (a && b))", Spaces);
11486   verifyFormat("\"Error!\"", Spaces);
11487   verifyFormat("! ! x", Spaces);
11488 }
11489 
11490 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11491   FormatStyle Spaces = getLLVMStyle();
11492 
11493   Spaces.SpacesInParentheses = true;
11494   verifyFormat("do_something( ::globalVar );", Spaces);
11495   verifyFormat("call( x, y, z );", Spaces);
11496   verifyFormat("call();", Spaces);
11497   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11498   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11499                Spaces);
11500   verifyFormat("while ( (bool)1 )\n"
11501                "  continue;",
11502                Spaces);
11503   verifyFormat("for ( ;; )\n"
11504                "  continue;",
11505                Spaces);
11506   verifyFormat("if ( true )\n"
11507                "  f();\n"
11508                "else if ( true )\n"
11509                "  f();",
11510                Spaces);
11511   verifyFormat("do {\n"
11512                "  do_something( (int)i );\n"
11513                "} while ( something() );",
11514                Spaces);
11515   verifyFormat("switch ( x ) {\n"
11516                "default:\n"
11517                "  break;\n"
11518                "}",
11519                Spaces);
11520 
11521   Spaces.SpacesInParentheses = false;
11522   Spaces.SpacesInCStyleCastParentheses = true;
11523   verifyFormat("Type *A = ( Type * )P;", Spaces);
11524   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11525   verifyFormat("x = ( int32 )y;", Spaces);
11526   verifyFormat("int a = ( int )(2.0f);", Spaces);
11527   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11528   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11529   verifyFormat("#define x (( int )-1)", Spaces);
11530 
11531   // Run the first set of tests again with:
11532   Spaces.SpacesInParentheses = false;
11533   Spaces.SpaceInEmptyParentheses = true;
11534   Spaces.SpacesInCStyleCastParentheses = true;
11535   verifyFormat("call(x, y, z);", Spaces);
11536   verifyFormat("call( );", Spaces);
11537   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11538   verifyFormat("while (( bool )1)\n"
11539                "  continue;",
11540                Spaces);
11541   verifyFormat("for (;;)\n"
11542                "  continue;",
11543                Spaces);
11544   verifyFormat("if (true)\n"
11545                "  f( );\n"
11546                "else if (true)\n"
11547                "  f( );",
11548                Spaces);
11549   verifyFormat("do {\n"
11550                "  do_something(( int )i);\n"
11551                "} while (something( ));",
11552                Spaces);
11553   verifyFormat("switch (x) {\n"
11554                "default:\n"
11555                "  break;\n"
11556                "}",
11557                Spaces);
11558 
11559   // Run the first set of tests again with:
11560   Spaces.SpaceAfterCStyleCast = true;
11561   verifyFormat("call(x, y, z);", Spaces);
11562   verifyFormat("call( );", Spaces);
11563   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11564   verifyFormat("while (( bool ) 1)\n"
11565                "  continue;",
11566                Spaces);
11567   verifyFormat("for (;;)\n"
11568                "  continue;",
11569                Spaces);
11570   verifyFormat("if (true)\n"
11571                "  f( );\n"
11572                "else if (true)\n"
11573                "  f( );",
11574                Spaces);
11575   verifyFormat("do {\n"
11576                "  do_something(( int ) i);\n"
11577                "} while (something( ));",
11578                Spaces);
11579   verifyFormat("switch (x) {\n"
11580                "default:\n"
11581                "  break;\n"
11582                "}",
11583                Spaces);
11584 
11585   // Run subset of tests again with:
11586   Spaces.SpacesInCStyleCastParentheses = false;
11587   Spaces.SpaceAfterCStyleCast = true;
11588   verifyFormat("while ((bool) 1)\n"
11589                "  continue;",
11590                Spaces);
11591   verifyFormat("do {\n"
11592                "  do_something((int) i);\n"
11593                "} while (something( ));",
11594                Spaces);
11595 }
11596 
11597 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
11598   verifyFormat("int a[5];");
11599   verifyFormat("a[3] += 42;");
11600 
11601   FormatStyle Spaces = getLLVMStyle();
11602   Spaces.SpacesInSquareBrackets = true;
11603   // Not lambdas.
11604   verifyFormat("int a[ 5 ];", Spaces);
11605   verifyFormat("a[ 3 ] += 42;", Spaces);
11606   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
11607   verifyFormat("double &operator[](int i) { return 0; }\n"
11608                "int i;",
11609                Spaces);
11610   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
11611   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
11612   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
11613   // Lambdas.
11614   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
11615   verifyFormat("return [ i, args... ] {};", Spaces);
11616   verifyFormat("int foo = [ &bar ]() {};", Spaces);
11617   verifyFormat("int foo = [ = ]() {};", Spaces);
11618   verifyFormat("int foo = [ & ]() {};", Spaces);
11619   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
11620   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
11621 }
11622 
11623 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
11624   FormatStyle NoSpaceStyle = getLLVMStyle();
11625   verifyFormat("int a[5];", NoSpaceStyle);
11626   verifyFormat("a[3] += 42;", NoSpaceStyle);
11627 
11628   verifyFormat("int a[1];", NoSpaceStyle);
11629   verifyFormat("int 1 [a];", NoSpaceStyle);
11630   verifyFormat("int a[1][2];", NoSpaceStyle);
11631   verifyFormat("a[7] = 5;", NoSpaceStyle);
11632   verifyFormat("int a = (f())[23];", NoSpaceStyle);
11633   verifyFormat("f([] {})", NoSpaceStyle);
11634 
11635   FormatStyle Space = getLLVMStyle();
11636   Space.SpaceBeforeSquareBrackets = true;
11637   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
11638   verifyFormat("return [i, args...] {};", Space);
11639 
11640   verifyFormat("int a [5];", Space);
11641   verifyFormat("a [3] += 42;", Space);
11642   verifyFormat("constexpr char hello []{\"hello\"};", Space);
11643   verifyFormat("double &operator[](int i) { return 0; }\n"
11644                "int i;",
11645                Space);
11646   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
11647   verifyFormat("int i = a [a][a]->f();", Space);
11648   verifyFormat("int i = (*b) [a]->f();", Space);
11649 
11650   verifyFormat("int a [1];", Space);
11651   verifyFormat("int 1 [a];", Space);
11652   verifyFormat("int a [1][2];", Space);
11653   verifyFormat("a [7] = 5;", Space);
11654   verifyFormat("int a = (f()) [23];", Space);
11655   verifyFormat("f([] {})", Space);
11656 }
11657 
11658 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
11659   verifyFormat("int a = 5;");
11660   verifyFormat("a += 42;");
11661   verifyFormat("a or_eq 8;");
11662 
11663   FormatStyle Spaces = getLLVMStyle();
11664   Spaces.SpaceBeforeAssignmentOperators = false;
11665   verifyFormat("int a= 5;", Spaces);
11666   verifyFormat("a+= 42;", Spaces);
11667   verifyFormat("a or_eq 8;", Spaces);
11668 }
11669 
11670 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
11671   verifyFormat("class Foo : public Bar {};");
11672   verifyFormat("Foo::Foo() : foo(1) {}");
11673   verifyFormat("for (auto a : b) {\n}");
11674   verifyFormat("int x = a ? b : c;");
11675   verifyFormat("{\n"
11676                "label0:\n"
11677                "  int x = 0;\n"
11678                "}");
11679   verifyFormat("switch (x) {\n"
11680                "case 1:\n"
11681                "default:\n"
11682                "}");
11683 
11684   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
11685   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
11686   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
11687   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
11688   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
11689   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
11690   verifyFormat("{\n"
11691                "label1:\n"
11692                "  int x = 0;\n"
11693                "}",
11694                CtorInitializerStyle);
11695   verifyFormat("switch (x) {\n"
11696                "case 1:\n"
11697                "default:\n"
11698                "}",
11699                CtorInitializerStyle);
11700   CtorInitializerStyle.BreakConstructorInitializers =
11701       FormatStyle::BCIS_AfterColon;
11702   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
11703                "    aaaaaaaaaaaaaaaa(1),\n"
11704                "    bbbbbbbbbbbbbbbb(2) {}",
11705                CtorInitializerStyle);
11706   CtorInitializerStyle.BreakConstructorInitializers =
11707       FormatStyle::BCIS_BeforeComma;
11708   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11709                "    : aaaaaaaaaaaaaaaa(1)\n"
11710                "    , bbbbbbbbbbbbbbbb(2) {}",
11711                CtorInitializerStyle);
11712   CtorInitializerStyle.BreakConstructorInitializers =
11713       FormatStyle::BCIS_BeforeColon;
11714   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11715                "    : aaaaaaaaaaaaaaaa(1),\n"
11716                "      bbbbbbbbbbbbbbbb(2) {}",
11717                CtorInitializerStyle);
11718   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
11719   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11720                ": aaaaaaaaaaaaaaaa(1),\n"
11721                "  bbbbbbbbbbbbbbbb(2) {}",
11722                CtorInitializerStyle);
11723 
11724   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
11725   InheritanceStyle.SpaceBeforeInheritanceColon = false;
11726   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
11727   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
11728   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
11729   verifyFormat("int x = a ? b : c;", InheritanceStyle);
11730   verifyFormat("{\n"
11731                "label2:\n"
11732                "  int x = 0;\n"
11733                "}",
11734                InheritanceStyle);
11735   verifyFormat("switch (x) {\n"
11736                "case 1:\n"
11737                "default:\n"
11738                "}",
11739                InheritanceStyle);
11740   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
11741   verifyFormat("class Foooooooooooooooooooooo:\n"
11742                "    public aaaaaaaaaaaaaaaaaa,\n"
11743                "    public bbbbbbbbbbbbbbbbbb {\n"
11744                "}",
11745                InheritanceStyle);
11746   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
11747   verifyFormat("class Foooooooooooooooooooooo\n"
11748                "    : public aaaaaaaaaaaaaaaaaa\n"
11749                "    , public bbbbbbbbbbbbbbbbbb {\n"
11750                "}",
11751                InheritanceStyle);
11752   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
11753   verifyFormat("class Foooooooooooooooooooooo\n"
11754                "    : public aaaaaaaaaaaaaaaaaa,\n"
11755                "      public bbbbbbbbbbbbbbbbbb {\n"
11756                "}",
11757                InheritanceStyle);
11758   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
11759   verifyFormat("class Foooooooooooooooooooooo\n"
11760                ": public aaaaaaaaaaaaaaaaaa,\n"
11761                "  public bbbbbbbbbbbbbbbbbb {}",
11762                InheritanceStyle);
11763 
11764   FormatStyle ForLoopStyle = getLLVMStyle();
11765   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
11766   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
11767   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
11768   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
11769   verifyFormat("int x = a ? b : c;", ForLoopStyle);
11770   verifyFormat("{\n"
11771                "label2:\n"
11772                "  int x = 0;\n"
11773                "}",
11774                ForLoopStyle);
11775   verifyFormat("switch (x) {\n"
11776                "case 1:\n"
11777                "default:\n"
11778                "}",
11779                ForLoopStyle);
11780 
11781   FormatStyle NoSpaceStyle = getLLVMStyle();
11782   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
11783   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
11784   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
11785   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
11786   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
11787   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
11788   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
11789   verifyFormat("{\n"
11790                "label3:\n"
11791                "  int x = 0;\n"
11792                "}",
11793                NoSpaceStyle);
11794   verifyFormat("switch (x) {\n"
11795                "case 1:\n"
11796                "default:\n"
11797                "}",
11798                NoSpaceStyle);
11799 }
11800 
11801 TEST_F(FormatTest, AlignConsecutiveMacros) {
11802   FormatStyle Style = getLLVMStyle();
11803   Style.AlignConsecutiveAssignments = true;
11804   Style.AlignConsecutiveDeclarations = true;
11805   Style.AlignConsecutiveMacros = false;
11806 
11807   verifyFormat("#define a 3\n"
11808                "#define bbbb 4\n"
11809                "#define ccc (5)",
11810                Style);
11811 
11812   verifyFormat("#define f(x) (x * x)\n"
11813                "#define fff(x, y, z) (x * y + z)\n"
11814                "#define ffff(x, y) (x - y)",
11815                Style);
11816 
11817   verifyFormat("#define foo(x, y) (x + y)\n"
11818                "#define bar (5, 6)(2 + 2)",
11819                Style);
11820 
11821   verifyFormat("#define a 3\n"
11822                "#define bbbb 4\n"
11823                "#define ccc (5)\n"
11824                "#define f(x) (x * x)\n"
11825                "#define fff(x, y, z) (x * y + z)\n"
11826                "#define ffff(x, y) (x - y)",
11827                Style);
11828 
11829   Style.AlignConsecutiveMacros = true;
11830   verifyFormat("#define a    3\n"
11831                "#define bbbb 4\n"
11832                "#define ccc  (5)",
11833                Style);
11834 
11835   verifyFormat("#define f(x)         (x * x)\n"
11836                "#define fff(x, y, z) (x * y + z)\n"
11837                "#define ffff(x, y)   (x - y)",
11838                Style);
11839 
11840   verifyFormat("#define foo(x, y) (x + y)\n"
11841                "#define bar       (5, 6)(2 + 2)",
11842                Style);
11843 
11844   verifyFormat("#define a            3\n"
11845                "#define bbbb         4\n"
11846                "#define ccc          (5)\n"
11847                "#define f(x)         (x * x)\n"
11848                "#define fff(x, y, z) (x * y + z)\n"
11849                "#define ffff(x, y)   (x - y)",
11850                Style);
11851 
11852   verifyFormat("#define a         5\n"
11853                "#define foo(x, y) (x + y)\n"
11854                "#define CCC       (6)\n"
11855                "auto lambda = []() {\n"
11856                "  auto  ii = 0;\n"
11857                "  float j  = 0;\n"
11858                "  return 0;\n"
11859                "};\n"
11860                "int   i  = 0;\n"
11861                "float i2 = 0;\n"
11862                "auto  v  = type{\n"
11863                "    i = 1,   //\n"
11864                "    (i = 2), //\n"
11865                "    i = 3    //\n"
11866                "};",
11867                Style);
11868 
11869   Style.AlignConsecutiveMacros = false;
11870   Style.ColumnLimit = 20;
11871 
11872   verifyFormat("#define a          \\\n"
11873                "  \"aabbbbbbbbbbbb\"\n"
11874                "#define D          \\\n"
11875                "  \"aabbbbbbbbbbbb\" \\\n"
11876                "  \"ccddeeeeeeeee\"\n"
11877                "#define B          \\\n"
11878                "  \"QQQQQQQQQQQQQ\"  \\\n"
11879                "  \"FFFFFFFFFFFFF\"  \\\n"
11880                "  \"LLLLLLLL\"\n",
11881                Style);
11882 
11883   Style.AlignConsecutiveMacros = true;
11884   verifyFormat("#define a          \\\n"
11885                "  \"aabbbbbbbbbbbb\"\n"
11886                "#define D          \\\n"
11887                "  \"aabbbbbbbbbbbb\" \\\n"
11888                "  \"ccddeeeeeeeee\"\n"
11889                "#define B          \\\n"
11890                "  \"QQQQQQQQQQQQQ\"  \\\n"
11891                "  \"FFFFFFFFFFFFF\"  \\\n"
11892                "  \"LLLLLLLL\"\n",
11893                Style);
11894 }
11895 
11896 TEST_F(FormatTest, AlignConsecutiveAssignments) {
11897   FormatStyle Alignment = getLLVMStyle();
11898   Alignment.AlignConsecutiveMacros = true;
11899   Alignment.AlignConsecutiveAssignments = false;
11900   verifyFormat("int a = 5;\n"
11901                "int oneTwoThree = 123;",
11902                Alignment);
11903   verifyFormat("int a = 5;\n"
11904                "int oneTwoThree = 123;",
11905                Alignment);
11906 
11907   Alignment.AlignConsecutiveAssignments = true;
11908   verifyFormat("int a           = 5;\n"
11909                "int oneTwoThree = 123;",
11910                Alignment);
11911   verifyFormat("int a           = method();\n"
11912                "int oneTwoThree = 133;",
11913                Alignment);
11914   verifyFormat("a &= 5;\n"
11915                "bcd *= 5;\n"
11916                "ghtyf += 5;\n"
11917                "dvfvdb -= 5;\n"
11918                "a /= 5;\n"
11919                "vdsvsv %= 5;\n"
11920                "sfdbddfbdfbb ^= 5;\n"
11921                "dvsdsv |= 5;\n"
11922                "int dsvvdvsdvvv = 123;",
11923                Alignment);
11924   verifyFormat("int i = 1, j = 10;\n"
11925                "something = 2000;",
11926                Alignment);
11927   verifyFormat("something = 2000;\n"
11928                "int i = 1, j = 10;\n",
11929                Alignment);
11930   verifyFormat("something = 2000;\n"
11931                "another   = 911;\n"
11932                "int i = 1, j = 10;\n"
11933                "oneMore = 1;\n"
11934                "i       = 2;",
11935                Alignment);
11936   verifyFormat("int a   = 5;\n"
11937                "int one = 1;\n"
11938                "method();\n"
11939                "int oneTwoThree = 123;\n"
11940                "int oneTwo      = 12;",
11941                Alignment);
11942   verifyFormat("int oneTwoThree = 123;\n"
11943                "int oneTwo      = 12;\n"
11944                "method();\n",
11945                Alignment);
11946   verifyFormat("int oneTwoThree = 123; // comment\n"
11947                "int oneTwo      = 12;  // comment",
11948                Alignment);
11949 
11950   // Bug 25167
11951   verifyFormat("#if A\n"
11952                "#else\n"
11953                "int aaaaaaaa = 12;\n"
11954                "#endif\n"
11955                "#if B\n"
11956                "#else\n"
11957                "int a = 12;\n"
11958                "#endif\n",
11959                Alignment);
11960   verifyFormat("enum foo {\n"
11961                "#if A\n"
11962                "#else\n"
11963                "  aaaaaaaa = 12;\n"
11964                "#endif\n"
11965                "#if B\n"
11966                "#else\n"
11967                "  a = 12;\n"
11968                "#endif\n"
11969                "};\n",
11970                Alignment);
11971 
11972   EXPECT_EQ("int a = 5;\n"
11973             "\n"
11974             "int oneTwoThree = 123;",
11975             format("int a       = 5;\n"
11976                    "\n"
11977                    "int oneTwoThree= 123;",
11978                    Alignment));
11979   EXPECT_EQ("int a   = 5;\n"
11980             "int one = 1;\n"
11981             "\n"
11982             "int oneTwoThree = 123;",
11983             format("int a = 5;\n"
11984                    "int one = 1;\n"
11985                    "\n"
11986                    "int oneTwoThree = 123;",
11987                    Alignment));
11988   EXPECT_EQ("int a   = 5;\n"
11989             "int one = 1;\n"
11990             "\n"
11991             "int oneTwoThree = 123;\n"
11992             "int oneTwo      = 12;",
11993             format("int a = 5;\n"
11994                    "int one = 1;\n"
11995                    "\n"
11996                    "int oneTwoThree = 123;\n"
11997                    "int oneTwo = 12;",
11998                    Alignment));
11999   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12000   verifyFormat("#define A \\\n"
12001                "  int aaaa       = 12; \\\n"
12002                "  int b          = 23; \\\n"
12003                "  int ccc        = 234; \\\n"
12004                "  int dddddddddd = 2345;",
12005                Alignment);
12006   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
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_Right;
12014   verifyFormat("#define A                                                      "
12015                "                \\\n"
12016                "  int aaaa       = 12;                                         "
12017                "                \\\n"
12018                "  int b          = 23;                                         "
12019                "                \\\n"
12020                "  int ccc        = 234;                                        "
12021                "                \\\n"
12022                "  int dddddddddd = 2345;",
12023                Alignment);
12024   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12025                "k = 4, int l = 5,\n"
12026                "                  int m = 6) {\n"
12027                "  int j      = 10;\n"
12028                "  otherThing = 1;\n"
12029                "}",
12030                Alignment);
12031   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12032                "  int i   = 1;\n"
12033                "  int j   = 2;\n"
12034                "  int big = 10000;\n"
12035                "}",
12036                Alignment);
12037   verifyFormat("class C {\n"
12038                "public:\n"
12039                "  int i            = 1;\n"
12040                "  virtual void f() = 0;\n"
12041                "};",
12042                Alignment);
12043   verifyFormat("int i = 1;\n"
12044                "if (SomeType t = getSomething()) {\n"
12045                "}\n"
12046                "int j   = 2;\n"
12047                "int big = 10000;",
12048                Alignment);
12049   verifyFormat("int j = 7;\n"
12050                "for (int k = 0; k < N; ++k) {\n"
12051                "}\n"
12052                "int j   = 2;\n"
12053                "int big = 10000;\n"
12054                "}",
12055                Alignment);
12056   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12057   verifyFormat("int i = 1;\n"
12058                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12059                "    = someLooooooooooooooooongFunction();\n"
12060                "int j = 2;",
12061                Alignment);
12062   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12063   verifyFormat("int i = 1;\n"
12064                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12065                "    someLooooooooooooooooongFunction();\n"
12066                "int j = 2;",
12067                Alignment);
12068 
12069   verifyFormat("auto lambda = []() {\n"
12070                "  auto i = 0;\n"
12071                "  return 0;\n"
12072                "};\n"
12073                "int i  = 0;\n"
12074                "auto v = type{\n"
12075                "    i = 1,   //\n"
12076                "    (i = 2), //\n"
12077                "    i = 3    //\n"
12078                "};",
12079                Alignment);
12080 
12081   verifyFormat(
12082       "int i      = 1;\n"
12083       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12084       "                          loooooooooooooooooooooongParameterB);\n"
12085       "int j      = 2;",
12086       Alignment);
12087 
12088   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12089                "          typename B   = very_long_type_name_1,\n"
12090                "          typename T_2 = very_long_type_name_2>\n"
12091                "auto foo() {}\n",
12092                Alignment);
12093   verifyFormat("int a, b = 1;\n"
12094                "int c  = 2;\n"
12095                "int dd = 3;\n",
12096                Alignment);
12097   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12098                "float b[1][] = {{3.f}};\n",
12099                Alignment);
12100   verifyFormat("for (int i = 0; i < 1; i++)\n"
12101                "  int x = 1;\n",
12102                Alignment);
12103   verifyFormat("for (i = 0; i < 1; i++)\n"
12104                "  x = 1;\n"
12105                "y = 1;\n",
12106                Alignment);
12107 
12108   Alignment.ReflowComments = true;
12109   Alignment.ColumnLimit = 50;
12110   EXPECT_EQ("int x   = 0;\n"
12111             "int yy  = 1; /// specificlennospace\n"
12112             "int zzz = 2;\n",
12113             format("int x   = 0;\n"
12114                    "int yy  = 1; ///specificlennospace\n"
12115                    "int zzz = 2;\n",
12116                    Alignment));
12117 }
12118 
12119 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12120   FormatStyle Alignment = getLLVMStyle();
12121   Alignment.AlignConsecutiveBitFields = true;
12122   verifyFormat("int const a     : 5;\n"
12123                "int oneTwoThree : 23;",
12124                Alignment);
12125 
12126   // Initializers are allowed starting with c++2a
12127   verifyFormat("int const a     : 5 = 1;\n"
12128                "int oneTwoThree : 23 = 0;",
12129                Alignment);
12130 
12131   Alignment.AlignConsecutiveDeclarations = true;
12132   verifyFormat("int const a           : 5;\n"
12133                "int       oneTwoThree : 23;",
12134                Alignment);
12135 
12136   verifyFormat("int const a           : 5;  // comment\n"
12137                "int       oneTwoThree : 23; // comment",
12138                Alignment);
12139 
12140   verifyFormat("int const a           : 5 = 1;\n"
12141                "int       oneTwoThree : 23 = 0;",
12142                Alignment);
12143 
12144   Alignment.AlignConsecutiveAssignments = true;
12145   verifyFormat("int const a           : 5  = 1;\n"
12146                "int       oneTwoThree : 23 = 0;",
12147                Alignment);
12148   verifyFormat("int const a           : 5  = {1};\n"
12149                "int       oneTwoThree : 23 = 0;",
12150                Alignment);
12151 
12152   // Known limitations: ':' is only recognized as a bitfield colon when
12153   // followed by a number.
12154   /*
12155   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12156                "int a           : 5;",
12157                Alignment);
12158   */
12159 }
12160 
12161 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12162   FormatStyle Alignment = getLLVMStyle();
12163   Alignment.AlignConsecutiveMacros = true;
12164   Alignment.AlignConsecutiveDeclarations = false;
12165   verifyFormat("float const a = 5;\n"
12166                "int oneTwoThree = 123;",
12167                Alignment);
12168   verifyFormat("int a = 5;\n"
12169                "float const oneTwoThree = 123;",
12170                Alignment);
12171 
12172   Alignment.AlignConsecutiveDeclarations = true;
12173   verifyFormat("float const a = 5;\n"
12174                "int         oneTwoThree = 123;",
12175                Alignment);
12176   verifyFormat("int         a = method();\n"
12177                "float const oneTwoThree = 133;",
12178                Alignment);
12179   verifyFormat("int i = 1, j = 10;\n"
12180                "something = 2000;",
12181                Alignment);
12182   verifyFormat("something = 2000;\n"
12183                "int i = 1, j = 10;\n",
12184                Alignment);
12185   verifyFormat("float      something = 2000;\n"
12186                "double     another = 911;\n"
12187                "int        i = 1, j = 10;\n"
12188                "const int *oneMore = 1;\n"
12189                "unsigned   i = 2;",
12190                Alignment);
12191   verifyFormat("float a = 5;\n"
12192                "int   one = 1;\n"
12193                "method();\n"
12194                "const double       oneTwoThree = 123;\n"
12195                "const unsigned int oneTwo = 12;",
12196                Alignment);
12197   verifyFormat("int      oneTwoThree{0}; // comment\n"
12198                "unsigned oneTwo;         // comment",
12199                Alignment);
12200   EXPECT_EQ("float const a = 5;\n"
12201             "\n"
12202             "int oneTwoThree = 123;",
12203             format("float const   a = 5;\n"
12204                    "\n"
12205                    "int           oneTwoThree= 123;",
12206                    Alignment));
12207   EXPECT_EQ("float a = 5;\n"
12208             "int   one = 1;\n"
12209             "\n"
12210             "unsigned oneTwoThree = 123;",
12211             format("float    a = 5;\n"
12212                    "int      one = 1;\n"
12213                    "\n"
12214                    "unsigned oneTwoThree = 123;",
12215                    Alignment));
12216   EXPECT_EQ("float a = 5;\n"
12217             "int   one = 1;\n"
12218             "\n"
12219             "unsigned oneTwoThree = 123;\n"
12220             "int      oneTwo = 12;",
12221             format("float    a = 5;\n"
12222                    "int one = 1;\n"
12223                    "\n"
12224                    "unsigned oneTwoThree = 123;\n"
12225                    "int oneTwo = 12;",
12226                    Alignment));
12227   // Function prototype alignment
12228   verifyFormat("int    a();\n"
12229                "double b();",
12230                Alignment);
12231   verifyFormat("int    a(int x);\n"
12232                "double b();",
12233                Alignment);
12234   unsigned OldColumnLimit = Alignment.ColumnLimit;
12235   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12236   // otherwise the function parameters will be re-flowed onto a single line.
12237   Alignment.ColumnLimit = 0;
12238   EXPECT_EQ("int    a(int   x,\n"
12239             "         float y);\n"
12240             "double b(int    x,\n"
12241             "         double y);",
12242             format("int a(int x,\n"
12243                    " float y);\n"
12244                    "double b(int x,\n"
12245                    " double y);",
12246                    Alignment));
12247   // This ensures that function parameters of function declarations are
12248   // correctly indented when their owning functions are indented.
12249   // The failure case here is for 'double y' to not be indented enough.
12250   EXPECT_EQ("double a(int x);\n"
12251             "int    b(int    y,\n"
12252             "         double z);",
12253             format("double a(int x);\n"
12254                    "int b(int y,\n"
12255                    " double z);",
12256                    Alignment));
12257   // Set ColumnLimit low so that we induce wrapping immediately after
12258   // the function name and opening paren.
12259   Alignment.ColumnLimit = 13;
12260   verifyFormat("int function(\n"
12261                "    int  x,\n"
12262                "    bool y);",
12263                Alignment);
12264   Alignment.ColumnLimit = OldColumnLimit;
12265   // Ensure function pointers don't screw up recursive alignment
12266   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12267                "double b();",
12268                Alignment);
12269   Alignment.AlignConsecutiveAssignments = true;
12270   // Ensure recursive alignment is broken by function braces, so that the
12271   // "a = 1" does not align with subsequent assignments inside the function
12272   // body.
12273   verifyFormat("int func(int a = 1) {\n"
12274                "  int b  = 2;\n"
12275                "  int cc = 3;\n"
12276                "}",
12277                Alignment);
12278   verifyFormat("float      something = 2000;\n"
12279                "double     another   = 911;\n"
12280                "int        i = 1, j = 10;\n"
12281                "const int *oneMore = 1;\n"
12282                "unsigned   i       = 2;",
12283                Alignment);
12284   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12285                "unsigned oneTwo      = 0;   // comment",
12286                Alignment);
12287   // Make sure that scope is correctly tracked, in the absence of braces
12288   verifyFormat("for (int i = 0; i < n; i++)\n"
12289                "  j = i;\n"
12290                "double x = 1;\n",
12291                Alignment);
12292   verifyFormat("if (int i = 0)\n"
12293                "  j = i;\n"
12294                "double x = 1;\n",
12295                Alignment);
12296   // Ensure operator[] and operator() are comprehended
12297   verifyFormat("struct test {\n"
12298                "  long long int foo();\n"
12299                "  int           operator[](int a);\n"
12300                "  double        bar();\n"
12301                "};\n",
12302                Alignment);
12303   verifyFormat("struct test {\n"
12304                "  long long int foo();\n"
12305                "  int           operator()(int a);\n"
12306                "  double        bar();\n"
12307                "};\n",
12308                Alignment);
12309   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12310             "  int const i   = 1;\n"
12311             "  int *     j   = 2;\n"
12312             "  int       big = 10000;\n"
12313             "\n"
12314             "  unsigned oneTwoThree = 123;\n"
12315             "  int      oneTwo      = 12;\n"
12316             "  method();\n"
12317             "  float k  = 2;\n"
12318             "  int   ll = 10000;\n"
12319             "}",
12320             format("void SomeFunction(int parameter= 0) {\n"
12321                    " int const  i= 1;\n"
12322                    "  int *j=2;\n"
12323                    " int big  =  10000;\n"
12324                    "\n"
12325                    "unsigned oneTwoThree  =123;\n"
12326                    "int oneTwo = 12;\n"
12327                    "  method();\n"
12328                    "float k= 2;\n"
12329                    "int ll=10000;\n"
12330                    "}",
12331                    Alignment));
12332   Alignment.AlignConsecutiveAssignments = false;
12333   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12334   verifyFormat("#define A \\\n"
12335                "  int       aaaa = 12; \\\n"
12336                "  float     b = 23; \\\n"
12337                "  const int ccc = 234; \\\n"
12338                "  unsigned  dddddddddd = 2345;",
12339                Alignment);
12340   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
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_Right;
12348   Alignment.ColumnLimit = 30;
12349   verifyFormat("#define A                    \\\n"
12350                "  int       aaaa = 12;       \\\n"
12351                "  float     b = 23;          \\\n"
12352                "  const int ccc = 234;       \\\n"
12353                "  int       dddddddddd = 2345;",
12354                Alignment);
12355   Alignment.ColumnLimit = 80;
12356   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12357                "k = 4, int l = 5,\n"
12358                "                  int m = 6) {\n"
12359                "  const int j = 10;\n"
12360                "  otherThing = 1;\n"
12361                "}",
12362                Alignment);
12363   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12364                "  int const i = 1;\n"
12365                "  int *     j = 2;\n"
12366                "  int       big = 10000;\n"
12367                "}",
12368                Alignment);
12369   verifyFormat("class C {\n"
12370                "public:\n"
12371                "  int          i = 1;\n"
12372                "  virtual void f() = 0;\n"
12373                "};",
12374                Alignment);
12375   verifyFormat("float i = 1;\n"
12376                "if (SomeType t = getSomething()) {\n"
12377                "}\n"
12378                "const unsigned j = 2;\n"
12379                "int            big = 10000;",
12380                Alignment);
12381   verifyFormat("float j = 7;\n"
12382                "for (int k = 0; k < N; ++k) {\n"
12383                "}\n"
12384                "unsigned j = 2;\n"
12385                "int      big = 10000;\n"
12386                "}",
12387                Alignment);
12388   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12389   verifyFormat("float              i = 1;\n"
12390                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12391                "    = someLooooooooooooooooongFunction();\n"
12392                "int j = 2;",
12393                Alignment);
12394   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12395   verifyFormat("int                i = 1;\n"
12396                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12397                "    someLooooooooooooooooongFunction();\n"
12398                "int j = 2;",
12399                Alignment);
12400 
12401   Alignment.AlignConsecutiveAssignments = true;
12402   verifyFormat("auto lambda = []() {\n"
12403                "  auto  ii = 0;\n"
12404                "  float j  = 0;\n"
12405                "  return 0;\n"
12406                "};\n"
12407                "int   i  = 0;\n"
12408                "float i2 = 0;\n"
12409                "auto  v  = type{\n"
12410                "    i = 1,   //\n"
12411                "    (i = 2), //\n"
12412                "    i = 3    //\n"
12413                "};",
12414                Alignment);
12415   Alignment.AlignConsecutiveAssignments = false;
12416 
12417   verifyFormat(
12418       "int      i = 1;\n"
12419       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12420       "                          loooooooooooooooooooooongParameterB);\n"
12421       "int      j = 2;",
12422       Alignment);
12423 
12424   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12425   // We expect declarations and assignments to align, as long as it doesn't
12426   // exceed the column limit, starting a new alignment sequence whenever it
12427   // happens.
12428   Alignment.AlignConsecutiveAssignments = true;
12429   Alignment.ColumnLimit = 30;
12430   verifyFormat("float    ii              = 1;\n"
12431                "unsigned j               = 2;\n"
12432                "int someVerylongVariable = 1;\n"
12433                "AnotherLongType  ll = 123456;\n"
12434                "VeryVeryLongType k  = 2;\n"
12435                "int              myvar = 1;",
12436                Alignment);
12437   Alignment.ColumnLimit = 80;
12438   Alignment.AlignConsecutiveAssignments = false;
12439 
12440   verifyFormat(
12441       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12442       "          typename LongType, typename B>\n"
12443       "auto foo() {}\n",
12444       Alignment);
12445   verifyFormat("float a, b = 1;\n"
12446                "int   c = 2;\n"
12447                "int   dd = 3;\n",
12448                Alignment);
12449   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12450                "float b[1][] = {{3.f}};\n",
12451                Alignment);
12452   Alignment.AlignConsecutiveAssignments = true;
12453   verifyFormat("float a, b = 1;\n"
12454                "int   c  = 2;\n"
12455                "int   dd = 3;\n",
12456                Alignment);
12457   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12458                "float b[1][] = {{3.f}};\n",
12459                Alignment);
12460   Alignment.AlignConsecutiveAssignments = false;
12461 
12462   Alignment.ColumnLimit = 30;
12463   Alignment.BinPackParameters = false;
12464   verifyFormat("void foo(float     a,\n"
12465                "         float     b,\n"
12466                "         int       c,\n"
12467                "         uint32_t *d) {\n"
12468                "  int *  e = 0;\n"
12469                "  float  f = 0;\n"
12470                "  double g = 0;\n"
12471                "}\n"
12472                "void bar(ino_t     a,\n"
12473                "         int       b,\n"
12474                "         uint32_t *c,\n"
12475                "         bool      d) {}\n",
12476                Alignment);
12477   Alignment.BinPackParameters = true;
12478   Alignment.ColumnLimit = 80;
12479 
12480   // Bug 33507
12481   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12482   verifyFormat(
12483       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12484       "  static const Version verVs2017;\n"
12485       "  return true;\n"
12486       "});\n",
12487       Alignment);
12488   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12489 
12490   // See llvm.org/PR35641
12491   Alignment.AlignConsecutiveDeclarations = true;
12492   verifyFormat("int func() { //\n"
12493                "  int      b;\n"
12494                "  unsigned c;\n"
12495                "}",
12496                Alignment);
12497 
12498   // See PR37175
12499   FormatStyle Style = getMozillaStyle();
12500   Style.AlignConsecutiveDeclarations = true;
12501   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12502             "foo(int a);",
12503             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12504 }
12505 
12506 TEST_F(FormatTest, LinuxBraceBreaking) {
12507   FormatStyle LinuxBraceStyle = getLLVMStyle();
12508   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12509   verifyFormat("namespace a\n"
12510                "{\n"
12511                "class A\n"
12512                "{\n"
12513                "  void f()\n"
12514                "  {\n"
12515                "    if (true) {\n"
12516                "      a();\n"
12517                "      b();\n"
12518                "    } else {\n"
12519                "      a();\n"
12520                "    }\n"
12521                "  }\n"
12522                "  void g() { return; }\n"
12523                "};\n"
12524                "struct B {\n"
12525                "  int x;\n"
12526                "};\n"
12527                "} // namespace a\n",
12528                LinuxBraceStyle);
12529   verifyFormat("enum X {\n"
12530                "  Y = 0,\n"
12531                "}\n",
12532                LinuxBraceStyle);
12533   verifyFormat("struct S {\n"
12534                "  int Type;\n"
12535                "  union {\n"
12536                "    int x;\n"
12537                "    double y;\n"
12538                "  } Value;\n"
12539                "  class C\n"
12540                "  {\n"
12541                "    MyFavoriteType Value;\n"
12542                "  } Class;\n"
12543                "}\n",
12544                LinuxBraceStyle);
12545 }
12546 
12547 TEST_F(FormatTest, MozillaBraceBreaking) {
12548   FormatStyle MozillaBraceStyle = getLLVMStyle();
12549   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
12550   MozillaBraceStyle.FixNamespaceComments = false;
12551   verifyFormat("namespace a {\n"
12552                "class A\n"
12553                "{\n"
12554                "  void f()\n"
12555                "  {\n"
12556                "    if (true) {\n"
12557                "      a();\n"
12558                "      b();\n"
12559                "    }\n"
12560                "  }\n"
12561                "  void g() { return; }\n"
12562                "};\n"
12563                "enum E\n"
12564                "{\n"
12565                "  A,\n"
12566                "  // foo\n"
12567                "  B,\n"
12568                "  C\n"
12569                "};\n"
12570                "struct B\n"
12571                "{\n"
12572                "  int x;\n"
12573                "};\n"
12574                "}\n",
12575                MozillaBraceStyle);
12576   verifyFormat("struct S\n"
12577                "{\n"
12578                "  int Type;\n"
12579                "  union\n"
12580                "  {\n"
12581                "    int x;\n"
12582                "    double y;\n"
12583                "  } Value;\n"
12584                "  class C\n"
12585                "  {\n"
12586                "    MyFavoriteType Value;\n"
12587                "  } Class;\n"
12588                "}\n",
12589                MozillaBraceStyle);
12590 }
12591 
12592 TEST_F(FormatTest, StroustrupBraceBreaking) {
12593   FormatStyle StroustrupBraceStyle = getLLVMStyle();
12594   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12595   verifyFormat("namespace a {\n"
12596                "class A {\n"
12597                "  void f()\n"
12598                "  {\n"
12599                "    if (true) {\n"
12600                "      a();\n"
12601                "      b();\n"
12602                "    }\n"
12603                "  }\n"
12604                "  void g() { return; }\n"
12605                "};\n"
12606                "struct B {\n"
12607                "  int x;\n"
12608                "};\n"
12609                "} // namespace a\n",
12610                StroustrupBraceStyle);
12611 
12612   verifyFormat("void foo()\n"
12613                "{\n"
12614                "  if (a) {\n"
12615                "    a();\n"
12616                "  }\n"
12617                "  else {\n"
12618                "    b();\n"
12619                "  }\n"
12620                "}\n",
12621                StroustrupBraceStyle);
12622 
12623   verifyFormat("#ifdef _DEBUG\n"
12624                "int foo(int i = 0)\n"
12625                "#else\n"
12626                "int foo(int i = 5)\n"
12627                "#endif\n"
12628                "{\n"
12629                "  return i;\n"
12630                "}",
12631                StroustrupBraceStyle);
12632 
12633   verifyFormat("void foo() {}\n"
12634                "void bar()\n"
12635                "#ifdef _DEBUG\n"
12636                "{\n"
12637                "  foo();\n"
12638                "}\n"
12639                "#else\n"
12640                "{\n"
12641                "}\n"
12642                "#endif",
12643                StroustrupBraceStyle);
12644 
12645   verifyFormat("void foobar() { int i = 5; }\n"
12646                "#ifdef _DEBUG\n"
12647                "void bar() {}\n"
12648                "#else\n"
12649                "void bar() { foobar(); }\n"
12650                "#endif",
12651                StroustrupBraceStyle);
12652 }
12653 
12654 TEST_F(FormatTest, AllmanBraceBreaking) {
12655   FormatStyle AllmanBraceStyle = getLLVMStyle();
12656   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
12657 
12658   EXPECT_EQ("namespace a\n"
12659             "{\n"
12660             "void f();\n"
12661             "void g();\n"
12662             "} // namespace a\n",
12663             format("namespace a\n"
12664                    "{\n"
12665                    "void f();\n"
12666                    "void g();\n"
12667                    "}\n",
12668                    AllmanBraceStyle));
12669 
12670   verifyFormat("namespace a\n"
12671                "{\n"
12672                "class A\n"
12673                "{\n"
12674                "  void f()\n"
12675                "  {\n"
12676                "    if (true)\n"
12677                "    {\n"
12678                "      a();\n"
12679                "      b();\n"
12680                "    }\n"
12681                "  }\n"
12682                "  void g() { return; }\n"
12683                "};\n"
12684                "struct B\n"
12685                "{\n"
12686                "  int x;\n"
12687                "};\n"
12688                "union C\n"
12689                "{\n"
12690                "};\n"
12691                "} // namespace a",
12692                AllmanBraceStyle);
12693 
12694   verifyFormat("void f()\n"
12695                "{\n"
12696                "  if (true)\n"
12697                "  {\n"
12698                "    a();\n"
12699                "  }\n"
12700                "  else if (false)\n"
12701                "  {\n"
12702                "    b();\n"
12703                "  }\n"
12704                "  else\n"
12705                "  {\n"
12706                "    c();\n"
12707                "  }\n"
12708                "}\n",
12709                AllmanBraceStyle);
12710 
12711   verifyFormat("void f()\n"
12712                "{\n"
12713                "  for (int i = 0; i < 10; ++i)\n"
12714                "  {\n"
12715                "    a();\n"
12716                "  }\n"
12717                "  while (false)\n"
12718                "  {\n"
12719                "    b();\n"
12720                "  }\n"
12721                "  do\n"
12722                "  {\n"
12723                "    c();\n"
12724                "  } while (false)\n"
12725                "}\n",
12726                AllmanBraceStyle);
12727 
12728   verifyFormat("void f(int a)\n"
12729                "{\n"
12730                "  switch (a)\n"
12731                "  {\n"
12732                "  case 0:\n"
12733                "    break;\n"
12734                "  case 1:\n"
12735                "  {\n"
12736                "    break;\n"
12737                "  }\n"
12738                "  case 2:\n"
12739                "  {\n"
12740                "  }\n"
12741                "  break;\n"
12742                "  default:\n"
12743                "    break;\n"
12744                "  }\n"
12745                "}\n",
12746                AllmanBraceStyle);
12747 
12748   verifyFormat("enum X\n"
12749                "{\n"
12750                "  Y = 0,\n"
12751                "}\n",
12752                AllmanBraceStyle);
12753   verifyFormat("enum X\n"
12754                "{\n"
12755                "  Y = 0\n"
12756                "}\n",
12757                AllmanBraceStyle);
12758 
12759   verifyFormat("@interface BSApplicationController ()\n"
12760                "{\n"
12761                "@private\n"
12762                "  id _extraIvar;\n"
12763                "}\n"
12764                "@end\n",
12765                AllmanBraceStyle);
12766 
12767   verifyFormat("#ifdef _DEBUG\n"
12768                "int foo(int i = 0)\n"
12769                "#else\n"
12770                "int foo(int i = 5)\n"
12771                "#endif\n"
12772                "{\n"
12773                "  return i;\n"
12774                "}",
12775                AllmanBraceStyle);
12776 
12777   verifyFormat("void foo() {}\n"
12778                "void bar()\n"
12779                "#ifdef _DEBUG\n"
12780                "{\n"
12781                "  foo();\n"
12782                "}\n"
12783                "#else\n"
12784                "{\n"
12785                "}\n"
12786                "#endif",
12787                AllmanBraceStyle);
12788 
12789   verifyFormat("void foobar() { int i = 5; }\n"
12790                "#ifdef _DEBUG\n"
12791                "void bar() {}\n"
12792                "#else\n"
12793                "void bar() { foobar(); }\n"
12794                "#endif",
12795                AllmanBraceStyle);
12796 
12797   // This shouldn't affect ObjC blocks..
12798   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
12799                "  // ...\n"
12800                "  int i;\n"
12801                "}];",
12802                AllmanBraceStyle);
12803   verifyFormat("void (^block)(void) = ^{\n"
12804                "  // ...\n"
12805                "  int i;\n"
12806                "};",
12807                AllmanBraceStyle);
12808   // .. or dict literals.
12809   verifyFormat("void f()\n"
12810                "{\n"
12811                "  // ...\n"
12812                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
12813                "}",
12814                AllmanBraceStyle);
12815   verifyFormat("void f()\n"
12816                "{\n"
12817                "  // ...\n"
12818                "  [object someMethod:@{a : @\"b\"}];\n"
12819                "}",
12820                AllmanBraceStyle);
12821   verifyFormat("int f()\n"
12822                "{ // comment\n"
12823                "  return 42;\n"
12824                "}",
12825                AllmanBraceStyle);
12826 
12827   AllmanBraceStyle.ColumnLimit = 19;
12828   verifyFormat("void f() { int i; }", AllmanBraceStyle);
12829   AllmanBraceStyle.ColumnLimit = 18;
12830   verifyFormat("void f()\n"
12831                "{\n"
12832                "  int i;\n"
12833                "}",
12834                AllmanBraceStyle);
12835   AllmanBraceStyle.ColumnLimit = 80;
12836 
12837   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
12838   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
12839       FormatStyle::SIS_WithoutElse;
12840   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
12841   verifyFormat("void f(bool b)\n"
12842                "{\n"
12843                "  if (b)\n"
12844                "  {\n"
12845                "    return;\n"
12846                "  }\n"
12847                "}\n",
12848                BreakBeforeBraceShortIfs);
12849   verifyFormat("void f(bool b)\n"
12850                "{\n"
12851                "  if constexpr (b)\n"
12852                "  {\n"
12853                "    return;\n"
12854                "  }\n"
12855                "}\n",
12856                BreakBeforeBraceShortIfs);
12857   verifyFormat("void f(bool b)\n"
12858                "{\n"
12859                "  if CONSTEXPR (b)\n"
12860                "  {\n"
12861                "    return;\n"
12862                "  }\n"
12863                "}\n",
12864                BreakBeforeBraceShortIfs);
12865   verifyFormat("void f(bool b)\n"
12866                "{\n"
12867                "  if (b) return;\n"
12868                "}\n",
12869                BreakBeforeBraceShortIfs);
12870   verifyFormat("void f(bool b)\n"
12871                "{\n"
12872                "  if constexpr (b) return;\n"
12873                "}\n",
12874                BreakBeforeBraceShortIfs);
12875   verifyFormat("void f(bool b)\n"
12876                "{\n"
12877                "  if CONSTEXPR (b) return;\n"
12878                "}\n",
12879                BreakBeforeBraceShortIfs);
12880   verifyFormat("void f(bool b)\n"
12881                "{\n"
12882                "  while (b)\n"
12883                "  {\n"
12884                "    return;\n"
12885                "  }\n"
12886                "}\n",
12887                BreakBeforeBraceShortIfs);
12888 }
12889 
12890 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
12891   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
12892   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
12893 
12894   // Make a few changes to the style for testing purposes
12895   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
12896       FormatStyle::SFS_Empty;
12897   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
12898   WhitesmithsBraceStyle.ColumnLimit = 0;
12899 
12900   // FIXME: this test case can't decide whether there should be a blank line
12901   // after the ~D() line or not. It adds one if one doesn't exist in the test
12902   // and it removes the line if one exists.
12903   /*
12904   verifyFormat("class A;\n"
12905                "namespace B\n"
12906                "  {\n"
12907                "class C;\n"
12908                "// Comment\n"
12909                "class D\n"
12910                "  {\n"
12911                "public:\n"
12912                "  D();\n"
12913                "  ~D() {}\n"
12914                "private:\n"
12915                "  enum E\n"
12916                "    {\n"
12917                "    F\n"
12918                "    }\n"
12919                "  };\n"
12920                "  } // namespace B\n",
12921                WhitesmithsBraceStyle);
12922   */
12923 
12924   verifyFormat("namespace a\n"
12925                "  {\n"
12926                "class A\n"
12927                "  {\n"
12928                "  void f()\n"
12929                "    {\n"
12930                "    if (true)\n"
12931                "      {\n"
12932                "      a();\n"
12933                "      b();\n"
12934                "      }\n"
12935                "    }\n"
12936                "  void g()\n"
12937                "    {\n"
12938                "    return;\n"
12939                "    }\n"
12940                "  };\n"
12941                "struct B\n"
12942                "  {\n"
12943                "  int x;\n"
12944                "  };\n"
12945                "  } // namespace a",
12946                WhitesmithsBraceStyle);
12947 
12948   verifyFormat("void f()\n"
12949                "  {\n"
12950                "  if (true)\n"
12951                "    {\n"
12952                "    a();\n"
12953                "    }\n"
12954                "  else if (false)\n"
12955                "    {\n"
12956                "    b();\n"
12957                "    }\n"
12958                "  else\n"
12959                "    {\n"
12960                "    c();\n"
12961                "    }\n"
12962                "  }\n",
12963                WhitesmithsBraceStyle);
12964 
12965   verifyFormat("void f()\n"
12966                "  {\n"
12967                "  for (int i = 0; i < 10; ++i)\n"
12968                "    {\n"
12969                "    a();\n"
12970                "    }\n"
12971                "  while (false)\n"
12972                "    {\n"
12973                "    b();\n"
12974                "    }\n"
12975                "  do\n"
12976                "    {\n"
12977                "    c();\n"
12978                "    } while (false)\n"
12979                "  }\n",
12980                WhitesmithsBraceStyle);
12981 
12982   WhitesmithsBraceStyle.IndentCaseBlocks = true;
12983   verifyFormat("void switchTest1(int a)\n"
12984                "  {\n"
12985                "  switch (a)\n"
12986                "    {\n"
12987                "    case 2:\n"
12988                "      {\n"
12989                "      }\n"
12990                "    break;\n"
12991                "    }\n"
12992                "  }\n",
12993                WhitesmithsBraceStyle);
12994 
12995   verifyFormat("void switchTest2(int a)\n"
12996                "  {\n"
12997                "  switch (a)\n"
12998                "    {\n"
12999                "    case 0:\n"
13000                "    break;\n"
13001                "    case 1:\n"
13002                "      {\n"
13003                "      break;\n"
13004                "      }\n"
13005                "    case 2:\n"
13006                "      {\n"
13007                "      }\n"
13008                "    break;\n"
13009                "    default:\n"
13010                "    break;\n"
13011                "    }\n"
13012                "  }\n",
13013                WhitesmithsBraceStyle);
13014 
13015   verifyFormat("void switchTest3(int a)\n"
13016                "  {\n"
13017                "  switch (a)\n"
13018                "    {\n"
13019                "    case 0:\n"
13020                "      {\n"
13021                "      foo(x);\n"
13022                "      }\n"
13023                "    break;\n"
13024                "    default:\n"
13025                "      {\n"
13026                "      foo(1);\n"
13027                "      }\n"
13028                "    break;\n"
13029                "    }\n"
13030                "  }\n",
13031                WhitesmithsBraceStyle);
13032 
13033   WhitesmithsBraceStyle.IndentCaseBlocks = false;
13034 
13035   verifyFormat("void switchTest4(int a)\n"
13036                "  {\n"
13037                "  switch (a)\n"
13038                "    {\n"
13039                "    case 2:\n"
13040                "    {\n"
13041                "    }\n"
13042                "    break;\n"
13043                "    }\n"
13044                "  }\n",
13045                WhitesmithsBraceStyle);
13046 
13047   verifyFormat("void switchTest5(int a)\n"
13048                "  {\n"
13049                "  switch (a)\n"
13050                "    {\n"
13051                "    case 0:\n"
13052                "    break;\n"
13053                "    case 1:\n"
13054                "    {\n"
13055                "    foo();\n"
13056                "    break;\n"
13057                "    }\n"
13058                "    case 2:\n"
13059                "    {\n"
13060                "    }\n"
13061                "    break;\n"
13062                "    default:\n"
13063                "    break;\n"
13064                "    }\n"
13065                "  }\n",
13066                WhitesmithsBraceStyle);
13067 
13068   verifyFormat("void switchTest6(int a)\n"
13069                "  {\n"
13070                "  switch (a)\n"
13071                "    {\n"
13072                "    case 0:\n"
13073                "    {\n"
13074                "    foo(x);\n"
13075                "    }\n"
13076                "    break;\n"
13077                "    default:\n"
13078                "    {\n"
13079                "    foo(1);\n"
13080                "    }\n"
13081                "    break;\n"
13082                "    }\n"
13083                "  }\n",
13084                WhitesmithsBraceStyle);
13085 
13086   verifyFormat("enum X\n"
13087                "  {\n"
13088                "  Y = 0, // testing\n"
13089                "  }\n",
13090                WhitesmithsBraceStyle);
13091 
13092   verifyFormat("enum X\n"
13093                "  {\n"
13094                "  Y = 0\n"
13095                "  }\n",
13096                WhitesmithsBraceStyle);
13097   verifyFormat("enum X\n"
13098                "  {\n"
13099                "  Y = 0,\n"
13100                "  Z = 1\n"
13101                "  };\n",
13102                WhitesmithsBraceStyle);
13103 
13104   verifyFormat("@interface BSApplicationController ()\n"
13105                "  {\n"
13106                "@private\n"
13107                "  id _extraIvar;\n"
13108                "  }\n"
13109                "@end\n",
13110                WhitesmithsBraceStyle);
13111 
13112   verifyFormat("#ifdef _DEBUG\n"
13113                "int foo(int i = 0)\n"
13114                "#else\n"
13115                "int foo(int i = 5)\n"
13116                "#endif\n"
13117                "  {\n"
13118                "  return i;\n"
13119                "  }",
13120                WhitesmithsBraceStyle);
13121 
13122   verifyFormat("void foo() {}\n"
13123                "void bar()\n"
13124                "#ifdef _DEBUG\n"
13125                "  {\n"
13126                "  foo();\n"
13127                "  }\n"
13128                "#else\n"
13129                "  {\n"
13130                "  }\n"
13131                "#endif",
13132                WhitesmithsBraceStyle);
13133 
13134   verifyFormat("void foobar()\n"
13135                "  {\n"
13136                "  int i = 5;\n"
13137                "  }\n"
13138                "#ifdef _DEBUG\n"
13139                "void bar()\n"
13140                "  {\n"
13141                "  }\n"
13142                "#else\n"
13143                "void bar()\n"
13144                "  {\n"
13145                "  foobar();\n"
13146                "  }\n"
13147                "#endif",
13148                WhitesmithsBraceStyle);
13149 
13150   // This shouldn't affect ObjC blocks..
13151   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13152                "  // ...\n"
13153                "  int i;\n"
13154                "}];",
13155                WhitesmithsBraceStyle);
13156   verifyFormat("void (^block)(void) = ^{\n"
13157                "  // ...\n"
13158                "  int i;\n"
13159                "};",
13160                WhitesmithsBraceStyle);
13161   // .. or dict literals.
13162   verifyFormat("void f()\n"
13163                "  {\n"
13164                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13165                "  }",
13166                WhitesmithsBraceStyle);
13167 
13168   verifyFormat("int f()\n"
13169                "  { // comment\n"
13170                "  return 42;\n"
13171                "  }",
13172                WhitesmithsBraceStyle);
13173 
13174   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13175   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13176       FormatStyle::SIS_Always;
13177   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13178   verifyFormat("void f(bool b)\n"
13179                "  {\n"
13180                "  if (b)\n"
13181                "    {\n"
13182                "    return;\n"
13183                "    }\n"
13184                "  }\n",
13185                BreakBeforeBraceShortIfs);
13186   verifyFormat("void f(bool b)\n"
13187                "  {\n"
13188                "  if (b) return;\n"
13189                "  }\n",
13190                BreakBeforeBraceShortIfs);
13191   verifyFormat("void f(bool b)\n"
13192                "  {\n"
13193                "  while (b)\n"
13194                "    {\n"
13195                "    return;\n"
13196                "    }\n"
13197                "  }\n",
13198                BreakBeforeBraceShortIfs);
13199 }
13200 
13201 TEST_F(FormatTest, GNUBraceBreaking) {
13202   FormatStyle GNUBraceStyle = getLLVMStyle();
13203   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13204   verifyFormat("namespace a\n"
13205                "{\n"
13206                "class A\n"
13207                "{\n"
13208                "  void f()\n"
13209                "  {\n"
13210                "    int a;\n"
13211                "    {\n"
13212                "      int b;\n"
13213                "    }\n"
13214                "    if (true)\n"
13215                "      {\n"
13216                "        a();\n"
13217                "        b();\n"
13218                "      }\n"
13219                "  }\n"
13220                "  void g() { return; }\n"
13221                "}\n"
13222                "} // namespace a",
13223                GNUBraceStyle);
13224 
13225   verifyFormat("void f()\n"
13226                "{\n"
13227                "  if (true)\n"
13228                "    {\n"
13229                "      a();\n"
13230                "    }\n"
13231                "  else if (false)\n"
13232                "    {\n"
13233                "      b();\n"
13234                "    }\n"
13235                "  else\n"
13236                "    {\n"
13237                "      c();\n"
13238                "    }\n"
13239                "}\n",
13240                GNUBraceStyle);
13241 
13242   verifyFormat("void f()\n"
13243                "{\n"
13244                "  for (int i = 0; i < 10; ++i)\n"
13245                "    {\n"
13246                "      a();\n"
13247                "    }\n"
13248                "  while (false)\n"
13249                "    {\n"
13250                "      b();\n"
13251                "    }\n"
13252                "  do\n"
13253                "    {\n"
13254                "      c();\n"
13255                "    }\n"
13256                "  while (false);\n"
13257                "}\n",
13258                GNUBraceStyle);
13259 
13260   verifyFormat("void f(int a)\n"
13261                "{\n"
13262                "  switch (a)\n"
13263                "    {\n"
13264                "    case 0:\n"
13265                "      break;\n"
13266                "    case 1:\n"
13267                "      {\n"
13268                "        break;\n"
13269                "      }\n"
13270                "    case 2:\n"
13271                "      {\n"
13272                "      }\n"
13273                "      break;\n"
13274                "    default:\n"
13275                "      break;\n"
13276                "    }\n"
13277                "}\n",
13278                GNUBraceStyle);
13279 
13280   verifyFormat("enum X\n"
13281                "{\n"
13282                "  Y = 0,\n"
13283                "}\n",
13284                GNUBraceStyle);
13285 
13286   verifyFormat("@interface BSApplicationController ()\n"
13287                "{\n"
13288                "@private\n"
13289                "  id _extraIvar;\n"
13290                "}\n"
13291                "@end\n",
13292                GNUBraceStyle);
13293 
13294   verifyFormat("#ifdef _DEBUG\n"
13295                "int foo(int i = 0)\n"
13296                "#else\n"
13297                "int foo(int i = 5)\n"
13298                "#endif\n"
13299                "{\n"
13300                "  return i;\n"
13301                "}",
13302                GNUBraceStyle);
13303 
13304   verifyFormat("void foo() {}\n"
13305                "void bar()\n"
13306                "#ifdef _DEBUG\n"
13307                "{\n"
13308                "  foo();\n"
13309                "}\n"
13310                "#else\n"
13311                "{\n"
13312                "}\n"
13313                "#endif",
13314                GNUBraceStyle);
13315 
13316   verifyFormat("void foobar() { int i = 5; }\n"
13317                "#ifdef _DEBUG\n"
13318                "void bar() {}\n"
13319                "#else\n"
13320                "void bar() { foobar(); }\n"
13321                "#endif",
13322                GNUBraceStyle);
13323 }
13324 
13325 TEST_F(FormatTest, WebKitBraceBreaking) {
13326   FormatStyle WebKitBraceStyle = getLLVMStyle();
13327   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13328   WebKitBraceStyle.FixNamespaceComments = false;
13329   verifyFormat("namespace a {\n"
13330                "class A {\n"
13331                "  void f()\n"
13332                "  {\n"
13333                "    if (true) {\n"
13334                "      a();\n"
13335                "      b();\n"
13336                "    }\n"
13337                "  }\n"
13338                "  void g() { return; }\n"
13339                "};\n"
13340                "enum E {\n"
13341                "  A,\n"
13342                "  // foo\n"
13343                "  B,\n"
13344                "  C\n"
13345                "};\n"
13346                "struct B {\n"
13347                "  int x;\n"
13348                "};\n"
13349                "}\n",
13350                WebKitBraceStyle);
13351   verifyFormat("struct S {\n"
13352                "  int Type;\n"
13353                "  union {\n"
13354                "    int x;\n"
13355                "    double y;\n"
13356                "  } Value;\n"
13357                "  class C {\n"
13358                "    MyFavoriteType Value;\n"
13359                "  } Class;\n"
13360                "};\n",
13361                WebKitBraceStyle);
13362 }
13363 
13364 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13365   verifyFormat("void f() {\n"
13366                "  try {\n"
13367                "  } catch (const Exception &e) {\n"
13368                "  }\n"
13369                "}\n",
13370                getLLVMStyle());
13371 }
13372 
13373 TEST_F(FormatTest, UnderstandsPragmas) {
13374   verifyFormat("#pragma omp reduction(| : var)");
13375   verifyFormat("#pragma omp reduction(+ : var)");
13376 
13377   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13378             "(including parentheses).",
13379             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13380                    "(including parentheses)."));
13381 }
13382 
13383 TEST_F(FormatTest, UnderstandPragmaOption) {
13384   verifyFormat("#pragma option -C -A");
13385 
13386   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13387 }
13388 
13389 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13390   FormatStyle Style = getLLVMStyle();
13391   Style.ColumnLimit = 20;
13392 
13393   // See PR41213
13394   EXPECT_EQ("/*\n"
13395             " *\t9012345\n"
13396             " * /8901\n"
13397             " */",
13398             format("/*\n"
13399                    " *\t9012345 /8901\n"
13400                    " */",
13401                    Style));
13402   EXPECT_EQ("/*\n"
13403             " *345678\n"
13404             " *\t/8901\n"
13405             " */",
13406             format("/*\n"
13407                    " *345678\t/8901\n"
13408                    " */",
13409                    Style));
13410 
13411   verifyFormat("int a; // the\n"
13412                "       // comment",
13413                Style);
13414   EXPECT_EQ("int a; /* first line\n"
13415             "        * second\n"
13416             "        * line third\n"
13417             "        * line\n"
13418             "        */",
13419             format("int a; /* first line\n"
13420                    "        * second\n"
13421                    "        * line third\n"
13422                    "        * line\n"
13423                    "        */",
13424                    Style));
13425   EXPECT_EQ("int a; // first line\n"
13426             "       // second\n"
13427             "       // line third\n"
13428             "       // line",
13429             format("int a; // first line\n"
13430                    "       // second line\n"
13431                    "       // third line",
13432                    Style));
13433 
13434   Style.PenaltyExcessCharacter = 90;
13435   verifyFormat("int a; // the comment", Style);
13436   EXPECT_EQ("int a; // the comment\n"
13437             "       // aaa",
13438             format("int a; // the comment aaa", Style));
13439   EXPECT_EQ("int a; /* first line\n"
13440             "        * second line\n"
13441             "        * third line\n"
13442             "        */",
13443             format("int a; /* first line\n"
13444                    "        * second line\n"
13445                    "        * third line\n"
13446                    "        */",
13447                    Style));
13448   EXPECT_EQ("int a; // first line\n"
13449             "       // second line\n"
13450             "       // third line",
13451             format("int a; // first line\n"
13452                    "       // second line\n"
13453                    "       // third line",
13454                    Style));
13455   // FIXME: Investigate why this is not getting the same layout as the test
13456   // above.
13457   EXPECT_EQ("int a; /* first line\n"
13458             "        * second line\n"
13459             "        * third line\n"
13460             "        */",
13461             format("int a; /* first line second line third line"
13462                    "\n*/",
13463                    Style));
13464 
13465   EXPECT_EQ("// foo bar baz bazfoo\n"
13466             "// foo bar foo bar\n",
13467             format("// foo bar baz bazfoo\n"
13468                    "// foo bar foo           bar\n",
13469                    Style));
13470   EXPECT_EQ("// foo bar baz bazfoo\n"
13471             "// foo bar foo bar\n",
13472             format("// foo bar baz      bazfoo\n"
13473                    "// foo            bar foo bar\n",
13474                    Style));
13475 
13476   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13477   // next one.
13478   EXPECT_EQ("// foo bar baz bazfoo\n"
13479             "// bar foo bar\n",
13480             format("// foo bar baz      bazfoo bar\n"
13481                    "// foo            bar\n",
13482                    Style));
13483 
13484   EXPECT_EQ("// foo bar baz bazfoo\n"
13485             "// foo bar baz bazfoo\n"
13486             "// bar foo bar\n",
13487             format("// foo bar baz      bazfoo\n"
13488                    "// foo bar baz      bazfoo bar\n"
13489                    "// foo bar\n",
13490                    Style));
13491 
13492   EXPECT_EQ("// foo bar baz bazfoo\n"
13493             "// foo bar baz bazfoo\n"
13494             "// bar foo bar\n",
13495             format("// foo bar baz      bazfoo\n"
13496                    "// foo bar baz      bazfoo bar\n"
13497                    "// foo           bar\n",
13498                    Style));
13499 
13500   // Make sure we do not keep protruding characters if strict mode reflow is
13501   // cheaper than keeping protruding characters.
13502   Style.ColumnLimit = 21;
13503   EXPECT_EQ(
13504       "// foo foo foo foo\n"
13505       "// foo foo foo foo\n"
13506       "// foo foo foo foo\n",
13507       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13508 
13509   EXPECT_EQ("int a = /* long block\n"
13510             "           comment */\n"
13511             "    42;",
13512             format("int a = /* long block comment */ 42;", Style));
13513 }
13514 
13515 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13516   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13517   EXPECT_EQ(Styles[0], Styles[i])                                              \
13518       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13519 
13520 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13521   SmallVector<FormatStyle, 3> Styles;
13522   Styles.resize(3);
13523 
13524   Styles[0] = getLLVMStyle();
13525   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13526   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13527   EXPECT_ALL_STYLES_EQUAL(Styles);
13528 
13529   Styles[0] = getGoogleStyle();
13530   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13531   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13532   EXPECT_ALL_STYLES_EQUAL(Styles);
13533 
13534   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13535   EXPECT_TRUE(
13536       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13537   EXPECT_TRUE(
13538       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13539   EXPECT_ALL_STYLES_EQUAL(Styles);
13540 
13541   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13542   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13543   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
13544   EXPECT_ALL_STYLES_EQUAL(Styles);
13545 
13546   Styles[0] = getMozillaStyle();
13547   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
13548   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
13549   EXPECT_ALL_STYLES_EQUAL(Styles);
13550 
13551   Styles[0] = getWebKitStyle();
13552   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
13553   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
13554   EXPECT_ALL_STYLES_EQUAL(Styles);
13555 
13556   Styles[0] = getGNUStyle();
13557   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
13558   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
13559   EXPECT_ALL_STYLES_EQUAL(Styles);
13560 
13561   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
13562 }
13563 
13564 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
13565   SmallVector<FormatStyle, 8> Styles;
13566   Styles.resize(2);
13567 
13568   Styles[0] = getGoogleStyle();
13569   Styles[1] = getLLVMStyle();
13570   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13571   EXPECT_ALL_STYLES_EQUAL(Styles);
13572 
13573   Styles.resize(5);
13574   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13575   Styles[1] = getLLVMStyle();
13576   Styles[1].Language = FormatStyle::LK_JavaScript;
13577   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13578 
13579   Styles[2] = getLLVMStyle();
13580   Styles[2].Language = FormatStyle::LK_JavaScript;
13581   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
13582                                   "BasedOnStyle: Google",
13583                                   &Styles[2])
13584                    .value());
13585 
13586   Styles[3] = getLLVMStyle();
13587   Styles[3].Language = FormatStyle::LK_JavaScript;
13588   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
13589                                   "Language: JavaScript",
13590                                   &Styles[3])
13591                    .value());
13592 
13593   Styles[4] = getLLVMStyle();
13594   Styles[4].Language = FormatStyle::LK_JavaScript;
13595   EXPECT_EQ(0, parseConfiguration("---\n"
13596                                   "BasedOnStyle: LLVM\n"
13597                                   "IndentWidth: 123\n"
13598                                   "---\n"
13599                                   "BasedOnStyle: Google\n"
13600                                   "Language: JavaScript",
13601                                   &Styles[4])
13602                    .value());
13603   EXPECT_ALL_STYLES_EQUAL(Styles);
13604 }
13605 
13606 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
13607   Style.FIELD = false;                                                         \
13608   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
13609   EXPECT_TRUE(Style.FIELD);                                                    \
13610   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
13611   EXPECT_FALSE(Style.FIELD);
13612 
13613 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
13614 
13615 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
13616   Style.STRUCT.FIELD = false;                                                  \
13617   EXPECT_EQ(0,                                                                 \
13618             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
13619                 .value());                                                     \
13620   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
13621   EXPECT_EQ(0,                                                                 \
13622             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
13623                 .value());                                                     \
13624   EXPECT_FALSE(Style.STRUCT.FIELD);
13625 
13626 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
13627   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
13628 
13629 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
13630   EXPECT_NE(VALUE, Style.FIELD);                                               \
13631   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
13632   EXPECT_EQ(VALUE, Style.FIELD)
13633 
13634 TEST_F(FormatTest, ParsesConfigurationBools) {
13635   FormatStyle Style = {};
13636   Style.Language = FormatStyle::LK_Cpp;
13637   CHECK_PARSE_BOOL(AlignTrailingComments);
13638   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
13639   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
13640   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
13641   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
13642   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
13643   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
13644   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
13645   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
13646   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
13647   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
13648   CHECK_PARSE_BOOL(BinPackArguments);
13649   CHECK_PARSE_BOOL(BinPackParameters);
13650   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
13651   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
13652   CHECK_PARSE_BOOL(BreakStringLiterals);
13653   CHECK_PARSE_BOOL(CompactNamespaces);
13654   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
13655   CHECK_PARSE_BOOL(DeriveLineEnding);
13656   CHECK_PARSE_BOOL(DerivePointerAlignment);
13657   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
13658   CHECK_PARSE_BOOL(DisableFormat);
13659   CHECK_PARSE_BOOL(IndentCaseLabels);
13660   CHECK_PARSE_BOOL(IndentCaseBlocks);
13661   CHECK_PARSE_BOOL(IndentGotoLabels);
13662   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
13663   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
13664   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
13665   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
13666   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
13667   CHECK_PARSE_BOOL(ReflowComments);
13668   CHECK_PARSE_BOOL(SortIncludes);
13669   CHECK_PARSE_BOOL(SortUsingDeclarations);
13670   CHECK_PARSE_BOOL(SpacesInParentheses);
13671   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
13672   CHECK_PARSE_BOOL(SpacesInAngles);
13673   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
13674   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
13675   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
13676   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
13677   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
13678   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
13679   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
13680   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
13681   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
13682   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
13683   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
13684   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
13685   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
13686   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
13687   CHECK_PARSE_BOOL(UseCRLF);
13688 
13689   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
13690   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
13691   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
13692   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
13693   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
13694   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
13695   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
13696   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
13697   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
13698   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
13699   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
13700   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
13701   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
13702   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
13703   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
13704   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
13705   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
13706 }
13707 
13708 #undef CHECK_PARSE_BOOL
13709 
13710 TEST_F(FormatTest, ParsesConfiguration) {
13711   FormatStyle Style = {};
13712   Style.Language = FormatStyle::LK_Cpp;
13713   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
13714   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
13715               ConstructorInitializerIndentWidth, 1234u);
13716   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
13717   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
13718   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
13719   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
13720   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
13721               PenaltyBreakBeforeFirstCallParameter, 1234u);
13722   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
13723               PenaltyBreakTemplateDeclaration, 1234u);
13724   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
13725   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
13726               PenaltyReturnTypeOnItsOwnLine, 1234u);
13727   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
13728               SpacesBeforeTrailingComments, 1234u);
13729   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
13730   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
13731   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
13732 
13733   Style.PointerAlignment = FormatStyle::PAS_Middle;
13734   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
13735               FormatStyle::PAS_Left);
13736   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
13737               FormatStyle::PAS_Right);
13738   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
13739               FormatStyle::PAS_Middle);
13740   // For backward compatibility:
13741   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
13742               FormatStyle::PAS_Left);
13743   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
13744               FormatStyle::PAS_Right);
13745   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
13746               FormatStyle::PAS_Middle);
13747 
13748   Style.Standard = FormatStyle::LS_Auto;
13749   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
13750   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
13751   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
13752   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
13753   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
13754   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
13755   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
13756   // Legacy aliases:
13757   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
13758   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
13759   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
13760   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
13761 
13762   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13763   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
13764               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
13765   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
13766               FormatStyle::BOS_None);
13767   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
13768               FormatStyle::BOS_All);
13769   // For backward compatibility:
13770   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
13771               FormatStyle::BOS_None);
13772   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
13773               FormatStyle::BOS_All);
13774 
13775   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
13776   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
13777               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13778   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
13779               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
13780   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
13781               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
13782   // For backward compatibility:
13783   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
13784               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13785 
13786   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
13787   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
13788               FormatStyle::BILS_BeforeComma);
13789   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
13790               FormatStyle::BILS_AfterColon);
13791   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
13792               FormatStyle::BILS_BeforeColon);
13793   // For backward compatibility:
13794   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
13795               FormatStyle::BILS_BeforeComma);
13796 
13797   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
13798   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
13799               FormatStyle::BAS_Align);
13800   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
13801               FormatStyle::BAS_DontAlign);
13802   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
13803               FormatStyle::BAS_AlwaysBreak);
13804   // For backward compatibility:
13805   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
13806               FormatStyle::BAS_DontAlign);
13807   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
13808               FormatStyle::BAS_Align);
13809 
13810   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13811   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
13812               FormatStyle::ENAS_DontAlign);
13813   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
13814               FormatStyle::ENAS_Left);
13815   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
13816               FormatStyle::ENAS_Right);
13817   // For backward compatibility:
13818   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
13819               FormatStyle::ENAS_Left);
13820   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
13821               FormatStyle::ENAS_Right);
13822 
13823   Style.AlignOperands = FormatStyle::OAS_Align;
13824   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
13825               FormatStyle::OAS_DontAlign);
13826   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
13827   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
13828               FormatStyle::OAS_AlignAfterOperator);
13829   // For backward compatibility:
13830   CHECK_PARSE("AlignOperands: false", AlignOperands,
13831               FormatStyle::OAS_DontAlign);
13832   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
13833 
13834   Style.UseTab = FormatStyle::UT_ForIndentation;
13835   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
13836   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
13837   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
13838   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
13839               FormatStyle::UT_ForContinuationAndIndentation);
13840   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
13841               FormatStyle::UT_AlignWithSpaces);
13842   // For backward compatibility:
13843   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
13844   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
13845 
13846   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
13847   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
13848               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13849   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
13850               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
13851   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
13852               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13853   // For backward compatibility:
13854   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
13855               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13856   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
13857               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13858 
13859   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
13860   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
13861               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13862   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
13863               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
13864   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
13865               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
13866   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
13867               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13868   // For backward compatibility:
13869   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
13870               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13871   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
13872               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13873 
13874   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
13875   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
13876               FormatStyle::SBPO_Never);
13877   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
13878               FormatStyle::SBPO_Always);
13879   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
13880               FormatStyle::SBPO_ControlStatements);
13881   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
13882               FormatStyle::SBPO_NonEmptyParentheses);
13883   // For backward compatibility:
13884   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
13885               FormatStyle::SBPO_Never);
13886   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
13887               FormatStyle::SBPO_ControlStatements);
13888 
13889   Style.ColumnLimit = 123;
13890   FormatStyle BaseStyle = getLLVMStyle();
13891   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
13892   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
13893 
13894   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
13895   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
13896               FormatStyle::BS_Attach);
13897   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
13898               FormatStyle::BS_Linux);
13899   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
13900               FormatStyle::BS_Mozilla);
13901   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
13902               FormatStyle::BS_Stroustrup);
13903   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
13904               FormatStyle::BS_Allman);
13905   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
13906               FormatStyle::BS_Whitesmiths);
13907   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
13908   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
13909               FormatStyle::BS_WebKit);
13910   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
13911               FormatStyle::BS_Custom);
13912 
13913   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
13914   CHECK_PARSE("BraceWrapping:\n"
13915               "  AfterControlStatement: MultiLine",
13916               BraceWrapping.AfterControlStatement,
13917               FormatStyle::BWACS_MultiLine);
13918   CHECK_PARSE("BraceWrapping:\n"
13919               "  AfterControlStatement: Always",
13920               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13921   CHECK_PARSE("BraceWrapping:\n"
13922               "  AfterControlStatement: Never",
13923               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13924   // For backward compatibility:
13925   CHECK_PARSE("BraceWrapping:\n"
13926               "  AfterControlStatement: true",
13927               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13928   CHECK_PARSE("BraceWrapping:\n"
13929               "  AfterControlStatement: false",
13930               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13931 
13932   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
13933   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
13934               FormatStyle::RTBS_None);
13935   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
13936               FormatStyle::RTBS_All);
13937   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
13938               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
13939   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
13940               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
13941   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
13942               AlwaysBreakAfterReturnType,
13943               FormatStyle::RTBS_TopLevelDefinitions);
13944 
13945   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
13946   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
13947               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
13948   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
13949               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
13950   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
13951               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
13952   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
13953               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
13954   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
13955               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
13956 
13957   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
13958   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
13959               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
13960   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
13961               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
13962   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
13963               AlwaysBreakAfterDefinitionReturnType,
13964               FormatStyle::DRTBS_TopLevel);
13965 
13966   Style.NamespaceIndentation = FormatStyle::NI_All;
13967   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
13968               FormatStyle::NI_None);
13969   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
13970               FormatStyle::NI_Inner);
13971   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
13972               FormatStyle::NI_All);
13973 
13974   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
13975   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
13976               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
13977   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
13978               AllowShortIfStatementsOnASingleLine,
13979               FormatStyle::SIS_WithoutElse);
13980   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
13981               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
13982   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
13983               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
13984   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
13985               AllowShortIfStatementsOnASingleLine,
13986               FormatStyle::SIS_WithoutElse);
13987 
13988   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
13989   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
13990               FormatStyle::IEBS_AfterExternBlock);
13991   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
13992               FormatStyle::IEBS_Indent);
13993   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
13994               FormatStyle::IEBS_NoIndent);
13995   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
13996               FormatStyle::IEBS_Indent);
13997   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
13998               FormatStyle::IEBS_NoIndent);
13999 
14000   // FIXME: This is required because parsing a configuration simply overwrites
14001   // the first N elements of the list instead of resetting it.
14002   Style.ForEachMacros.clear();
14003   std::vector<std::string> BoostForeach;
14004   BoostForeach.push_back("BOOST_FOREACH");
14005   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
14006   std::vector<std::string> BoostAndQForeach;
14007   BoostAndQForeach.push_back("BOOST_FOREACH");
14008   BoostAndQForeach.push_back("Q_FOREACH");
14009   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
14010               BoostAndQForeach);
14011 
14012   Style.StatementMacros.clear();
14013   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
14014               std::vector<std::string>{"QUNUSED"});
14015   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
14016               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
14017 
14018   Style.NamespaceMacros.clear();
14019   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
14020               std::vector<std::string>{"TESTSUITE"});
14021   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
14022               std::vector<std::string>({"TESTSUITE", "SUITE"}));
14023 
14024   Style.WhitespaceSensitiveMacros.clear();
14025   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
14026               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14027   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
14028               WhitespaceSensitiveMacros,
14029               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14030   Style.WhitespaceSensitiveMacros.clear();
14031   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
14032               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14033   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
14034               WhitespaceSensitiveMacros,
14035               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14036 
14037   Style.IncludeStyle.IncludeCategories.clear();
14038   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
14039       {"abc/.*", 2, 0}, {".*", 1, 0}};
14040   CHECK_PARSE("IncludeCategories:\n"
14041               "  - Regex: abc/.*\n"
14042               "    Priority: 2\n"
14043               "  - Regex: .*\n"
14044               "    Priority: 1",
14045               IncludeStyle.IncludeCategories, ExpectedCategories);
14046   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
14047               "abc$");
14048   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
14049               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
14050 
14051   Style.RawStringFormats.clear();
14052   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
14053       {
14054           FormatStyle::LK_TextProto,
14055           {"pb", "proto"},
14056           {"PARSE_TEXT_PROTO"},
14057           /*CanonicalDelimiter=*/"",
14058           "llvm",
14059       },
14060       {
14061           FormatStyle::LK_Cpp,
14062           {"cc", "cpp"},
14063           {"C_CODEBLOCK", "CPPEVAL"},
14064           /*CanonicalDelimiter=*/"cc",
14065           /*BasedOnStyle=*/"",
14066       },
14067   };
14068 
14069   CHECK_PARSE("RawStringFormats:\n"
14070               "  - Language: TextProto\n"
14071               "    Delimiters:\n"
14072               "      - 'pb'\n"
14073               "      - 'proto'\n"
14074               "    EnclosingFunctions:\n"
14075               "      - 'PARSE_TEXT_PROTO'\n"
14076               "    BasedOnStyle: llvm\n"
14077               "  - Language: Cpp\n"
14078               "    Delimiters:\n"
14079               "      - 'cc'\n"
14080               "      - 'cpp'\n"
14081               "    EnclosingFunctions:\n"
14082               "      - 'C_CODEBLOCK'\n"
14083               "      - 'CPPEVAL'\n"
14084               "    CanonicalDelimiter: 'cc'",
14085               RawStringFormats, ExpectedRawStringFormats);
14086 }
14087 
14088 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
14089   FormatStyle Style = {};
14090   Style.Language = FormatStyle::LK_Cpp;
14091   CHECK_PARSE("Language: Cpp\n"
14092               "IndentWidth: 12",
14093               IndentWidth, 12u);
14094   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
14095                                "IndentWidth: 34",
14096                                &Style),
14097             ParseError::Unsuitable);
14098   FormatStyle BinPackedTCS = {};
14099   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
14100   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
14101                                "InsertTrailingCommas: Wrapped",
14102                                &BinPackedTCS),
14103             ParseError::BinPackTrailingCommaConflict);
14104   EXPECT_EQ(12u, Style.IndentWidth);
14105   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14106   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14107 
14108   Style.Language = FormatStyle::LK_JavaScript;
14109   CHECK_PARSE("Language: JavaScript\n"
14110               "IndentWidth: 12",
14111               IndentWidth, 12u);
14112   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14113   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14114                                "IndentWidth: 34",
14115                                &Style),
14116             ParseError::Unsuitable);
14117   EXPECT_EQ(23u, Style.IndentWidth);
14118   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14119   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14120 
14121   CHECK_PARSE("BasedOnStyle: LLVM\n"
14122               "IndentWidth: 67",
14123               IndentWidth, 67u);
14124 
14125   CHECK_PARSE("---\n"
14126               "Language: JavaScript\n"
14127               "IndentWidth: 12\n"
14128               "---\n"
14129               "Language: Cpp\n"
14130               "IndentWidth: 34\n"
14131               "...\n",
14132               IndentWidth, 12u);
14133 
14134   Style.Language = FormatStyle::LK_Cpp;
14135   CHECK_PARSE("---\n"
14136               "Language: JavaScript\n"
14137               "IndentWidth: 12\n"
14138               "---\n"
14139               "Language: Cpp\n"
14140               "IndentWidth: 34\n"
14141               "...\n",
14142               IndentWidth, 34u);
14143   CHECK_PARSE("---\n"
14144               "IndentWidth: 78\n"
14145               "---\n"
14146               "Language: JavaScript\n"
14147               "IndentWidth: 56\n"
14148               "...\n",
14149               IndentWidth, 78u);
14150 
14151   Style.ColumnLimit = 123;
14152   Style.IndentWidth = 234;
14153   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14154   Style.TabWidth = 345;
14155   EXPECT_FALSE(parseConfiguration("---\n"
14156                                   "IndentWidth: 456\n"
14157                                   "BreakBeforeBraces: Allman\n"
14158                                   "---\n"
14159                                   "Language: JavaScript\n"
14160                                   "IndentWidth: 111\n"
14161                                   "TabWidth: 111\n"
14162                                   "---\n"
14163                                   "Language: Cpp\n"
14164                                   "BreakBeforeBraces: Stroustrup\n"
14165                                   "TabWidth: 789\n"
14166                                   "...\n",
14167                                   &Style));
14168   EXPECT_EQ(123u, Style.ColumnLimit);
14169   EXPECT_EQ(456u, Style.IndentWidth);
14170   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14171   EXPECT_EQ(789u, Style.TabWidth);
14172 
14173   EXPECT_EQ(parseConfiguration("---\n"
14174                                "Language: JavaScript\n"
14175                                "IndentWidth: 56\n"
14176                                "---\n"
14177                                "IndentWidth: 78\n"
14178                                "...\n",
14179                                &Style),
14180             ParseError::Error);
14181   EXPECT_EQ(parseConfiguration("---\n"
14182                                "Language: JavaScript\n"
14183                                "IndentWidth: 56\n"
14184                                "---\n"
14185                                "Language: JavaScript\n"
14186                                "IndentWidth: 78\n"
14187                                "...\n",
14188                                &Style),
14189             ParseError::Error);
14190 
14191   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14192 }
14193 
14194 #undef CHECK_PARSE
14195 
14196 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14197   FormatStyle Style = {};
14198   Style.Language = FormatStyle::LK_JavaScript;
14199   Style.BreakBeforeTernaryOperators = true;
14200   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14201   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14202 
14203   Style.BreakBeforeTernaryOperators = true;
14204   EXPECT_EQ(0, parseConfiguration("---\n"
14205                                   "BasedOnStyle: Google\n"
14206                                   "---\n"
14207                                   "Language: JavaScript\n"
14208                                   "IndentWidth: 76\n"
14209                                   "...\n",
14210                                   &Style)
14211                    .value());
14212   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14213   EXPECT_EQ(76u, Style.IndentWidth);
14214   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14215 }
14216 
14217 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14218   FormatStyle Style = getLLVMStyle();
14219   std::string YAML = configurationAsText(Style);
14220   FormatStyle ParsedStyle = {};
14221   ParsedStyle.Language = FormatStyle::LK_Cpp;
14222   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14223   EXPECT_EQ(Style, ParsedStyle);
14224 }
14225 
14226 TEST_F(FormatTest, WorksFor8bitEncodings) {
14227   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14228             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14229             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14230             "\"\xef\xee\xf0\xf3...\"",
14231             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14232                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14233                    "\xef\xee\xf0\xf3...\"",
14234                    getLLVMStyleWithColumns(12)));
14235 }
14236 
14237 TEST_F(FormatTest, HandlesUTF8BOM) {
14238   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14239   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14240             format("\xef\xbb\xbf#include <iostream>"));
14241   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14242             format("\xef\xbb\xbf\n#include <iostream>"));
14243 }
14244 
14245 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14246 #if !defined(_MSC_VER)
14247 
14248 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14249   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14250                getLLVMStyleWithColumns(35));
14251   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14252                getLLVMStyleWithColumns(31));
14253   verifyFormat("// Однажды в студёную зимнюю пору...",
14254                getLLVMStyleWithColumns(36));
14255   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14256   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14257                getLLVMStyleWithColumns(39));
14258   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14259                getLLVMStyleWithColumns(35));
14260 }
14261 
14262 TEST_F(FormatTest, SplitsUTF8Strings) {
14263   // Non-printable characters' width is currently considered to be the length in
14264   // bytes in UTF8. The characters can be displayed in very different manner
14265   // (zero-width, single width with a substitution glyph, expanded to their code
14266   // (e.g. "<8d>"), so there's no single correct way to handle them.
14267   EXPECT_EQ("\"aaaaÄ\"\n"
14268             "\"\xc2\x8d\";",
14269             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14270   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14271             "\"\xc2\x8d\";",
14272             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14273   EXPECT_EQ("\"Однажды, в \"\n"
14274             "\"студёную \"\n"
14275             "\"зимнюю \"\n"
14276             "\"пору,\"",
14277             format("\"Однажды, в студёную зимнюю пору,\"",
14278                    getLLVMStyleWithColumns(13)));
14279   EXPECT_EQ(
14280       "\"一 二 三 \"\n"
14281       "\"四 五六 \"\n"
14282       "\"七 八 九 \"\n"
14283       "\"十\"",
14284       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14285   EXPECT_EQ("\"一\t\"\n"
14286             "\"二 \t\"\n"
14287             "\"三 四 \"\n"
14288             "\"五\t\"\n"
14289             "\"六 \t\"\n"
14290             "\"七 \"\n"
14291             "\"八九十\tqq\"",
14292             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14293                    getLLVMStyleWithColumns(11)));
14294 
14295   // UTF8 character in an escape sequence.
14296   EXPECT_EQ("\"aaaaaa\"\n"
14297             "\"\\\xC2\x8D\"",
14298             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14299 }
14300 
14301 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14302   EXPECT_EQ("const char *sssss =\n"
14303             "    \"一二三四五六七八\\\n"
14304             " 九 十\";",
14305             format("const char *sssss = \"一二三四五六七八\\\n"
14306                    " 九 十\";",
14307                    getLLVMStyleWithColumns(30)));
14308 }
14309 
14310 TEST_F(FormatTest, SplitsUTF8LineComments) {
14311   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14312             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14313   EXPECT_EQ("// Я из лесу\n"
14314             "// вышел; был\n"
14315             "// сильный\n"
14316             "// мороз.",
14317             format("// Я из лесу вышел; был сильный мороз.",
14318                    getLLVMStyleWithColumns(13)));
14319   EXPECT_EQ("// 一二三\n"
14320             "// 四五六七\n"
14321             "// 八  九\n"
14322             "// 十",
14323             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14324 }
14325 
14326 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14327   EXPECT_EQ("/* Гляжу,\n"
14328             " * поднимается\n"
14329             " * медленно в\n"
14330             " * гору\n"
14331             " * Лошадка,\n"
14332             " * везущая\n"
14333             " * хворосту\n"
14334             " * воз. */",
14335             format("/* Гляжу, поднимается медленно в гору\n"
14336                    " * Лошадка, везущая хворосту воз. */",
14337                    getLLVMStyleWithColumns(13)));
14338   EXPECT_EQ(
14339       "/* 一二三\n"
14340       " * 四五六七\n"
14341       " * 八  九\n"
14342       " * 十  */",
14343       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14344   EXPECT_EQ("/* �������� ��������\n"
14345             " * ��������\n"
14346             " * ������-�� */",
14347             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14348 }
14349 
14350 #endif // _MSC_VER
14351 
14352 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14353   FormatStyle Style = getLLVMStyle();
14354 
14355   Style.ConstructorInitializerIndentWidth = 4;
14356   verifyFormat(
14357       "SomeClass::Constructor()\n"
14358       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14359       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14360       Style);
14361 
14362   Style.ConstructorInitializerIndentWidth = 2;
14363   verifyFormat(
14364       "SomeClass::Constructor()\n"
14365       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14366       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14367       Style);
14368 
14369   Style.ConstructorInitializerIndentWidth = 0;
14370   verifyFormat(
14371       "SomeClass::Constructor()\n"
14372       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14373       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14374       Style);
14375   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14376   verifyFormat(
14377       "SomeLongTemplateVariableName<\n"
14378       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14379       Style);
14380   verifyFormat("bool smaller = 1 < "
14381                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14382                "                       "
14383                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14384                Style);
14385 
14386   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14387   verifyFormat("SomeClass::Constructor() :\n"
14388                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14389                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14390                Style);
14391 }
14392 
14393 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14394   FormatStyle Style = getLLVMStyle();
14395   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14396   Style.ConstructorInitializerIndentWidth = 4;
14397   verifyFormat("SomeClass::Constructor()\n"
14398                "    : a(a)\n"
14399                "    , b(b)\n"
14400                "    , c(c) {}",
14401                Style);
14402   verifyFormat("SomeClass::Constructor()\n"
14403                "    : a(a) {}",
14404                Style);
14405 
14406   Style.ColumnLimit = 0;
14407   verifyFormat("SomeClass::Constructor()\n"
14408                "    : a(a) {}",
14409                Style);
14410   verifyFormat("SomeClass::Constructor() noexcept\n"
14411                "    : a(a) {}",
14412                Style);
14413   verifyFormat("SomeClass::Constructor()\n"
14414                "    : a(a)\n"
14415                "    , b(b)\n"
14416                "    , c(c) {}",
14417                Style);
14418   verifyFormat("SomeClass::Constructor()\n"
14419                "    : a(a) {\n"
14420                "  foo();\n"
14421                "  bar();\n"
14422                "}",
14423                Style);
14424 
14425   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14426   verifyFormat("SomeClass::Constructor()\n"
14427                "    : a(a)\n"
14428                "    , b(b)\n"
14429                "    , c(c) {\n}",
14430                Style);
14431   verifyFormat("SomeClass::Constructor()\n"
14432                "    : a(a) {\n}",
14433                Style);
14434 
14435   Style.ColumnLimit = 80;
14436   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14437   Style.ConstructorInitializerIndentWidth = 2;
14438   verifyFormat("SomeClass::Constructor()\n"
14439                "  : a(a)\n"
14440                "  , b(b)\n"
14441                "  , c(c) {}",
14442                Style);
14443 
14444   Style.ConstructorInitializerIndentWidth = 0;
14445   verifyFormat("SomeClass::Constructor()\n"
14446                ": a(a)\n"
14447                ", b(b)\n"
14448                ", c(c) {}",
14449                Style);
14450 
14451   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14452   Style.ConstructorInitializerIndentWidth = 4;
14453   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14454   verifyFormat(
14455       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14456       Style);
14457   verifyFormat(
14458       "SomeClass::Constructor()\n"
14459       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14460       Style);
14461   Style.ConstructorInitializerIndentWidth = 4;
14462   Style.ColumnLimit = 60;
14463   verifyFormat("SomeClass::Constructor()\n"
14464                "    : aaaaaaaa(aaaaaaaa)\n"
14465                "    , aaaaaaaa(aaaaaaaa)\n"
14466                "    , aaaaaaaa(aaaaaaaa) {}",
14467                Style);
14468 }
14469 
14470 TEST_F(FormatTest, Destructors) {
14471   verifyFormat("void F(int &i) { i.~int(); }");
14472   verifyFormat("void F(int &i) { i->~int(); }");
14473 }
14474 
14475 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14476   FormatStyle Style = getWebKitStyle();
14477 
14478   // Don't indent in outer namespaces.
14479   verifyFormat("namespace outer {\n"
14480                "int i;\n"
14481                "namespace inner {\n"
14482                "    int i;\n"
14483                "} // namespace inner\n"
14484                "} // namespace outer\n"
14485                "namespace other_outer {\n"
14486                "int i;\n"
14487                "}",
14488                Style);
14489 
14490   // Don't indent case labels.
14491   verifyFormat("switch (variable) {\n"
14492                "case 1:\n"
14493                "case 2:\n"
14494                "    doSomething();\n"
14495                "    break;\n"
14496                "default:\n"
14497                "    ++variable;\n"
14498                "}",
14499                Style);
14500 
14501   // Wrap before binary operators.
14502   EXPECT_EQ("void f()\n"
14503             "{\n"
14504             "    if (aaaaaaaaaaaaaaaa\n"
14505             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14506             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14507             "        return;\n"
14508             "}",
14509             format("void f() {\n"
14510                    "if (aaaaaaaaaaaaaaaa\n"
14511                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
14512                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14513                    "return;\n"
14514                    "}",
14515                    Style));
14516 
14517   // Allow functions on a single line.
14518   verifyFormat("void f() { return; }", Style);
14519 
14520   // Allow empty blocks on a single line and insert a space in empty blocks.
14521   EXPECT_EQ("void f() { }", format("void f() {}", Style));
14522   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
14523   // However, don't merge non-empty short loops.
14524   EXPECT_EQ("while (true) {\n"
14525             "    continue;\n"
14526             "}",
14527             format("while (true) { continue; }", Style));
14528 
14529   // Constructor initializers are formatted one per line with the "," on the
14530   // new line.
14531   verifyFormat("Constructor()\n"
14532                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
14533                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
14534                "          aaaaaaaaaaaaaa)\n"
14535                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
14536                "{\n"
14537                "}",
14538                Style);
14539   verifyFormat("SomeClass::Constructor()\n"
14540                "    : a(a)\n"
14541                "{\n"
14542                "}",
14543                Style);
14544   EXPECT_EQ("SomeClass::Constructor()\n"
14545             "    : a(a)\n"
14546             "{\n"
14547             "}",
14548             format("SomeClass::Constructor():a(a){}", Style));
14549   verifyFormat("SomeClass::Constructor()\n"
14550                "    : a(a)\n"
14551                "    , b(b)\n"
14552                "    , c(c)\n"
14553                "{\n"
14554                "}",
14555                Style);
14556   verifyFormat("SomeClass::Constructor()\n"
14557                "    : a(a)\n"
14558                "{\n"
14559                "    foo();\n"
14560                "    bar();\n"
14561                "}",
14562                Style);
14563 
14564   // Access specifiers should be aligned left.
14565   verifyFormat("class C {\n"
14566                "public:\n"
14567                "    int i;\n"
14568                "};",
14569                Style);
14570 
14571   // Do not align comments.
14572   verifyFormat("int a; // Do not\n"
14573                "double b; // align comments.",
14574                Style);
14575 
14576   // Do not align operands.
14577   EXPECT_EQ("ASSERT(aaaa\n"
14578             "    || bbbb);",
14579             format("ASSERT ( aaaa\n||bbbb);", Style));
14580 
14581   // Accept input's line breaks.
14582   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
14583             "    || bbbbbbbbbbbbbbb) {\n"
14584             "    i++;\n"
14585             "}",
14586             format("if (aaaaaaaaaaaaaaa\n"
14587                    "|| bbbbbbbbbbbbbbb) { i++; }",
14588                    Style));
14589   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
14590             "    i++;\n"
14591             "}",
14592             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
14593 
14594   // Don't automatically break all macro definitions (llvm.org/PR17842).
14595   verifyFormat("#define aNumber 10", Style);
14596   // However, generally keep the line breaks that the user authored.
14597   EXPECT_EQ("#define aNumber \\\n"
14598             "    10",
14599             format("#define aNumber \\\n"
14600                    " 10",
14601                    Style));
14602 
14603   // Keep empty and one-element array literals on a single line.
14604   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
14605             "                                  copyItems:YES];",
14606             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
14607                    "copyItems:YES];",
14608                    Style));
14609   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
14610             "                                  copyItems:YES];",
14611             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
14612                    "             copyItems:YES];",
14613                    Style));
14614   // FIXME: This does not seem right, there should be more indentation before
14615   // the array literal's entries. Nested blocks have the same problem.
14616   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14617             "    @\"a\",\n"
14618             "    @\"a\"\n"
14619             "]\n"
14620             "                                  copyItems:YES];",
14621             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14622                    "     @\"a\",\n"
14623                    "     @\"a\"\n"
14624                    "     ]\n"
14625                    "       copyItems:YES];",
14626                    Style));
14627   EXPECT_EQ(
14628       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14629       "                                  copyItems:YES];",
14630       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14631              "   copyItems:YES];",
14632              Style));
14633 
14634   verifyFormat("[self.a b:c c:d];", Style);
14635   EXPECT_EQ("[self.a b:c\n"
14636             "        c:d];",
14637             format("[self.a b:c\n"
14638                    "c:d];",
14639                    Style));
14640 }
14641 
14642 TEST_F(FormatTest, FormatsLambdas) {
14643   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
14644   verifyFormat(
14645       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
14646   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
14647   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
14648   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
14649   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
14650   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
14651   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
14652   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
14653   verifyFormat("int x = f(*+[] {});");
14654   verifyFormat("void f() {\n"
14655                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
14656                "}\n");
14657   verifyFormat("void f() {\n"
14658                "  other(x.begin(), //\n"
14659                "        x.end(),   //\n"
14660                "        [&](int, int) { return 1; });\n"
14661                "}\n");
14662   verifyFormat("void f() {\n"
14663                "  other.other.other.other.other(\n"
14664                "      x.begin(), x.end(),\n"
14665                "      [something, rather](int, int, int, int, int, int, int) { "
14666                "return 1; });\n"
14667                "}\n");
14668   verifyFormat(
14669       "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) {\n"
14673       "        //\n"
14674       "      });\n"
14675       "}\n");
14676   verifyFormat("SomeFunction([]() { // A cool function...\n"
14677                "  return 43;\n"
14678                "});");
14679   EXPECT_EQ("SomeFunction([]() {\n"
14680             "#define A a\n"
14681             "  return 43;\n"
14682             "});",
14683             format("SomeFunction([](){\n"
14684                    "#define A a\n"
14685                    "return 43;\n"
14686                    "});"));
14687   verifyFormat("void f() {\n"
14688                "  SomeFunction([](decltype(x), A *a) {});\n"
14689                "}");
14690   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14691                "    [](const aaaaaaaaaa &a) { return a; });");
14692   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
14693                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
14694                "});");
14695   verifyFormat("Constructor()\n"
14696                "    : Field([] { // comment\n"
14697                "        int i;\n"
14698                "      }) {}");
14699   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
14700                "  return some_parameter.size();\n"
14701                "};");
14702   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
14703                "    [](const string &s) { return s; };");
14704   verifyFormat("int i = aaaaaa ? 1 //\n"
14705                "               : [] {\n"
14706                "                   return 2; //\n"
14707                "                 }();");
14708   verifyFormat("llvm::errs() << \"number of twos is \"\n"
14709                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
14710                "                  return x == 2; // force break\n"
14711                "                });");
14712   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14713                "    [=](int iiiiiiiiiiii) {\n"
14714                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
14715                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
14716                "    });",
14717                getLLVMStyleWithColumns(60));
14718   verifyFormat("SomeFunction({[&] {\n"
14719                "                // comment\n"
14720                "              },\n"
14721                "              [&] {\n"
14722                "                // comment\n"
14723                "              }});");
14724   verifyFormat("SomeFunction({[&] {\n"
14725                "  // comment\n"
14726                "}});");
14727   verifyFormat(
14728       "virtual aaaaaaaaaaaaaaaa(\n"
14729       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
14730       "    aaaaa aaaaaaaaa);");
14731 
14732   // Lambdas with return types.
14733   verifyFormat("int c = []() -> int { return 2; }();\n");
14734   verifyFormat("int c = []() -> int * { return 2; }();\n");
14735   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
14736   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
14737   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
14738   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
14739   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
14740   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
14741   verifyFormat("[a, a]() -> a<1> {};");
14742   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
14743   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
14744   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
14745   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
14746   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
14747   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
14748   verifyFormat("[]() -> foo<!5> { return {}; };");
14749   verifyFormat("[]() -> foo<~5> { 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 != 2> { return {}; };");
14756   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
14757   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
14758   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
14759   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
14760   verifyFormat("namespace bar {\n"
14761                "// broken:\n"
14762                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
14763                "} // namespace bar");
14764   verifyFormat("namespace bar {\n"
14765                "// broken:\n"
14766                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
14767                "} // namespace bar");
14768   verifyFormat("namespace bar {\n"
14769                "// broken:\n"
14770                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
14771                "} // namespace bar");
14772   verifyFormat("namespace bar {\n"
14773                "// broken:\n"
14774                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
14775                "} // namespace bar");
14776   verifyFormat("namespace bar {\n"
14777                "// broken:\n"
14778                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
14779                "} // namespace bar");
14780   verifyFormat("namespace bar {\n"
14781                "// broken:\n"
14782                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
14783                "} // namespace bar");
14784   verifyFormat("namespace bar {\n"
14785                "// broken:\n"
14786                "auto foo{[]() -> foo<!5> { return {}; }};\n"
14787                "} // namespace bar");
14788   verifyFormat("namespace bar {\n"
14789                "// broken:\n"
14790                "auto foo{[]() -> foo<~5> { return {}; }};\n"
14791                "} // namespace bar");
14792   verifyFormat("namespace bar {\n"
14793                "// broken:\n"
14794                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
14795                "} // namespace bar");
14796   verifyFormat("namespace bar {\n"
14797                "// broken:\n"
14798                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
14799                "} // namespace bar");
14800   verifyFormat("namespace bar {\n"
14801                "// broken:\n"
14802                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
14803                "} // namespace bar");
14804   verifyFormat("namespace bar {\n"
14805                "// broken:\n"
14806                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
14807                "} // namespace bar");
14808   verifyFormat("namespace bar {\n"
14809                "// broken:\n"
14810                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
14811                "} // namespace bar");
14812   verifyFormat("namespace bar {\n"
14813                "// broken:\n"
14814                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
14815                "} // namespace bar");
14816   verifyFormat("namespace bar {\n"
14817                "// broken:\n"
14818                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
14819                "} // namespace bar");
14820   verifyFormat("namespace bar {\n"
14821                "// broken:\n"
14822                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
14823                "} // namespace bar");
14824   verifyFormat("namespace bar {\n"
14825                "// broken:\n"
14826                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
14827                "} // namespace bar");
14828   verifyFormat("namespace bar {\n"
14829                "// broken:\n"
14830                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
14831                "} // namespace bar");
14832   verifyFormat("[]() -> a<1> {};");
14833   verifyFormat("[]() -> a<1> { ; };");
14834   verifyFormat("[]() -> a<1> { ; }();");
14835   verifyFormat("[a, a]() -> a<true> {};");
14836   verifyFormat("[]() -> a<true> {};");
14837   verifyFormat("[]() -> a<true> { ; };");
14838   verifyFormat("[]() -> a<true> { ; }();");
14839   verifyFormat("[a, a]() -> a<false> {};");
14840   verifyFormat("[]() -> a<false> {};");
14841   verifyFormat("[]() -> a<false> { ; };");
14842   verifyFormat("[]() -> a<false> { ; }();");
14843   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
14844   verifyFormat("namespace bar {\n"
14845                "auto foo{[]() -> foo<false> { ; }};\n"
14846                "} // namespace bar");
14847   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
14848                "                   int j) -> int {\n"
14849                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
14850                "};");
14851   verifyFormat(
14852       "aaaaaaaaaaaaaaaaaaaaaa(\n"
14853       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
14854       "      return aaaaaaaaaaaaaaaaa;\n"
14855       "    });",
14856       getLLVMStyleWithColumns(70));
14857   verifyFormat("[]() //\n"
14858                "    -> int {\n"
14859                "  return 1; //\n"
14860                "};");
14861   verifyFormat("[]() -> Void<T...> {};");
14862   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
14863 
14864   // Lambdas with explicit template argument lists.
14865   verifyFormat(
14866       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
14867 
14868   // Multiple lambdas in the same parentheses change indentation rules. These
14869   // lambdas are forced to start on new lines.
14870   verifyFormat("SomeFunction(\n"
14871                "    []() {\n"
14872                "      //\n"
14873                "    },\n"
14874                "    []() {\n"
14875                "      //\n"
14876                "    });");
14877 
14878   // A lambda passed as arg0 is always pushed to the next line.
14879   verifyFormat("SomeFunction(\n"
14880                "    [this] {\n"
14881                "      //\n"
14882                "    },\n"
14883                "    1);\n");
14884 
14885   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
14886   // the arg0 case above.
14887   auto Style = getGoogleStyle();
14888   Style.BinPackArguments = false;
14889   verifyFormat("SomeFunction(\n"
14890                "    a,\n"
14891                "    [this] {\n"
14892                "      //\n"
14893                "    },\n"
14894                "    b);\n",
14895                Style);
14896   verifyFormat("SomeFunction(\n"
14897                "    a,\n"
14898                "    [this] {\n"
14899                "      //\n"
14900                "    },\n"
14901                "    b);\n");
14902 
14903   // A lambda with a very long line forces arg0 to be pushed out irrespective of
14904   // the BinPackArguments value (as long as the code is wide enough).
14905   verifyFormat(
14906       "something->SomeFunction(\n"
14907       "    a,\n"
14908       "    [this] {\n"
14909       "      "
14910       "D0000000000000000000000000000000000000000000000000000000000001();\n"
14911       "    },\n"
14912       "    b);\n");
14913 
14914   // A multi-line lambda is pulled up as long as the introducer fits on the
14915   // previous line and there are no further args.
14916   verifyFormat("function(1, [this, that] {\n"
14917                "  //\n"
14918                "});\n");
14919   verifyFormat("function([this, that] {\n"
14920                "  //\n"
14921                "});\n");
14922   // FIXME: this format is not ideal and we should consider forcing the first
14923   // arg onto its own line.
14924   verifyFormat("function(a, b, c, //\n"
14925                "         d, [this, that] {\n"
14926                "           //\n"
14927                "         });\n");
14928 
14929   // Multiple lambdas are treated correctly even when there is a short arg0.
14930   verifyFormat("SomeFunction(\n"
14931                "    1,\n"
14932                "    [this] {\n"
14933                "      //\n"
14934                "    },\n"
14935                "    [this] {\n"
14936                "      //\n"
14937                "    },\n"
14938                "    1);\n");
14939 
14940   // More complex introducers.
14941   verifyFormat("return [i, args...] {};");
14942 
14943   // Not lambdas.
14944   verifyFormat("constexpr char hello[]{\"hello\"};");
14945   verifyFormat("double &operator[](int i) { return 0; }\n"
14946                "int i;");
14947   verifyFormat("std::unique_ptr<int[]> foo() {}");
14948   verifyFormat("int i = a[a][a]->f();");
14949   verifyFormat("int i = (*b)[a]->f();");
14950 
14951   // Other corner cases.
14952   verifyFormat("void f() {\n"
14953                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
14954                "  );\n"
14955                "}");
14956 
14957   // Lambdas created through weird macros.
14958   verifyFormat("void f() {\n"
14959                "  MACRO((const AA &a) { return 1; });\n"
14960                "  MACRO((AA &a) { return 1; });\n"
14961                "}");
14962 
14963   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
14964                "      doo_dah();\n"
14965                "      doo_dah();\n"
14966                "    })) {\n"
14967                "}");
14968   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
14969                "                doo_dah();\n"
14970                "                doo_dah();\n"
14971                "              })) {\n"
14972                "}");
14973   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
14974                "                doo_dah();\n"
14975                "                doo_dah();\n"
14976                "              })) {\n"
14977                "}");
14978   verifyFormat("auto lambda = []() {\n"
14979                "  int a = 2\n"
14980                "#if A\n"
14981                "          + 2\n"
14982                "#endif\n"
14983                "      ;\n"
14984                "};");
14985 
14986   // Lambdas with complex multiline introducers.
14987   verifyFormat(
14988       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14989       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
14990       "        -> ::std::unordered_set<\n"
14991       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
14992       "      //\n"
14993       "    });");
14994 
14995   FormatStyle DoNotMerge = getLLVMStyle();
14996   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
14997   verifyFormat("auto c = []() {\n"
14998                "  return b;\n"
14999                "};",
15000                "auto c = []() { return b; };", DoNotMerge);
15001   verifyFormat("auto c = []() {\n"
15002                "};",
15003                " auto c = []() {};", DoNotMerge);
15004 
15005   FormatStyle MergeEmptyOnly = getLLVMStyle();
15006   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
15007   verifyFormat("auto c = []() {\n"
15008                "  return b;\n"
15009                "};",
15010                "auto c = []() {\n"
15011                "  return b;\n"
15012                " };",
15013                MergeEmptyOnly);
15014   verifyFormat("auto c = []() {};",
15015                "auto c = []() {\n"
15016                "};",
15017                MergeEmptyOnly);
15018 
15019   FormatStyle MergeInline = getLLVMStyle();
15020   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
15021   verifyFormat("auto c = []() {\n"
15022                "  return b;\n"
15023                "};",
15024                "auto c = []() { return b; };", MergeInline);
15025   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
15026                MergeInline);
15027   verifyFormat("function([]() { return b; }, a)",
15028                "function([]() { return b; }, a)", MergeInline);
15029   verifyFormat("function(a, []() { return b; })",
15030                "function(a, []() { return b; })", MergeInline);
15031 
15032   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
15033   // AllowShortLambdasOnASingleLine
15034   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15035   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15036   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15037   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15038       FormatStyle::ShortLambdaStyle::SLS_None;
15039   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
15040                "    []()\n"
15041                "    {\n"
15042                "      return 17;\n"
15043                "    });",
15044                LLVMWithBeforeLambdaBody);
15045   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
15046                "    []()\n"
15047                "    {\n"
15048                "    });",
15049                LLVMWithBeforeLambdaBody);
15050   verifyFormat("auto fct_SLS_None = []()\n"
15051                "{\n"
15052                "  return 17;\n"
15053                "};",
15054                LLVMWithBeforeLambdaBody);
15055   verifyFormat("TwoNestedLambdas_SLS_None(\n"
15056                "    []()\n"
15057                "    {\n"
15058                "      return Call(\n"
15059                "          []()\n"
15060                "          {\n"
15061                "            return 17;\n"
15062                "          });\n"
15063                "    });",
15064                LLVMWithBeforeLambdaBody);
15065   verifyFormat("void Fct()\n"
15066                "{\n"
15067                "  return {[]()\n"
15068                "          {\n"
15069                "            return 17;\n"
15070                "          }};\n"
15071                "}",
15072                LLVMWithBeforeLambdaBody);
15073 
15074   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15075       FormatStyle::ShortLambdaStyle::SLS_Empty;
15076   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
15077                "    []()\n"
15078                "    {\n"
15079                "      return 17;\n"
15080                "    });",
15081                LLVMWithBeforeLambdaBody);
15082   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
15083                LLVMWithBeforeLambdaBody);
15084   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
15085                "ongFunctionName_SLS_Empty(\n"
15086                "    []() {});",
15087                LLVMWithBeforeLambdaBody);
15088   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
15089                "                                []()\n"
15090                "                                {\n"
15091                "                                  return 17;\n"
15092                "                                });",
15093                LLVMWithBeforeLambdaBody);
15094   verifyFormat("auto fct_SLS_Empty = []()\n"
15095                "{\n"
15096                "  return 17;\n"
15097                "};",
15098                LLVMWithBeforeLambdaBody);
15099   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
15100                "    []()\n"
15101                "    {\n"
15102                "      return Call([]() {});\n"
15103                "    });",
15104                LLVMWithBeforeLambdaBody);
15105   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15106                "                           []()\n"
15107                "                           {\n"
15108                "                             return Call([]() {});\n"
15109                "                           });",
15110                LLVMWithBeforeLambdaBody);
15111   verifyFormat(
15112       "FctWithLongLineInLambda_SLS_Empty(\n"
15113       "    []()\n"
15114       "    {\n"
15115       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15116       "                               AndShouldNotBeConsiderAsInline,\n"
15117       "                               LambdaBodyMustBeBreak);\n"
15118       "    });",
15119       LLVMWithBeforeLambdaBody);
15120 
15121   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15122       FormatStyle::ShortLambdaStyle::SLS_Inline;
15123   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15124                LLVMWithBeforeLambdaBody);
15125   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15126                LLVMWithBeforeLambdaBody);
15127   verifyFormat("auto fct_SLS_Inline = []()\n"
15128                "{\n"
15129                "  return 17;\n"
15130                "};",
15131                LLVMWithBeforeLambdaBody);
15132   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15133                "17; }); });",
15134                LLVMWithBeforeLambdaBody);
15135   verifyFormat(
15136       "FctWithLongLineInLambda_SLS_Inline(\n"
15137       "    []()\n"
15138       "    {\n"
15139       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15140       "                               AndShouldNotBeConsiderAsInline,\n"
15141       "                               LambdaBodyMustBeBreak);\n"
15142       "    });",
15143       LLVMWithBeforeLambdaBody);
15144   verifyFormat("FctWithMultipleParams_SLS_Inline("
15145                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15146                "                                 []() { return 17; });",
15147                LLVMWithBeforeLambdaBody);
15148   verifyFormat(
15149       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15150       LLVMWithBeforeLambdaBody);
15151 
15152   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15153       FormatStyle::ShortLambdaStyle::SLS_All;
15154   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15155                LLVMWithBeforeLambdaBody);
15156   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15157                LLVMWithBeforeLambdaBody);
15158   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15159                LLVMWithBeforeLambdaBody);
15160   verifyFormat("FctWithOneParam_SLS_All(\n"
15161                "    []()\n"
15162                "    {\n"
15163                "      // A cool function...\n"
15164                "      return 43;\n"
15165                "    });",
15166                LLVMWithBeforeLambdaBody);
15167   verifyFormat("FctWithMultipleParams_SLS_All("
15168                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15169                "                              []() { return 17; });",
15170                LLVMWithBeforeLambdaBody);
15171   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15172                LLVMWithBeforeLambdaBody);
15173   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15174                LLVMWithBeforeLambdaBody);
15175   verifyFormat(
15176       "FctWithLongLineInLambda_SLS_All(\n"
15177       "    []()\n"
15178       "    {\n"
15179       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15180       "                               AndShouldNotBeConsiderAsInline,\n"
15181       "                               LambdaBodyMustBeBreak);\n"
15182       "    });",
15183       LLVMWithBeforeLambdaBody);
15184   verifyFormat(
15185       "auto fct_SLS_All = []()\n"
15186       "{\n"
15187       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15188       "                           AndShouldNotBeConsiderAsInline,\n"
15189       "                           LambdaBodyMustBeBreak);\n"
15190       "};",
15191       LLVMWithBeforeLambdaBody);
15192   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15193   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15194                LLVMWithBeforeLambdaBody);
15195   verifyFormat(
15196       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15197       "                                FirstParam,\n"
15198       "                                SecondParam,\n"
15199       "                                ThirdParam,\n"
15200       "                                FourthParam);",
15201       LLVMWithBeforeLambdaBody);
15202   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15203                "    []() { return "
15204                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15205                "    FirstParam,\n"
15206                "    SecondParam,\n"
15207                "    ThirdParam,\n"
15208                "    FourthParam);",
15209                LLVMWithBeforeLambdaBody);
15210   verifyFormat(
15211       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15212       "                                SecondParam,\n"
15213       "                                ThirdParam,\n"
15214       "                                FourthParam,\n"
15215       "                                []() { return SomeValueNotSoLong; });",
15216       LLVMWithBeforeLambdaBody);
15217   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15218                "    []()\n"
15219                "    {\n"
15220                "      return "
15221                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15222                "eConsiderAsInline;\n"
15223                "    });",
15224                LLVMWithBeforeLambdaBody);
15225   verifyFormat(
15226       "FctWithLongLineInLambda_SLS_All(\n"
15227       "    []()\n"
15228       "    {\n"
15229       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15230       "                               AndShouldNotBeConsiderAsInline,\n"
15231       "                               LambdaBodyMustBeBreak);\n"
15232       "    });",
15233       LLVMWithBeforeLambdaBody);
15234   verifyFormat("FctWithTwoParams_SLS_All(\n"
15235                "    []()\n"
15236                "    {\n"
15237                "      // A cool function...\n"
15238                "      return 43;\n"
15239                "    },\n"
15240                "    87);",
15241                LLVMWithBeforeLambdaBody);
15242   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15243                LLVMWithBeforeLambdaBody);
15244   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15245                LLVMWithBeforeLambdaBody);
15246   verifyFormat(
15247       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15248       LLVMWithBeforeLambdaBody);
15249   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15250                "}); }, x);",
15251                LLVMWithBeforeLambdaBody);
15252   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15253                "    []()\n"
15254                "    {\n"
15255                "      // A cool function...\n"
15256                "      return Call([]() { return 17; });\n"
15257                "    });",
15258                LLVMWithBeforeLambdaBody);
15259   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15260                "    []()\n"
15261                "    {\n"
15262                "      return Call(\n"
15263                "          []()\n"
15264                "          {\n"
15265                "            // A cool function...\n"
15266                "            return 17;\n"
15267                "          });\n"
15268                "    });",
15269                LLVMWithBeforeLambdaBody);
15270 }
15271 
15272 TEST_F(FormatTest, LambdaWithLineComments) {
15273   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15274   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15275   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15276   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15277       FormatStyle::ShortLambdaStyle::SLS_All;
15278 
15279   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15280   verifyFormat("auto k = []() // comment\n"
15281                "{ return; }",
15282                LLVMWithBeforeLambdaBody);
15283   verifyFormat("auto k = []() /* comment */ { return; }",
15284                LLVMWithBeforeLambdaBody);
15285   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15286                LLVMWithBeforeLambdaBody);
15287   verifyFormat("auto k = []() // X\n"
15288                "{ return; }",
15289                LLVMWithBeforeLambdaBody);
15290   verifyFormat(
15291       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15292       "{ return; }",
15293       LLVMWithBeforeLambdaBody);
15294 }
15295 
15296 TEST_F(FormatTest, EmptyLinesInLambdas) {
15297   verifyFormat("auto lambda = []() {\n"
15298                "  x(); //\n"
15299                "};",
15300                "auto lambda = []() {\n"
15301                "\n"
15302                "  x(); //\n"
15303                "\n"
15304                "};");
15305 }
15306 
15307 TEST_F(FormatTest, FormatsBlocks) {
15308   FormatStyle ShortBlocks = getLLVMStyle();
15309   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15310   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15311   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15312   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15313   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15314   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15315   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15316 
15317   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15318   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15319   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15320 
15321   verifyFormat("[operation setCompletionBlock:^{\n"
15322                "  [self onOperationDone];\n"
15323                "}];");
15324   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15325                "  [self onOperationDone];\n"
15326                "}]};");
15327   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15328                "  f();\n"
15329                "}];");
15330   verifyFormat("int a = [operation block:^int(int *i) {\n"
15331                "  return 1;\n"
15332                "}];");
15333   verifyFormat("[myObject doSomethingWith:arg1\n"
15334                "                      aaa:^int(int *a) {\n"
15335                "                        return 1;\n"
15336                "                      }\n"
15337                "                      bbb:f(a * bbbbbbbb)];");
15338 
15339   verifyFormat("[operation setCompletionBlock:^{\n"
15340                "  [self.delegate newDataAvailable];\n"
15341                "}];",
15342                getLLVMStyleWithColumns(60));
15343   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15344                "  NSString *path = [self sessionFilePath];\n"
15345                "  if (path) {\n"
15346                "    // ...\n"
15347                "  }\n"
15348                "});");
15349   verifyFormat("[[SessionService sharedService]\n"
15350                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15351                "      if (window) {\n"
15352                "        [self windowDidLoad:window];\n"
15353                "      } else {\n"
15354                "        [self errorLoadingWindow];\n"
15355                "      }\n"
15356                "    }];");
15357   verifyFormat("void (^largeBlock)(void) = ^{\n"
15358                "  // ...\n"
15359                "};\n",
15360                getLLVMStyleWithColumns(40));
15361   verifyFormat("[[SessionService sharedService]\n"
15362                "    loadWindowWithCompletionBlock: //\n"
15363                "        ^(SessionWindow *window) {\n"
15364                "          if (window) {\n"
15365                "            [self windowDidLoad:window];\n"
15366                "          } else {\n"
15367                "            [self errorLoadingWindow];\n"
15368                "          }\n"
15369                "        }];",
15370                getLLVMStyleWithColumns(60));
15371   verifyFormat("[myObject doSomethingWith:arg1\n"
15372                "    firstBlock:^(Foo *a) {\n"
15373                "      // ...\n"
15374                "      int i;\n"
15375                "    }\n"
15376                "    secondBlock:^(Bar *b) {\n"
15377                "      // ...\n"
15378                "      int i;\n"
15379                "    }\n"
15380                "    thirdBlock:^Foo(Bar *b) {\n"
15381                "      // ...\n"
15382                "      int i;\n"
15383                "    }];");
15384   verifyFormat("[myObject doSomethingWith:arg1\n"
15385                "               firstBlock:-1\n"
15386                "              secondBlock:^(Bar *b) {\n"
15387                "                // ...\n"
15388                "                int i;\n"
15389                "              }];");
15390 
15391   verifyFormat("f(^{\n"
15392                "  @autoreleasepool {\n"
15393                "    if (a) {\n"
15394                "      g();\n"
15395                "    }\n"
15396                "  }\n"
15397                "});");
15398   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15399   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15400                "};");
15401 
15402   FormatStyle FourIndent = getLLVMStyle();
15403   FourIndent.ObjCBlockIndentWidth = 4;
15404   verifyFormat("[operation setCompletionBlock:^{\n"
15405                "    [self onOperationDone];\n"
15406                "}];",
15407                FourIndent);
15408 }
15409 
15410 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15411   FormatStyle ZeroColumn = getLLVMStyle();
15412   ZeroColumn.ColumnLimit = 0;
15413 
15414   verifyFormat("[[SessionService sharedService] "
15415                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15416                "  if (window) {\n"
15417                "    [self windowDidLoad:window];\n"
15418                "  } else {\n"
15419                "    [self errorLoadingWindow];\n"
15420                "  }\n"
15421                "}];",
15422                ZeroColumn);
15423   EXPECT_EQ("[[SessionService sharedService]\n"
15424             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15425             "      if (window) {\n"
15426             "        [self windowDidLoad:window];\n"
15427             "      } else {\n"
15428             "        [self errorLoadingWindow];\n"
15429             "      }\n"
15430             "    }];",
15431             format("[[SessionService sharedService]\n"
15432                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15433                    "                if (window) {\n"
15434                    "    [self windowDidLoad:window];\n"
15435                    "  } else {\n"
15436                    "    [self errorLoadingWindow];\n"
15437                    "  }\n"
15438                    "}];",
15439                    ZeroColumn));
15440   verifyFormat("[myObject doSomethingWith:arg1\n"
15441                "    firstBlock:^(Foo *a) {\n"
15442                "      // ...\n"
15443                "      int i;\n"
15444                "    }\n"
15445                "    secondBlock:^(Bar *b) {\n"
15446                "      // ...\n"
15447                "      int i;\n"
15448                "    }\n"
15449                "    thirdBlock:^Foo(Bar *b) {\n"
15450                "      // ...\n"
15451                "      int i;\n"
15452                "    }];",
15453                ZeroColumn);
15454   verifyFormat("f(^{\n"
15455                "  @autoreleasepool {\n"
15456                "    if (a) {\n"
15457                "      g();\n"
15458                "    }\n"
15459                "  }\n"
15460                "});",
15461                ZeroColumn);
15462   verifyFormat("void (^largeBlock)(void) = ^{\n"
15463                "  // ...\n"
15464                "};",
15465                ZeroColumn);
15466 
15467   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15468   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15469             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15470   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15471   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15472             "  int i;\n"
15473             "};",
15474             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15475 }
15476 
15477 TEST_F(FormatTest, SupportsCRLF) {
15478   EXPECT_EQ("int a;\r\n"
15479             "int b;\r\n"
15480             "int c;\r\n",
15481             format("int a;\r\n"
15482                    "  int b;\r\n"
15483                    "    int c;\r\n",
15484                    getLLVMStyle()));
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;\n"
15490                    "    int c;\r\n",
15491                    getLLVMStyle()));
15492   EXPECT_EQ("int a;\n"
15493             "int b;\n"
15494             "int c;\n",
15495             format("int a;\r\n"
15496                    "  int b;\n"
15497                    "    int c;\n",
15498                    getLLVMStyle()));
15499   EXPECT_EQ("\"aaaaaaa \"\r\n"
15500             "\"bbbbbbb\";\r\n",
15501             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15502   EXPECT_EQ("#define A \\\r\n"
15503             "  b;      \\\r\n"
15504             "  c;      \\\r\n"
15505             "  d;\r\n",
15506             format("#define A \\\r\n"
15507                    "  b; \\\r\n"
15508                    "  c; d; \r\n",
15509                    getGoogleStyle()));
15510 
15511   EXPECT_EQ("/*\r\n"
15512             "multi line block comments\r\n"
15513             "should not introduce\r\n"
15514             "an extra carriage return\r\n"
15515             "*/\r\n",
15516             format("/*\r\n"
15517                    "multi line block comments\r\n"
15518                    "should not introduce\r\n"
15519                    "an extra carriage return\r\n"
15520                    "*/\r\n"));
15521   EXPECT_EQ("/*\r\n"
15522             "\r\n"
15523             "*/",
15524             format("/*\r\n"
15525                    "    \r\r\r\n"
15526                    "*/"));
15527 
15528   FormatStyle style = getLLVMStyle();
15529 
15530   style.DeriveLineEnding = true;
15531   style.UseCRLF = false;
15532   EXPECT_EQ("union FooBarBazQux {\n"
15533             "  int foo;\n"
15534             "  int bar;\n"
15535             "  int baz;\n"
15536             "};",
15537             format("union FooBarBazQux {\r\n"
15538                    "  int foo;\n"
15539                    "  int bar;\r\n"
15540                    "  int baz;\n"
15541                    "};",
15542                    style));
15543   style.UseCRLF = true;
15544   EXPECT_EQ("union FooBarBazQux {\r\n"
15545             "  int foo;\r\n"
15546             "  int bar;\r\n"
15547             "  int baz;\r\n"
15548             "};",
15549             format("union FooBarBazQux {\r\n"
15550                    "  int foo;\n"
15551                    "  int bar;\r\n"
15552                    "  int baz;\n"
15553                    "};",
15554                    style));
15555 
15556   style.DeriveLineEnding = false;
15557   style.UseCRLF = false;
15558   EXPECT_EQ("union FooBarBazQux {\n"
15559             "  int foo;\n"
15560             "  int bar;\n"
15561             "  int baz;\n"
15562             "  int qux;\n"
15563             "};",
15564             format("union FooBarBazQux {\r\n"
15565                    "  int foo;\n"
15566                    "  int bar;\r\n"
15567                    "  int baz;\n"
15568                    "  int qux;\r\n"
15569                    "};",
15570                    style));
15571   style.UseCRLF = true;
15572   EXPECT_EQ("union FooBarBazQux {\r\n"
15573             "  int foo;\r\n"
15574             "  int bar;\r\n"
15575             "  int baz;\r\n"
15576             "  int qux;\r\n"
15577             "};",
15578             format("union FooBarBazQux {\r\n"
15579                    "  int foo;\n"
15580                    "  int bar;\r\n"
15581                    "  int baz;\n"
15582                    "  int qux;\n"
15583                    "};",
15584                    style));
15585 
15586   style.DeriveLineEnding = true;
15587   style.UseCRLF = false;
15588   EXPECT_EQ("union FooBarBazQux {\r\n"
15589             "  int foo;\r\n"
15590             "  int bar;\r\n"
15591             "  int baz;\r\n"
15592             "  int qux;\r\n"
15593             "};",
15594             format("union FooBarBazQux {\r\n"
15595                    "  int foo;\n"
15596                    "  int bar;\r\n"
15597                    "  int baz;\n"
15598                    "  int qux;\r\n"
15599                    "};",
15600                    style));
15601   style.UseCRLF = true;
15602   EXPECT_EQ("union FooBarBazQux {\n"
15603             "  int foo;\n"
15604             "  int bar;\n"
15605             "  int baz;\n"
15606             "  int qux;\n"
15607             "};",
15608             format("union FooBarBazQux {\r\n"
15609                    "  int foo;\n"
15610                    "  int bar;\r\n"
15611                    "  int baz;\n"
15612                    "  int qux;\n"
15613                    "};",
15614                    style));
15615 }
15616 
15617 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
15618   verifyFormat("MY_CLASS(C) {\n"
15619                "  int i;\n"
15620                "  int j;\n"
15621                "};");
15622 }
15623 
15624 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
15625   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
15626   TwoIndent.ContinuationIndentWidth = 2;
15627 
15628   EXPECT_EQ("int i =\n"
15629             "  longFunction(\n"
15630             "    arg);",
15631             format("int i = longFunction(arg);", TwoIndent));
15632 
15633   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
15634   SixIndent.ContinuationIndentWidth = 6;
15635 
15636   EXPECT_EQ("int i =\n"
15637             "      longFunction(\n"
15638             "            arg);",
15639             format("int i = longFunction(arg);", SixIndent));
15640 }
15641 
15642 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
15643   FormatStyle Style = getLLVMStyle();
15644   verifyFormat("int Foo::getter(\n"
15645                "    //\n"
15646                ") const {\n"
15647                "  return foo;\n"
15648                "}",
15649                Style);
15650   verifyFormat("void Foo::setter(\n"
15651                "    //\n"
15652                ") {\n"
15653                "  foo = 1;\n"
15654                "}",
15655                Style);
15656 }
15657 
15658 TEST_F(FormatTest, SpacesInAngles) {
15659   FormatStyle Spaces = getLLVMStyle();
15660   Spaces.SpacesInAngles = true;
15661 
15662   verifyFormat("static_cast< int >(arg);", Spaces);
15663   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
15664   verifyFormat("f< int, float >();", Spaces);
15665   verifyFormat("template <> g() {}", Spaces);
15666   verifyFormat("template < std::vector< int > > f() {}", Spaces);
15667   verifyFormat("std::function< void(int, int) > fct;", Spaces);
15668   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
15669                Spaces);
15670 
15671   Spaces.Standard = FormatStyle::LS_Cpp03;
15672   Spaces.SpacesInAngles = true;
15673   verifyFormat("A< A< int > >();", Spaces);
15674 
15675   Spaces.SpacesInAngles = false;
15676   verifyFormat("A<A<int> >();", Spaces);
15677 
15678   Spaces.Standard = FormatStyle::LS_Cpp11;
15679   Spaces.SpacesInAngles = true;
15680   verifyFormat("A< A< int > >();", Spaces);
15681 
15682   Spaces.SpacesInAngles = false;
15683   verifyFormat("A<A<int>>();", Spaces);
15684 }
15685 
15686 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
15687   FormatStyle Style = getLLVMStyle();
15688   Style.SpaceAfterTemplateKeyword = false;
15689   verifyFormat("template<int> void foo();", Style);
15690 }
15691 
15692 TEST_F(FormatTest, TripleAngleBrackets) {
15693   verifyFormat("f<<<1, 1>>>();");
15694   verifyFormat("f<<<1, 1, 1, s>>>();");
15695   verifyFormat("f<<<a, b, c, d>>>();");
15696   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
15697   verifyFormat("f<param><<<1, 1>>>();");
15698   verifyFormat("f<1><<<1, 1>>>();");
15699   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
15700   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15701                "aaaaaaaaaaa<<<\n    1, 1>>>();");
15702   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
15703                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
15704 }
15705 
15706 TEST_F(FormatTest, MergeLessLessAtEnd) {
15707   verifyFormat("<<");
15708   EXPECT_EQ("< < <", format("\\\n<<<"));
15709   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15710                "aaallvm::outs() <<");
15711   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15712                "aaaallvm::outs()\n    <<");
15713 }
15714 
15715 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
15716   std::string code = "#if A\n"
15717                      "#if B\n"
15718                      "a.\n"
15719                      "#endif\n"
15720                      "    a = 1;\n"
15721                      "#else\n"
15722                      "#endif\n"
15723                      "#if C\n"
15724                      "#else\n"
15725                      "#endif\n";
15726   EXPECT_EQ(code, format(code));
15727 }
15728 
15729 TEST_F(FormatTest, HandleConflictMarkers) {
15730   // Git/SVN conflict markers.
15731   EXPECT_EQ("int a;\n"
15732             "void f() {\n"
15733             "  callme(some(parameter1,\n"
15734             "<<<<<<< text by the vcs\n"
15735             "              parameter2),\n"
15736             "||||||| text by the vcs\n"
15737             "              parameter2),\n"
15738             "         parameter3,\n"
15739             "======= text by the vcs\n"
15740             "              parameter2, parameter3),\n"
15741             ">>>>>>> text by the vcs\n"
15742             "         otherparameter);\n",
15743             format("int a;\n"
15744                    "void f() {\n"
15745                    "  callme(some(parameter1,\n"
15746                    "<<<<<<< text by the vcs\n"
15747                    "  parameter2),\n"
15748                    "||||||| text by the vcs\n"
15749                    "  parameter2),\n"
15750                    "  parameter3,\n"
15751                    "======= text by the vcs\n"
15752                    "  parameter2,\n"
15753                    "  parameter3),\n"
15754                    ">>>>>>> text by the vcs\n"
15755                    "  otherparameter);\n"));
15756 
15757   // Perforce markers.
15758   EXPECT_EQ("void f() {\n"
15759             "  function(\n"
15760             ">>>> text by the vcs\n"
15761             "      parameter,\n"
15762             "==== text by the vcs\n"
15763             "      parameter,\n"
15764             "==== text by the vcs\n"
15765             "      parameter,\n"
15766             "<<<< text by the vcs\n"
15767             "      parameter);\n",
15768             format("void f() {\n"
15769                    "  function(\n"
15770                    ">>>> text by the vcs\n"
15771                    "  parameter,\n"
15772                    "==== text by the vcs\n"
15773                    "  parameter,\n"
15774                    "==== text by the vcs\n"
15775                    "  parameter,\n"
15776                    "<<<< text by the vcs\n"
15777                    "  parameter);\n"));
15778 
15779   EXPECT_EQ("<<<<<<<\n"
15780             "|||||||\n"
15781             "=======\n"
15782             ">>>>>>>",
15783             format("<<<<<<<\n"
15784                    "|||||||\n"
15785                    "=======\n"
15786                    ">>>>>>>"));
15787 
15788   EXPECT_EQ("<<<<<<<\n"
15789             "|||||||\n"
15790             "int i;\n"
15791             "=======\n"
15792             ">>>>>>>",
15793             format("<<<<<<<\n"
15794                    "|||||||\n"
15795                    "int i;\n"
15796                    "=======\n"
15797                    ">>>>>>>"));
15798 
15799   // FIXME: Handle parsing of macros around conflict markers correctly:
15800   EXPECT_EQ("#define Macro \\\n"
15801             "<<<<<<<\n"
15802             "Something \\\n"
15803             "|||||||\n"
15804             "Else \\\n"
15805             "=======\n"
15806             "Other \\\n"
15807             ">>>>>>>\n"
15808             "    End int i;\n",
15809             format("#define Macro \\\n"
15810                    "<<<<<<<\n"
15811                    "  Something \\\n"
15812                    "|||||||\n"
15813                    "  Else \\\n"
15814                    "=======\n"
15815                    "  Other \\\n"
15816                    ">>>>>>>\n"
15817                    "  End\n"
15818                    "int i;\n"));
15819 }
15820 
15821 TEST_F(FormatTest, DisableRegions) {
15822   EXPECT_EQ("int i;\n"
15823             "// clang-format off\n"
15824             "  int j;\n"
15825             "// clang-format on\n"
15826             "int k;",
15827             format(" int  i;\n"
15828                    "   // clang-format off\n"
15829                    "  int j;\n"
15830                    " // clang-format on\n"
15831                    "   int   k;"));
15832   EXPECT_EQ("int i;\n"
15833             "/* clang-format off */\n"
15834             "  int j;\n"
15835             "/* clang-format on */\n"
15836             "int k;",
15837             format(" int  i;\n"
15838                    "   /* clang-format off */\n"
15839                    "  int j;\n"
15840                    " /* clang-format on */\n"
15841                    "   int   k;"));
15842 
15843   // Don't reflow comments within disabled regions.
15844   EXPECT_EQ("// clang-format off\n"
15845             "// long long long long long long line\n"
15846             "/* clang-format on */\n"
15847             "/* long long long\n"
15848             " * long long long\n"
15849             " * line */\n"
15850             "int i;\n"
15851             "/* clang-format off */\n"
15852             "/* long long long long long long line */\n",
15853             format("// clang-format off\n"
15854                    "// long long long long long long line\n"
15855                    "/* clang-format on */\n"
15856                    "/* long long long long long long line */\n"
15857                    "int i;\n"
15858                    "/* clang-format off */\n"
15859                    "/* long long long long long long line */\n",
15860                    getLLVMStyleWithColumns(20)));
15861 }
15862 
15863 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
15864   format("? ) =");
15865   verifyNoCrash("#define a\\\n /**/}");
15866 }
15867 
15868 TEST_F(FormatTest, FormatsTableGenCode) {
15869   FormatStyle Style = getLLVMStyle();
15870   Style.Language = FormatStyle::LK_TableGen;
15871   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
15872 }
15873 
15874 TEST_F(FormatTest, ArrayOfTemplates) {
15875   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
15876             format("auto a = new unique_ptr<int > [ 10];"));
15877 
15878   FormatStyle Spaces = getLLVMStyle();
15879   Spaces.SpacesInSquareBrackets = true;
15880   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
15881             format("auto a = new unique_ptr<int > [10];", Spaces));
15882 }
15883 
15884 TEST_F(FormatTest, ArrayAsTemplateType) {
15885   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
15886             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
15887 
15888   FormatStyle Spaces = getLLVMStyle();
15889   Spaces.SpacesInSquareBrackets = true;
15890   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
15891             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
15892 }
15893 
15894 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
15895 
15896 TEST(FormatStyle, GetStyleWithEmptyFileName) {
15897   llvm::vfs::InMemoryFileSystem FS;
15898   auto Style1 = getStyle("file", "", "Google", "", &FS);
15899   ASSERT_TRUE((bool)Style1);
15900   ASSERT_EQ(*Style1, getGoogleStyle());
15901 }
15902 
15903 TEST(FormatStyle, GetStyleOfFile) {
15904   llvm::vfs::InMemoryFileSystem FS;
15905   // Test 1: format file in the same directory.
15906   ASSERT_TRUE(
15907       FS.addFile("/a/.clang-format", 0,
15908                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
15909   ASSERT_TRUE(
15910       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15911   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
15912   ASSERT_TRUE((bool)Style1);
15913   ASSERT_EQ(*Style1, getLLVMStyle());
15914 
15915   // Test 2.1: fallback to default.
15916   ASSERT_TRUE(
15917       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15918   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
15919   ASSERT_TRUE((bool)Style2);
15920   ASSERT_EQ(*Style2, getMozillaStyle());
15921 
15922   // Test 2.2: no format on 'none' fallback style.
15923   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
15924   ASSERT_TRUE((bool)Style2);
15925   ASSERT_EQ(*Style2, getNoStyle());
15926 
15927   // Test 2.3: format if config is found with no based style while fallback is
15928   // 'none'.
15929   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
15930                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
15931   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
15932   ASSERT_TRUE((bool)Style2);
15933   ASSERT_EQ(*Style2, getLLVMStyle());
15934 
15935   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
15936   Style2 = getStyle("{}", "a.h", "none", "", &FS);
15937   ASSERT_TRUE((bool)Style2);
15938   ASSERT_EQ(*Style2, getLLVMStyle());
15939 
15940   // Test 3: format file in parent directory.
15941   ASSERT_TRUE(
15942       FS.addFile("/c/.clang-format", 0,
15943                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
15944   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
15945                          llvm::MemoryBuffer::getMemBuffer("int i;")));
15946   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
15947   ASSERT_TRUE((bool)Style3);
15948   ASSERT_EQ(*Style3, getGoogleStyle());
15949 
15950   // Test 4: error on invalid fallback style
15951   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
15952   ASSERT_FALSE((bool)Style4);
15953   llvm::consumeError(Style4.takeError());
15954 
15955   // Test 5: error on invalid yaml on command line
15956   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
15957   ASSERT_FALSE((bool)Style5);
15958   llvm::consumeError(Style5.takeError());
15959 
15960   // Test 6: error on invalid style
15961   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
15962   ASSERT_FALSE((bool)Style6);
15963   llvm::consumeError(Style6.takeError());
15964 
15965   // Test 7: found config file, error on parsing it
15966   ASSERT_TRUE(
15967       FS.addFile("/d/.clang-format", 0,
15968                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
15969                                                   "InvalidKey: InvalidValue")));
15970   ASSERT_TRUE(
15971       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15972   auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
15973   ASSERT_FALSE((bool)Style7);
15974   llvm::consumeError(Style7.takeError());
15975 
15976   // Test 8: inferred per-language defaults apply.
15977   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
15978   ASSERT_TRUE((bool)StyleTd);
15979   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
15980 }
15981 
15982 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
15983   // Column limit is 20.
15984   std::string Code = "Type *a =\n"
15985                      "    new Type();\n"
15986                      "g(iiiii, 0, jjjjj,\n"
15987                      "  0, kkkkk, 0, mm);\n"
15988                      "int  bad     = format   ;";
15989   std::string Expected = "auto a = new Type();\n"
15990                          "g(iiiii, nullptr,\n"
15991                          "  jjjjj, nullptr,\n"
15992                          "  kkkkk, nullptr,\n"
15993                          "  mm);\n"
15994                          "int  bad     = format   ;";
15995   FileID ID = Context.createInMemoryFile("format.cpp", Code);
15996   tooling::Replacements Replaces = toReplacements(
15997       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
15998                             "auto "),
15999        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
16000                             "nullptr"),
16001        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
16002                             "nullptr"),
16003        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
16004                             "nullptr")});
16005 
16006   format::FormatStyle Style = format::getLLVMStyle();
16007   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
16008   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16009   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16010       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16011   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16012   EXPECT_TRUE(static_cast<bool>(Result));
16013   EXPECT_EQ(Expected, *Result);
16014 }
16015 
16016 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
16017   std::string Code = "#include \"a.h\"\n"
16018                      "#include \"c.h\"\n"
16019                      "\n"
16020                      "int main() {\n"
16021                      "  return 0;\n"
16022                      "}";
16023   std::string Expected = "#include \"a.h\"\n"
16024                          "#include \"b.h\"\n"
16025                          "#include \"c.h\"\n"
16026                          "\n"
16027                          "int main() {\n"
16028                          "  return 0;\n"
16029                          "}";
16030   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
16031   tooling::Replacements Replaces = toReplacements(
16032       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
16033                             "#include \"b.h\"\n")});
16034 
16035   format::FormatStyle Style = format::getLLVMStyle();
16036   Style.SortIncludes = true;
16037   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16038   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16039       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16040   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16041   EXPECT_TRUE(static_cast<bool>(Result));
16042   EXPECT_EQ(Expected, *Result);
16043 }
16044 
16045 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
16046   EXPECT_EQ("using std::cin;\n"
16047             "using std::cout;",
16048             format("using std::cout;\n"
16049                    "using std::cin;",
16050                    getGoogleStyle()));
16051 }
16052 
16053 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
16054   format::FormatStyle Style = format::getLLVMStyle();
16055   Style.Standard = FormatStyle::LS_Cpp03;
16056   // cpp03 recognize this string as identifier u8 and literal character 'a'
16057   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
16058 }
16059 
16060 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
16061   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
16062   // all modes, including C++11, C++14 and C++17
16063   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
16064 }
16065 
16066 TEST_F(FormatTest, DoNotFormatLikelyXml) {
16067   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
16068   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
16069 }
16070 
16071 TEST_F(FormatTest, StructuredBindings) {
16072   // Structured bindings is a C++17 feature.
16073   // all modes, including C++11, C++14 and C++17
16074   verifyFormat("auto [a, b] = f();");
16075   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
16076   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
16077   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
16078   EXPECT_EQ("auto const volatile [a, b] = f();",
16079             format("auto  const   volatile[a, b] = f();"));
16080   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
16081   EXPECT_EQ("auto &[a, b, c] = f();",
16082             format("auto   &[  a  ,  b,c   ] = f();"));
16083   EXPECT_EQ("auto &&[a, b, c] = f();",
16084             format("auto   &&[  a  ,  b,c   ] = f();"));
16085   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
16086   EXPECT_EQ("auto const volatile &&[a, b] = f();",
16087             format("auto  const  volatile  &&[a, b] = f();"));
16088   EXPECT_EQ("auto const &&[a, b] = f();",
16089             format("auto  const   &&  [a, b] = f();"));
16090   EXPECT_EQ("const auto &[a, b] = f();",
16091             format("const  auto  &  [a, b] = f();"));
16092   EXPECT_EQ("const auto volatile &&[a, b] = f();",
16093             format("const  auto   volatile  &&[a, b] = f();"));
16094   EXPECT_EQ("volatile const auto &&[a, b] = f();",
16095             format("volatile  const  auto   &&[a, b] = f();"));
16096   EXPECT_EQ("const auto &&[a, b] = f();",
16097             format("const  auto  &&  [a, b] = f();"));
16098 
16099   // Make sure we don't mistake structured bindings for lambdas.
16100   FormatStyle PointerMiddle = getLLVMStyle();
16101   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16102   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16103   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16104   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16105   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16106   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16107   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16108   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16109   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16110   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16111   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16112   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16113   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16114 
16115   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16116             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16117   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16118             format("for (const auto   &   [a, b] : some_range) {\n}"));
16119   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16120             format("for (const auto[a, b] : some_range) {\n}"));
16121   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16122   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16123   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16124   EXPECT_EQ("auto const &[x, y](expr);",
16125             format("auto  const  &  [x,y]  (expr);"));
16126   EXPECT_EQ("auto const &&[x, y](expr);",
16127             format("auto  const  &&  [x,y]  (expr);"));
16128   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16129   EXPECT_EQ("auto const &[x, y]{expr};",
16130             format("auto  const  &  [x,y]  {expr};"));
16131   EXPECT_EQ("auto const &&[x, y]{expr};",
16132             format("auto  const  &&  [x,y]  {expr};"));
16133 
16134   format::FormatStyle Spaces = format::getLLVMStyle();
16135   Spaces.SpacesInSquareBrackets = true;
16136   verifyFormat("auto [ a, b ] = f();", Spaces);
16137   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16138   verifyFormat("auto &[ a, b ] = f();", Spaces);
16139   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16140   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16141 }
16142 
16143 TEST_F(FormatTest, FileAndCode) {
16144   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16145   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16146   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16147   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16148   EXPECT_EQ(FormatStyle::LK_ObjC,
16149             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16150   EXPECT_EQ(
16151       FormatStyle::LK_ObjC,
16152       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16153   EXPECT_EQ(FormatStyle::LK_ObjC,
16154             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16155   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16156   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16157   EXPECT_EQ(FormatStyle::LK_ObjC,
16158             guessLanguage("foo", "@interface Foo\n@end\n"));
16159   EXPECT_EQ(FormatStyle::LK_ObjC,
16160             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16161   EXPECT_EQ(
16162       FormatStyle::LK_ObjC,
16163       guessLanguage("foo.h",
16164                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16165   EXPECT_EQ(
16166       FormatStyle::LK_Cpp,
16167       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16168 }
16169 
16170 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16171   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16172   EXPECT_EQ(FormatStyle::LK_ObjC,
16173             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16174   EXPECT_EQ(FormatStyle::LK_Cpp,
16175             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16176   EXPECT_EQ(
16177       FormatStyle::LK_Cpp,
16178       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16179   EXPECT_EQ(FormatStyle::LK_ObjC,
16180             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16181   EXPECT_EQ(FormatStyle::LK_Cpp,
16182             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16183   EXPECT_EQ(FormatStyle::LK_ObjC,
16184             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16185   EXPECT_EQ(FormatStyle::LK_Cpp,
16186             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16187   EXPECT_EQ(FormatStyle::LK_Cpp,
16188             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16189   EXPECT_EQ(FormatStyle::LK_ObjC,
16190             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16191   EXPECT_EQ(FormatStyle::LK_Cpp,
16192             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16193   EXPECT_EQ(
16194       FormatStyle::LK_Cpp,
16195       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16196   EXPECT_EQ(
16197       FormatStyle::LK_Cpp,
16198       guessLanguage("foo.h",
16199                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16200   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16201 }
16202 
16203 TEST_F(FormatTest, GuessLanguageWithCaret) {
16204   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16205   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16206   EXPECT_EQ(FormatStyle::LK_ObjC,
16207             guessLanguage("foo.h", "int(^)(char, float);"));
16208   EXPECT_EQ(FormatStyle::LK_ObjC,
16209             guessLanguage("foo.h", "int(^foo)(char, float);"));
16210   EXPECT_EQ(FormatStyle::LK_ObjC,
16211             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16212   EXPECT_EQ(FormatStyle::LK_ObjC,
16213             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16214   EXPECT_EQ(
16215       FormatStyle::LK_ObjC,
16216       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16217 }
16218 
16219 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16220   // ASM symbolic names are identifiers that must be surrounded by [] without
16221   // space in between:
16222   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16223 
16224   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16225   verifyFormat(R"(//
16226 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16227 )");
16228 
16229   // A list of several ASM symbolic names.
16230   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16231 
16232   // ASM symbolic names in inline ASM with inputs and outputs.
16233   verifyFormat(R"(//
16234 asm("cmoveq %1, %2, %[result]"
16235     : [result] "=r"(result)
16236     : "r"(test), "r"(new), "[result]"(old));
16237 )");
16238 
16239   // ASM symbolic names in inline ASM with no outputs.
16240   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16241 }
16242 
16243 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
16244   EXPECT_EQ(FormatStyle::LK_Cpp,
16245             guessLanguage("foo.h", "void f() {\n"
16246                                    "  asm (\"mov %[e], %[d]\"\n"
16247                                    "     : [d] \"=rm\" (d)\n"
16248                                    "       [e] \"rm\" (*e));\n"
16249                                    "}"));
16250   EXPECT_EQ(FormatStyle::LK_Cpp,
16251             guessLanguage("foo.h", "void f() {\n"
16252                                    "  _asm (\"mov %[e], %[d]\"\n"
16253                                    "     : [d] \"=rm\" (d)\n"
16254                                    "       [e] \"rm\" (*e));\n"
16255                                    "}"));
16256   EXPECT_EQ(FormatStyle::LK_Cpp,
16257             guessLanguage("foo.h", "void f() {\n"
16258                                    "  __asm (\"mov %[e], %[d]\"\n"
16259                                    "     : [d] \"=rm\" (d)\n"
16260                                    "       [e] \"rm\" (*e));\n"
16261                                    "}"));
16262   EXPECT_EQ(FormatStyle::LK_Cpp,
16263             guessLanguage("foo.h", "void f() {\n"
16264                                    "  __asm__ (\"mov %[e], %[d]\"\n"
16265                                    "     : [d] \"=rm\" (d)\n"
16266                                    "       [e] \"rm\" (*e));\n"
16267                                    "}"));
16268   EXPECT_EQ(FormatStyle::LK_Cpp,
16269             guessLanguage("foo.h", "void f() {\n"
16270                                    "  asm (\"mov %[e], %[d]\"\n"
16271                                    "     : [d] \"=rm\" (d),\n"
16272                                    "       [e] \"rm\" (*e));\n"
16273                                    "}"));
16274   EXPECT_EQ(FormatStyle::LK_Cpp,
16275             guessLanguage("foo.h", "void f() {\n"
16276                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16277                                    "     : [d] \"=rm\" (d)\n"
16278                                    "       [e] \"rm\" (*e));\n"
16279                                    "}"));
16280 }
16281 
16282 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16283   EXPECT_EQ(FormatStyle::LK_Cpp,
16284             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16285   EXPECT_EQ(FormatStyle::LK_ObjC,
16286             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16287   EXPECT_EQ(
16288       FormatStyle::LK_Cpp,
16289       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16290   EXPECT_EQ(
16291       FormatStyle::LK_ObjC,
16292       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16293 }
16294 
16295 TEST_F(FormatTest, TypenameMacros) {
16296   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16297 
16298   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16299   FormatStyle Google = getGoogleStyleWithColumns(0);
16300   Google.TypenameMacros = TypenameMacros;
16301   verifyFormat("struct foo {\n"
16302                "  int bar;\n"
16303                "  TAILQ_ENTRY(a) bleh;\n"
16304                "};",
16305                Google);
16306 
16307   FormatStyle Macros = getLLVMStyle();
16308   Macros.TypenameMacros = TypenameMacros;
16309 
16310   verifyFormat("STACK_OF(int) a;", Macros);
16311   verifyFormat("STACK_OF(int) *a;", Macros);
16312   verifyFormat("STACK_OF(int const *) *a;", Macros);
16313   verifyFormat("STACK_OF(int *const) *a;", Macros);
16314   verifyFormat("STACK_OF(int, string) a;", Macros);
16315   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16316   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16317   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16318   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16319 
16320   Macros.PointerAlignment = FormatStyle::PAS_Left;
16321   verifyFormat("STACK_OF(int)* a;", Macros);
16322   verifyFormat("STACK_OF(int*)* a;", Macros);
16323 }
16324 
16325 TEST_F(FormatTest, AmbersandInLamda) {
16326   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16327   FormatStyle AlignStyle = getLLVMStyle();
16328   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16329   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16330   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16331   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16332 }
16333 
16334 TEST_F(FormatTest, SpacesInConditionalStatement) {
16335   FormatStyle Spaces = getLLVMStyle();
16336   Spaces.SpacesInConditionalStatement = true;
16337   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16338   verifyFormat("if ( !a )\n  return;", Spaces);
16339   verifyFormat("if ( a )\n  return;", Spaces);
16340   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16341   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16342   verifyFormat("while ( a )\n  return;", Spaces);
16343   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16344   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16345   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16346   // Check that space on the left of "::" is inserted as expected at beginning
16347   // of condition.
16348   verifyFormat("while ( ::func() )\n  return;", Spaces);
16349 }
16350 
16351 TEST_F(FormatTest, AlternativeOperators) {
16352   // Test case for ensuring alternate operators are not
16353   // combined with their right most neighbour.
16354   verifyFormat("int a and b;");
16355   verifyFormat("int a and_eq b;");
16356   verifyFormat("int a bitand b;");
16357   verifyFormat("int a bitor b;");
16358   verifyFormat("int a compl b;");
16359   verifyFormat("int a not b;");
16360   verifyFormat("int a not_eq b;");
16361   verifyFormat("int a or b;");
16362   verifyFormat("int a xor b;");
16363   verifyFormat("int a xor_eq b;");
16364   verifyFormat("return this not_eq bitand other;");
16365   verifyFormat("bool operator not_eq(const X bitand other)");
16366 
16367   verifyFormat("int a and 5;");
16368   verifyFormat("int a and_eq 5;");
16369   verifyFormat("int a bitand 5;");
16370   verifyFormat("int a bitor 5;");
16371   verifyFormat("int a compl 5;");
16372   verifyFormat("int a not 5;");
16373   verifyFormat("int a not_eq 5;");
16374   verifyFormat("int a or 5;");
16375   verifyFormat("int a xor 5;");
16376   verifyFormat("int a xor_eq 5;");
16377 
16378   verifyFormat("int a compl(5);");
16379   verifyFormat("int a not(5);");
16380 
16381   /* FIXME handle alternate tokens
16382    * https://en.cppreference.com/w/cpp/language/operator_alternative
16383   // alternative tokens
16384   verifyFormat("compl foo();");     //  ~foo();
16385   verifyFormat("foo() <%%>;");      // foo();
16386   verifyFormat("void foo() <%%>;"); // void foo(){}
16387   verifyFormat("int a <:1:>;");     // int a[1];[
16388   verifyFormat("%:define ABC abc"); // #define ABC abc
16389   verifyFormat("%:%:");             // ##
16390   */
16391 }
16392 
16393 TEST_F(FormatTest, STLWhileNotDefineChed) {
16394   verifyFormat("#if defined(while)\n"
16395                "#define while EMIT WARNING C4005\n"
16396                "#endif // while");
16397 }
16398 
16399 TEST_F(FormatTest, OperatorSpacing) {
16400   FormatStyle Style = getLLVMStyle();
16401   Style.PointerAlignment = FormatStyle::PAS_Right;
16402   verifyFormat("Foo::operator*();", Style);
16403   verifyFormat("Foo::operator void *();", Style);
16404   verifyFormat("Foo::operator void **();", Style);
16405   verifyFormat("Foo::operator void *&();", Style);
16406   verifyFormat("Foo::operator void *&&();", Style);
16407   verifyFormat("Foo::operator()(void *);", Style);
16408   verifyFormat("Foo::operator*(void *);", Style);
16409   verifyFormat("Foo::operator*();", Style);
16410   verifyFormat("Foo::operator**();", Style);
16411   verifyFormat("Foo::operator&();", Style);
16412   verifyFormat("Foo::operator<int> *();", Style);
16413   verifyFormat("Foo::operator<Foo> *();", Style);
16414   verifyFormat("Foo::operator<int> **();", Style);
16415   verifyFormat("Foo::operator<Foo> **();", Style);
16416   verifyFormat("Foo::operator<int> &();", Style);
16417   verifyFormat("Foo::operator<Foo> &();", Style);
16418   verifyFormat("Foo::operator<int> &&();", Style);
16419   verifyFormat("Foo::operator<Foo> &&();", Style);
16420   verifyFormat("Foo::operator<int> *&();", Style);
16421   verifyFormat("Foo::operator<Foo> *&();", Style);
16422   verifyFormat("Foo::operator<int> *&&();", Style);
16423   verifyFormat("Foo::operator<Foo> *&&();", Style);
16424   verifyFormat("operator*(int (*)(), class Foo);", Style);
16425 
16426   verifyFormat("Foo::operator&();", Style);
16427   verifyFormat("Foo::operator void &();", Style);
16428   verifyFormat("Foo::operator()(void &);", Style);
16429   verifyFormat("Foo::operator&(void &);", Style);
16430   verifyFormat("Foo::operator&();", Style);
16431   verifyFormat("operator&(int (&)(), class Foo);", Style);
16432 
16433   verifyFormat("Foo::operator&&();", Style);
16434   verifyFormat("Foo::operator**();", Style);
16435   verifyFormat("Foo::operator void &&();", Style);
16436   verifyFormat("Foo::operator()(void &&);", Style);
16437   verifyFormat("Foo::operator&&(void &&);", Style);
16438   verifyFormat("Foo::operator&&();", Style);
16439   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16440   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16441   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16442                Style);
16443   verifyFormat("operator void **()", Style);
16444   verifyFormat("operator const FooRight<Object> &()", Style);
16445   verifyFormat("operator const FooRight<Object> *()", Style);
16446   verifyFormat("operator const FooRight<Object> **()", Style);
16447   verifyFormat("operator const FooRight<Object> *&()", Style);
16448   verifyFormat("operator const FooRight<Object> *&&()", Style);
16449 
16450   Style.PointerAlignment = FormatStyle::PAS_Left;
16451   verifyFormat("Foo::operator*();", Style);
16452   verifyFormat("Foo::operator**();", Style);
16453   verifyFormat("Foo::operator void*();", Style);
16454   verifyFormat("Foo::operator void**();", Style);
16455   verifyFormat("Foo::operator void*&();", Style);
16456   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16457   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16458   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16459   verifyFormat("Foo::operator()(void*);", Style);
16460   verifyFormat("Foo::operator*(void*);", Style);
16461   verifyFormat("Foo::operator*();", Style);
16462   verifyFormat("Foo::operator<int>*();", Style);
16463   verifyFormat("Foo::operator<Foo>*();", Style);
16464   verifyFormat("Foo::operator<int>**();", Style);
16465   verifyFormat("Foo::operator<Foo>**();", Style);
16466   verifyFormat("Foo::operator<Foo>*&();", Style);
16467   verifyFormat("Foo::operator<int>&();", Style);
16468   verifyFormat("Foo::operator<Foo>&();", 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("operator*(int (*)(), class Foo);", Style);
16474 
16475   verifyFormat("Foo::operator&();", Style);
16476   verifyFormat("Foo::operator void&();", Style);
16477   verifyFormat("Foo::operator/*comment*/ void&();", Style);
16478   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
16479   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
16480   verifyFormat("Foo::operator()(void&);", Style);
16481   verifyFormat("Foo::operator&(void&);", Style);
16482   verifyFormat("Foo::operator&();", Style);
16483   verifyFormat("operator&(int (&)(), class Foo);", Style);
16484 
16485   verifyFormat("Foo::operator&&();", Style);
16486   verifyFormat("Foo::operator void&&();", Style);
16487   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
16488   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
16489   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
16490   verifyFormat("Foo::operator()(void&&);", Style);
16491   verifyFormat("Foo::operator&&(void&&);", Style);
16492   verifyFormat("Foo::operator&&();", Style);
16493   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16494   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
16495   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
16496                Style);
16497   verifyFormat("operator void**()", Style);
16498   verifyFormat("operator const FooLeft<Object>&()", Style);
16499   verifyFormat("operator const FooLeft<Object>*()", Style);
16500   verifyFormat("operator const FooLeft<Object>**()", Style);
16501   verifyFormat("operator const FooLeft<Object>*&()", Style);
16502   verifyFormat("operator const FooLeft<Object>*&&()", Style);
16503 
16504   // PR45107
16505   verifyFormat("operator Vector<String>&();", Style);
16506   verifyFormat("operator const Vector<String>&();", Style);
16507   verifyFormat("operator foo::Bar*();", Style);
16508   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
16509   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
16510                Style);
16511 
16512   Style.PointerAlignment = FormatStyle::PAS_Middle;
16513   verifyFormat("Foo::operator*();", Style);
16514   verifyFormat("Foo::operator void *();", Style);
16515   verifyFormat("Foo::operator()(void *);", Style);
16516   verifyFormat("Foo::operator*(void *);", Style);
16517   verifyFormat("Foo::operator*();", Style);
16518   verifyFormat("operator*(int (*)(), class Foo);", Style);
16519 
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 
16535 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
16536   FormatStyle Style = getLLVMStyle();
16537   // PR46157
16538   verifyFormat("foo(operator+, -42);", Style);
16539   verifyFormat("foo(operator++, -42);", Style);
16540   verifyFormat("foo(operator--, -42);", Style);
16541   verifyFormat("foo(-42, operator--);", Style);
16542   verifyFormat("foo(-42, operator, );", Style);
16543   verifyFormat("foo(operator, , -42);", Style);
16544 }
16545 
16546 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
16547   FormatStyle Style = getLLVMStyle();
16548   Style.WhitespaceSensitiveMacros.push_back("FOO");
16549 
16550   // Don't use the helpers here, since 'mess up' will change the whitespace
16551   // and these are all whitespace sensitive by definition
16552   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
16553             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
16554   EXPECT_EQ(
16555       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
16556       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
16557   EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
16558             format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
16559   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
16560             "       Still=Intentional);",
16561             format("FOO(String-ized&Messy+But,: :\n"
16562                    "       Still=Intentional);",
16563                    Style));
16564   Style.AlignConsecutiveAssignments = true;
16565   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
16566             "       Still=Intentional);",
16567             format("FOO(String-ized=&Messy+But,: :\n"
16568                    "       Still=Intentional);",
16569                    Style));
16570 
16571   Style.ColumnLimit = 21;
16572   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
16573             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
16574 }
16575 
16576 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
16577   // These tests are not in NamespaceFixer because that doesn't
16578   // test its interaction with line wrapping
16579   FormatStyle Style = getLLVMStyle();
16580   Style.ColumnLimit = 80;
16581   verifyFormat("namespace {\n"
16582                "int i;\n"
16583                "int j;\n"
16584                "} // namespace",
16585                Style);
16586 
16587   verifyFormat("namespace AAA {\n"
16588                "int i;\n"
16589                "int j;\n"
16590                "} // namespace AAA",
16591                Style);
16592 
16593   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
16594             "int i;\n"
16595             "int j;\n"
16596             "} // namespace Averyveryveryverylongnamespace",
16597             format("namespace Averyveryveryverylongnamespace {\n"
16598                    "int i;\n"
16599                    "int j;\n"
16600                    "}",
16601                    Style));
16602 
16603   EXPECT_EQ(
16604       "namespace "
16605       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16606       "    went::mad::now {\n"
16607       "int i;\n"
16608       "int j;\n"
16609       "} // namespace\n"
16610       "  // "
16611       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16612       "went::mad::now",
16613       format("namespace "
16614              "would::it::save::you::a::lot::of::time::if_::i::"
16615              "just::gave::up::and_::went::mad::now {\n"
16616              "int i;\n"
16617              "int j;\n"
16618              "}",
16619              Style));
16620 
16621   // This used to duplicate the comment again and again on subsequent runs
16622   EXPECT_EQ(
16623       "namespace "
16624       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16625       "    went::mad::now {\n"
16626       "int i;\n"
16627       "int j;\n"
16628       "} // namespace\n"
16629       "  // "
16630       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16631       "went::mad::now",
16632       format("namespace "
16633              "would::it::save::you::a::lot::of::time::if_::i::"
16634              "just::gave::up::and_::went::mad::now {\n"
16635              "int i;\n"
16636              "int j;\n"
16637              "} // namespace\n"
16638              "  // "
16639              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
16640              "and_::went::mad::now",
16641              Style));
16642 }
16643 
16644 TEST_F(FormatTest, LikelyUnlikely) {
16645   FormatStyle Style = getLLVMStyle();
16646 
16647   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16648                "  return 29;\n"
16649                "}",
16650                Style);
16651 
16652   verifyFormat("if (argc > 5) [[likely]] {\n"
16653                "  return 29;\n"
16654                "}",
16655                Style);
16656 
16657   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16658                "  return 29;\n"
16659                "} else [[likely]] {\n"
16660                "  return 42;\n"
16661                "}\n",
16662                Style);
16663 
16664   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16665                "  return 29;\n"
16666                "} else if (argc > 10) [[likely]] {\n"
16667                "  return 99;\n"
16668                "} else {\n"
16669                "  return 42;\n"
16670                "}\n",
16671                Style);
16672 
16673   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
16674                "  return 29;\n"
16675                "}",
16676                Style);
16677 }
16678 
16679 TEST_F(FormatTest, LLVMDefaultStyle) {
16680   FormatStyle Style = getLLVMStyle();
16681   verifyFormat("extern \"C\" {\n"
16682                "int foo();\n"
16683                "}",
16684                Style);
16685 }
16686 TEST_F(FormatTest, GNUDefaultStyle) {
16687   FormatStyle Style = getGNUStyle();
16688   verifyFormat("extern \"C\"\n"
16689                "{\n"
16690                "  int foo ();\n"
16691                "}",
16692                Style);
16693 }
16694 TEST_F(FormatTest, MozillaDefaultStyle) {
16695   FormatStyle Style = getMozillaStyle();
16696   verifyFormat("extern \"C\"\n"
16697                "{\n"
16698                "  int foo();\n"
16699                "}",
16700                Style);
16701 }
16702 TEST_F(FormatTest, GoogleDefaultStyle) {
16703   FormatStyle Style = getGoogleStyle();
16704   verifyFormat("extern \"C\" {\n"
16705                "int foo();\n"
16706                "}",
16707                Style);
16708 }
16709 TEST_F(FormatTest, ChromiumDefaultStyle) {
16710   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
16711   verifyFormat("extern \"C\" {\n"
16712                "int foo();\n"
16713                "}",
16714                Style);
16715 }
16716 TEST_F(FormatTest, MicrosoftDefaultStyle) {
16717   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
16718   verifyFormat("extern \"C\"\n"
16719                "{\n"
16720                "    int foo();\n"
16721                "}",
16722                Style);
16723 }
16724 TEST_F(FormatTest, WebKitDefaultStyle) {
16725   FormatStyle Style = getWebKitStyle();
16726   verifyFormat("extern \"C\" {\n"
16727                "int foo();\n"
16728                "}",
16729                Style);
16730 }
16731 } // namespace
16732 } // namespace format
16733 } // namespace clang
16734