1 //===- unittest/Format/FormatTest.cpp - Formatting unit tests -------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "clang/Format/Format.h"
10 
11 #include "../Tooling/ReplacementTest.h"
12 #include "FormatTestUtils.h"
13 
14 #include "clang/Frontend/TextDiagnosticPrinter.h"
15 #include "llvm/Support/Debug.h"
16 #include "llvm/Support/MemoryBuffer.h"
17 #include "gtest/gtest.h"
18 
19 #define DEBUG_TYPE "format-test"
20 
21 using clang::tooling::ReplacementTest;
22 using clang::tooling::toReplacements;
23 
24 namespace clang {
25 namespace format {
26 namespace {
27 
28 FormatStyle getGoogleStyle() { return getGoogleStyle(FormatStyle::LK_Cpp); }
29 
30 class FormatTest : public ::testing::Test {
31 protected:
32   enum StatusCheck { SC_ExpectComplete, SC_ExpectIncomplete, SC_DoNotCheck };
33 
34   std::string format(llvm::StringRef Code,
35                      const FormatStyle &Style = getLLVMStyle(),
36                      StatusCheck CheckComplete = SC_ExpectComplete) {
37     LLVM_DEBUG(llvm::errs() << "---\n");
38     LLVM_DEBUG(llvm::errs() << Code << "\n\n");
39     std::vector<tooling::Range> Ranges(1, tooling::Range(0, Code.size()));
40     FormattingAttemptStatus Status;
41     tooling::Replacements Replaces =
42         reformat(Style, Code, Ranges, "<stdin>", &Status);
43     if (CheckComplete != SC_DoNotCheck) {
44       bool ExpectedCompleteFormat = CheckComplete == SC_ExpectComplete;
45       EXPECT_EQ(ExpectedCompleteFormat, Status.FormatComplete)
46           << Code << "\n\n";
47     }
48     ReplacementCount = Replaces.size();
49     auto Result = applyAllReplacements(Code, Replaces);
50     EXPECT_TRUE(static_cast<bool>(Result));
51     LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
52     return *Result;
53   }
54 
55   FormatStyle getStyleWithColumns(FormatStyle Style, unsigned ColumnLimit) {
56     Style.ColumnLimit = ColumnLimit;
57     return Style;
58   }
59 
60   FormatStyle getLLVMStyleWithColumns(unsigned ColumnLimit) {
61     return getStyleWithColumns(getLLVMStyle(), ColumnLimit);
62   }
63 
64   FormatStyle getGoogleStyleWithColumns(unsigned ColumnLimit) {
65     return getStyleWithColumns(getGoogleStyle(), ColumnLimit);
66   }
67 
68   void verifyFormat(llvm::StringRef Expected, llvm::StringRef Code,
69                     const FormatStyle &Style = getLLVMStyle()) {
70     EXPECT_EQ(Expected.str(), format(Expected, Style))
71         << "Expected code is not stable";
72     EXPECT_EQ(Expected.str(), format(Code, Style));
73     if (Style.Language == FormatStyle::LK_Cpp) {
74       // Objective-C++ is a superset of C++, so everything checked for C++
75       // needs to be checked for Objective-C++ as well.
76       FormatStyle ObjCStyle = Style;
77       ObjCStyle.Language = FormatStyle::LK_ObjC;
78       EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
79     }
80   }
81 
82   void verifyFormat(llvm::StringRef Code,
83                     const FormatStyle &Style = getLLVMStyle()) {
84     verifyFormat(Code, test::messUp(Code), Style);
85   }
86 
87   void verifyIncompleteFormat(llvm::StringRef Code,
88                               const FormatStyle &Style = getLLVMStyle()) {
89     EXPECT_EQ(Code.str(),
90               format(test::messUp(Code), Style, SC_ExpectIncomplete));
91   }
92 
93   void verifyGoogleFormat(llvm::StringRef Code) {
94     verifyFormat(Code, getGoogleStyle());
95   }
96 
97   void verifyIndependentOfContext(llvm::StringRef text) {
98     verifyFormat(text);
99     verifyFormat(llvm::Twine("void f() { " + text + " }").str());
100   }
101 
102   /// \brief Verify that clang-format does not crash on the given input.
103   void verifyNoCrash(llvm::StringRef Code,
104                      const FormatStyle &Style = getLLVMStyle()) {
105     format(Code, Style, SC_DoNotCheck);
106   }
107 
108   int ReplacementCount;
109 };
110 
111 TEST_F(FormatTest, MessUp) {
112   EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
113   EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
114   EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
115   EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
116   EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
117 }
118 
119 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) {
120   EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language);
121 }
122 
123 TEST_F(FormatTest, LLVMStyleOverride) {
124   EXPECT_EQ(FormatStyle::LK_Proto,
125             getLLVMStyle(FormatStyle::LK_Proto).Language);
126 }
127 
128 //===----------------------------------------------------------------------===//
129 // Basic function tests.
130 //===----------------------------------------------------------------------===//
131 
132 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
133   EXPECT_EQ(";", format(";"));
134 }
135 
136 TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
137   EXPECT_EQ("int i;", format("  int i;"));
138   EXPECT_EQ("\nint i;", format(" \n\t \v \f  int i;"));
139   EXPECT_EQ("int i;\nint j;", format("    int i; int j;"));
140   EXPECT_EQ("int i;\nint j;", format("    int i;\n  int j;"));
141 }
142 
143 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
144   EXPECT_EQ("int i;", format("int\ni;"));
145 }
146 
147 TEST_F(FormatTest, FormatsNestedBlockStatements) {
148   EXPECT_EQ("{\n  {\n    {}\n  }\n}", format("{{{}}}"));
149 }
150 
151 TEST_F(FormatTest, FormatsNestedCall) {
152   verifyFormat("Method(f1, f2(f3));");
153   verifyFormat("Method(f1(f2, f3()));");
154   verifyFormat("Method(f1(f2, (f3())));");
155 }
156 
157 TEST_F(FormatTest, NestedNameSpecifiers) {
158   verifyFormat("vector<::Type> v;");
159   verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
160   verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
161   verifyFormat("bool a = 2 < ::SomeFunction();");
162   verifyFormat("ALWAYS_INLINE ::std::string getName();");
163   verifyFormat("some::string getName();");
164 }
165 
166 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
167   EXPECT_EQ("if (a) {\n"
168             "  f();\n"
169             "}",
170             format("if(a){f();}"));
171   EXPECT_EQ(4, ReplacementCount);
172   EXPECT_EQ("if (a) {\n"
173             "  f();\n"
174             "}",
175             format("if (a) {\n"
176                    "  f();\n"
177                    "}"));
178   EXPECT_EQ(0, ReplacementCount);
179   EXPECT_EQ("/*\r\n"
180             "\r\n"
181             "*/\r\n",
182             format("/*\r\n"
183                    "\r\n"
184                    "*/\r\n"));
185   EXPECT_EQ(0, ReplacementCount);
186 }
187 
188 TEST_F(FormatTest, RemovesEmptyLines) {
189   EXPECT_EQ("class C {\n"
190             "  int i;\n"
191             "};",
192             format("class C {\n"
193                    " int i;\n"
194                    "\n"
195                    "};"));
196 
197   // Don't remove empty lines at the start of namespaces or extern "C" blocks.
198   EXPECT_EQ("namespace N {\n"
199             "\n"
200             "int i;\n"
201             "}",
202             format("namespace N {\n"
203                    "\n"
204                    "int    i;\n"
205                    "}",
206                    getGoogleStyle()));
207   EXPECT_EQ("/* something */ namespace N {\n"
208             "\n"
209             "int i;\n"
210             "}",
211             format("/* something */ namespace N {\n"
212                    "\n"
213                    "int    i;\n"
214                    "}",
215                    getGoogleStyle()));
216   EXPECT_EQ("inline namespace N {\n"
217             "\n"
218             "int i;\n"
219             "}",
220             format("inline namespace N {\n"
221                    "\n"
222                    "int    i;\n"
223                    "}",
224                    getGoogleStyle()));
225   EXPECT_EQ("/* something */ inline namespace N {\n"
226             "\n"
227             "int i;\n"
228             "}",
229             format("/* something */ inline namespace N {\n"
230                    "\n"
231                    "int    i;\n"
232                    "}",
233                    getGoogleStyle()));
234   EXPECT_EQ("export namespace N {\n"
235             "\n"
236             "int i;\n"
237             "}",
238             format("export namespace N {\n"
239                    "\n"
240                    "int    i;\n"
241                    "}",
242                    getGoogleStyle()));
243   EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
244             "\n"
245             "int i;\n"
246             "}",
247             format("extern /**/ \"C\" /**/ {\n"
248                    "\n"
249                    "int    i;\n"
250                    "}",
251                    getGoogleStyle()));
252 
253   // ...but do keep inlining and removing empty lines for non-block extern "C"
254   // functions.
255   verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
256   EXPECT_EQ("extern \"C\" int f() {\n"
257             "  int i = 42;\n"
258             "  return i;\n"
259             "}",
260             format("extern \"C\" int f() {\n"
261                    "\n"
262                    "  int i = 42;\n"
263                    "  return i;\n"
264                    "}",
265                    getGoogleStyle()));
266 
267   // Remove empty lines at the beginning and end of blocks.
268   EXPECT_EQ("void f() {\n"
269             "\n"
270             "  if (a) {\n"
271             "\n"
272             "    f();\n"
273             "  }\n"
274             "}",
275             format("void f() {\n"
276                    "\n"
277                    "  if (a) {\n"
278                    "\n"
279                    "    f();\n"
280                    "\n"
281                    "  }\n"
282                    "\n"
283                    "}",
284                    getLLVMStyle()));
285   EXPECT_EQ("void f() {\n"
286             "  if (a) {\n"
287             "    f();\n"
288             "  }\n"
289             "}",
290             format("void f() {\n"
291                    "\n"
292                    "  if (a) {\n"
293                    "\n"
294                    "    f();\n"
295                    "\n"
296                    "  }\n"
297                    "\n"
298                    "}",
299                    getGoogleStyle()));
300 
301   // Don't remove empty lines in more complex control statements.
302   EXPECT_EQ("void f() {\n"
303             "  if (a) {\n"
304             "    f();\n"
305             "\n"
306             "  } else if (b) {\n"
307             "    f();\n"
308             "  }\n"
309             "}",
310             format("void f() {\n"
311                    "  if (a) {\n"
312                    "    f();\n"
313                    "\n"
314                    "  } else if (b) {\n"
315                    "    f();\n"
316                    "\n"
317                    "  }\n"
318                    "\n"
319                    "}"));
320 
321   // Don't remove empty lines before namespace endings.
322   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
323   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
324   EXPECT_EQ("namespace {\n"
325             "int i;\n"
326             "\n"
327             "}",
328             format("namespace {\n"
329                    "int i;\n"
330                    "\n"
331                    "}",
332                    LLVMWithNoNamespaceFix));
333   EXPECT_EQ("namespace {\n"
334             "int i;\n"
335             "}",
336             format("namespace {\n"
337                    "int i;\n"
338                    "}",
339                    LLVMWithNoNamespaceFix));
340   EXPECT_EQ("namespace {\n"
341             "int i;\n"
342             "\n"
343             "};",
344             format("namespace {\n"
345                    "int i;\n"
346                    "\n"
347                    "};",
348                    LLVMWithNoNamespaceFix));
349   EXPECT_EQ("namespace {\n"
350             "int i;\n"
351             "};",
352             format("namespace {\n"
353                    "int i;\n"
354                    "};",
355                    LLVMWithNoNamespaceFix));
356   EXPECT_EQ("namespace {\n"
357             "int i;\n"
358             "\n"
359             "}",
360             format("namespace {\n"
361                    "int i;\n"
362                    "\n"
363                    "}"));
364   EXPECT_EQ("namespace {\n"
365             "int i;\n"
366             "\n"
367             "} // namespace",
368             format("namespace {\n"
369                    "int i;\n"
370                    "\n"
371                    "}  // namespace"));
372 
373   FormatStyle Style = getLLVMStyle();
374   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
375   Style.MaxEmptyLinesToKeep = 2;
376   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
377   Style.BraceWrapping.AfterClass = true;
378   Style.BraceWrapping.AfterFunction = true;
379   Style.KeepEmptyLinesAtTheStartOfBlocks = false;
380 
381   EXPECT_EQ("class Foo\n"
382             "{\n"
383             "  Foo() {}\n"
384             "\n"
385             "  void funk() {}\n"
386             "};",
387             format("class Foo\n"
388                    "{\n"
389                    "  Foo()\n"
390                    "  {\n"
391                    "  }\n"
392                    "\n"
393                    "  void funk() {}\n"
394                    "};",
395                    Style));
396 }
397 
398 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
399   verifyFormat("x = (a) and (b);");
400   verifyFormat("x = (a) or (b);");
401   verifyFormat("x = (a) bitand (b);");
402   verifyFormat("x = (a) bitor (b);");
403   verifyFormat("x = (a) not_eq (b);");
404   verifyFormat("x = (a) and_eq (b);");
405   verifyFormat("x = (a) or_eq (b);");
406   verifyFormat("x = (a) xor (b);");
407 }
408 
409 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) {
410   verifyFormat("x = compl(a);");
411   verifyFormat("x = not(a);");
412   verifyFormat("x = bitand(a);");
413   // Unary operator must not be merged with the next identifier
414   verifyFormat("x = compl a;");
415   verifyFormat("x = not a;");
416   verifyFormat("x = bitand a;");
417 }
418 
419 //===----------------------------------------------------------------------===//
420 // Tests for control statements.
421 //===----------------------------------------------------------------------===//
422 
423 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
424   verifyFormat("if (true)\n  f();\ng();");
425   verifyFormat("if (a)\n  if (b)\n    if (c)\n      g();\nh();");
426   verifyFormat("if (a)\n  if (b) {\n    f();\n  }\ng();");
427   verifyFormat("if constexpr (true)\n"
428                "  f();\ng();");
429   verifyFormat("if CONSTEXPR (true)\n"
430                "  f();\ng();");
431   verifyFormat("if constexpr (a)\n"
432                "  if constexpr (b)\n"
433                "    if constexpr (c)\n"
434                "      g();\n"
435                "h();");
436   verifyFormat("if CONSTEXPR (a)\n"
437                "  if CONSTEXPR (b)\n"
438                "    if CONSTEXPR (c)\n"
439                "      g();\n"
440                "h();");
441   verifyFormat("if constexpr (a)\n"
442                "  if constexpr (b) {\n"
443                "    f();\n"
444                "  }\n"
445                "g();");
446   verifyFormat("if CONSTEXPR (a)\n"
447                "  if CONSTEXPR (b) {\n"
448                "    f();\n"
449                "  }\n"
450                "g();");
451 
452   FormatStyle AllowsMergedIf = getLLVMStyle();
453   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
454   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
455       FormatStyle::SIS_WithoutElse;
456   verifyFormat("if (a)\n"
457                "  // comment\n"
458                "  f();",
459                AllowsMergedIf);
460   verifyFormat("{\n"
461                "  if (a)\n"
462                "  label:\n"
463                "    f();\n"
464                "}",
465                AllowsMergedIf);
466   verifyFormat("#define A \\\n"
467                "  if (a)  \\\n"
468                "  label:  \\\n"
469                "    f()",
470                AllowsMergedIf);
471   verifyFormat("if (a)\n"
472                "  ;",
473                AllowsMergedIf);
474   verifyFormat("if (a)\n"
475                "  if (b) return;",
476                AllowsMergedIf);
477 
478   verifyFormat("if (a) // Can't merge this\n"
479                "  f();\n",
480                AllowsMergedIf);
481   verifyFormat("if (a) /* still don't merge */\n"
482                "  f();",
483                AllowsMergedIf);
484   verifyFormat("if (a) { // Never merge this\n"
485                "  f();\n"
486                "}",
487                AllowsMergedIf);
488   verifyFormat("if (a) { /* Never merge this */\n"
489                "  f();\n"
490                "}",
491                AllowsMergedIf);
492 
493   AllowsMergedIf.ColumnLimit = 14;
494   verifyFormat("if (a) return;", AllowsMergedIf);
495   verifyFormat("if (aaaaaaaaa)\n"
496                "  return;",
497                AllowsMergedIf);
498 
499   AllowsMergedIf.ColumnLimit = 13;
500   verifyFormat("if (a)\n  return;", AllowsMergedIf);
501 }
502 
503 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) {
504   FormatStyle AllowsMergedIf = getLLVMStyle();
505   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
506   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
507       FormatStyle::SIS_WithoutElse;
508   verifyFormat("if (a)\n"
509                "  f();\n"
510                "else {\n"
511                "  g();\n"
512                "}",
513                AllowsMergedIf);
514   verifyFormat("if (a)\n"
515                "  f();\n"
516                "else\n"
517                "  g();\n",
518                AllowsMergedIf);
519 
520   AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
521 
522   verifyFormat("if (a) f();\n"
523                "else {\n"
524                "  g();\n"
525                "}",
526                AllowsMergedIf);
527   verifyFormat("if (a) f();\n"
528                "else {\n"
529                "  if (a) f();\n"
530                "  else {\n"
531                "    g();\n"
532                "  }\n"
533                "  g();\n"
534                "}",
535                AllowsMergedIf);
536 }
537 
538 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
539   FormatStyle AllowsMergedLoops = getLLVMStyle();
540   AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
541   verifyFormat("while (true) continue;", AllowsMergedLoops);
542   verifyFormat("for (;;) continue;", AllowsMergedLoops);
543   verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
544   verifyFormat("while (true)\n"
545                "  ;",
546                AllowsMergedLoops);
547   verifyFormat("for (;;)\n"
548                "  ;",
549                AllowsMergedLoops);
550   verifyFormat("for (;;)\n"
551                "  for (;;) continue;",
552                AllowsMergedLoops);
553   verifyFormat("for (;;) // Can't merge this\n"
554                "  continue;",
555                AllowsMergedLoops);
556   verifyFormat("for (;;) /* still don't merge */\n"
557                "  continue;",
558                AllowsMergedLoops);
559   verifyFormat("do a++;\n"
560                "while (true);",
561                AllowsMergedLoops);
562   verifyFormat("do /* Don't merge */\n"
563                "  a++;\n"
564                "while (true);",
565                AllowsMergedLoops);
566   verifyFormat("do // Don't merge\n"
567                "  a++;\n"
568                "while (true);",
569                AllowsMergedLoops);
570   verifyFormat("do\n"
571                "  // Don't merge\n"
572                "  a++;\n"
573                "while (true);",
574                AllowsMergedLoops);
575   // Without braces labels are interpreted differently.
576   verifyFormat("{\n"
577                "  do\n"
578                "  label:\n"
579                "    a++;\n"
580                "  while (true);\n"
581                "}",
582                AllowsMergedLoops);
583 }
584 
585 TEST_F(FormatTest, FormatShortBracedStatements) {
586   FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
587   AllowSimpleBracedStatements.ColumnLimit = 40;
588   AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine =
589       FormatStyle::SBS_Always;
590 
591   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
592       FormatStyle::SIS_WithoutElse;
593   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
594 
595   AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom;
596   AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true;
597   AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false;
598 
599   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
600   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
601   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
602   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
603   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
604   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
605   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
606   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
607   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
608   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
609   verifyFormat("if (true) { fffffffffffffffffffffff(); }",
610                AllowSimpleBracedStatements);
611   verifyFormat("if (true) {\n"
612                "  ffffffffffffffffffffffff();\n"
613                "}",
614                AllowSimpleBracedStatements);
615   verifyFormat("if (true) {\n"
616                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
617                "}",
618                AllowSimpleBracedStatements);
619   verifyFormat("if (true) { //\n"
620                "  f();\n"
621                "}",
622                AllowSimpleBracedStatements);
623   verifyFormat("if (true) {\n"
624                "  f();\n"
625                "  f();\n"
626                "}",
627                AllowSimpleBracedStatements);
628   verifyFormat("if (true) {\n"
629                "  f();\n"
630                "} else {\n"
631                "  f();\n"
632                "}",
633                AllowSimpleBracedStatements);
634 
635   verifyFormat("struct A2 {\n"
636                "  int X;\n"
637                "};",
638                AllowSimpleBracedStatements);
639   verifyFormat("typedef struct A2 {\n"
640                "  int X;\n"
641                "} A2_t;",
642                AllowSimpleBracedStatements);
643   verifyFormat("template <int> struct A2 {\n"
644                "  struct B {};\n"
645                "};",
646                AllowSimpleBracedStatements);
647 
648   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
649       FormatStyle::SIS_Never;
650   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
651   verifyFormat("if (true) {\n"
652                "  f();\n"
653                "}",
654                AllowSimpleBracedStatements);
655   verifyFormat("if (true) {\n"
656                "  f();\n"
657                "} else {\n"
658                "  f();\n"
659                "}",
660                AllowSimpleBracedStatements);
661 
662   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
663   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
664   verifyFormat("while (true) {\n"
665                "  f();\n"
666                "}",
667                AllowSimpleBracedStatements);
668   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
669   verifyFormat("for (;;) {\n"
670                "  f();\n"
671                "}",
672                AllowSimpleBracedStatements);
673 
674   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
675       FormatStyle::SIS_WithoutElse;
676   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
677   AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement =
678       FormatStyle::BWACS_Always;
679 
680   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
681   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
682   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
683   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
684   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
685   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
686   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
687   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
688   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
689   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
690   verifyFormat("if (true) { fffffffffffffffffffffff(); }",
691                AllowSimpleBracedStatements);
692   verifyFormat("if (true)\n"
693                "{\n"
694                "  ffffffffffffffffffffffff();\n"
695                "}",
696                AllowSimpleBracedStatements);
697   verifyFormat("if (true)\n"
698                "{\n"
699                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
700                "}",
701                AllowSimpleBracedStatements);
702   verifyFormat("if (true)\n"
703                "{ //\n"
704                "  f();\n"
705                "}",
706                AllowSimpleBracedStatements);
707   verifyFormat("if (true)\n"
708                "{\n"
709                "  f();\n"
710                "  f();\n"
711                "}",
712                AllowSimpleBracedStatements);
713   verifyFormat("if (true)\n"
714                "{\n"
715                "  f();\n"
716                "} else\n"
717                "{\n"
718                "  f();\n"
719                "}",
720                AllowSimpleBracedStatements);
721 
722   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
723       FormatStyle::SIS_Never;
724   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
725   verifyFormat("if (true)\n"
726                "{\n"
727                "  f();\n"
728                "}",
729                AllowSimpleBracedStatements);
730   verifyFormat("if (true)\n"
731                "{\n"
732                "  f();\n"
733                "} else\n"
734                "{\n"
735                "  f();\n"
736                "}",
737                AllowSimpleBracedStatements);
738 
739   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
740   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
741   verifyFormat("while (true)\n"
742                "{\n"
743                "  f();\n"
744                "}",
745                AllowSimpleBracedStatements);
746   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
747   verifyFormat("for (;;)\n"
748                "{\n"
749                "  f();\n"
750                "}",
751                AllowSimpleBracedStatements);
752 }
753 
754 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) {
755   FormatStyle Style = getLLVMStyleWithColumns(60);
756   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
757   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
758   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
759   EXPECT_EQ("#define A                                                  \\\n"
760             "  if (HANDLEwernufrnuLwrmviferuvnierv)                     \\\n"
761             "  {                                                        \\\n"
762             "    RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier;               \\\n"
763             "  }\n"
764             "X;",
765             format("#define A \\\n"
766                    "   if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"
767                    "      RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
768                    "   }\n"
769                    "X;",
770                    Style));
771 }
772 
773 TEST_F(FormatTest, ParseIfElse) {
774   verifyFormat("if (true)\n"
775                "  if (true)\n"
776                "    if (true)\n"
777                "      f();\n"
778                "    else\n"
779                "      g();\n"
780                "  else\n"
781                "    h();\n"
782                "else\n"
783                "  i();");
784   verifyFormat("if (true)\n"
785                "  if (true)\n"
786                "    if (true) {\n"
787                "      if (true)\n"
788                "        f();\n"
789                "    } else {\n"
790                "      g();\n"
791                "    }\n"
792                "  else\n"
793                "    h();\n"
794                "else {\n"
795                "  i();\n"
796                "}");
797   verifyFormat("if (true)\n"
798                "  if constexpr (true)\n"
799                "    if (true) {\n"
800                "      if constexpr (true)\n"
801                "        f();\n"
802                "    } else {\n"
803                "      g();\n"
804                "    }\n"
805                "  else\n"
806                "    h();\n"
807                "else {\n"
808                "  i();\n"
809                "}");
810   verifyFormat("if (true)\n"
811                "  if CONSTEXPR (true)\n"
812                "    if (true) {\n"
813                "      if CONSTEXPR (true)\n"
814                "        f();\n"
815                "    } else {\n"
816                "      g();\n"
817                "    }\n"
818                "  else\n"
819                "    h();\n"
820                "else {\n"
821                "  i();\n"
822                "}");
823   verifyFormat("void f() {\n"
824                "  if (a) {\n"
825                "  } else {\n"
826                "  }\n"
827                "}");
828 }
829 
830 TEST_F(FormatTest, ElseIf) {
831   verifyFormat("if (a) {\n} else if (b) {\n}");
832   verifyFormat("if (a)\n"
833                "  f();\n"
834                "else if (b)\n"
835                "  g();\n"
836                "else\n"
837                "  h();");
838   verifyFormat("if constexpr (a)\n"
839                "  f();\n"
840                "else if constexpr (b)\n"
841                "  g();\n"
842                "else\n"
843                "  h();");
844   verifyFormat("if CONSTEXPR (a)\n"
845                "  f();\n"
846                "else if CONSTEXPR (b)\n"
847                "  g();\n"
848                "else\n"
849                "  h();");
850   verifyFormat("if (a) {\n"
851                "  f();\n"
852                "}\n"
853                "// or else ..\n"
854                "else {\n"
855                "  g()\n"
856                "}");
857 
858   verifyFormat("if (a) {\n"
859                "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
860                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
861                "}");
862   verifyFormat("if (a) {\n"
863                "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
864                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
865                "}");
866   verifyFormat("if (a) {\n"
867                "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
868                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
869                "}");
870   verifyFormat("if (a) {\n"
871                "} else if (\n"
872                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
873                "}",
874                getLLVMStyleWithColumns(62));
875   verifyFormat("if (a) {\n"
876                "} else if constexpr (\n"
877                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
878                "}",
879                getLLVMStyleWithColumns(62));
880   verifyFormat("if (a) {\n"
881                "} else if CONSTEXPR (\n"
882                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
883                "}",
884                getLLVMStyleWithColumns(62));
885 }
886 
887 TEST_F(FormatTest, FormatsForLoop) {
888   verifyFormat(
889       "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
890       "     ++VeryVeryLongLoopVariable)\n"
891       "  ;");
892   verifyFormat("for (;;)\n"
893                "  f();");
894   verifyFormat("for (;;) {\n}");
895   verifyFormat("for (;;) {\n"
896                "  f();\n"
897                "}");
898   verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
899 
900   verifyFormat(
901       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
902       "                                          E = UnwrappedLines.end();\n"
903       "     I != E; ++I) {\n}");
904 
905   verifyFormat(
906       "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
907       "     ++IIIII) {\n}");
908   verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
909                "         aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
910                "     aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
911   verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
912                "         I = FD->getDeclsInPrototypeScope().begin(),\n"
913                "         E = FD->getDeclsInPrototypeScope().end();\n"
914                "     I != E; ++I) {\n}");
915   verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
916                "         I = Container.begin(),\n"
917                "         E = Container.end();\n"
918                "     I != E; ++I) {\n}",
919                getLLVMStyleWithColumns(76));
920 
921   verifyFormat(
922       "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
923       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
924       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
925       "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
926       "     ++aaaaaaaaaaa) {\n}");
927   verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
928                "                bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
929                "     ++i) {\n}");
930   verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
931                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
932                "}");
933   verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
934                "         aaaaaaaaaa);\n"
935                "     iter; ++iter) {\n"
936                "}");
937   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
938                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
939                "     aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
940                "     ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
941 
942   // These should not be formatted as Objective-C for-in loops.
943   verifyFormat("for (Foo *x = 0; x != in; x++) {\n}");
944   verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}");
945   verifyFormat("Foo *x;\nfor (x in y) {\n}");
946   verifyFormat(
947       "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}");
948 
949   FormatStyle NoBinPacking = getLLVMStyle();
950   NoBinPacking.BinPackParameters = false;
951   verifyFormat("for (int aaaaaaaaaaa = 1;\n"
952                "     aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
953                "                                           aaaaaaaaaaaaaaaa,\n"
954                "                                           aaaaaaaaaaaaaaaa,\n"
955                "                                           aaaaaaaaaaaaaaaa);\n"
956                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
957                "}",
958                NoBinPacking);
959   verifyFormat(
960       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
961       "                                          E = UnwrappedLines.end();\n"
962       "     I != E;\n"
963       "     ++I) {\n}",
964       NoBinPacking);
965 
966   FormatStyle AlignLeft = getLLVMStyle();
967   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
968   verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
969 }
970 
971 TEST_F(FormatTest, RangeBasedForLoops) {
972   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
973                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
974   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
975                "     aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
976   verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
977                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
978   verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
979                "     aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
980 }
981 
982 TEST_F(FormatTest, ForEachLoops) {
983   verifyFormat("void f() {\n"
984                "  foreach (Item *item, itemlist) {}\n"
985                "  Q_FOREACH (Item *item, itemlist) {}\n"
986                "  BOOST_FOREACH (Item *item, itemlist) {}\n"
987                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
988                "}");
989 
990   FormatStyle Style = getLLVMStyle();
991   Style.SpaceBeforeParens =
992       FormatStyle::SBPO_ControlStatementsExceptForEachMacros;
993   verifyFormat("void f() {\n"
994                "  foreach(Item *item, itemlist) {}\n"
995                "  Q_FOREACH(Item *item, itemlist) {}\n"
996                "  BOOST_FOREACH(Item *item, itemlist) {}\n"
997                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
998                "}",
999                Style);
1000 
1001   // As function-like macros.
1002   verifyFormat("#define foreach(x, y)\n"
1003                "#define Q_FOREACH(x, y)\n"
1004                "#define BOOST_FOREACH(x, y)\n"
1005                "#define UNKNOWN_FOREACH(x, y)\n");
1006 
1007   // Not as function-like macros.
1008   verifyFormat("#define foreach (x, y)\n"
1009                "#define Q_FOREACH (x, y)\n"
1010                "#define BOOST_FOREACH (x, y)\n"
1011                "#define UNKNOWN_FOREACH (x, y)\n");
1012 
1013   // handle microsoft non standard extension
1014   verifyFormat("for each (char c in x->MyStringProperty)");
1015 }
1016 
1017 TEST_F(FormatTest, FormatsWhileLoop) {
1018   verifyFormat("while (true) {\n}");
1019   verifyFormat("while (true)\n"
1020                "  f();");
1021   verifyFormat("while () {\n}");
1022   verifyFormat("while () {\n"
1023                "  f();\n"
1024                "}");
1025 }
1026 
1027 TEST_F(FormatTest, FormatsDoWhile) {
1028   verifyFormat("do {\n"
1029                "  do_something();\n"
1030                "} while (something());");
1031   verifyFormat("do\n"
1032                "  do_something();\n"
1033                "while (something());");
1034 }
1035 
1036 TEST_F(FormatTest, FormatsSwitchStatement) {
1037   verifyFormat("switch (x) {\n"
1038                "case 1:\n"
1039                "  f();\n"
1040                "  break;\n"
1041                "case kFoo:\n"
1042                "case ns::kBar:\n"
1043                "case kBaz:\n"
1044                "  break;\n"
1045                "default:\n"
1046                "  g();\n"
1047                "  break;\n"
1048                "}");
1049   verifyFormat("switch (x) {\n"
1050                "case 1: {\n"
1051                "  f();\n"
1052                "  break;\n"
1053                "}\n"
1054                "case 2: {\n"
1055                "  break;\n"
1056                "}\n"
1057                "}");
1058   verifyFormat("switch (x) {\n"
1059                "case 1: {\n"
1060                "  f();\n"
1061                "  {\n"
1062                "    g();\n"
1063                "    h();\n"
1064                "  }\n"
1065                "  break;\n"
1066                "}\n"
1067                "}");
1068   verifyFormat("switch (x) {\n"
1069                "case 1: {\n"
1070                "  f();\n"
1071                "  if (foo) {\n"
1072                "    g();\n"
1073                "    h();\n"
1074                "  }\n"
1075                "  break;\n"
1076                "}\n"
1077                "}");
1078   verifyFormat("switch (x) {\n"
1079                "case 1: {\n"
1080                "  f();\n"
1081                "  g();\n"
1082                "} break;\n"
1083                "}");
1084   verifyFormat("switch (test)\n"
1085                "  ;");
1086   verifyFormat("switch (x) {\n"
1087                "default: {\n"
1088                "  // Do nothing.\n"
1089                "}\n"
1090                "}");
1091   verifyFormat("switch (x) {\n"
1092                "// comment\n"
1093                "// if 1, do f()\n"
1094                "case 1:\n"
1095                "  f();\n"
1096                "}");
1097   verifyFormat("switch (x) {\n"
1098                "case 1:\n"
1099                "  // Do amazing stuff\n"
1100                "  {\n"
1101                "    f();\n"
1102                "    g();\n"
1103                "  }\n"
1104                "  break;\n"
1105                "}");
1106   verifyFormat("#define A          \\\n"
1107                "  switch (x) {     \\\n"
1108                "  case a:          \\\n"
1109                "    foo = b;       \\\n"
1110                "  }",
1111                getLLVMStyleWithColumns(20));
1112   verifyFormat("#define OPERATION_CASE(name)           \\\n"
1113                "  case OP_name:                        \\\n"
1114                "    return operations::Operation##name\n",
1115                getLLVMStyleWithColumns(40));
1116   verifyFormat("switch (x) {\n"
1117                "case 1:;\n"
1118                "default:;\n"
1119                "  int i;\n"
1120                "}");
1121 
1122   verifyGoogleFormat("switch (x) {\n"
1123                      "  case 1:\n"
1124                      "    f();\n"
1125                      "    break;\n"
1126                      "  case kFoo:\n"
1127                      "  case ns::kBar:\n"
1128                      "  case kBaz:\n"
1129                      "    break;\n"
1130                      "  default:\n"
1131                      "    g();\n"
1132                      "    break;\n"
1133                      "}");
1134   verifyGoogleFormat("switch (x) {\n"
1135                      "  case 1: {\n"
1136                      "    f();\n"
1137                      "    break;\n"
1138                      "  }\n"
1139                      "}");
1140   verifyGoogleFormat("switch (test)\n"
1141                      "  ;");
1142 
1143   verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
1144                      "  case OP_name:              \\\n"
1145                      "    return operations::Operation##name\n");
1146   verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
1147                      "  // Get the correction operation class.\n"
1148                      "  switch (OpCode) {\n"
1149                      "    CASE(Add);\n"
1150                      "    CASE(Subtract);\n"
1151                      "    default:\n"
1152                      "      return operations::Unknown;\n"
1153                      "  }\n"
1154                      "#undef OPERATION_CASE\n"
1155                      "}");
1156   verifyFormat("DEBUG({\n"
1157                "  switch (x) {\n"
1158                "  case A:\n"
1159                "    f();\n"
1160                "    break;\n"
1161                "    // fallthrough\n"
1162                "  case B:\n"
1163                "    g();\n"
1164                "    break;\n"
1165                "  }\n"
1166                "});");
1167   EXPECT_EQ("DEBUG({\n"
1168             "  switch (x) {\n"
1169             "  case A:\n"
1170             "    f();\n"
1171             "    break;\n"
1172             "  // On B:\n"
1173             "  case B:\n"
1174             "    g();\n"
1175             "    break;\n"
1176             "  }\n"
1177             "});",
1178             format("DEBUG({\n"
1179                    "  switch (x) {\n"
1180                    "  case A:\n"
1181                    "    f();\n"
1182                    "    break;\n"
1183                    "  // On B:\n"
1184                    "  case B:\n"
1185                    "    g();\n"
1186                    "    break;\n"
1187                    "  }\n"
1188                    "});",
1189                    getLLVMStyle()));
1190   EXPECT_EQ("switch (n) {\n"
1191             "case 0: {\n"
1192             "  return false;\n"
1193             "}\n"
1194             "default: {\n"
1195             "  return true;\n"
1196             "}\n"
1197             "}",
1198             format("switch (n)\n"
1199                    "{\n"
1200                    "case 0: {\n"
1201                    "  return false;\n"
1202                    "}\n"
1203                    "default: {\n"
1204                    "  return true;\n"
1205                    "}\n"
1206                    "}",
1207                    getLLVMStyle()));
1208   verifyFormat("switch (a) {\n"
1209                "case (b):\n"
1210                "  return;\n"
1211                "}");
1212 
1213   verifyFormat("switch (a) {\n"
1214                "case some_namespace::\n"
1215                "    some_constant:\n"
1216                "  return;\n"
1217                "}",
1218                getLLVMStyleWithColumns(34));
1219 
1220   FormatStyle Style = getLLVMStyle();
1221   Style.IndentCaseLabels = true;
1222   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
1223   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1224   Style.BraceWrapping.AfterCaseLabel = true;
1225   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1226   EXPECT_EQ("switch (n)\n"
1227             "{\n"
1228             "  case 0:\n"
1229             "  {\n"
1230             "    return false;\n"
1231             "  }\n"
1232             "  default:\n"
1233             "  {\n"
1234             "    return true;\n"
1235             "  }\n"
1236             "}",
1237             format("switch (n) {\n"
1238                    "  case 0: {\n"
1239                    "    return false;\n"
1240                    "  }\n"
1241                    "  default: {\n"
1242                    "    return true;\n"
1243                    "  }\n"
1244                    "}",
1245                    Style));
1246   Style.BraceWrapping.AfterCaseLabel = false;
1247   EXPECT_EQ("switch (n)\n"
1248             "{\n"
1249             "  case 0: {\n"
1250             "    return false;\n"
1251             "  }\n"
1252             "  default: {\n"
1253             "    return true;\n"
1254             "  }\n"
1255             "}",
1256             format("switch (n) {\n"
1257                    "  case 0:\n"
1258                    "  {\n"
1259                    "    return false;\n"
1260                    "  }\n"
1261                    "  default:\n"
1262                    "  {\n"
1263                    "    return true;\n"
1264                    "  }\n"
1265                    "}",
1266                    Style));
1267   Style.IndentCaseLabels = false;
1268   Style.IndentCaseBlocks = true;
1269   EXPECT_EQ("switch (n)\n"
1270             "{\n"
1271             "case 0:\n"
1272             "  {\n"
1273             "    return false;\n"
1274             "  }\n"
1275             "case 1:\n"
1276             "  break;\n"
1277             "default:\n"
1278             "  {\n"
1279             "    return true;\n"
1280             "  }\n"
1281             "}",
1282             format("switch (n) {\n"
1283                    "case 0: {\n"
1284                    "  return false;\n"
1285                    "}\n"
1286                    "case 1:\n"
1287                    "  break;\n"
1288                    "default: {\n"
1289                    "  return true;\n"
1290                    "}\n"
1291                    "}",
1292                    Style));
1293   Style.IndentCaseLabels = true;
1294   Style.IndentCaseBlocks = true;
1295   EXPECT_EQ("switch (n)\n"
1296             "{\n"
1297             "  case 0:\n"
1298             "    {\n"
1299             "      return false;\n"
1300             "    }\n"
1301             "  case 1:\n"
1302             "    break;\n"
1303             "  default:\n"
1304             "    {\n"
1305             "      return true;\n"
1306             "    }\n"
1307             "}",
1308             format("switch (n) {\n"
1309                    "case 0: {\n"
1310                    "  return false;\n"
1311                    "}\n"
1312                    "case 1:\n"
1313                    "  break;\n"
1314                    "default: {\n"
1315                    "  return true;\n"
1316                    "}\n"
1317                    "}",
1318                    Style));
1319 }
1320 
1321 TEST_F(FormatTest, CaseRanges) {
1322   verifyFormat("switch (x) {\n"
1323                "case 'A' ... 'Z':\n"
1324                "case 1 ... 5:\n"
1325                "case a ... b:\n"
1326                "  break;\n"
1327                "}");
1328 }
1329 
1330 TEST_F(FormatTest, ShortEnums) {
1331   FormatStyle Style = getLLVMStyle();
1332   Style.AllowShortEnumsOnASingleLine = true;
1333   verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style);
1334   Style.AllowShortEnumsOnASingleLine = false;
1335   verifyFormat("enum\n"
1336                "{\n"
1337                "  A,\n"
1338                "  B,\n"
1339                "  C\n"
1340                "} ShortEnum1, ShortEnum2;",
1341                Style);
1342 }
1343 
1344 TEST_F(FormatTest, ShortCaseLabels) {
1345   FormatStyle Style = getLLVMStyle();
1346   Style.AllowShortCaseLabelsOnASingleLine = true;
1347   verifyFormat("switch (a) {\n"
1348                "case 1: x = 1; break;\n"
1349                "case 2: return;\n"
1350                "case 3:\n"
1351                "case 4:\n"
1352                "case 5: return;\n"
1353                "case 6: // comment\n"
1354                "  return;\n"
1355                "case 7:\n"
1356                "  // comment\n"
1357                "  return;\n"
1358                "case 8:\n"
1359                "  x = 8; // comment\n"
1360                "  break;\n"
1361                "default: y = 1; break;\n"
1362                "}",
1363                Style);
1364   verifyFormat("switch (a) {\n"
1365                "case 0: return; // comment\n"
1366                "case 1: break;  // comment\n"
1367                "case 2: return;\n"
1368                "// comment\n"
1369                "case 3: return;\n"
1370                "// comment 1\n"
1371                "// comment 2\n"
1372                "// comment 3\n"
1373                "case 4: break; /* comment */\n"
1374                "case 5:\n"
1375                "  // comment\n"
1376                "  break;\n"
1377                "case 6: /* comment */ x = 1; break;\n"
1378                "case 7: x = /* comment */ 1; break;\n"
1379                "case 8:\n"
1380                "  x = 1; /* comment */\n"
1381                "  break;\n"
1382                "case 9:\n"
1383                "  break; // comment line 1\n"
1384                "         // comment line 2\n"
1385                "}",
1386                Style);
1387   EXPECT_EQ("switch (a) {\n"
1388             "case 1:\n"
1389             "  x = 8;\n"
1390             "  // fall through\n"
1391             "case 2: x = 8;\n"
1392             "// comment\n"
1393             "case 3:\n"
1394             "  return; /* comment line 1\n"
1395             "           * comment line 2 */\n"
1396             "case 4: i = 8;\n"
1397             "// something else\n"
1398             "#if FOO\n"
1399             "case 5: break;\n"
1400             "#endif\n"
1401             "}",
1402             format("switch (a) {\n"
1403                    "case 1: x = 8;\n"
1404                    "  // fall through\n"
1405                    "case 2:\n"
1406                    "  x = 8;\n"
1407                    "// comment\n"
1408                    "case 3:\n"
1409                    "  return; /* comment line 1\n"
1410                    "           * comment line 2 */\n"
1411                    "case 4:\n"
1412                    "  i = 8;\n"
1413                    "// something else\n"
1414                    "#if FOO\n"
1415                    "case 5: break;\n"
1416                    "#endif\n"
1417                    "}",
1418                    Style));
1419   EXPECT_EQ("switch (a) {\n"
1420             "case 0:\n"
1421             "  return; // long long long long long long long long long long "
1422             "long long comment\n"
1423             "          // line\n"
1424             "}",
1425             format("switch (a) {\n"
1426                    "case 0: return; // long long long long long long long long "
1427                    "long long long long comment line\n"
1428                    "}",
1429                    Style));
1430   EXPECT_EQ("switch (a) {\n"
1431             "case 0:\n"
1432             "  return; /* long long long long long long long long long long "
1433             "long long comment\n"
1434             "             line */\n"
1435             "}",
1436             format("switch (a) {\n"
1437                    "case 0: return; /* long long long long long long long long "
1438                    "long long long long comment line */\n"
1439                    "}",
1440                    Style));
1441   verifyFormat("switch (a) {\n"
1442                "#if FOO\n"
1443                "case 0: return 0;\n"
1444                "#endif\n"
1445                "}",
1446                Style);
1447   verifyFormat("switch (a) {\n"
1448                "case 1: {\n"
1449                "}\n"
1450                "case 2: {\n"
1451                "  return;\n"
1452                "}\n"
1453                "case 3: {\n"
1454                "  x = 1;\n"
1455                "  return;\n"
1456                "}\n"
1457                "case 4:\n"
1458                "  if (x)\n"
1459                "    return;\n"
1460                "}",
1461                Style);
1462   Style.ColumnLimit = 21;
1463   verifyFormat("switch (a) {\n"
1464                "case 1: x = 1; break;\n"
1465                "case 2: return;\n"
1466                "case 3:\n"
1467                "case 4:\n"
1468                "case 5: return;\n"
1469                "default:\n"
1470                "  y = 1;\n"
1471                "  break;\n"
1472                "}",
1473                Style);
1474   Style.ColumnLimit = 80;
1475   Style.AllowShortCaseLabelsOnASingleLine = false;
1476   Style.IndentCaseLabels = true;
1477   EXPECT_EQ("switch (n) {\n"
1478             "  default /*comments*/:\n"
1479             "    return true;\n"
1480             "  case 0:\n"
1481             "    return false;\n"
1482             "}",
1483             format("switch (n) {\n"
1484                    "default/*comments*/:\n"
1485                    "  return true;\n"
1486                    "case 0:\n"
1487                    "  return false;\n"
1488                    "}",
1489                    Style));
1490   Style.AllowShortCaseLabelsOnASingleLine = true;
1491   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1492   Style.BraceWrapping.AfterCaseLabel = true;
1493   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1494   EXPECT_EQ("switch (n)\n"
1495             "{\n"
1496             "  case 0:\n"
1497             "  {\n"
1498             "    return false;\n"
1499             "  }\n"
1500             "  default:\n"
1501             "  {\n"
1502             "    return true;\n"
1503             "  }\n"
1504             "}",
1505             format("switch (n) {\n"
1506                    "  case 0: {\n"
1507                    "    return false;\n"
1508                    "  }\n"
1509                    "  default:\n"
1510                    "  {\n"
1511                    "    return true;\n"
1512                    "  }\n"
1513                    "}",
1514                    Style));
1515 }
1516 
1517 TEST_F(FormatTest, FormatsLabels) {
1518   verifyFormat("void f() {\n"
1519                "  some_code();\n"
1520                "test_label:\n"
1521                "  some_other_code();\n"
1522                "  {\n"
1523                "    some_more_code();\n"
1524                "  another_label:\n"
1525                "    some_more_code();\n"
1526                "  }\n"
1527                "}");
1528   verifyFormat("{\n"
1529                "  some_code();\n"
1530                "test_label:\n"
1531                "  some_other_code();\n"
1532                "}");
1533   verifyFormat("{\n"
1534                "  some_code();\n"
1535                "test_label:;\n"
1536                "  int i = 0;\n"
1537                "}");
1538   FormatStyle Style = getLLVMStyle();
1539   Style.IndentGotoLabels = false;
1540   verifyFormat("void f() {\n"
1541                "  some_code();\n"
1542                "test_label:\n"
1543                "  some_other_code();\n"
1544                "  {\n"
1545                "    some_more_code();\n"
1546                "another_label:\n"
1547                "    some_more_code();\n"
1548                "  }\n"
1549                "}",
1550                Style);
1551   verifyFormat("{\n"
1552                "  some_code();\n"
1553                "test_label:\n"
1554                "  some_other_code();\n"
1555                "}",
1556                Style);
1557   verifyFormat("{\n"
1558                "  some_code();\n"
1559                "test_label:;\n"
1560                "  int i = 0;\n"
1561                "}");
1562 }
1563 
1564 TEST_F(FormatTest, MultiLineControlStatements) {
1565   FormatStyle Style = getLLVMStyle();
1566   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1567   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine;
1568   Style.ColumnLimit = 20;
1569   // Short lines should keep opening brace on same line.
1570   EXPECT_EQ("if (foo) {\n"
1571             "  bar();\n"
1572             "}",
1573             format("if(foo){bar();}", Style));
1574   EXPECT_EQ("if (foo) {\n"
1575             "  bar();\n"
1576             "} else {\n"
1577             "  baz();\n"
1578             "}",
1579             format("if(foo){bar();}else{baz();}", Style));
1580   EXPECT_EQ("if (foo && bar) {\n"
1581             "  baz();\n"
1582             "}",
1583             format("if(foo&&bar){baz();}", Style));
1584   EXPECT_EQ("if (foo) {\n"
1585             "  bar();\n"
1586             "} else if (baz) {\n"
1587             "  quux();\n"
1588             "}",
1589             format("if(foo){bar();}else if(baz){quux();}", Style));
1590   EXPECT_EQ(
1591       "if (foo) {\n"
1592       "  bar();\n"
1593       "} else if (baz) {\n"
1594       "  quux();\n"
1595       "} else {\n"
1596       "  foobar();\n"
1597       "}",
1598       format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style));
1599   EXPECT_EQ("for (;;) {\n"
1600             "  foo();\n"
1601             "}",
1602             format("for(;;){foo();}"));
1603   EXPECT_EQ("while (1) {\n"
1604             "  foo();\n"
1605             "}",
1606             format("while(1){foo();}", Style));
1607   EXPECT_EQ("switch (foo) {\n"
1608             "case bar:\n"
1609             "  return;\n"
1610             "}",
1611             format("switch(foo){case bar:return;}", Style));
1612   EXPECT_EQ("try {\n"
1613             "  foo();\n"
1614             "} catch (...) {\n"
1615             "  bar();\n"
1616             "}",
1617             format("try{foo();}catch(...){bar();}", Style));
1618   EXPECT_EQ("do {\n"
1619             "  foo();\n"
1620             "} while (bar &&\n"
1621             "         baz);",
1622             format("do{foo();}while(bar&&baz);", Style));
1623   // Long lines should put opening brace on new line.
1624   EXPECT_EQ("if (foo && bar &&\n"
1625             "    baz)\n"
1626             "{\n"
1627             "  quux();\n"
1628             "}",
1629             format("if(foo&&bar&&baz){quux();}", Style));
1630   EXPECT_EQ("if (foo && bar &&\n"
1631             "    baz)\n"
1632             "{\n"
1633             "  quux();\n"
1634             "}",
1635             format("if (foo && bar &&\n"
1636                    "    baz) {\n"
1637                    "  quux();\n"
1638                    "}",
1639                    Style));
1640   EXPECT_EQ("if (foo) {\n"
1641             "  bar();\n"
1642             "} else if (baz ||\n"
1643             "           quux)\n"
1644             "{\n"
1645             "  foobar();\n"
1646             "}",
1647             format("if(foo){bar();}else if(baz||quux){foobar();}", Style));
1648   EXPECT_EQ(
1649       "if (foo) {\n"
1650       "  bar();\n"
1651       "} else if (baz ||\n"
1652       "           quux)\n"
1653       "{\n"
1654       "  foobar();\n"
1655       "} else {\n"
1656       "  barbaz();\n"
1657       "}",
1658       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1659              Style));
1660   EXPECT_EQ("for (int i = 0;\n"
1661             "     i < 10; ++i)\n"
1662             "{\n"
1663             "  foo();\n"
1664             "}",
1665             format("for(int i=0;i<10;++i){foo();}", Style));
1666   EXPECT_EQ("foreach (int i,\n"
1667             "         list)\n"
1668             "{\n"
1669             "  foo();\n"
1670             "}",
1671             format("foreach(int i, list){foo();}", Style));
1672   Style.ColumnLimit =
1673       40; // to concentrate at brace wrapping, not line wrap due to column limit
1674   EXPECT_EQ("foreach (int i, list) {\n"
1675             "  foo();\n"
1676             "}",
1677             format("foreach(int i, list){foo();}", Style));
1678   Style.ColumnLimit =
1679       20; // to concentrate at brace wrapping, not line wrap due to column limit
1680   EXPECT_EQ("while (foo || bar ||\n"
1681             "       baz)\n"
1682             "{\n"
1683             "  quux();\n"
1684             "}",
1685             format("while(foo||bar||baz){quux();}", Style));
1686   EXPECT_EQ("switch (\n"
1687             "    foo = barbaz)\n"
1688             "{\n"
1689             "case quux:\n"
1690             "  return;\n"
1691             "}",
1692             format("switch(foo=barbaz){case quux:return;}", Style));
1693   EXPECT_EQ("try {\n"
1694             "  foo();\n"
1695             "} catch (\n"
1696             "    Exception &bar)\n"
1697             "{\n"
1698             "  baz();\n"
1699             "}",
1700             format("try{foo();}catch(Exception&bar){baz();}", Style));
1701   Style.ColumnLimit =
1702       40; // to concentrate at brace wrapping, not line wrap due to column limit
1703   EXPECT_EQ("try {\n"
1704             "  foo();\n"
1705             "} catch (Exception &bar) {\n"
1706             "  baz();\n"
1707             "}",
1708             format("try{foo();}catch(Exception&bar){baz();}", Style));
1709   Style.ColumnLimit =
1710       20; // to concentrate at brace wrapping, not line wrap due to column limit
1711 
1712   Style.BraceWrapping.BeforeElse = true;
1713   EXPECT_EQ(
1714       "if (foo) {\n"
1715       "  bar();\n"
1716       "}\n"
1717       "else if (baz ||\n"
1718       "         quux)\n"
1719       "{\n"
1720       "  foobar();\n"
1721       "}\n"
1722       "else {\n"
1723       "  barbaz();\n"
1724       "}",
1725       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1726              Style));
1727 
1728   Style.BraceWrapping.BeforeCatch = true;
1729   EXPECT_EQ("try {\n"
1730             "  foo();\n"
1731             "}\n"
1732             "catch (...) {\n"
1733             "  baz();\n"
1734             "}",
1735             format("try{foo();}catch(...){baz();}", Style));
1736 }
1737 
1738 TEST_F(FormatTest, BeforeWhile) {
1739   FormatStyle Style = getLLVMStyle();
1740   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1741 
1742   verifyFormat("do {\n"
1743                "  foo();\n"
1744                "} while (1);",
1745                Style);
1746   Style.BraceWrapping.BeforeWhile = true;
1747   verifyFormat("do {\n"
1748                "  foo();\n"
1749                "}\n"
1750                "while (1);",
1751                Style);
1752 }
1753 
1754 //===----------------------------------------------------------------------===//
1755 // Tests for classes, namespaces, etc.
1756 //===----------------------------------------------------------------------===//
1757 
1758 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
1759   verifyFormat("class A {};");
1760 }
1761 
1762 TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1763   verifyFormat("class A {\n"
1764                "public:\n"
1765                "public: // comment\n"
1766                "protected:\n"
1767                "private:\n"
1768                "  void f() {}\n"
1769                "};");
1770   verifyFormat("export class A {\n"
1771                "public:\n"
1772                "public: // comment\n"
1773                "protected:\n"
1774                "private:\n"
1775                "  void f() {}\n"
1776                "};");
1777   verifyGoogleFormat("class A {\n"
1778                      " public:\n"
1779                      " protected:\n"
1780                      " private:\n"
1781                      "  void f() {}\n"
1782                      "};");
1783   verifyGoogleFormat("export class A {\n"
1784                      " public:\n"
1785                      " protected:\n"
1786                      " private:\n"
1787                      "  void f() {}\n"
1788                      "};");
1789   verifyFormat("class A {\n"
1790                "public slots:\n"
1791                "  void f1() {}\n"
1792                "public Q_SLOTS:\n"
1793                "  void f2() {}\n"
1794                "protected slots:\n"
1795                "  void f3() {}\n"
1796                "protected Q_SLOTS:\n"
1797                "  void f4() {}\n"
1798                "private slots:\n"
1799                "  void f5() {}\n"
1800                "private Q_SLOTS:\n"
1801                "  void f6() {}\n"
1802                "signals:\n"
1803                "  void g1();\n"
1804                "Q_SIGNALS:\n"
1805                "  void g2();\n"
1806                "};");
1807 
1808   // Don't interpret 'signals' the wrong way.
1809   verifyFormat("signals.set();");
1810   verifyFormat("for (Signals signals : f()) {\n}");
1811   verifyFormat("{\n"
1812                "  signals.set(); // This needs indentation.\n"
1813                "}");
1814   verifyFormat("void f() {\n"
1815                "label:\n"
1816                "  signals.baz();\n"
1817                "}");
1818 }
1819 
1820 TEST_F(FormatTest, SeparatesLogicalBlocks) {
1821   EXPECT_EQ("class A {\n"
1822             "public:\n"
1823             "  void f();\n"
1824             "\n"
1825             "private:\n"
1826             "  void g() {}\n"
1827             "  // test\n"
1828             "protected:\n"
1829             "  int h;\n"
1830             "};",
1831             format("class A {\n"
1832                    "public:\n"
1833                    "void f();\n"
1834                    "private:\n"
1835                    "void g() {}\n"
1836                    "// test\n"
1837                    "protected:\n"
1838                    "int h;\n"
1839                    "};"));
1840   EXPECT_EQ("class A {\n"
1841             "protected:\n"
1842             "public:\n"
1843             "  void f();\n"
1844             "};",
1845             format("class A {\n"
1846                    "protected:\n"
1847                    "\n"
1848                    "public:\n"
1849                    "\n"
1850                    "  void f();\n"
1851                    "};"));
1852 
1853   // Even ensure proper spacing inside macros.
1854   EXPECT_EQ("#define B     \\\n"
1855             "  class A {   \\\n"
1856             "   protected: \\\n"
1857             "   public:    \\\n"
1858             "    void f(); \\\n"
1859             "  };",
1860             format("#define B     \\\n"
1861                    "  class A {   \\\n"
1862                    "   protected: \\\n"
1863                    "              \\\n"
1864                    "   public:    \\\n"
1865                    "              \\\n"
1866                    "    void f(); \\\n"
1867                    "  };",
1868                    getGoogleStyle()));
1869   // But don't remove empty lines after macros ending in access specifiers.
1870   EXPECT_EQ("#define A private:\n"
1871             "\n"
1872             "int i;",
1873             format("#define A         private:\n"
1874                    "\n"
1875                    "int              i;"));
1876 }
1877 
1878 TEST_F(FormatTest, FormatsClasses) {
1879   verifyFormat("class A : public B {};");
1880   verifyFormat("class A : public ::B {};");
1881 
1882   verifyFormat(
1883       "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1884       "                             public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1885   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1886                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1887                "      public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1888   verifyFormat(
1889       "class A : public B, public C, public D, public E, public F {};");
1890   verifyFormat("class AAAAAAAAAAAA : public B,\n"
1891                "                     public C,\n"
1892                "                     public D,\n"
1893                "                     public E,\n"
1894                "                     public F,\n"
1895                "                     public G {};");
1896 
1897   verifyFormat("class\n"
1898                "    ReallyReallyLongClassName {\n"
1899                "  int i;\n"
1900                "};",
1901                getLLVMStyleWithColumns(32));
1902   verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1903                "                           aaaaaaaaaaaaaaaa> {};");
1904   verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1905                "    : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1906                "                                 aaaaaaaaaaaaaaaaaaaaaa> {};");
1907   verifyFormat("template <class R, class C>\n"
1908                "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1909                "    : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
1910   verifyFormat("class ::A::B {};");
1911 }
1912 
1913 TEST_F(FormatTest, BreakInheritanceStyle) {
1914   FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle();
1915   StyleWithInheritanceBreakBeforeComma.BreakInheritanceList =
1916       FormatStyle::BILS_BeforeComma;
1917   verifyFormat("class MyClass : public X {};",
1918                StyleWithInheritanceBreakBeforeComma);
1919   verifyFormat("class MyClass\n"
1920                "    : public X\n"
1921                "    , public Y {};",
1922                StyleWithInheritanceBreakBeforeComma);
1923   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
1924                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"
1925                "    , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1926                StyleWithInheritanceBreakBeforeComma);
1927   verifyFormat("struct aaaaaaaaaaaaa\n"
1928                "    : public aaaaaaaaaaaaaaaaaaa< // break\n"
1929                "          aaaaaaaaaaaaaaaa> {};",
1930                StyleWithInheritanceBreakBeforeComma);
1931 
1932   FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle();
1933   StyleWithInheritanceBreakAfterColon.BreakInheritanceList =
1934       FormatStyle::BILS_AfterColon;
1935   verifyFormat("class MyClass : public X {};",
1936                StyleWithInheritanceBreakAfterColon);
1937   verifyFormat("class MyClass : public X, public Y {};",
1938                StyleWithInheritanceBreakAfterColon);
1939   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
1940                "    public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1941                "    public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1942                StyleWithInheritanceBreakAfterColon);
1943   verifyFormat("struct aaaaaaaaaaaaa :\n"
1944                "    public aaaaaaaaaaaaaaaaaaa< // break\n"
1945                "        aaaaaaaaaaaaaaaa> {};",
1946                StyleWithInheritanceBreakAfterColon);
1947 }
1948 
1949 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
1950   verifyFormat("class A {\n} a, b;");
1951   verifyFormat("struct A {\n} a, b;");
1952   verifyFormat("union A {\n} a;");
1953 }
1954 
1955 TEST_F(FormatTest, FormatsEnum) {
1956   verifyFormat("enum {\n"
1957                "  Zero,\n"
1958                "  One = 1,\n"
1959                "  Two = One + 1,\n"
1960                "  Three = (One + Two),\n"
1961                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1962                "  Five = (One, Two, Three, Four, 5)\n"
1963                "};");
1964   verifyGoogleFormat("enum {\n"
1965                      "  Zero,\n"
1966                      "  One = 1,\n"
1967                      "  Two = One + 1,\n"
1968                      "  Three = (One + Two),\n"
1969                      "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1970                      "  Five = (One, Two, Three, Four, 5)\n"
1971                      "};");
1972   verifyFormat("enum Enum {};");
1973   verifyFormat("enum {};");
1974   verifyFormat("enum X E {} d;");
1975   verifyFormat("enum __attribute__((...)) E {} d;");
1976   verifyFormat("enum __declspec__((...)) E {} d;");
1977   verifyFormat("enum {\n"
1978                "  Bar = Foo<int, int>::value\n"
1979                "};",
1980                getLLVMStyleWithColumns(30));
1981 
1982   verifyFormat("enum ShortEnum { A, B, C };");
1983   verifyGoogleFormat("enum ShortEnum { A, B, C };");
1984 
1985   EXPECT_EQ("enum KeepEmptyLines {\n"
1986             "  ONE,\n"
1987             "\n"
1988             "  TWO,\n"
1989             "\n"
1990             "  THREE\n"
1991             "}",
1992             format("enum KeepEmptyLines {\n"
1993                    "  ONE,\n"
1994                    "\n"
1995                    "  TWO,\n"
1996                    "\n"
1997                    "\n"
1998                    "  THREE\n"
1999                    "}"));
2000   verifyFormat("enum E { // comment\n"
2001                "  ONE,\n"
2002                "  TWO\n"
2003                "};\n"
2004                "int i;");
2005 
2006   FormatStyle EightIndent = getLLVMStyle();
2007   EightIndent.IndentWidth = 8;
2008   verifyFormat("enum {\n"
2009                "        VOID,\n"
2010                "        CHAR,\n"
2011                "        SHORT,\n"
2012                "        INT,\n"
2013                "        LONG,\n"
2014                "        SIGNED,\n"
2015                "        UNSIGNED,\n"
2016                "        BOOL,\n"
2017                "        FLOAT,\n"
2018                "        DOUBLE,\n"
2019                "        COMPLEX\n"
2020                "};",
2021                EightIndent);
2022 
2023   // Not enums.
2024   verifyFormat("enum X f() {\n"
2025                "  a();\n"
2026                "  return 42;\n"
2027                "}");
2028   verifyFormat("enum X Type::f() {\n"
2029                "  a();\n"
2030                "  return 42;\n"
2031                "}");
2032   verifyFormat("enum ::X f() {\n"
2033                "  a();\n"
2034                "  return 42;\n"
2035                "}");
2036   verifyFormat("enum ns::X f() {\n"
2037                "  a();\n"
2038                "  return 42;\n"
2039                "}");
2040 }
2041 
2042 TEST_F(FormatTest, FormatsEnumsWithErrors) {
2043   verifyFormat("enum Type {\n"
2044                "  One = 0; // These semicolons should be commas.\n"
2045                "  Two = 1;\n"
2046                "};");
2047   verifyFormat("namespace n {\n"
2048                "enum Type {\n"
2049                "  One,\n"
2050                "  Two, // missing };\n"
2051                "  int i;\n"
2052                "}\n"
2053                "void g() {}");
2054 }
2055 
2056 TEST_F(FormatTest, FormatsEnumStruct) {
2057   verifyFormat("enum struct {\n"
2058                "  Zero,\n"
2059                "  One = 1,\n"
2060                "  Two = One + 1,\n"
2061                "  Three = (One + Two),\n"
2062                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2063                "  Five = (One, Two, Three, Four, 5)\n"
2064                "};");
2065   verifyFormat("enum struct Enum {};");
2066   verifyFormat("enum struct {};");
2067   verifyFormat("enum struct X E {} d;");
2068   verifyFormat("enum struct __attribute__((...)) E {} d;");
2069   verifyFormat("enum struct __declspec__((...)) E {} d;");
2070   verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
2071 }
2072 
2073 TEST_F(FormatTest, FormatsEnumClass) {
2074   verifyFormat("enum class {\n"
2075                "  Zero,\n"
2076                "  One = 1,\n"
2077                "  Two = One + 1,\n"
2078                "  Three = (One + Two),\n"
2079                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2080                "  Five = (One, Two, Three, Four, 5)\n"
2081                "};");
2082   verifyFormat("enum class Enum {};");
2083   verifyFormat("enum class {};");
2084   verifyFormat("enum class X E {} d;");
2085   verifyFormat("enum class __attribute__((...)) E {} d;");
2086   verifyFormat("enum class __declspec__((...)) E {} d;");
2087   verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
2088 }
2089 
2090 TEST_F(FormatTest, FormatsEnumTypes) {
2091   verifyFormat("enum X : int {\n"
2092                "  A, // Force multiple lines.\n"
2093                "  B\n"
2094                "};");
2095   verifyFormat("enum X : int { A, B };");
2096   verifyFormat("enum X : std::uint32_t { A, B };");
2097 }
2098 
2099 TEST_F(FormatTest, FormatsTypedefEnum) {
2100   FormatStyle Style = getLLVMStyle();
2101   Style.ColumnLimit = 40;
2102   verifyFormat("typedef enum {} EmptyEnum;");
2103   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2104   verifyFormat("typedef enum {\n"
2105                "  ZERO = 0,\n"
2106                "  ONE = 1,\n"
2107                "  TWO = 2,\n"
2108                "  THREE = 3\n"
2109                "} LongEnum;",
2110                Style);
2111   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2112   Style.BraceWrapping.AfterEnum = true;
2113   verifyFormat("typedef enum {} EmptyEnum;");
2114   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2115   verifyFormat("typedef enum\n"
2116                "{\n"
2117                "  ZERO = 0,\n"
2118                "  ONE = 1,\n"
2119                "  TWO = 2,\n"
2120                "  THREE = 3\n"
2121                "} LongEnum;",
2122                Style);
2123 }
2124 
2125 TEST_F(FormatTest, FormatsNSEnums) {
2126   verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
2127   verifyGoogleFormat(
2128       "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }");
2129   verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
2130                      "  // Information about someDecentlyLongValue.\n"
2131                      "  someDecentlyLongValue,\n"
2132                      "  // Information about anotherDecentlyLongValue.\n"
2133                      "  anotherDecentlyLongValue,\n"
2134                      "  // Information about aThirdDecentlyLongValue.\n"
2135                      "  aThirdDecentlyLongValue\n"
2136                      "};");
2137   verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n"
2138                      "  // Information about someDecentlyLongValue.\n"
2139                      "  someDecentlyLongValue,\n"
2140                      "  // Information about anotherDecentlyLongValue.\n"
2141                      "  anotherDecentlyLongValue,\n"
2142                      "  // Information about aThirdDecentlyLongValue.\n"
2143                      "  aThirdDecentlyLongValue\n"
2144                      "};");
2145   verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
2146                      "  a = 1,\n"
2147                      "  b = 2,\n"
2148                      "  c = 3,\n"
2149                      "};");
2150   verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
2151                      "  a = 1,\n"
2152                      "  b = 2,\n"
2153                      "  c = 3,\n"
2154                      "};");
2155   verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n"
2156                      "  a = 1,\n"
2157                      "  b = 2,\n"
2158                      "  c = 3,\n"
2159                      "};");
2160   verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
2161                      "  a = 1,\n"
2162                      "  b = 2,\n"
2163                      "  c = 3,\n"
2164                      "};");
2165 }
2166 
2167 TEST_F(FormatTest, FormatsBitfields) {
2168   verifyFormat("struct Bitfields {\n"
2169                "  unsigned sClass : 8;\n"
2170                "  unsigned ValueKind : 2;\n"
2171                "};");
2172   verifyFormat("struct A {\n"
2173                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
2174                "      bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
2175                "};");
2176   verifyFormat("struct MyStruct {\n"
2177                "  uchar data;\n"
2178                "  uchar : 8;\n"
2179                "  uchar : 8;\n"
2180                "  uchar other;\n"
2181                "};");
2182   FormatStyle Style = getLLVMStyle();
2183   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
2184   verifyFormat("struct Bitfields {\n"
2185                "  unsigned sClass:8;\n"
2186                "  unsigned ValueKind:2;\n"
2187                "  uchar other;\n"
2188                "};",
2189                Style);
2190   verifyFormat("struct A {\n"
2191                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:1,\n"
2192                "      bbbbbbbbbbbbbbbbbbbbbbbbb:2;\n"
2193                "};",
2194                Style);
2195   Style.BitFieldColonSpacing = FormatStyle::BFCS_Before;
2196   verifyFormat("struct Bitfields {\n"
2197                "  unsigned sClass :8;\n"
2198                "  unsigned ValueKind :2;\n"
2199                "  uchar other;\n"
2200                "};",
2201                Style);
2202   Style.BitFieldColonSpacing = FormatStyle::BFCS_After;
2203   verifyFormat("struct Bitfields {\n"
2204                "  unsigned sClass: 8;\n"
2205                "  unsigned ValueKind: 2;\n"
2206                "  uchar other;\n"
2207                "};",
2208                Style);
2209 }
2210 
2211 TEST_F(FormatTest, FormatsNamespaces) {
2212   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
2213   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
2214 
2215   verifyFormat("namespace some_namespace {\n"
2216                "class A {};\n"
2217                "void f() { f(); }\n"
2218                "}",
2219                LLVMWithNoNamespaceFix);
2220   verifyFormat("namespace N::inline D {\n"
2221                "class A {};\n"
2222                "void f() { f(); }\n"
2223                "}",
2224                LLVMWithNoNamespaceFix);
2225   verifyFormat("namespace N::inline D::E {\n"
2226                "class A {};\n"
2227                "void f() { f(); }\n"
2228                "}",
2229                LLVMWithNoNamespaceFix);
2230   verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
2231                "class A {};\n"
2232                "void f() { f(); }\n"
2233                "}",
2234                LLVMWithNoNamespaceFix);
2235   verifyFormat("/* something */ namespace some_namespace {\n"
2236                "class A {};\n"
2237                "void f() { f(); }\n"
2238                "}",
2239                LLVMWithNoNamespaceFix);
2240   verifyFormat("namespace {\n"
2241                "class A {};\n"
2242                "void f() { f(); }\n"
2243                "}",
2244                LLVMWithNoNamespaceFix);
2245   verifyFormat("/* something */ namespace {\n"
2246                "class A {};\n"
2247                "void f() { f(); }\n"
2248                "}",
2249                LLVMWithNoNamespaceFix);
2250   verifyFormat("inline namespace X {\n"
2251                "class A {};\n"
2252                "void f() { f(); }\n"
2253                "}",
2254                LLVMWithNoNamespaceFix);
2255   verifyFormat("/* something */ inline namespace X {\n"
2256                "class A {};\n"
2257                "void f() { f(); }\n"
2258                "}",
2259                LLVMWithNoNamespaceFix);
2260   verifyFormat("export namespace X {\n"
2261                "class A {};\n"
2262                "void f() { f(); }\n"
2263                "}",
2264                LLVMWithNoNamespaceFix);
2265   verifyFormat("using namespace some_namespace;\n"
2266                "class A {};\n"
2267                "void f() { f(); }",
2268                LLVMWithNoNamespaceFix);
2269 
2270   // This code is more common than we thought; if we
2271   // layout this correctly the semicolon will go into
2272   // its own line, which is undesirable.
2273   verifyFormat("namespace {};", LLVMWithNoNamespaceFix);
2274   verifyFormat("namespace {\n"
2275                "class A {};\n"
2276                "};",
2277                LLVMWithNoNamespaceFix);
2278 
2279   verifyFormat("namespace {\n"
2280                "int SomeVariable = 0; // comment\n"
2281                "} // namespace",
2282                LLVMWithNoNamespaceFix);
2283   EXPECT_EQ("#ifndef HEADER_GUARD\n"
2284             "#define HEADER_GUARD\n"
2285             "namespace my_namespace {\n"
2286             "int i;\n"
2287             "} // my_namespace\n"
2288             "#endif // HEADER_GUARD",
2289             format("#ifndef HEADER_GUARD\n"
2290                    " #define HEADER_GUARD\n"
2291                    "   namespace my_namespace {\n"
2292                    "int i;\n"
2293                    "}    // my_namespace\n"
2294                    "#endif    // HEADER_GUARD",
2295                    LLVMWithNoNamespaceFix));
2296 
2297   EXPECT_EQ("namespace A::B {\n"
2298             "class C {};\n"
2299             "}",
2300             format("namespace A::B {\n"
2301                    "class C {};\n"
2302                    "}",
2303                    LLVMWithNoNamespaceFix));
2304 
2305   FormatStyle Style = getLLVMStyle();
2306   Style.NamespaceIndentation = FormatStyle::NI_All;
2307   EXPECT_EQ("namespace out {\n"
2308             "  int i;\n"
2309             "  namespace in {\n"
2310             "    int i;\n"
2311             "  } // namespace in\n"
2312             "} // namespace out",
2313             format("namespace out {\n"
2314                    "int i;\n"
2315                    "namespace in {\n"
2316                    "int i;\n"
2317                    "} // namespace in\n"
2318                    "} // namespace out",
2319                    Style));
2320 
2321   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2322   EXPECT_EQ("namespace out {\n"
2323             "int i;\n"
2324             "namespace in {\n"
2325             "  int i;\n"
2326             "} // namespace in\n"
2327             "} // namespace out",
2328             format("namespace out {\n"
2329                    "int i;\n"
2330                    "namespace in {\n"
2331                    "int i;\n"
2332                    "} // namespace in\n"
2333                    "} // namespace out",
2334                    Style));
2335 }
2336 
2337 TEST_F(FormatTest, NamespaceMacros) {
2338   FormatStyle Style = getLLVMStyle();
2339   Style.NamespaceMacros.push_back("TESTSUITE");
2340 
2341   verifyFormat("TESTSUITE(A) {\n"
2342                "int foo();\n"
2343                "} // TESTSUITE(A)",
2344                Style);
2345 
2346   verifyFormat("TESTSUITE(A, B) {\n"
2347                "int foo();\n"
2348                "} // TESTSUITE(A)",
2349                Style);
2350 
2351   // Properly indent according to NamespaceIndentation style
2352   Style.NamespaceIndentation = FormatStyle::NI_All;
2353   verifyFormat("TESTSUITE(A) {\n"
2354                "  int foo();\n"
2355                "} // TESTSUITE(A)",
2356                Style);
2357   verifyFormat("TESTSUITE(A) {\n"
2358                "  namespace B {\n"
2359                "    int foo();\n"
2360                "  } // namespace B\n"
2361                "} // TESTSUITE(A)",
2362                Style);
2363   verifyFormat("namespace A {\n"
2364                "  TESTSUITE(B) {\n"
2365                "    int foo();\n"
2366                "  } // TESTSUITE(B)\n"
2367                "} // namespace A",
2368                Style);
2369 
2370   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2371   verifyFormat("TESTSUITE(A) {\n"
2372                "TESTSUITE(B) {\n"
2373                "  int foo();\n"
2374                "} // TESTSUITE(B)\n"
2375                "} // TESTSUITE(A)",
2376                Style);
2377   verifyFormat("TESTSUITE(A) {\n"
2378                "namespace B {\n"
2379                "  int foo();\n"
2380                "} // namespace B\n"
2381                "} // TESTSUITE(A)",
2382                Style);
2383   verifyFormat("namespace A {\n"
2384                "TESTSUITE(B) {\n"
2385                "  int foo();\n"
2386                "} // TESTSUITE(B)\n"
2387                "} // namespace A",
2388                Style);
2389 
2390   // Properly merge namespace-macros blocks in CompactNamespaces mode
2391   Style.NamespaceIndentation = FormatStyle::NI_None;
2392   Style.CompactNamespaces = true;
2393   verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
2394                "}} // TESTSUITE(A::B)",
2395                Style);
2396 
2397   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2398             "}} // TESTSUITE(out::in)",
2399             format("TESTSUITE(out) {\n"
2400                    "TESTSUITE(in) {\n"
2401                    "} // TESTSUITE(in)\n"
2402                    "} // TESTSUITE(out)",
2403                    Style));
2404 
2405   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2406             "}} // TESTSUITE(out::in)",
2407             format("TESTSUITE(out) {\n"
2408                    "TESTSUITE(in) {\n"
2409                    "} // TESTSUITE(in)\n"
2410                    "} // TESTSUITE(out)",
2411                    Style));
2412 
2413   // Do not merge different namespaces/macros
2414   EXPECT_EQ("namespace out {\n"
2415             "TESTSUITE(in) {\n"
2416             "} // TESTSUITE(in)\n"
2417             "} // namespace out",
2418             format("namespace out {\n"
2419                    "TESTSUITE(in) {\n"
2420                    "} // TESTSUITE(in)\n"
2421                    "} // namespace out",
2422                    Style));
2423   EXPECT_EQ("TESTSUITE(out) {\n"
2424             "namespace in {\n"
2425             "} // namespace in\n"
2426             "} // TESTSUITE(out)",
2427             format("TESTSUITE(out) {\n"
2428                    "namespace in {\n"
2429                    "} // namespace in\n"
2430                    "} // TESTSUITE(out)",
2431                    Style));
2432   Style.NamespaceMacros.push_back("FOOBAR");
2433   EXPECT_EQ("TESTSUITE(out) {\n"
2434             "FOOBAR(in) {\n"
2435             "} // FOOBAR(in)\n"
2436             "} // TESTSUITE(out)",
2437             format("TESTSUITE(out) {\n"
2438                    "FOOBAR(in) {\n"
2439                    "} // FOOBAR(in)\n"
2440                    "} // TESTSUITE(out)",
2441                    Style));
2442 }
2443 
2444 TEST_F(FormatTest, FormatsCompactNamespaces) {
2445   FormatStyle Style = getLLVMStyle();
2446   Style.CompactNamespaces = true;
2447   Style.NamespaceMacros.push_back("TESTSUITE");
2448 
2449   verifyFormat("namespace A { namespace B {\n"
2450                "}} // namespace A::B",
2451                Style);
2452 
2453   EXPECT_EQ("namespace out { namespace in {\n"
2454             "}} // namespace out::in",
2455             format("namespace out {\n"
2456                    "namespace in {\n"
2457                    "} // namespace in\n"
2458                    "} // namespace out",
2459                    Style));
2460 
2461   // Only namespaces which have both consecutive opening and end get compacted
2462   EXPECT_EQ("namespace out {\n"
2463             "namespace in1 {\n"
2464             "} // namespace in1\n"
2465             "namespace in2 {\n"
2466             "} // namespace in2\n"
2467             "} // namespace out",
2468             format("namespace out {\n"
2469                    "namespace in1 {\n"
2470                    "} // namespace in1\n"
2471                    "namespace in2 {\n"
2472                    "} // namespace in2\n"
2473                    "} // namespace out",
2474                    Style));
2475 
2476   EXPECT_EQ("namespace out {\n"
2477             "int i;\n"
2478             "namespace in {\n"
2479             "int j;\n"
2480             "} // namespace in\n"
2481             "int k;\n"
2482             "} // namespace out",
2483             format("namespace out { int i;\n"
2484                    "namespace in { int j; } // namespace in\n"
2485                    "int k; } // namespace out",
2486                    Style));
2487 
2488   EXPECT_EQ("namespace A { namespace B { namespace C {\n"
2489             "}}} // namespace A::B::C\n",
2490             format("namespace A { namespace B {\n"
2491                    "namespace C {\n"
2492                    "}} // namespace B::C\n"
2493                    "} // namespace A\n",
2494                    Style));
2495 
2496   Style.ColumnLimit = 40;
2497   EXPECT_EQ("namespace aaaaaaaaaa {\n"
2498             "namespace bbbbbbbbbb {\n"
2499             "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
2500             format("namespace aaaaaaaaaa {\n"
2501                    "namespace bbbbbbbbbb {\n"
2502                    "} // namespace bbbbbbbbbb\n"
2503                    "} // namespace aaaaaaaaaa",
2504                    Style));
2505 
2506   EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
2507             "namespace cccccc {\n"
2508             "}}} // namespace aaaaaa::bbbbbb::cccccc",
2509             format("namespace aaaaaa {\n"
2510                    "namespace bbbbbb {\n"
2511                    "namespace cccccc {\n"
2512                    "} // namespace cccccc\n"
2513                    "} // namespace bbbbbb\n"
2514                    "} // namespace aaaaaa",
2515                    Style));
2516   Style.ColumnLimit = 80;
2517 
2518   // Extra semicolon after 'inner' closing brace prevents merging
2519   EXPECT_EQ("namespace out { namespace in {\n"
2520             "}; } // namespace out::in",
2521             format("namespace out {\n"
2522                    "namespace in {\n"
2523                    "}; // namespace in\n"
2524                    "} // namespace out",
2525                    Style));
2526 
2527   // Extra semicolon after 'outer' closing brace is conserved
2528   EXPECT_EQ("namespace out { namespace in {\n"
2529             "}}; // namespace out::in",
2530             format("namespace out {\n"
2531                    "namespace in {\n"
2532                    "} // namespace in\n"
2533                    "}; // namespace out",
2534                    Style));
2535 
2536   Style.NamespaceIndentation = FormatStyle::NI_All;
2537   EXPECT_EQ("namespace out { namespace in {\n"
2538             "  int i;\n"
2539             "}} // namespace out::in",
2540             format("namespace out {\n"
2541                    "namespace in {\n"
2542                    "int i;\n"
2543                    "} // namespace in\n"
2544                    "} // namespace out",
2545                    Style));
2546   EXPECT_EQ("namespace out { namespace mid {\n"
2547             "  namespace in {\n"
2548             "    int j;\n"
2549             "  } // namespace in\n"
2550             "  int k;\n"
2551             "}} // namespace out::mid",
2552             format("namespace out { namespace mid {\n"
2553                    "namespace in { int j; } // namespace in\n"
2554                    "int k; }} // namespace out::mid",
2555                    Style));
2556 
2557   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2558   EXPECT_EQ("namespace out { namespace in {\n"
2559             "  int i;\n"
2560             "}} // namespace out::in",
2561             format("namespace out {\n"
2562                    "namespace in {\n"
2563                    "int i;\n"
2564                    "} // namespace in\n"
2565                    "} // namespace out",
2566                    Style));
2567   EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
2568             "  int i;\n"
2569             "}}} // namespace out::mid::in",
2570             format("namespace out {\n"
2571                    "namespace mid {\n"
2572                    "namespace in {\n"
2573                    "int i;\n"
2574                    "} // namespace in\n"
2575                    "} // namespace mid\n"
2576                    "} // namespace out",
2577                    Style));
2578 }
2579 
2580 TEST_F(FormatTest, FormatsExternC) {
2581   verifyFormat("extern \"C\" {\nint a;");
2582   verifyFormat("extern \"C\" {}");
2583   verifyFormat("extern \"C\" {\n"
2584                "int foo();\n"
2585                "}");
2586   verifyFormat("extern \"C\" int foo() {}");
2587   verifyFormat("extern \"C\" int foo();");
2588   verifyFormat("extern \"C\" int foo() {\n"
2589                "  int i = 42;\n"
2590                "  return i;\n"
2591                "}");
2592 
2593   FormatStyle Style = getLLVMStyle();
2594   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2595   Style.BraceWrapping.AfterFunction = true;
2596   verifyFormat("extern \"C\" int foo() {}", Style);
2597   verifyFormat("extern \"C\" int foo();", Style);
2598   verifyFormat("extern \"C\" int foo()\n"
2599                "{\n"
2600                "  int i = 42;\n"
2601                "  return i;\n"
2602                "}",
2603                Style);
2604 
2605   Style.BraceWrapping.AfterExternBlock = true;
2606   Style.BraceWrapping.SplitEmptyRecord = false;
2607   verifyFormat("extern \"C\"\n"
2608                "{}",
2609                Style);
2610   verifyFormat("extern \"C\"\n"
2611                "{\n"
2612                "  int foo();\n"
2613                "}",
2614                Style);
2615 }
2616 
2617 TEST_F(FormatTest, IndentExternBlockStyle) {
2618   FormatStyle Style = getLLVMStyle();
2619   Style.IndentWidth = 2;
2620 
2621   Style.IndentExternBlock = FormatStyle::IEBS_Indent;
2622   verifyFormat("extern \"C\" { /*9*/\n}", Style);
2623   verifyFormat("extern \"C\" {\n"
2624                "  int foo10();\n"
2625                "}",
2626                Style);
2627 
2628   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
2629   verifyFormat("extern \"C\" { /*11*/\n}", Style);
2630   verifyFormat("extern \"C\" {\n"
2631                "int foo12();\n"
2632                "}",
2633                Style);
2634 
2635   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2636   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2637   Style.BraceWrapping.AfterExternBlock = true;
2638   verifyFormat("extern \"C\"\n{ /*13*/\n}", Style);
2639   verifyFormat("extern \"C\"\n{\n"
2640                "  int foo14();\n"
2641                "}",
2642                Style);
2643 
2644   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2645   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2646   Style.BraceWrapping.AfterExternBlock = false;
2647   verifyFormat("extern \"C\" { /*15*/\n}", Style);
2648   verifyFormat("extern \"C\" {\n"
2649                "int foo16();\n"
2650                "}",
2651                Style);
2652 }
2653 
2654 TEST_F(FormatTest, FormatsInlineASM) {
2655   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
2656   verifyFormat("asm(\"nop\" ::: \"memory\");");
2657   verifyFormat(
2658       "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
2659       "    \"cpuid\\n\\t\"\n"
2660       "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
2661       "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
2662       "    : \"a\"(value));");
2663   EXPECT_EQ(
2664       "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
2665       "  __asm {\n"
2666       "        mov     edx,[that] // vtable in edx\n"
2667       "        mov     eax,methodIndex\n"
2668       "        call    [edx][eax*4] // stdcall\n"
2669       "  }\n"
2670       "}",
2671       format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
2672              "    __asm {\n"
2673              "        mov     edx,[that] // vtable in edx\n"
2674              "        mov     eax,methodIndex\n"
2675              "        call    [edx][eax*4] // stdcall\n"
2676              "    }\n"
2677              "}"));
2678   EXPECT_EQ("_asm {\n"
2679             "  xor eax, eax;\n"
2680             "  cpuid;\n"
2681             "}",
2682             format("_asm {\n"
2683                    "  xor eax, eax;\n"
2684                    "  cpuid;\n"
2685                    "}"));
2686   verifyFormat("void function() {\n"
2687                "  // comment\n"
2688                "  asm(\"\");\n"
2689                "}");
2690   EXPECT_EQ("__asm {\n"
2691             "}\n"
2692             "int i;",
2693             format("__asm   {\n"
2694                    "}\n"
2695                    "int   i;"));
2696 }
2697 
2698 TEST_F(FormatTest, FormatTryCatch) {
2699   verifyFormat("try {\n"
2700                "  throw a * b;\n"
2701                "} catch (int a) {\n"
2702                "  // Do nothing.\n"
2703                "} catch (...) {\n"
2704                "  exit(42);\n"
2705                "}");
2706 
2707   // Function-level try statements.
2708   verifyFormat("int f() try { return 4; } catch (...) {\n"
2709                "  return 5;\n"
2710                "}");
2711   verifyFormat("class A {\n"
2712                "  int a;\n"
2713                "  A() try : a(0) {\n"
2714                "  } catch (...) {\n"
2715                "    throw;\n"
2716                "  }\n"
2717                "};\n");
2718 
2719   // Incomplete try-catch blocks.
2720   verifyIncompleteFormat("try {} catch (");
2721 }
2722 
2723 TEST_F(FormatTest, FormatTryAsAVariable) {
2724   verifyFormat("int try;");
2725   verifyFormat("int try, size;");
2726   verifyFormat("try = foo();");
2727   verifyFormat("if (try < size) {\n  return true;\n}");
2728 
2729   verifyFormat("int catch;");
2730   verifyFormat("int catch, size;");
2731   verifyFormat("catch = foo();");
2732   verifyFormat("if (catch < size) {\n  return true;\n}");
2733 }
2734 
2735 TEST_F(FormatTest, FormatSEHTryCatch) {
2736   verifyFormat("__try {\n"
2737                "  int a = b * c;\n"
2738                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2739                "  // Do nothing.\n"
2740                "}");
2741 
2742   verifyFormat("__try {\n"
2743                "  int a = b * c;\n"
2744                "} __finally {\n"
2745                "  // Do nothing.\n"
2746                "}");
2747 
2748   verifyFormat("DEBUG({\n"
2749                "  __try {\n"
2750                "  } __finally {\n"
2751                "  }\n"
2752                "});\n");
2753 }
2754 
2755 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2756   verifyFormat("try {\n"
2757                "  f();\n"
2758                "} catch {\n"
2759                "  g();\n"
2760                "}");
2761   verifyFormat("try {\n"
2762                "  f();\n"
2763                "} catch (A a) MACRO(x) {\n"
2764                "  g();\n"
2765                "} catch (B b) MACRO(x) {\n"
2766                "  g();\n"
2767                "}");
2768 }
2769 
2770 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2771   FormatStyle Style = getLLVMStyle();
2772   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2773                           FormatStyle::BS_WebKit}) {
2774     Style.BreakBeforeBraces = BraceStyle;
2775     verifyFormat("try {\n"
2776                  "  // something\n"
2777                  "} catch (...) {\n"
2778                  "  // something\n"
2779                  "}",
2780                  Style);
2781   }
2782   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2783   verifyFormat("try {\n"
2784                "  // something\n"
2785                "}\n"
2786                "catch (...) {\n"
2787                "  // something\n"
2788                "}",
2789                Style);
2790   verifyFormat("__try {\n"
2791                "  // something\n"
2792                "}\n"
2793                "__finally {\n"
2794                "  // something\n"
2795                "}",
2796                Style);
2797   verifyFormat("@try {\n"
2798                "  // something\n"
2799                "}\n"
2800                "@finally {\n"
2801                "  // something\n"
2802                "}",
2803                Style);
2804   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2805   verifyFormat("try\n"
2806                "{\n"
2807                "  // something\n"
2808                "}\n"
2809                "catch (...)\n"
2810                "{\n"
2811                "  // something\n"
2812                "}",
2813                Style);
2814   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2815   verifyFormat("try\n"
2816                "  {\n"
2817                "  // something white\n"
2818                "  }\n"
2819                "catch (...)\n"
2820                "  {\n"
2821                "  // something white\n"
2822                "  }",
2823                Style);
2824   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2825   verifyFormat("try\n"
2826                "  {\n"
2827                "    // something\n"
2828                "  }\n"
2829                "catch (...)\n"
2830                "  {\n"
2831                "    // something\n"
2832                "  }",
2833                Style);
2834   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2835   Style.BraceWrapping.BeforeCatch = true;
2836   verifyFormat("try {\n"
2837                "  // something\n"
2838                "}\n"
2839                "catch (...) {\n"
2840                "  // something\n"
2841                "}",
2842                Style);
2843 }
2844 
2845 TEST_F(FormatTest, StaticInitializers) {
2846   verifyFormat("static SomeClass SC = {1, 'a'};");
2847 
2848   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2849                "    100000000, "
2850                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2851 
2852   // Here, everything other than the "}" would fit on a line.
2853   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2854                "    10000000000000000000000000};");
2855   EXPECT_EQ("S s = {a,\n"
2856             "\n"
2857             "       b};",
2858             format("S s = {\n"
2859                    "  a,\n"
2860                    "\n"
2861                    "  b\n"
2862                    "};"));
2863 
2864   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2865   // line. However, the formatting looks a bit off and this probably doesn't
2866   // happen often in practice.
2867   verifyFormat("static int Variable[1] = {\n"
2868                "    {1000000000000000000000000000000000000}};",
2869                getLLVMStyleWithColumns(40));
2870 }
2871 
2872 TEST_F(FormatTest, DesignatedInitializers) {
2873   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2874   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2875                "                    .bbbbbbbbbb = 2,\n"
2876                "                    .cccccccccc = 3,\n"
2877                "                    .dddddddddd = 4,\n"
2878                "                    .eeeeeeeeee = 5};");
2879   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2880                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2881                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2882                "    .ccccccccccccccccccccccccccc = 3,\n"
2883                "    .ddddddddddddddddddddddddddd = 4,\n"
2884                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2885 
2886   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2887 
2888   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2889   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2890                "                    [2] = bbbbbbbbbb,\n"
2891                "                    [3] = cccccccccc,\n"
2892                "                    [4] = dddddddddd,\n"
2893                "                    [5] = eeeeeeeeee};");
2894   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2895                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2896                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2897                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2898                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2899                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2900 }
2901 
2902 TEST_F(FormatTest, NestedStaticInitializers) {
2903   verifyFormat("static A x = {{{}}};\n");
2904   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2905                "               {init1, init2, init3, init4}}};",
2906                getLLVMStyleWithColumns(50));
2907 
2908   verifyFormat("somes Status::global_reps[3] = {\n"
2909                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2910                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2911                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2912                getLLVMStyleWithColumns(60));
2913   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2914                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2915                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2916                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2917   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2918                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
2919                "rect.fTop}};");
2920 
2921   verifyFormat(
2922       "SomeArrayOfSomeType a = {\n"
2923       "    {{1, 2, 3},\n"
2924       "     {1, 2, 3},\n"
2925       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
2926       "      333333333333333333333333333333},\n"
2927       "     {1, 2, 3},\n"
2928       "     {1, 2, 3}}};");
2929   verifyFormat(
2930       "SomeArrayOfSomeType a = {\n"
2931       "    {{1, 2, 3}},\n"
2932       "    {{1, 2, 3}},\n"
2933       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2934       "      333333333333333333333333333333}},\n"
2935       "    {{1, 2, 3}},\n"
2936       "    {{1, 2, 3}}};");
2937 
2938   verifyFormat("struct {\n"
2939                "  unsigned bit;\n"
2940                "  const char *const name;\n"
2941                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2942                "                 {kOsWin, \"Windows\"},\n"
2943                "                 {kOsLinux, \"Linux\"},\n"
2944                "                 {kOsCrOS, \"Chrome OS\"}};");
2945   verifyFormat("struct {\n"
2946                "  unsigned bit;\n"
2947                "  const char *const name;\n"
2948                "} kBitsToOs[] = {\n"
2949                "    {kOsMac, \"Mac\"},\n"
2950                "    {kOsWin, \"Windows\"},\n"
2951                "    {kOsLinux, \"Linux\"},\n"
2952                "    {kOsCrOS, \"Chrome OS\"},\n"
2953                "};");
2954 }
2955 
2956 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2957   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2958                "                      \\\n"
2959                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2960 }
2961 
2962 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
2963   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2964                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
2965 
2966   // Do break defaulted and deleted functions.
2967   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2968                "    default;",
2969                getLLVMStyleWithColumns(40));
2970   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2971                "    delete;",
2972                getLLVMStyleWithColumns(40));
2973 }
2974 
2975 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2976   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2977                getLLVMStyleWithColumns(40));
2978   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2979                getLLVMStyleWithColumns(40));
2980   EXPECT_EQ("#define Q                              \\\n"
2981             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
2982             "  \"aaaaaaaa.cpp\"",
2983             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2984                    getLLVMStyleWithColumns(40)));
2985 }
2986 
2987 TEST_F(FormatTest, UnderstandsLinePPDirective) {
2988   EXPECT_EQ("# 123 \"A string literal\"",
2989             format("   #     123    \"A string literal\""));
2990 }
2991 
2992 TEST_F(FormatTest, LayoutUnknownPPDirective) {
2993   EXPECT_EQ("#;", format("#;"));
2994   verifyFormat("#\n;\n;\n;");
2995 }
2996 
2997 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
2998   EXPECT_EQ("#line 42 \"test\"\n",
2999             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
3000   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
3001                                     getLLVMStyleWithColumns(12)));
3002 }
3003 
3004 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
3005   EXPECT_EQ("#line 42 \"test\"",
3006             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
3007   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
3008 }
3009 
3010 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
3011   verifyFormat("#define A \\x20");
3012   verifyFormat("#define A \\ x20");
3013   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
3014   verifyFormat("#define A ''");
3015   verifyFormat("#define A ''qqq");
3016   verifyFormat("#define A `qqq");
3017   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
3018   EXPECT_EQ("const char *c = STRINGIFY(\n"
3019             "\\na : b);",
3020             format("const char * c = STRINGIFY(\n"
3021                    "\\na : b);"));
3022 
3023   verifyFormat("a\r\\");
3024   verifyFormat("a\v\\");
3025   verifyFormat("a\f\\");
3026 }
3027 
3028 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
3029   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
3030   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
3031   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
3032   // FIXME: We never break before the macro name.
3033   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
3034 
3035   verifyFormat("#define A A\n#define A A");
3036   verifyFormat("#define A(X) A\n#define A A");
3037 
3038   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
3039   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
3040 }
3041 
3042 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
3043   EXPECT_EQ("// somecomment\n"
3044             "#include \"a.h\"\n"
3045             "#define A(  \\\n"
3046             "    A, B)\n"
3047             "#include \"b.h\"\n"
3048             "// somecomment\n",
3049             format("  // somecomment\n"
3050                    "  #include \"a.h\"\n"
3051                    "#define A(A,\\\n"
3052                    "    B)\n"
3053                    "    #include \"b.h\"\n"
3054                    " // somecomment\n",
3055                    getLLVMStyleWithColumns(13)));
3056 }
3057 
3058 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
3059 
3060 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
3061   EXPECT_EQ("#define A    \\\n"
3062             "  c;         \\\n"
3063             "  e;\n"
3064             "f;",
3065             format("#define A c; e;\n"
3066                    "f;",
3067                    getLLVMStyleWithColumns(14)));
3068 }
3069 
3070 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
3071 
3072 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
3073   EXPECT_EQ("int x,\n"
3074             "#define A\n"
3075             "    y;",
3076             format("int x,\n#define A\ny;"));
3077 }
3078 
3079 TEST_F(FormatTest, HashInMacroDefinition) {
3080   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
3081   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
3082   verifyFormat("#define A  \\\n"
3083                "  {        \\\n"
3084                "    f(#c); \\\n"
3085                "  }",
3086                getLLVMStyleWithColumns(11));
3087 
3088   verifyFormat("#define A(X)         \\\n"
3089                "  void function##X()",
3090                getLLVMStyleWithColumns(22));
3091 
3092   verifyFormat("#define A(a, b, c)   \\\n"
3093                "  void a##b##c()",
3094                getLLVMStyleWithColumns(22));
3095 
3096   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
3097 }
3098 
3099 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
3100   EXPECT_EQ("#define A (x)", format("#define A (x)"));
3101   EXPECT_EQ("#define A(x)", format("#define A(x)"));
3102 
3103   FormatStyle Style = getLLVMStyle();
3104   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
3105   verifyFormat("#define true ((foo)1)", Style);
3106   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
3107   verifyFormat("#define false((foo)0)", Style);
3108 }
3109 
3110 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
3111   EXPECT_EQ("#define A b;", format("#define A \\\n"
3112                                    "          \\\n"
3113                                    "  b;",
3114                                    getLLVMStyleWithColumns(25)));
3115   EXPECT_EQ("#define A \\\n"
3116             "          \\\n"
3117             "  a;      \\\n"
3118             "  b;",
3119             format("#define A \\\n"
3120                    "          \\\n"
3121                    "  a;      \\\n"
3122                    "  b;",
3123                    getLLVMStyleWithColumns(11)));
3124   EXPECT_EQ("#define A \\\n"
3125             "  a;      \\\n"
3126             "          \\\n"
3127             "  b;",
3128             format("#define A \\\n"
3129                    "  a;      \\\n"
3130                    "          \\\n"
3131                    "  b;",
3132                    getLLVMStyleWithColumns(11)));
3133 }
3134 
3135 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
3136   verifyIncompleteFormat("#define A :");
3137   verifyFormat("#define SOMECASES  \\\n"
3138                "  case 1:          \\\n"
3139                "  case 2\n",
3140                getLLVMStyleWithColumns(20));
3141   verifyFormat("#define MACRO(a) \\\n"
3142                "  if (a)         \\\n"
3143                "    f();         \\\n"
3144                "  else           \\\n"
3145                "    g()",
3146                getLLVMStyleWithColumns(18));
3147   verifyFormat("#define A template <typename T>");
3148   verifyIncompleteFormat("#define STR(x) #x\n"
3149                          "f(STR(this_is_a_string_literal{));");
3150   verifyFormat("#pragma omp threadprivate( \\\n"
3151                "    y)), // expected-warning",
3152                getLLVMStyleWithColumns(28));
3153   verifyFormat("#d, = };");
3154   verifyFormat("#if \"a");
3155   verifyIncompleteFormat("({\n"
3156                          "#define b     \\\n"
3157                          "  }           \\\n"
3158                          "  a\n"
3159                          "a",
3160                          getLLVMStyleWithColumns(15));
3161   verifyFormat("#define A     \\\n"
3162                "  {           \\\n"
3163                "    {\n"
3164                "#define B     \\\n"
3165                "  }           \\\n"
3166                "  }",
3167                getLLVMStyleWithColumns(15));
3168   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
3169   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
3170   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
3171   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
3172 }
3173 
3174 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
3175   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
3176   EXPECT_EQ("class A : public QObject {\n"
3177             "  Q_OBJECT\n"
3178             "\n"
3179             "  A() {}\n"
3180             "};",
3181             format("class A  :  public QObject {\n"
3182                    "     Q_OBJECT\n"
3183                    "\n"
3184                    "  A() {\n}\n"
3185                    "}  ;"));
3186   EXPECT_EQ("MACRO\n"
3187             "/*static*/ int i;",
3188             format("MACRO\n"
3189                    " /*static*/ int   i;"));
3190   EXPECT_EQ("SOME_MACRO\n"
3191             "namespace {\n"
3192             "void f();\n"
3193             "} // namespace",
3194             format("SOME_MACRO\n"
3195                    "  namespace    {\n"
3196                    "void   f(  );\n"
3197                    "} // namespace"));
3198   // Only if the identifier contains at least 5 characters.
3199   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
3200   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
3201   // Only if everything is upper case.
3202   EXPECT_EQ("class A : public QObject {\n"
3203             "  Q_Object A() {}\n"
3204             "};",
3205             format("class A  :  public QObject {\n"
3206                    "     Q_Object\n"
3207                    "  A() {\n}\n"
3208                    "}  ;"));
3209 
3210   // Only if the next line can actually start an unwrapped line.
3211   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
3212             format("SOME_WEIRD_LOG_MACRO\n"
3213                    "<< SomeThing;"));
3214 
3215   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3216                "(n, buffers))\n",
3217                getChromiumStyle(FormatStyle::LK_Cpp));
3218 
3219   // See PR41483
3220   EXPECT_EQ("/**/ FOO(a)\n"
3221             "FOO(b)",
3222             format("/**/ FOO(a)\n"
3223                    "FOO(b)"));
3224 }
3225 
3226 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
3227   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3228             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3229             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3230             "class X {};\n"
3231             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3232             "int *createScopDetectionPass() { return 0; }",
3233             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3234                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3235                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3236                    "  class X {};\n"
3237                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3238                    "  int *createScopDetectionPass() { return 0; }"));
3239   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
3240   // braces, so that inner block is indented one level more.
3241   EXPECT_EQ("int q() {\n"
3242             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3243             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3244             "  IPC_END_MESSAGE_MAP()\n"
3245             "}",
3246             format("int q() {\n"
3247                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3248                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3249                    "  IPC_END_MESSAGE_MAP()\n"
3250                    "}"));
3251 
3252   // Same inside macros.
3253   EXPECT_EQ("#define LIST(L) \\\n"
3254             "  L(A)          \\\n"
3255             "  L(B)          \\\n"
3256             "  L(C)",
3257             format("#define LIST(L) \\\n"
3258                    "  L(A) \\\n"
3259                    "  L(B) \\\n"
3260                    "  L(C)",
3261                    getGoogleStyle()));
3262 
3263   // These must not be recognized as macros.
3264   EXPECT_EQ("int q() {\n"
3265             "  f(x);\n"
3266             "  f(x) {}\n"
3267             "  f(x)->g();\n"
3268             "  f(x)->*g();\n"
3269             "  f(x).g();\n"
3270             "  f(x) = x;\n"
3271             "  f(x) += x;\n"
3272             "  f(x) -= x;\n"
3273             "  f(x) *= x;\n"
3274             "  f(x) /= x;\n"
3275             "  f(x) %= x;\n"
3276             "  f(x) &= x;\n"
3277             "  f(x) |= x;\n"
3278             "  f(x) ^= x;\n"
3279             "  f(x) >>= x;\n"
3280             "  f(x) <<= x;\n"
3281             "  f(x)[y].z();\n"
3282             "  LOG(INFO) << x;\n"
3283             "  ifstream(x) >> x;\n"
3284             "}\n",
3285             format("int q() {\n"
3286                    "  f(x)\n;\n"
3287                    "  f(x)\n {}\n"
3288                    "  f(x)\n->g();\n"
3289                    "  f(x)\n->*g();\n"
3290                    "  f(x)\n.g();\n"
3291                    "  f(x)\n = x;\n"
3292                    "  f(x)\n += x;\n"
3293                    "  f(x)\n -= x;\n"
3294                    "  f(x)\n *= x;\n"
3295                    "  f(x)\n /= x;\n"
3296                    "  f(x)\n %= x;\n"
3297                    "  f(x)\n &= x;\n"
3298                    "  f(x)\n |= x;\n"
3299                    "  f(x)\n ^= x;\n"
3300                    "  f(x)\n >>= x;\n"
3301                    "  f(x)\n <<= x;\n"
3302                    "  f(x)\n[y].z();\n"
3303                    "  LOG(INFO)\n << x;\n"
3304                    "  ifstream(x)\n >> x;\n"
3305                    "}\n"));
3306   EXPECT_EQ("int q() {\n"
3307             "  F(x)\n"
3308             "  if (1) {\n"
3309             "  }\n"
3310             "  F(x)\n"
3311             "  while (1) {\n"
3312             "  }\n"
3313             "  F(x)\n"
3314             "  G(x);\n"
3315             "  F(x)\n"
3316             "  try {\n"
3317             "    Q();\n"
3318             "  } catch (...) {\n"
3319             "  }\n"
3320             "}\n",
3321             format("int q() {\n"
3322                    "F(x)\n"
3323                    "if (1) {}\n"
3324                    "F(x)\n"
3325                    "while (1) {}\n"
3326                    "F(x)\n"
3327                    "G(x);\n"
3328                    "F(x)\n"
3329                    "try { Q(); } catch (...) {}\n"
3330                    "}\n"));
3331   EXPECT_EQ("class A {\n"
3332             "  A() : t(0) {}\n"
3333             "  A(int i) noexcept() : {}\n"
3334             "  A(X x)\n" // FIXME: function-level try blocks are broken.
3335             "  try : t(0) {\n"
3336             "  } catch (...) {\n"
3337             "  }\n"
3338             "};",
3339             format("class A {\n"
3340                    "  A()\n : t(0) {}\n"
3341                    "  A(int i)\n noexcept() : {}\n"
3342                    "  A(X x)\n"
3343                    "  try : t(0) {} catch (...) {}\n"
3344                    "};"));
3345   FormatStyle Style = getLLVMStyle();
3346   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3347   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3348   Style.BraceWrapping.AfterFunction = true;
3349   EXPECT_EQ("void f()\n"
3350             "try\n"
3351             "{\n"
3352             "}",
3353             format("void f() try {\n"
3354                    "}",
3355                    Style));
3356   EXPECT_EQ("class SomeClass {\n"
3357             "public:\n"
3358             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3359             "};",
3360             format("class SomeClass {\n"
3361                    "public:\n"
3362                    "  SomeClass()\n"
3363                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3364                    "};"));
3365   EXPECT_EQ("class SomeClass {\n"
3366             "public:\n"
3367             "  SomeClass()\n"
3368             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3369             "};",
3370             format("class SomeClass {\n"
3371                    "public:\n"
3372                    "  SomeClass()\n"
3373                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3374                    "};",
3375                    getLLVMStyleWithColumns(40)));
3376 
3377   verifyFormat("MACRO(>)");
3378 
3379   // Some macros contain an implicit semicolon.
3380   Style = getLLVMStyle();
3381   Style.StatementMacros.push_back("FOO");
3382   verifyFormat("FOO(a) int b = 0;");
3383   verifyFormat("FOO(a)\n"
3384                "int b = 0;",
3385                Style);
3386   verifyFormat("FOO(a);\n"
3387                "int b = 0;",
3388                Style);
3389   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3390                "int b = 0;",
3391                Style);
3392   verifyFormat("FOO()\n"
3393                "int b = 0;",
3394                Style);
3395   verifyFormat("FOO\n"
3396                "int b = 0;",
3397                Style);
3398   verifyFormat("void f() {\n"
3399                "  FOO(a)\n"
3400                "  return a;\n"
3401                "}",
3402                Style);
3403   verifyFormat("FOO(a)\n"
3404                "FOO(b)",
3405                Style);
3406   verifyFormat("int a = 0;\n"
3407                "FOO(b)\n"
3408                "int c = 0;",
3409                Style);
3410   verifyFormat("int a = 0;\n"
3411                "int x = FOO(a)\n"
3412                "int b = 0;",
3413                Style);
3414   verifyFormat("void foo(int a) { FOO(a) }\n"
3415                "uint32_t bar() {}",
3416                Style);
3417 }
3418 
3419 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3420   verifyFormat("#define A \\\n"
3421                "  f({     \\\n"
3422                "    g();  \\\n"
3423                "  });",
3424                getLLVMStyleWithColumns(11));
3425 }
3426 
3427 TEST_F(FormatTest, IndentPreprocessorDirectives) {
3428   FormatStyle Style = getLLVMStyle();
3429   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3430   Style.ColumnLimit = 40;
3431   verifyFormat("#ifdef _WIN32\n"
3432                "#define A 0\n"
3433                "#ifdef VAR2\n"
3434                "#define B 1\n"
3435                "#include <someheader.h>\n"
3436                "#define MACRO                          \\\n"
3437                "  some_very_long_func_aaaaaaaaaa();\n"
3438                "#endif\n"
3439                "#else\n"
3440                "#define A 1\n"
3441                "#endif",
3442                Style);
3443   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3444   verifyFormat("#ifdef _WIN32\n"
3445                "#  define A 0\n"
3446                "#  ifdef VAR2\n"
3447                "#    define B 1\n"
3448                "#    include <someheader.h>\n"
3449                "#    define MACRO                      \\\n"
3450                "      some_very_long_func_aaaaaaaaaa();\n"
3451                "#  endif\n"
3452                "#else\n"
3453                "#  define A 1\n"
3454                "#endif",
3455                Style);
3456   verifyFormat("#if A\n"
3457                "#  define MACRO                        \\\n"
3458                "    void a(int x) {                    \\\n"
3459                "      b();                             \\\n"
3460                "      c();                             \\\n"
3461                "      d();                             \\\n"
3462                "      e();                             \\\n"
3463                "      f();                             \\\n"
3464                "    }\n"
3465                "#endif",
3466                Style);
3467   // Comments before include guard.
3468   verifyFormat("// file comment\n"
3469                "// file comment\n"
3470                "#ifndef HEADER_H\n"
3471                "#define HEADER_H\n"
3472                "code();\n"
3473                "#endif",
3474                Style);
3475   // Test with include guards.
3476   verifyFormat("#ifndef HEADER_H\n"
3477                "#define HEADER_H\n"
3478                "code();\n"
3479                "#endif",
3480                Style);
3481   // Include guards must have a #define with the same variable immediately
3482   // after #ifndef.
3483   verifyFormat("#ifndef NOT_GUARD\n"
3484                "#  define FOO\n"
3485                "code();\n"
3486                "#endif",
3487                Style);
3488 
3489   // Include guards must cover the entire file.
3490   verifyFormat("code();\n"
3491                "code();\n"
3492                "#ifndef NOT_GUARD\n"
3493                "#  define NOT_GUARD\n"
3494                "code();\n"
3495                "#endif",
3496                Style);
3497   verifyFormat("#ifndef NOT_GUARD\n"
3498                "#  define NOT_GUARD\n"
3499                "code();\n"
3500                "#endif\n"
3501                "code();",
3502                Style);
3503   // Test with trailing blank lines.
3504   verifyFormat("#ifndef HEADER_H\n"
3505                "#define HEADER_H\n"
3506                "code();\n"
3507                "#endif\n",
3508                Style);
3509   // Include guards don't have #else.
3510   verifyFormat("#ifndef NOT_GUARD\n"
3511                "#  define NOT_GUARD\n"
3512                "code();\n"
3513                "#else\n"
3514                "#endif",
3515                Style);
3516   verifyFormat("#ifndef NOT_GUARD\n"
3517                "#  define NOT_GUARD\n"
3518                "code();\n"
3519                "#elif FOO\n"
3520                "#endif",
3521                Style);
3522   // Non-identifier #define after potential include guard.
3523   verifyFormat("#ifndef FOO\n"
3524                "#  define 1\n"
3525                "#endif\n",
3526                Style);
3527   // #if closes past last non-preprocessor line.
3528   verifyFormat("#ifndef FOO\n"
3529                "#define FOO\n"
3530                "#if 1\n"
3531                "int i;\n"
3532                "#  define A 0\n"
3533                "#endif\n"
3534                "#endif\n",
3535                Style);
3536   // Don't crash if there is an #elif directive without a condition.
3537   verifyFormat("#if 1\n"
3538                "int x;\n"
3539                "#elif\n"
3540                "int y;\n"
3541                "#else\n"
3542                "int z;\n"
3543                "#endif",
3544                Style);
3545   // FIXME: This doesn't handle the case where there's code between the
3546   // #ifndef and #define but all other conditions hold. This is because when
3547   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3548   // previous code line yet, so we can't detect it.
3549   EXPECT_EQ("#ifndef NOT_GUARD\n"
3550             "code();\n"
3551             "#define NOT_GUARD\n"
3552             "code();\n"
3553             "#endif",
3554             format("#ifndef NOT_GUARD\n"
3555                    "code();\n"
3556                    "#  define NOT_GUARD\n"
3557                    "code();\n"
3558                    "#endif",
3559                    Style));
3560   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3561   // be outside an include guard. Examples are #pragma once and
3562   // #pragma GCC diagnostic, or anything else that does not change the meaning
3563   // of the file if it's included multiple times.
3564   EXPECT_EQ("#ifdef WIN32\n"
3565             "#  pragma once\n"
3566             "#endif\n"
3567             "#ifndef HEADER_H\n"
3568             "#  define HEADER_H\n"
3569             "code();\n"
3570             "#endif",
3571             format("#ifdef WIN32\n"
3572                    "#  pragma once\n"
3573                    "#endif\n"
3574                    "#ifndef HEADER_H\n"
3575                    "#define HEADER_H\n"
3576                    "code();\n"
3577                    "#endif",
3578                    Style));
3579   // FIXME: This does not detect when there is a single non-preprocessor line
3580   // in front of an include-guard-like structure where other conditions hold
3581   // because ScopedLineState hides the line.
3582   EXPECT_EQ("code();\n"
3583             "#ifndef HEADER_H\n"
3584             "#define HEADER_H\n"
3585             "code();\n"
3586             "#endif",
3587             format("code();\n"
3588                    "#ifndef HEADER_H\n"
3589                    "#  define HEADER_H\n"
3590                    "code();\n"
3591                    "#endif",
3592                    Style));
3593   // Keep comments aligned with #, otherwise indent comments normally. These
3594   // tests cannot use verifyFormat because messUp manipulates leading
3595   // whitespace.
3596   {
3597     const char *Expected = ""
3598                            "void f() {\n"
3599                            "#if 1\n"
3600                            "// Preprocessor aligned.\n"
3601                            "#  define A 0\n"
3602                            "  // Code. Separated by blank line.\n"
3603                            "\n"
3604                            "#  define B 0\n"
3605                            "  // Code. Not aligned with #\n"
3606                            "#  define C 0\n"
3607                            "#endif";
3608     const char *ToFormat = ""
3609                            "void f() {\n"
3610                            "#if 1\n"
3611                            "// Preprocessor aligned.\n"
3612                            "#  define A 0\n"
3613                            "// Code. Separated by blank line.\n"
3614                            "\n"
3615                            "#  define B 0\n"
3616                            "   // Code. Not aligned with #\n"
3617                            "#  define C 0\n"
3618                            "#endif";
3619     EXPECT_EQ(Expected, format(ToFormat, Style));
3620     EXPECT_EQ(Expected, format(Expected, Style));
3621   }
3622   // Keep block quotes aligned.
3623   {
3624     const char *Expected = ""
3625                            "void f() {\n"
3626                            "#if 1\n"
3627                            "/* Preprocessor aligned. */\n"
3628                            "#  define A 0\n"
3629                            "  /* Code. Separated by blank line. */\n"
3630                            "\n"
3631                            "#  define B 0\n"
3632                            "  /* Code. Not aligned with # */\n"
3633                            "#  define C 0\n"
3634                            "#endif";
3635     const char *ToFormat = ""
3636                            "void f() {\n"
3637                            "#if 1\n"
3638                            "/* Preprocessor aligned. */\n"
3639                            "#  define A 0\n"
3640                            "/* Code. Separated by blank line. */\n"
3641                            "\n"
3642                            "#  define B 0\n"
3643                            "   /* Code. Not aligned with # */\n"
3644                            "#  define C 0\n"
3645                            "#endif";
3646     EXPECT_EQ(Expected, format(ToFormat, Style));
3647     EXPECT_EQ(Expected, format(Expected, Style));
3648   }
3649   // Keep comments aligned with un-indented directives.
3650   {
3651     const char *Expected = ""
3652                            "void f() {\n"
3653                            "// Preprocessor aligned.\n"
3654                            "#define A 0\n"
3655                            "  // Code. Separated by blank line.\n"
3656                            "\n"
3657                            "#define B 0\n"
3658                            "  // Code. Not aligned with #\n"
3659                            "#define C 0\n";
3660     const char *ToFormat = ""
3661                            "void f() {\n"
3662                            "// Preprocessor aligned.\n"
3663                            "#define A 0\n"
3664                            "// Code. Separated by blank line.\n"
3665                            "\n"
3666                            "#define B 0\n"
3667                            "   // Code. Not aligned with #\n"
3668                            "#define C 0\n";
3669     EXPECT_EQ(Expected, format(ToFormat, Style));
3670     EXPECT_EQ(Expected, format(Expected, Style));
3671   }
3672   // Test AfterHash with tabs.
3673   {
3674     FormatStyle Tabbed = Style;
3675     Tabbed.UseTab = FormatStyle::UT_Always;
3676     Tabbed.IndentWidth = 8;
3677     Tabbed.TabWidth = 8;
3678     verifyFormat("#ifdef _WIN32\n"
3679                  "#\tdefine A 0\n"
3680                  "#\tifdef VAR2\n"
3681                  "#\t\tdefine B 1\n"
3682                  "#\t\tinclude <someheader.h>\n"
3683                  "#\t\tdefine MACRO          \\\n"
3684                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3685                  "#\tendif\n"
3686                  "#else\n"
3687                  "#\tdefine A 1\n"
3688                  "#endif",
3689                  Tabbed);
3690   }
3691 
3692   // Regression test: Multiline-macro inside include guards.
3693   verifyFormat("#ifndef HEADER_H\n"
3694                "#define HEADER_H\n"
3695                "#define A()        \\\n"
3696                "  int i;           \\\n"
3697                "  int j;\n"
3698                "#endif // HEADER_H",
3699                getLLVMStyleWithColumns(20));
3700 
3701   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3702   // Basic before hash indent tests
3703   verifyFormat("#ifdef _WIN32\n"
3704                "  #define A 0\n"
3705                "  #ifdef VAR2\n"
3706                "    #define B 1\n"
3707                "    #include <someheader.h>\n"
3708                "    #define MACRO                      \\\n"
3709                "      some_very_long_func_aaaaaaaaaa();\n"
3710                "  #endif\n"
3711                "#else\n"
3712                "  #define A 1\n"
3713                "#endif",
3714                Style);
3715   verifyFormat("#if A\n"
3716                "  #define MACRO                        \\\n"
3717                "    void a(int x) {                    \\\n"
3718                "      b();                             \\\n"
3719                "      c();                             \\\n"
3720                "      d();                             \\\n"
3721                "      e();                             \\\n"
3722                "      f();                             \\\n"
3723                "    }\n"
3724                "#endif",
3725                Style);
3726   // Keep comments aligned with indented directives. These
3727   // tests cannot use verifyFormat because messUp manipulates leading
3728   // whitespace.
3729   {
3730     const char *Expected = "void f() {\n"
3731                            "// Aligned to preprocessor.\n"
3732                            "#if 1\n"
3733                            "  // Aligned to code.\n"
3734                            "  int a;\n"
3735                            "  #if 1\n"
3736                            "    // Aligned to preprocessor.\n"
3737                            "    #define A 0\n"
3738                            "  // Aligned to code.\n"
3739                            "  int b;\n"
3740                            "  #endif\n"
3741                            "#endif\n"
3742                            "}";
3743     const char *ToFormat = "void f() {\n"
3744                            "// Aligned to preprocessor.\n"
3745                            "#if 1\n"
3746                            "// Aligned to code.\n"
3747                            "int a;\n"
3748                            "#if 1\n"
3749                            "// Aligned to preprocessor.\n"
3750                            "#define A 0\n"
3751                            "// Aligned to code.\n"
3752                            "int b;\n"
3753                            "#endif\n"
3754                            "#endif\n"
3755                            "}";
3756     EXPECT_EQ(Expected, format(ToFormat, Style));
3757     EXPECT_EQ(Expected, format(Expected, Style));
3758   }
3759   {
3760     const char *Expected = "void f() {\n"
3761                            "/* Aligned to preprocessor. */\n"
3762                            "#if 1\n"
3763                            "  /* Aligned to code. */\n"
3764                            "  int a;\n"
3765                            "  #if 1\n"
3766                            "    /* Aligned to preprocessor. */\n"
3767                            "    #define A 0\n"
3768                            "  /* Aligned to code. */\n"
3769                            "  int b;\n"
3770                            "  #endif\n"
3771                            "#endif\n"
3772                            "}";
3773     const char *ToFormat = "void f() {\n"
3774                            "/* Aligned to preprocessor. */\n"
3775                            "#if 1\n"
3776                            "/* Aligned to code. */\n"
3777                            "int a;\n"
3778                            "#if 1\n"
3779                            "/* Aligned to preprocessor. */\n"
3780                            "#define A 0\n"
3781                            "/* Aligned to code. */\n"
3782                            "int b;\n"
3783                            "#endif\n"
3784                            "#endif\n"
3785                            "}";
3786     EXPECT_EQ(Expected, format(ToFormat, Style));
3787     EXPECT_EQ(Expected, format(Expected, Style));
3788   }
3789 
3790   // Test single comment before preprocessor
3791   verifyFormat("// Comment\n"
3792                "\n"
3793                "#if 1\n"
3794                "#endif",
3795                Style);
3796 }
3797 
3798 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3799   verifyFormat("{\n  { a #c; }\n}");
3800 }
3801 
3802 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3803   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
3804             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3805   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
3806             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3807 }
3808 
3809 TEST_F(FormatTest, EscapedNewlines) {
3810   FormatStyle Narrow = getLLVMStyleWithColumns(11);
3811   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
3812             format("#define A \\\nint i;\\\n  int j;", Narrow));
3813   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3814   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3815   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
3816   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3817 
3818   FormatStyle AlignLeft = getLLVMStyle();
3819   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3820   EXPECT_EQ("#define MACRO(x) \\\n"
3821             "private:         \\\n"
3822             "  int x(int a);\n",
3823             format("#define MACRO(x) \\\n"
3824                    "private:         \\\n"
3825                    "  int x(int a);\n",
3826                    AlignLeft));
3827 
3828   // CRLF line endings
3829   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
3830             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
3831   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3832   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3833   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
3834   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3835   EXPECT_EQ("#define MACRO(x) \\\r\n"
3836             "private:         \\\r\n"
3837             "  int x(int a);\r\n",
3838             format("#define MACRO(x) \\\r\n"
3839                    "private:         \\\r\n"
3840                    "  int x(int a);\r\n",
3841                    AlignLeft));
3842 
3843   FormatStyle DontAlign = getLLVMStyle();
3844   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3845   DontAlign.MaxEmptyLinesToKeep = 3;
3846   // FIXME: can't use verifyFormat here because the newline before
3847   // "public:" is not inserted the first time it's reformatted
3848   EXPECT_EQ("#define A \\\n"
3849             "  class Foo { \\\n"
3850             "    void bar(); \\\n"
3851             "\\\n"
3852             "\\\n"
3853             "\\\n"
3854             "  public: \\\n"
3855             "    void baz(); \\\n"
3856             "  };",
3857             format("#define A \\\n"
3858                    "  class Foo { \\\n"
3859                    "    void bar(); \\\n"
3860                    "\\\n"
3861                    "\\\n"
3862                    "\\\n"
3863                    "  public: \\\n"
3864                    "    void baz(); \\\n"
3865                    "  };",
3866                    DontAlign));
3867 }
3868 
3869 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3870   verifyFormat("#define A \\\n"
3871                "  int v(  \\\n"
3872                "      a); \\\n"
3873                "  int i;",
3874                getLLVMStyleWithColumns(11));
3875 }
3876 
3877 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3878   EXPECT_EQ(
3879       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3880       "                      \\\n"
3881       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3882       "\n"
3883       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3884       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3885       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
3886              "\\\n"
3887              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3888              "  \n"
3889              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3890              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3891 }
3892 
3893 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3894   EXPECT_EQ("int\n"
3895             "#define A\n"
3896             "    a;",
3897             format("int\n#define A\na;"));
3898   verifyFormat("functionCallTo(\n"
3899                "    someOtherFunction(\n"
3900                "        withSomeParameters, whichInSequence,\n"
3901                "        areLongerThanALine(andAnotherCall,\n"
3902                "#define A B\n"
3903                "                           withMoreParamters,\n"
3904                "                           whichStronglyInfluenceTheLayout),\n"
3905                "        andMoreParameters),\n"
3906                "    trailing);",
3907                getLLVMStyleWithColumns(69));
3908   verifyFormat("Foo::Foo()\n"
3909                "#ifdef BAR\n"
3910                "    : baz(0)\n"
3911                "#endif\n"
3912                "{\n"
3913                "}");
3914   verifyFormat("void f() {\n"
3915                "  if (true)\n"
3916                "#ifdef A\n"
3917                "    f(42);\n"
3918                "  x();\n"
3919                "#else\n"
3920                "    g();\n"
3921                "  x();\n"
3922                "#endif\n"
3923                "}");
3924   verifyFormat("void f(param1, param2,\n"
3925                "       param3,\n"
3926                "#ifdef A\n"
3927                "       param4(param5,\n"
3928                "#ifdef A1\n"
3929                "              param6,\n"
3930                "#ifdef A2\n"
3931                "              param7),\n"
3932                "#else\n"
3933                "              param8),\n"
3934                "       param9,\n"
3935                "#endif\n"
3936                "       param10,\n"
3937                "#endif\n"
3938                "       param11)\n"
3939                "#else\n"
3940                "       param12)\n"
3941                "#endif\n"
3942                "{\n"
3943                "  x();\n"
3944                "}",
3945                getLLVMStyleWithColumns(28));
3946   verifyFormat("#if 1\n"
3947                "int i;");
3948   verifyFormat("#if 1\n"
3949                "#endif\n"
3950                "#if 1\n"
3951                "#else\n"
3952                "#endif\n");
3953   verifyFormat("DEBUG({\n"
3954                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3955                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
3956                "});\n"
3957                "#if a\n"
3958                "#else\n"
3959                "#endif");
3960 
3961   verifyIncompleteFormat("void f(\n"
3962                          "#if A\n"
3963                          ");\n"
3964                          "#else\n"
3965                          "#endif");
3966 }
3967 
3968 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
3969   verifyFormat("#endif\n"
3970                "#if B");
3971 }
3972 
3973 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
3974   FormatStyle SingleLine = getLLVMStyle();
3975   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
3976   verifyFormat("#if 0\n"
3977                "#elif 1\n"
3978                "#endif\n"
3979                "void foo() {\n"
3980                "  if (test) foo2();\n"
3981                "}",
3982                SingleLine);
3983 }
3984 
3985 TEST_F(FormatTest, LayoutBlockInsideParens) {
3986   verifyFormat("functionCall({ int i; });");
3987   verifyFormat("functionCall({\n"
3988                "  int i;\n"
3989                "  int j;\n"
3990                "});");
3991   verifyFormat("functionCall(\n"
3992                "    {\n"
3993                "      int i;\n"
3994                "      int j;\n"
3995                "    },\n"
3996                "    aaaa, bbbb, cccc);");
3997   verifyFormat("functionA(functionB({\n"
3998                "            int i;\n"
3999                "            int j;\n"
4000                "          }),\n"
4001                "          aaaa, bbbb, cccc);");
4002   verifyFormat("functionCall(\n"
4003                "    {\n"
4004                "      int i;\n"
4005                "      int j;\n"
4006                "    },\n"
4007                "    aaaa, bbbb, // comment\n"
4008                "    cccc);");
4009   verifyFormat("functionA(functionB({\n"
4010                "            int i;\n"
4011                "            int j;\n"
4012                "          }),\n"
4013                "          aaaa, bbbb, // comment\n"
4014                "          cccc);");
4015   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
4016   verifyFormat("functionCall(aaaa, bbbb, {\n"
4017                "  int i;\n"
4018                "  int j;\n"
4019                "});");
4020   verifyFormat(
4021       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
4022       "    {\n"
4023       "      int i; // break\n"
4024       "    },\n"
4025       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
4026       "                                     ccccccccccccccccc));");
4027   verifyFormat("DEBUG({\n"
4028                "  if (a)\n"
4029                "    f();\n"
4030                "});");
4031 }
4032 
4033 TEST_F(FormatTest, LayoutBlockInsideStatement) {
4034   EXPECT_EQ("SOME_MACRO { int i; }\n"
4035             "int i;",
4036             format("  SOME_MACRO  {int i;}  int i;"));
4037 }
4038 
4039 TEST_F(FormatTest, LayoutNestedBlocks) {
4040   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
4041                "  struct s {\n"
4042                "    int i;\n"
4043                "  };\n"
4044                "  s kBitsToOs[] = {{10}};\n"
4045                "  for (int i = 0; i < 10; ++i)\n"
4046                "    return;\n"
4047                "}");
4048   verifyFormat("call(parameter, {\n"
4049                "  something();\n"
4050                "  // Comment using all columns.\n"
4051                "  somethingelse();\n"
4052                "});",
4053                getLLVMStyleWithColumns(40));
4054   verifyFormat("DEBUG( //\n"
4055                "    { f(); }, a);");
4056   verifyFormat("DEBUG( //\n"
4057                "    {\n"
4058                "      f(); //\n"
4059                "    },\n"
4060                "    a);");
4061 
4062   EXPECT_EQ("call(parameter, {\n"
4063             "  something();\n"
4064             "  // Comment too\n"
4065             "  // looooooooooong.\n"
4066             "  somethingElse();\n"
4067             "});",
4068             format("call(parameter, {\n"
4069                    "  something();\n"
4070                    "  // Comment too looooooooooong.\n"
4071                    "  somethingElse();\n"
4072                    "});",
4073                    getLLVMStyleWithColumns(29)));
4074   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
4075   EXPECT_EQ("DEBUG({ // comment\n"
4076             "  int i;\n"
4077             "});",
4078             format("DEBUG({ // comment\n"
4079                    "int  i;\n"
4080                    "});"));
4081   EXPECT_EQ("DEBUG({\n"
4082             "  int i;\n"
4083             "\n"
4084             "  // comment\n"
4085             "  int j;\n"
4086             "});",
4087             format("DEBUG({\n"
4088                    "  int  i;\n"
4089                    "\n"
4090                    "  // comment\n"
4091                    "  int  j;\n"
4092                    "});"));
4093 
4094   verifyFormat("DEBUG({\n"
4095                "  if (a)\n"
4096                "    return;\n"
4097                "});");
4098   verifyGoogleFormat("DEBUG({\n"
4099                      "  if (a) return;\n"
4100                      "});");
4101   FormatStyle Style = getGoogleStyle();
4102   Style.ColumnLimit = 45;
4103   verifyFormat("Debug(\n"
4104                "    aaaaa,\n"
4105                "    {\n"
4106                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
4107                "    },\n"
4108                "    a);",
4109                Style);
4110 
4111   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
4112 
4113   verifyNoCrash("^{v^{a}}");
4114 }
4115 
4116 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
4117   EXPECT_EQ("#define MACRO()                     \\\n"
4118             "  Debug(aaa, /* force line break */ \\\n"
4119             "        {                           \\\n"
4120             "          int i;                    \\\n"
4121             "          int j;                    \\\n"
4122             "        })",
4123             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
4124                    "          {  int   i;  int  j;   })",
4125                    getGoogleStyle()));
4126 
4127   EXPECT_EQ("#define A                                       \\\n"
4128             "  [] {                                          \\\n"
4129             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
4130             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
4131             "  }",
4132             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4133                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
4134                    getGoogleStyle()));
4135 }
4136 
4137 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
4138   EXPECT_EQ("{}", format("{}"));
4139   verifyFormat("enum E {};");
4140   verifyFormat("enum E {}");
4141   FormatStyle Style = getLLVMStyle();
4142   Style.SpaceInEmptyBlock = true;
4143   EXPECT_EQ("void f() { }", format("void f() {}", Style));
4144   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
4145   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4146 }
4147 
4148 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
4149   FormatStyle Style = getLLVMStyle();
4150   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
4151   Style.MacroBlockEnd = "^[A-Z_]+_END$";
4152   verifyFormat("FOO_BEGIN\n"
4153                "  FOO_ENTRY\n"
4154                "FOO_END",
4155                Style);
4156   verifyFormat("FOO_BEGIN\n"
4157                "  NESTED_FOO_BEGIN\n"
4158                "    NESTED_FOO_ENTRY\n"
4159                "  NESTED_FOO_END\n"
4160                "FOO_END",
4161                Style);
4162   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
4163                "  int x;\n"
4164                "  x = 1;\n"
4165                "FOO_END(Baz)",
4166                Style);
4167 }
4168 
4169 //===----------------------------------------------------------------------===//
4170 // Line break tests.
4171 //===----------------------------------------------------------------------===//
4172 
4173 TEST_F(FormatTest, PreventConfusingIndents) {
4174   verifyFormat(
4175       "void f() {\n"
4176       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
4177       "                         parameter, parameter, parameter)),\n"
4178       "                     SecondLongCall(parameter));\n"
4179       "}");
4180   verifyFormat(
4181       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4182       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4183       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4184       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
4185   verifyFormat(
4186       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4187       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
4188       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4189       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
4190   verifyFormat(
4191       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
4192       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
4193       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
4194       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
4195   verifyFormat("int a = bbbb && ccc &&\n"
4196                "        fffff(\n"
4197                "#define A Just forcing a new line\n"
4198                "            ddd);");
4199 }
4200 
4201 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
4202   verifyFormat(
4203       "bool aaaaaaa =\n"
4204       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
4205       "    bbbbbbbb();");
4206   verifyFormat(
4207       "bool aaaaaaa =\n"
4208       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
4209       "    bbbbbbbb();");
4210 
4211   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4212                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
4213                "    ccccccccc == ddddddddddd;");
4214   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4215                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
4216                "    ccccccccc == ddddddddddd;");
4217   verifyFormat(
4218       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
4219       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
4220       "    ccccccccc == ddddddddddd;");
4221 
4222   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4223                "                 aaaaaa) &&\n"
4224                "         bbbbbb && cccccc;");
4225   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4226                "                 aaaaaa) >>\n"
4227                "         bbbbbb;");
4228   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
4229                "    SourceMgr.getSpellingColumnNumber(\n"
4230                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
4231                "    1);");
4232 
4233   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4234                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
4235                "    cccccc) {\n}");
4236   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4237                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4238                "              cccccc) {\n}");
4239   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4240                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4241                "              cccccc) {\n}");
4242   verifyFormat("b = a &&\n"
4243                "    // Comment\n"
4244                "    b.c && d;");
4245 
4246   // If the LHS of a comparison is not a binary expression itself, the
4247   // additional linebreak confuses many people.
4248   verifyFormat(
4249       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4250       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
4251       "}");
4252   verifyFormat(
4253       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4254       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4255       "}");
4256   verifyFormat(
4257       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
4258       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4259       "}");
4260   verifyFormat(
4261       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4262       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
4263       "}");
4264   // Even explicit parentheses stress the precedence enough to make the
4265   // additional break unnecessary.
4266   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4267                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4268                "}");
4269   // This cases is borderline, but with the indentation it is still readable.
4270   verifyFormat(
4271       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4272       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4273       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4274       "}",
4275       getLLVMStyleWithColumns(75));
4276 
4277   // If the LHS is a binary expression, we should still use the additional break
4278   // as otherwise the formatting hides the operator precedence.
4279   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4280                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4281                "    5) {\n"
4282                "}");
4283   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4284                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4285                "    5) {\n"
4286                "}");
4287 
4288   FormatStyle OnePerLine = getLLVMStyle();
4289   OnePerLine.BinPackParameters = false;
4290   verifyFormat(
4291       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4292       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4293       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4294       OnePerLine);
4295 
4296   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4297                "                .aaa(aaaaaaaaaaaaa) *\n"
4298                "            aaaaaaa +\n"
4299                "        aaaaaaa;",
4300                getLLVMStyleWithColumns(40));
4301 }
4302 
4303 TEST_F(FormatTest, ExpressionIndentation) {
4304   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4305                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4306                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4307                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4308                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4309                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4310                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4311                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4312                "                 ccccccccccccccccccccccccccccccccccccccccc;");
4313   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4314                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4315                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4316                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4317   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4318                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4319                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4320                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4321   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4322                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4323                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4324                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4325   verifyFormat("if () {\n"
4326                "} else if (aaaaa && bbbbb > // break\n"
4327                "                        ccccc) {\n"
4328                "}");
4329   verifyFormat("if () {\n"
4330                "} else if constexpr (aaaaa && bbbbb > // break\n"
4331                "                                  ccccc) {\n"
4332                "}");
4333   verifyFormat("if () {\n"
4334                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4335                "                                  ccccc) {\n"
4336                "}");
4337   verifyFormat("if () {\n"
4338                "} else if (aaaaa &&\n"
4339                "           bbbbb > // break\n"
4340                "               ccccc &&\n"
4341                "           ddddd) {\n"
4342                "}");
4343 
4344   // Presence of a trailing comment used to change indentation of b.
4345   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4346                "       b;\n"
4347                "return aaaaaaaaaaaaaaaaaaa +\n"
4348                "       b; //",
4349                getLLVMStyleWithColumns(30));
4350 }
4351 
4352 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4353   // Not sure what the best system is here. Like this, the LHS can be found
4354   // immediately above an operator (everything with the same or a higher
4355   // indent). The RHS is aligned right of the operator and so compasses
4356   // everything until something with the same indent as the operator is found.
4357   // FIXME: Is this a good system?
4358   FormatStyle Style = getLLVMStyle();
4359   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4360   verifyFormat(
4361       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4362       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4363       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4364       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4365       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4366       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4367       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4368       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4369       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
4370       Style);
4371   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4372                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4373                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4374                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4375                Style);
4376   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4377                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4378                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4379                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4380                Style);
4381   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4382                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4383                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4384                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4385                Style);
4386   verifyFormat("if () {\n"
4387                "} else if (aaaaa\n"
4388                "           && bbbbb // break\n"
4389                "                  > ccccc) {\n"
4390                "}",
4391                Style);
4392   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4393                "       && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4394                Style);
4395   verifyFormat("return (a)\n"
4396                "       // comment\n"
4397                "       + b;",
4398                Style);
4399   verifyFormat(
4400       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4401       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4402       "             + cc;",
4403       Style);
4404 
4405   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4406                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4407                Style);
4408 
4409   // Forced by comments.
4410   verifyFormat(
4411       "unsigned ContentSize =\n"
4412       "    sizeof(int16_t)   // DWARF ARange version number\n"
4413       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4414       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4415       "    + sizeof(int8_t); // Segment Size (in bytes)");
4416 
4417   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4418                "       == boost::fusion::at_c<1>(iiii).second;",
4419                Style);
4420 
4421   Style.ColumnLimit = 60;
4422   verifyFormat("zzzzzzzzzz\n"
4423                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4424                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4425                Style);
4426 
4427   Style.ColumnLimit = 80;
4428   Style.IndentWidth = 4;
4429   Style.TabWidth = 4;
4430   Style.UseTab = FormatStyle::UT_Always;
4431   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4432   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4433   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4434             "\t&& (someOtherLongishConditionPart1\n"
4435             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4436             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4437                    "(someOtherLongishConditionPart1 || "
4438                    "someOtherEvenLongerNestedConditionPart2);",
4439                    Style));
4440 }
4441 
4442 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
4443   FormatStyle Style = getLLVMStyle();
4444   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4445   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
4446 
4447   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4448                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4449                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4450                "              == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4451                "                         * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4452                "                     + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4453                "          && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4454                "                     * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4455                "                 > ccccccccccccccccccccccccccccccccccccccccc;",
4456                Style);
4457   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4458                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4459                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4460                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4461                Style);
4462   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4463                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4464                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4465                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4466                Style);
4467   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4468                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4469                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4470                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4471                Style);
4472   verifyFormat("if () {\n"
4473                "} else if (aaaaa\n"
4474                "           && bbbbb // break\n"
4475                "                  > ccccc) {\n"
4476                "}",
4477                Style);
4478   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4479                "    && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4480                Style);
4481   verifyFormat("return (a)\n"
4482                "     // comment\n"
4483                "     + b;",
4484                Style);
4485   verifyFormat(
4486       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4487       "               * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4488       "           + cc;",
4489       Style);
4490   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
4491                "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4492                "                        : 3333333333333333;",
4493                Style);
4494   verifyFormat(
4495       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
4496       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
4497       "                                             : eeeeeeeeeeeeeeeeee)\n"
4498       "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4499       "                        : 3333333333333333;",
4500       Style);
4501   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4502                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4503                Style);
4504 
4505   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4506                "    == boost::fusion::at_c<1>(iiii).second;",
4507                Style);
4508 
4509   Style.ColumnLimit = 60;
4510   verifyFormat("zzzzzzzzzzzzz\n"
4511                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4512                "   >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4513                Style);
4514 
4515   // Forced by comments.
4516   Style.ColumnLimit = 80;
4517   verifyFormat(
4518       "unsigned ContentSize\n"
4519       "    = sizeof(int16_t) // DWARF ARange version number\n"
4520       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4521       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4522       "    + sizeof(int8_t); // Segment Size (in bytes)",
4523       Style);
4524 
4525   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4526   verifyFormat(
4527       "unsigned ContentSize =\n"
4528       "    sizeof(int16_t)   // DWARF ARange version number\n"
4529       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4530       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4531       "    + sizeof(int8_t); // Segment Size (in bytes)",
4532       Style);
4533 
4534   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4535   verifyFormat(
4536       "unsigned ContentSize =\n"
4537       "    sizeof(int16_t)   // DWARF ARange version number\n"
4538       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4539       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4540       "    + sizeof(int8_t); // Segment Size (in bytes)",
4541       Style);
4542 }
4543 
4544 TEST_F(FormatTest, EnforcedOperatorWraps) {
4545   // Here we'd like to wrap after the || operators, but a comment is forcing an
4546   // earlier wrap.
4547   verifyFormat("bool x = aaaaa //\n"
4548                "         || bbbbb\n"
4549                "         //\n"
4550                "         || cccc;");
4551 }
4552 
4553 TEST_F(FormatTest, NoOperandAlignment) {
4554   FormatStyle Style = getLLVMStyle();
4555   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4556   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4557                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4558                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4559                Style);
4560   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4561   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4562                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4563                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4564                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4565                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4566                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4567                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4568                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4569                "        > ccccccccccccccccccccccccccccccccccccccccc;",
4570                Style);
4571 
4572   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4573                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4574                "    + cc;",
4575                Style);
4576   verifyFormat("int a = aa\n"
4577                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4578                "        * cccccccccccccccccccccccccccccccccccc;\n",
4579                Style);
4580 
4581   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4582   verifyFormat("return (a > b\n"
4583                "    // comment1\n"
4584                "    // comment2\n"
4585                "    || c);",
4586                Style);
4587 }
4588 
4589 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4590   FormatStyle Style = getLLVMStyle();
4591   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4592   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4593                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4594                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4595                Style);
4596 }
4597 
4598 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4599   FormatStyle Style = getLLVMStyle();
4600   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4601   Style.BinPackArguments = false;
4602   Style.ColumnLimit = 40;
4603   verifyFormat("void test() {\n"
4604                "  someFunction(\n"
4605                "      this + argument + is + quite\n"
4606                "      + long + so + it + gets + wrapped\n"
4607                "      + but + remains + bin - packed);\n"
4608                "}",
4609                Style);
4610   verifyFormat("void test() {\n"
4611                "  someFunction(arg1,\n"
4612                "               this + argument + is\n"
4613                "                   + quite + long + so\n"
4614                "                   + it + gets + wrapped\n"
4615                "                   + but + remains + bin\n"
4616                "                   - packed,\n"
4617                "               arg3);\n"
4618                "}",
4619                Style);
4620   verifyFormat("void test() {\n"
4621                "  someFunction(\n"
4622                "      arg1,\n"
4623                "      this + argument + has\n"
4624                "          + anotherFunc(nested,\n"
4625                "                        calls + whose\n"
4626                "                            + arguments\n"
4627                "                            + are + also\n"
4628                "                            + wrapped,\n"
4629                "                        in + addition)\n"
4630                "          + to + being + bin - packed,\n"
4631                "      arg3);\n"
4632                "}",
4633                Style);
4634 
4635   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4636   verifyFormat("void test() {\n"
4637                "  someFunction(\n"
4638                "      arg1,\n"
4639                "      this + argument + has +\n"
4640                "          anotherFunc(nested,\n"
4641                "                      calls + whose +\n"
4642                "                          arguments +\n"
4643                "                          are + also +\n"
4644                "                          wrapped,\n"
4645                "                      in + addition) +\n"
4646                "          to + being + bin - packed,\n"
4647                "      arg3);\n"
4648                "}",
4649                Style);
4650 }
4651 
4652 TEST_F(FormatTest, ConstructorInitializers) {
4653   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4654   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4655                getLLVMStyleWithColumns(45));
4656   verifyFormat("Constructor()\n"
4657                "    : Inttializer(FitsOnTheLine) {}",
4658                getLLVMStyleWithColumns(44));
4659   verifyFormat("Constructor()\n"
4660                "    : Inttializer(FitsOnTheLine) {}",
4661                getLLVMStyleWithColumns(43));
4662 
4663   verifyFormat("template <typename T>\n"
4664                "Constructor() : Initializer(FitsOnTheLine) {}",
4665                getLLVMStyleWithColumns(45));
4666 
4667   verifyFormat(
4668       "SomeClass::Constructor()\n"
4669       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4670 
4671   verifyFormat(
4672       "SomeClass::Constructor()\n"
4673       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4674       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4675   verifyFormat(
4676       "SomeClass::Constructor()\n"
4677       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4678       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4679   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4680                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4681                "    : aaaaaaaaaa(aaaaaa) {}");
4682 
4683   verifyFormat("Constructor()\n"
4684                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4685                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4686                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4687                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
4688 
4689   verifyFormat("Constructor()\n"
4690                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4691                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4692 
4693   verifyFormat("Constructor(int Parameter = 0)\n"
4694                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4695                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4696   verifyFormat("Constructor()\n"
4697                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4698                "}",
4699                getLLVMStyleWithColumns(60));
4700   verifyFormat("Constructor()\n"
4701                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4702                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4703 
4704   // Here a line could be saved by splitting the second initializer onto two
4705   // lines, but that is not desirable.
4706   verifyFormat("Constructor()\n"
4707                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4708                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
4709                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4710 
4711   FormatStyle OnePerLine = getLLVMStyle();
4712   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4713   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4714   verifyFormat("SomeClass::Constructor()\n"
4715                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4716                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4717                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4718                OnePerLine);
4719   verifyFormat("SomeClass::Constructor()\n"
4720                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4721                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4722                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4723                OnePerLine);
4724   verifyFormat("MyClass::MyClass(int var)\n"
4725                "    : some_var_(var),            // 4 space indent\n"
4726                "      some_other_var_(var + 1) { // lined up\n"
4727                "}",
4728                OnePerLine);
4729   verifyFormat("Constructor()\n"
4730                "    : aaaaa(aaaaaa),\n"
4731                "      aaaaa(aaaaaa),\n"
4732                "      aaaaa(aaaaaa),\n"
4733                "      aaaaa(aaaaaa),\n"
4734                "      aaaaa(aaaaaa) {}",
4735                OnePerLine);
4736   verifyFormat("Constructor()\n"
4737                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4738                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
4739                OnePerLine);
4740   OnePerLine.BinPackParameters = false;
4741   verifyFormat(
4742       "Constructor()\n"
4743       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4744       "          aaaaaaaaaaa().aaa(),\n"
4745       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4746       OnePerLine);
4747   OnePerLine.ColumnLimit = 60;
4748   verifyFormat("Constructor()\n"
4749                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4750                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4751                OnePerLine);
4752 
4753   EXPECT_EQ("Constructor()\n"
4754             "    : // Comment forcing unwanted break.\n"
4755             "      aaaa(aaaa) {}",
4756             format("Constructor() :\n"
4757                    "    // Comment forcing unwanted break.\n"
4758                    "    aaaa(aaaa) {}"));
4759 }
4760 
4761 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4762   FormatStyle Style = getLLVMStyle();
4763   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4764   Style.ColumnLimit = 60;
4765   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4766   Style.AllowAllConstructorInitializersOnNextLine = true;
4767   Style.BinPackParameters = false;
4768 
4769   for (int i = 0; i < 4; ++i) {
4770     // Test all combinations of parameters that should not have an effect.
4771     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4772     Style.AllowAllArgumentsOnNextLine = i & 2;
4773 
4774     Style.AllowAllConstructorInitializersOnNextLine = true;
4775     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4776     verifyFormat("Constructor()\n"
4777                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4778                  Style);
4779     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4780 
4781     Style.AllowAllConstructorInitializersOnNextLine = false;
4782     verifyFormat("Constructor()\n"
4783                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4784                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4785                  Style);
4786     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4787 
4788     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4789     Style.AllowAllConstructorInitializersOnNextLine = true;
4790     verifyFormat("Constructor()\n"
4791                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4792                  Style);
4793 
4794     Style.AllowAllConstructorInitializersOnNextLine = false;
4795     verifyFormat("Constructor()\n"
4796                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4797                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4798                  Style);
4799 
4800     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4801     Style.AllowAllConstructorInitializersOnNextLine = true;
4802     verifyFormat("Constructor() :\n"
4803                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4804                  Style);
4805 
4806     Style.AllowAllConstructorInitializersOnNextLine = false;
4807     verifyFormat("Constructor() :\n"
4808                  "    aaaaaaaaaaaaaaaaaa(a),\n"
4809                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4810                  Style);
4811   }
4812 
4813   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4814   // AllowAllConstructorInitializersOnNextLine in all
4815   // BreakConstructorInitializers modes
4816   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4817   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4818   Style.AllowAllConstructorInitializersOnNextLine = false;
4819   verifyFormat("SomeClassWithALongName::Constructor(\n"
4820                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4821                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4822                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4823                Style);
4824 
4825   Style.AllowAllConstructorInitializersOnNextLine = true;
4826   verifyFormat("SomeClassWithALongName::Constructor(\n"
4827                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4828                "    int bbbbbbbbbbbbb,\n"
4829                "    int cccccccccccccccc)\n"
4830                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4831                Style);
4832 
4833   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4834   Style.AllowAllConstructorInitializersOnNextLine = false;
4835   verifyFormat("SomeClassWithALongName::Constructor(\n"
4836                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4837                "    int bbbbbbbbbbbbb)\n"
4838                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4839                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4840                Style);
4841 
4842   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4843 
4844   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4845   verifyFormat("SomeClassWithALongName::Constructor(\n"
4846                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4847                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4848                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4849                Style);
4850 
4851   Style.AllowAllConstructorInitializersOnNextLine = true;
4852   verifyFormat("SomeClassWithALongName::Constructor(\n"
4853                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4854                "    int bbbbbbbbbbbbb,\n"
4855                "    int cccccccccccccccc)\n"
4856                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4857                Style);
4858 
4859   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4860   Style.AllowAllConstructorInitializersOnNextLine = false;
4861   verifyFormat("SomeClassWithALongName::Constructor(\n"
4862                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4863                "    int bbbbbbbbbbbbb)\n"
4864                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4865                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4866                Style);
4867 
4868   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4869   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4870   verifyFormat("SomeClassWithALongName::Constructor(\n"
4871                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4872                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4873                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4874                Style);
4875 
4876   Style.AllowAllConstructorInitializersOnNextLine = true;
4877   verifyFormat("SomeClassWithALongName::Constructor(\n"
4878                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4879                "    int bbbbbbbbbbbbb,\n"
4880                "    int cccccccccccccccc) :\n"
4881                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4882                Style);
4883 
4884   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4885   Style.AllowAllConstructorInitializersOnNextLine = false;
4886   verifyFormat("SomeClassWithALongName::Constructor(\n"
4887                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4888                "    int bbbbbbbbbbbbb) :\n"
4889                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4890                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4891                Style);
4892 }
4893 
4894 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4895   FormatStyle Style = getLLVMStyle();
4896   Style.ColumnLimit = 60;
4897   Style.BinPackArguments = false;
4898   for (int i = 0; i < 4; ++i) {
4899     // Test all combinations of parameters that should not have an effect.
4900     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4901     Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4902 
4903     Style.AllowAllArgumentsOnNextLine = true;
4904     verifyFormat("void foo() {\n"
4905                  "  FunctionCallWithReallyLongName(\n"
4906                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4907                  "}",
4908                  Style);
4909     Style.AllowAllArgumentsOnNextLine = false;
4910     verifyFormat("void foo() {\n"
4911                  "  FunctionCallWithReallyLongName(\n"
4912                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4913                  "      bbbbbbbbbbbb);\n"
4914                  "}",
4915                  Style);
4916 
4917     Style.AllowAllArgumentsOnNextLine = true;
4918     verifyFormat("void foo() {\n"
4919                  "  auto VariableWithReallyLongName = {\n"
4920                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4921                  "}",
4922                  Style);
4923     Style.AllowAllArgumentsOnNextLine = false;
4924     verifyFormat("void foo() {\n"
4925                  "  auto VariableWithReallyLongName = {\n"
4926                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4927                  "      bbbbbbbbbbbb};\n"
4928                  "}",
4929                  Style);
4930   }
4931 
4932   // This parameter should not affect declarations.
4933   Style.BinPackParameters = false;
4934   Style.AllowAllArgumentsOnNextLine = false;
4935   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4936   verifyFormat("void FunctionCallWithReallyLongName(\n"
4937                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
4938                Style);
4939   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4940   verifyFormat("void FunctionCallWithReallyLongName(\n"
4941                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
4942                "    int bbbbbbbbbbbb);",
4943                Style);
4944 }
4945 
4946 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
4947   FormatStyle Style = getLLVMStyle();
4948   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4949 
4950   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4951   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
4952                getStyleWithColumns(Style, 45));
4953   verifyFormat("Constructor() :\n"
4954                "    Initializer(FitsOnTheLine) {}",
4955                getStyleWithColumns(Style, 44));
4956   verifyFormat("Constructor() :\n"
4957                "    Initializer(FitsOnTheLine) {}",
4958                getStyleWithColumns(Style, 43));
4959 
4960   verifyFormat("template <typename T>\n"
4961                "Constructor() : Initializer(FitsOnTheLine) {}",
4962                getStyleWithColumns(Style, 50));
4963   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4964   verifyFormat(
4965       "SomeClass::Constructor() :\n"
4966       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4967       Style);
4968 
4969   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
4970   verifyFormat(
4971       "SomeClass::Constructor() :\n"
4972       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4973       Style);
4974 
4975   verifyFormat(
4976       "SomeClass::Constructor() :\n"
4977       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4978       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4979       Style);
4980   verifyFormat(
4981       "SomeClass::Constructor() :\n"
4982       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4983       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4984       Style);
4985   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4986                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4987                "    aaaaaaaaaa(aaaaaa) {}",
4988                Style);
4989 
4990   verifyFormat("Constructor() :\n"
4991                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4992                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4993                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4994                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
4995                Style);
4996 
4997   verifyFormat("Constructor() :\n"
4998                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4999                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5000                Style);
5001 
5002   verifyFormat("Constructor(int Parameter = 0) :\n"
5003                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
5004                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
5005                Style);
5006   verifyFormat("Constructor() :\n"
5007                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
5008                "}",
5009                getStyleWithColumns(Style, 60));
5010   verifyFormat("Constructor() :\n"
5011                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5012                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
5013                Style);
5014 
5015   // Here a line could be saved by splitting the second initializer onto two
5016   // lines, but that is not desirable.
5017   verifyFormat("Constructor() :\n"
5018                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
5019                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
5020                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5021                Style);
5022 
5023   FormatStyle OnePerLine = Style;
5024   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5025   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
5026   verifyFormat("SomeClass::Constructor() :\n"
5027                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5028                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5029                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5030                OnePerLine);
5031   verifyFormat("SomeClass::Constructor() :\n"
5032                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
5033                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5034                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5035                OnePerLine);
5036   verifyFormat("MyClass::MyClass(int var) :\n"
5037                "    some_var_(var),            // 4 space indent\n"
5038                "    some_other_var_(var + 1) { // lined up\n"
5039                "}",
5040                OnePerLine);
5041   verifyFormat("Constructor() :\n"
5042                "    aaaaa(aaaaaa),\n"
5043                "    aaaaa(aaaaaa),\n"
5044                "    aaaaa(aaaaaa),\n"
5045                "    aaaaa(aaaaaa),\n"
5046                "    aaaaa(aaaaaa) {}",
5047                OnePerLine);
5048   verifyFormat("Constructor() :\n"
5049                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5050                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
5051                OnePerLine);
5052   OnePerLine.BinPackParameters = false;
5053   verifyFormat("Constructor() :\n"
5054                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5055                "        aaaaaaaaaaa().aaa(),\n"
5056                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5057                OnePerLine);
5058   OnePerLine.ColumnLimit = 60;
5059   verifyFormat("Constructor() :\n"
5060                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
5061                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
5062                OnePerLine);
5063 
5064   EXPECT_EQ("Constructor() :\n"
5065             "    // Comment forcing unwanted break.\n"
5066             "    aaaa(aaaa) {}",
5067             format("Constructor() :\n"
5068                    "    // Comment forcing unwanted break.\n"
5069                    "    aaaa(aaaa) {}",
5070                    Style));
5071 
5072   Style.ColumnLimit = 0;
5073   verifyFormat("SomeClass::Constructor() :\n"
5074                "    a(a) {}",
5075                Style);
5076   verifyFormat("SomeClass::Constructor() noexcept :\n"
5077                "    a(a) {}",
5078                Style);
5079   verifyFormat("SomeClass::Constructor() :\n"
5080                "    a(a), b(b), c(c) {}",
5081                Style);
5082   verifyFormat("SomeClass::Constructor() :\n"
5083                "    a(a) {\n"
5084                "  foo();\n"
5085                "  bar();\n"
5086                "}",
5087                Style);
5088 
5089   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5090   verifyFormat("SomeClass::Constructor() :\n"
5091                "    a(a), b(b), c(c) {\n"
5092                "}",
5093                Style);
5094   verifyFormat("SomeClass::Constructor() :\n"
5095                "    a(a) {\n"
5096                "}",
5097                Style);
5098 
5099   Style.ColumnLimit = 80;
5100   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5101   Style.ConstructorInitializerIndentWidth = 2;
5102   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5103   verifyFormat("SomeClass::Constructor() :\n"
5104                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5105                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5106                Style);
5107 
5108   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5109   // well
5110   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5111   verifyFormat(
5112       "class SomeClass\n"
5113       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5114       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5115       Style);
5116   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5117   verifyFormat(
5118       "class SomeClass\n"
5119       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5120       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5121       Style);
5122   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5123   verifyFormat(
5124       "class SomeClass :\n"
5125       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5126       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5127       Style);
5128 }
5129 
5130 #ifndef EXPENSIVE_CHECKS
5131 // Expensive checks enables libstdc++ checking which includes validating the
5132 // state of ranges used in std::priority_queue - this blows out the
5133 // runtime/scalability of the function and makes this test unacceptably slow.
5134 TEST_F(FormatTest, MemoizationTests) {
5135   // This breaks if the memoization lookup does not take \c Indent and
5136   // \c LastSpace into account.
5137   verifyFormat(
5138       "extern CFRunLoopTimerRef\n"
5139       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5140       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
5141       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
5142       "                     CFRunLoopTimerContext *context) {}");
5143 
5144   // Deep nesting somewhat works around our memoization.
5145   verifyFormat(
5146       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5147       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5148       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5149       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5150       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
5151       getLLVMStyleWithColumns(65));
5152   verifyFormat(
5153       "aaaaa(\n"
5154       "    aaaaa,\n"
5155       "    aaaaa(\n"
5156       "        aaaaa,\n"
5157       "        aaaaa(\n"
5158       "            aaaaa,\n"
5159       "            aaaaa(\n"
5160       "                aaaaa,\n"
5161       "                aaaaa(\n"
5162       "                    aaaaa,\n"
5163       "                    aaaaa(\n"
5164       "                        aaaaa,\n"
5165       "                        aaaaa(\n"
5166       "                            aaaaa,\n"
5167       "                            aaaaa(\n"
5168       "                                aaaaa,\n"
5169       "                                aaaaa(\n"
5170       "                                    aaaaa,\n"
5171       "                                    aaaaa(\n"
5172       "                                        aaaaa,\n"
5173       "                                        aaaaa(\n"
5174       "                                            aaaaa,\n"
5175       "                                            aaaaa(\n"
5176       "                                                aaaaa,\n"
5177       "                                                aaaaa))))))))))));",
5178       getLLVMStyleWithColumns(65));
5179   verifyFormat(
5180       "a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(a(), a), a), a), a),\n"
5181       "                                  a),\n"
5182       "                                a),\n"
5183       "                              a),\n"
5184       "                            a),\n"
5185       "                          a),\n"
5186       "                        a),\n"
5187       "                      a),\n"
5188       "                    a),\n"
5189       "                  a),\n"
5190       "                a),\n"
5191       "              a),\n"
5192       "            a),\n"
5193       "          a),\n"
5194       "        a),\n"
5195       "      a),\n"
5196       "    a),\n"
5197       "  a)",
5198       getLLVMStyleWithColumns(65));
5199 
5200   // This test takes VERY long when memoization is broken.
5201   FormatStyle OnePerLine = getLLVMStyle();
5202   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5203   OnePerLine.BinPackParameters = false;
5204   std::string input = "Constructor()\n"
5205                       "    : aaaa(a,\n";
5206   for (unsigned i = 0, e = 80; i != e; ++i) {
5207     input += "           a,\n";
5208   }
5209   input += "           a) {}";
5210   verifyFormat(input, OnePerLine);
5211 }
5212 #endif
5213 
5214 TEST_F(FormatTest, BreaksAsHighAsPossible) {
5215   verifyFormat(
5216       "void f() {\n"
5217       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5218       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5219       "    f();\n"
5220       "}");
5221   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5222                "    Intervals[i - 1].getRange().getLast()) {\n}");
5223 }
5224 
5225 TEST_F(FormatTest, BreaksFunctionDeclarations) {
5226   // Principially, we break function declarations in a certain order:
5227   // 1) break amongst arguments.
5228   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5229                "                              Cccccccccccccc cccccccccccccc);");
5230   verifyFormat("template <class TemplateIt>\n"
5231                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5232                "                            TemplateIt *stop) {}");
5233 
5234   // 2) break after return type.
5235   verifyFormat(
5236       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5237       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5238       getGoogleStyle());
5239 
5240   // 3) break after (.
5241   verifyFormat(
5242       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5243       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5244       getGoogleStyle());
5245 
5246   // 4) break before after nested name specifiers.
5247   verifyFormat(
5248       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5249       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5250       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5251       getGoogleStyle());
5252 
5253   // However, there are exceptions, if a sufficient amount of lines can be
5254   // saved.
5255   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5256   // more adjusting.
5257   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5258                "                                  Cccccccccccccc cccccccccc,\n"
5259                "                                  Cccccccccccccc cccccccccc,\n"
5260                "                                  Cccccccccccccc cccccccccc,\n"
5261                "                                  Cccccccccccccc cccccccccc);");
5262   verifyFormat(
5263       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5264       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5265       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5266       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5267       getGoogleStyle());
5268   verifyFormat(
5269       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5270       "                                          Cccccccccccccc cccccccccc,\n"
5271       "                                          Cccccccccccccc cccccccccc,\n"
5272       "                                          Cccccccccccccc cccccccccc,\n"
5273       "                                          Cccccccccccccc cccccccccc,\n"
5274       "                                          Cccccccccccccc cccccccccc,\n"
5275       "                                          Cccccccccccccc cccccccccc);");
5276   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5277                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5278                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5279                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5280                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5281 
5282   // Break after multi-line parameters.
5283   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5284                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5285                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5286                "    bbbb bbbb);");
5287   verifyFormat("void SomeLoooooooooooongFunction(\n"
5288                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5289                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5290                "    int bbbbbbbbbbbbb);");
5291 
5292   // Treat overloaded operators like other functions.
5293   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5294                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5295   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5296                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5297   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5298                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5299   verifyGoogleFormat(
5300       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5301       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5302   verifyGoogleFormat(
5303       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5304       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5305   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5306                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5307   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5308                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5309   verifyGoogleFormat(
5310       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5311       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5312       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5313   verifyGoogleFormat("template <typename T>\n"
5314                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5315                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5316                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5317 
5318   FormatStyle Style = getLLVMStyle();
5319   Style.PointerAlignment = FormatStyle::PAS_Left;
5320   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5321                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5322                Style);
5323   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5324                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5325                Style);
5326 }
5327 
5328 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5329   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5330   // Prefer keeping `::` followed by `operator` together.
5331   EXPECT_EQ("const aaaa::bbbbbbb &\n"
5332             "ccccccccc::operator++() {\n"
5333             "  stuff();\n"
5334             "}",
5335             format("const aaaa::bbbbbbb\n"
5336                    "&ccccccccc::operator++() { stuff(); }",
5337                    getLLVMStyleWithColumns(40)));
5338 }
5339 
5340 TEST_F(FormatTest, TrailingReturnType) {
5341   verifyFormat("auto foo() -> int;\n");
5342   // correct trailing return type spacing
5343   verifyFormat("auto operator->() -> int;\n");
5344   verifyFormat("auto operator++(int) -> int;\n");
5345 
5346   verifyFormat("struct S {\n"
5347                "  auto bar() const -> int;\n"
5348                "};");
5349   verifyFormat("template <size_t Order, typename T>\n"
5350                "auto load_img(const std::string &filename)\n"
5351                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
5352   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5353                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5354   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5355   verifyFormat("template <typename T>\n"
5356                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5357                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5358 
5359   // Not trailing return types.
5360   verifyFormat("void f() { auto a = b->c(); }");
5361 }
5362 
5363 TEST_F(FormatTest, DeductionGuides) {
5364   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5365   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5366   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5367   verifyFormat(
5368       "template <class... T>\n"
5369       "array(T &&...t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5370   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5371   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5372   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5373   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5374   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5375   verifyFormat("template <class T> x() -> x<1>;");
5376   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5377 
5378   // Ensure not deduction guides.
5379   verifyFormat("c()->f<int>();");
5380   verifyFormat("x()->foo<1>;");
5381   verifyFormat("x = p->foo<3>();");
5382   verifyFormat("x()->x<1>();");
5383   verifyFormat("x()->x<1>;");
5384 }
5385 
5386 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5387   // Avoid breaking before trailing 'const' or other trailing annotations, if
5388   // they are not function-like.
5389   FormatStyle Style = getGoogleStyle();
5390   Style.ColumnLimit = 47;
5391   verifyFormat("void someLongFunction(\n"
5392                "    int someLoooooooooooooongParameter) const {\n}",
5393                getLLVMStyleWithColumns(47));
5394   verifyFormat("LoooooongReturnType\n"
5395                "someLoooooooongFunction() const {}",
5396                getLLVMStyleWithColumns(47));
5397   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5398                "    const {}",
5399                Style);
5400   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5401                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5402   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5403                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5404   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5405                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5406   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5407                "                   aaaaaaaaaaa aaaaa) const override;");
5408   verifyGoogleFormat(
5409       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5410       "    const override;");
5411 
5412   // Even if the first parameter has to be wrapped.
5413   verifyFormat("void someLongFunction(\n"
5414                "    int someLongParameter) const {}",
5415                getLLVMStyleWithColumns(46));
5416   verifyFormat("void someLongFunction(\n"
5417                "    int someLongParameter) const {}",
5418                Style);
5419   verifyFormat("void someLongFunction(\n"
5420                "    int someLongParameter) override {}",
5421                Style);
5422   verifyFormat("void someLongFunction(\n"
5423                "    int someLongParameter) OVERRIDE {}",
5424                Style);
5425   verifyFormat("void someLongFunction(\n"
5426                "    int someLongParameter) final {}",
5427                Style);
5428   verifyFormat("void someLongFunction(\n"
5429                "    int someLongParameter) FINAL {}",
5430                Style);
5431   verifyFormat("void someLongFunction(\n"
5432                "    int parameter) const override {}",
5433                Style);
5434 
5435   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5436   verifyFormat("void someLongFunction(\n"
5437                "    int someLongParameter) const\n"
5438                "{\n"
5439                "}",
5440                Style);
5441 
5442   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5443   verifyFormat("void someLongFunction(\n"
5444                "    int someLongParameter) const\n"
5445                "  {\n"
5446                "  }",
5447                Style);
5448 
5449   // Unless these are unknown annotations.
5450   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5451                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5452                "    LONG_AND_UGLY_ANNOTATION;");
5453 
5454   // Breaking before function-like trailing annotations is fine to keep them
5455   // close to their arguments.
5456   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5457                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5458   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5459                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5460   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5461                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5462   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5463                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5464   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5465 
5466   verifyFormat(
5467       "void aaaaaaaaaaaaaaaaaa()\n"
5468       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5469       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5470   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5471                "    __attribute__((unused));");
5472   verifyGoogleFormat(
5473       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5474       "    GUARDED_BY(aaaaaaaaaaaa);");
5475   verifyGoogleFormat(
5476       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5477       "    GUARDED_BY(aaaaaaaaaaaa);");
5478   verifyGoogleFormat(
5479       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5480       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5481   verifyGoogleFormat(
5482       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5483       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5484 }
5485 
5486 TEST_F(FormatTest, FunctionAnnotations) {
5487   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5488                "int OldFunction(const string &parameter) {}");
5489   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5490                "string OldFunction(const string &parameter) {}");
5491   verifyFormat("template <typename T>\n"
5492                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5493                "string OldFunction(const string &parameter) {}");
5494 
5495   // Not function annotations.
5496   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5497                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5498   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5499                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5500   verifyFormat("MACRO(abc).function() // wrap\n"
5501                "    << abc;");
5502   verifyFormat("MACRO(abc)->function() // wrap\n"
5503                "    << abc;");
5504   verifyFormat("MACRO(abc)::function() // wrap\n"
5505                "    << abc;");
5506 }
5507 
5508 TEST_F(FormatTest, BreaksDesireably) {
5509   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5510                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5511                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5512   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5513                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5514                "}");
5515 
5516   verifyFormat(
5517       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5518       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5519 
5520   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5521                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5522                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5523 
5524   verifyFormat(
5525       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5526       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5527       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5528       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5529       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5530 
5531   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5532                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5533 
5534   verifyFormat(
5535       "void f() {\n"
5536       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5537       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5538       "}");
5539   verifyFormat(
5540       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5541       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5542   verifyFormat(
5543       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5544       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5545   verifyFormat(
5546       "aaaaaa(aaa,\n"
5547       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5548       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5549       "       aaaa);");
5550   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5551                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5552                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5553 
5554   // Indent consistently independent of call expression and unary operator.
5555   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5556                "    dddddddddddddddddddddddddddddd));");
5557   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5558                "    dddddddddddddddddddddddddddddd));");
5559   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5560                "    dddddddddddddddddddddddddddddd));");
5561 
5562   // This test case breaks on an incorrect memoization, i.e. an optimization not
5563   // taking into account the StopAt value.
5564   verifyFormat(
5565       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5566       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5567       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5568       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5569 
5570   verifyFormat("{\n  {\n    {\n"
5571                "      Annotation.SpaceRequiredBefore =\n"
5572                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5573                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5574                "    }\n  }\n}");
5575 
5576   // Break on an outer level if there was a break on an inner level.
5577   EXPECT_EQ("f(g(h(a, // comment\n"
5578             "      b, c),\n"
5579             "    d, e),\n"
5580             "  x, y);",
5581             format("f(g(h(a, // comment\n"
5582                    "    b, c), d, e), x, y);"));
5583 
5584   // Prefer breaking similar line breaks.
5585   verifyFormat(
5586       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5587       "                             NSTrackingMouseEnteredAndExited |\n"
5588       "                             NSTrackingActiveAlways;");
5589 }
5590 
5591 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5592   FormatStyle NoBinPacking = getGoogleStyle();
5593   NoBinPacking.BinPackParameters = false;
5594   NoBinPacking.BinPackArguments = true;
5595   verifyFormat("void f() {\n"
5596                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5597                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5598                "}",
5599                NoBinPacking);
5600   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5601                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5602                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5603                NoBinPacking);
5604 
5605   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5606   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5607                "                        vector<int> bbbbbbbbbbbbbbb);",
5608                NoBinPacking);
5609   // FIXME: This behavior difference is probably not wanted. However, currently
5610   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5611   // template arguments from BreakBeforeParameter being set because of the
5612   // one-per-line formatting.
5613   verifyFormat(
5614       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5615       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5616       NoBinPacking);
5617   verifyFormat(
5618       "void fffffffffff(\n"
5619       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5620       "        aaaaaaaaaa);");
5621 }
5622 
5623 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5624   FormatStyle NoBinPacking = getGoogleStyle();
5625   NoBinPacking.BinPackParameters = false;
5626   NoBinPacking.BinPackArguments = false;
5627   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5628                "  aaaaaaaaaaaaaaaaaaaa,\n"
5629                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5630                NoBinPacking);
5631   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5632                "        aaaaaaaaaaaaa,\n"
5633                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5634                NoBinPacking);
5635   verifyFormat(
5636       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5637       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5638       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5639       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5640       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5641       NoBinPacking);
5642   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5643                "    .aaaaaaaaaaaaaaaaaa();",
5644                NoBinPacking);
5645   verifyFormat("void f() {\n"
5646                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5647                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5648                "}",
5649                NoBinPacking);
5650 
5651   verifyFormat(
5652       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5653       "             aaaaaaaaaaaa,\n"
5654       "             aaaaaaaaaaaa);",
5655       NoBinPacking);
5656   verifyFormat(
5657       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5658       "                               ddddddddddddddddddddddddddddd),\n"
5659       "             test);",
5660       NoBinPacking);
5661 
5662   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5663                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5664                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5665                "    aaaaaaaaaaaaaaaaaa;",
5666                NoBinPacking);
5667   verifyFormat("a(\"a\"\n"
5668                "  \"a\",\n"
5669                "  a);");
5670 
5671   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5672   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5673                "                aaaaaaaaa,\n"
5674                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5675                NoBinPacking);
5676   verifyFormat(
5677       "void f() {\n"
5678       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5679       "      .aaaaaaa();\n"
5680       "}",
5681       NoBinPacking);
5682   verifyFormat(
5683       "template <class SomeType, class SomeOtherType>\n"
5684       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5685       NoBinPacking);
5686 }
5687 
5688 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5689   FormatStyle Style = getLLVMStyleWithColumns(15);
5690   Style.ExperimentalAutoDetectBinPacking = true;
5691   EXPECT_EQ("aaa(aaaa,\n"
5692             "    aaaa,\n"
5693             "    aaaa);\n"
5694             "aaa(aaaa,\n"
5695             "    aaaa,\n"
5696             "    aaaa);",
5697             format("aaa(aaaa,\n" // one-per-line
5698                    "  aaaa,\n"
5699                    "    aaaa  );\n"
5700                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5701                    Style));
5702   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5703             "    aaaa);\n"
5704             "aaa(aaaa, aaaa,\n"
5705             "    aaaa);",
5706             format("aaa(aaaa,  aaaa,\n" // bin-packed
5707                    "    aaaa  );\n"
5708                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5709                    Style));
5710 }
5711 
5712 TEST_F(FormatTest, FormatsBuilderPattern) {
5713   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5714                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5715                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5716                "    .StartsWith(\".init\", ORDER_INIT)\n"
5717                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5718                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5719                "    .Default(ORDER_TEXT);\n");
5720 
5721   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5722                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5723   verifyFormat("aaaaaaa->aaaaaaa\n"
5724                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5725                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5726                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5727   verifyFormat(
5728       "aaaaaaa->aaaaaaa\n"
5729       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5730       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5731   verifyFormat(
5732       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5733       "    aaaaaaaaaaaaaa);");
5734   verifyFormat(
5735       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5736       "    aaaaaa->aaaaaaaaaaaa()\n"
5737       "        ->aaaaaaaaaaaaaaaa(\n"
5738       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5739       "        ->aaaaaaaaaaaaaaaaa();");
5740   verifyGoogleFormat(
5741       "void f() {\n"
5742       "  someo->Add((new util::filetools::Handler(dir))\n"
5743       "                 ->OnEvent1(NewPermanentCallback(\n"
5744       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5745       "                 ->OnEvent2(NewPermanentCallback(\n"
5746       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5747       "                 ->OnEvent3(NewPermanentCallback(\n"
5748       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5749       "                 ->OnEvent5(NewPermanentCallback(\n"
5750       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5751       "                 ->OnEvent6(NewPermanentCallback(\n"
5752       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5753       "}");
5754 
5755   verifyFormat(
5756       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5757   verifyFormat("aaaaaaaaaaaaaaa()\n"
5758                "    .aaaaaaaaaaaaaaa()\n"
5759                "    .aaaaaaaaaaaaaaa()\n"
5760                "    .aaaaaaaaaaaaaaa()\n"
5761                "    .aaaaaaaaaaaaaaa();");
5762   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5763                "    .aaaaaaaaaaaaaaa()\n"
5764                "    .aaaaaaaaaaaaaaa()\n"
5765                "    .aaaaaaaaaaaaaaa();");
5766   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5767                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5768                "    .aaaaaaaaaaaaaaa();");
5769   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5770                "    ->aaaaaaaaaaaaaae(0)\n"
5771                "    ->aaaaaaaaaaaaaaa();");
5772 
5773   // Don't linewrap after very short segments.
5774   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5775                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5776                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5777   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5778                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5779                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5780   verifyFormat("aaa()\n"
5781                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5782                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5783                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5784 
5785   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5786                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5787                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5788   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5789                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5790                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5791 
5792   // Prefer not to break after empty parentheses.
5793   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5794                "    First->LastNewlineOffset);");
5795 
5796   // Prefer not to create "hanging" indents.
5797   verifyFormat(
5798       "return !soooooooooooooome_map\n"
5799       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5800       "            .second;");
5801   verifyFormat(
5802       "return aaaaaaaaaaaaaaaa\n"
5803       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5804       "    .aaaa(aaaaaaaaaaaaaa);");
5805   // No hanging indent here.
5806   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5807                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5808   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5809                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5810   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5811                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5812                getLLVMStyleWithColumns(60));
5813   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5814                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5815                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5816                getLLVMStyleWithColumns(59));
5817   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5818                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5819                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5820 
5821   // Dont break if only closing statements before member call
5822   verifyFormat("test() {\n"
5823                "  ([]() -> {\n"
5824                "    int b = 32;\n"
5825                "    return 3;\n"
5826                "  }).foo();\n"
5827                "}");
5828   verifyFormat("test() {\n"
5829                "  (\n"
5830                "      []() -> {\n"
5831                "        int b = 32;\n"
5832                "        return 3;\n"
5833                "      },\n"
5834                "      foo, bar)\n"
5835                "      .foo();\n"
5836                "}");
5837   verifyFormat("test() {\n"
5838                "  ([]() -> {\n"
5839                "    int b = 32;\n"
5840                "    return 3;\n"
5841                "  })\n"
5842                "      .foo()\n"
5843                "      .bar();\n"
5844                "}");
5845   verifyFormat("test() {\n"
5846                "  ([]() -> {\n"
5847                "    int b = 32;\n"
5848                "    return 3;\n"
5849                "  })\n"
5850                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5851                "           \"bbbb\");\n"
5852                "}",
5853                getLLVMStyleWithColumns(30));
5854 }
5855 
5856 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5857   verifyFormat(
5858       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5859       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5860   verifyFormat(
5861       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5862       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5863 
5864   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5865                "    ccccccccccccccccccccccccc) {\n}");
5866   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5867                "    ccccccccccccccccccccccccc) {\n}");
5868 
5869   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5870                "    ccccccccccccccccccccccccc) {\n}");
5871   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5872                "    ccccccccccccccccccccccccc) {\n}");
5873 
5874   verifyFormat(
5875       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
5876       "    ccccccccccccccccccccccccc) {\n}");
5877   verifyFormat(
5878       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
5879       "    ccccccccccccccccccccccccc) {\n}");
5880 
5881   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5882                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
5883                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
5884                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5885   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5886                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
5887                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
5888                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5889 
5890   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5891                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
5892                "    aaaaaaaaaaaaaaa != aa) {\n}");
5893   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5894                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
5895                "    aaaaaaaaaaaaaaa != aa) {\n}");
5896 }
5897 
5898 TEST_F(FormatTest, BreaksAfterAssignments) {
5899   verifyFormat(
5900       "unsigned Cost =\n"
5901       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
5902       "                        SI->getPointerAddressSpaceee());\n");
5903   verifyFormat(
5904       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
5905       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
5906 
5907   verifyFormat(
5908       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
5909       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
5910   verifyFormat("unsigned OriginalStartColumn =\n"
5911                "    SourceMgr.getSpellingColumnNumber(\n"
5912                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
5913                "    1;");
5914 }
5915 
5916 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
5917   FormatStyle Style = getLLVMStyle();
5918   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5919                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
5920                Style);
5921 
5922   Style.PenaltyBreakAssignment = 20;
5923   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5924                "                                 cccccccccccccccccccccccccc;",
5925                Style);
5926 }
5927 
5928 TEST_F(FormatTest, AlignsAfterAssignments) {
5929   verifyFormat(
5930       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5931       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
5932   verifyFormat(
5933       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5934       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
5935   verifyFormat(
5936       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5937       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
5938   verifyFormat(
5939       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5940       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
5941   verifyFormat(
5942       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5943       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5944       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
5945 }
5946 
5947 TEST_F(FormatTest, AlignsAfterReturn) {
5948   verifyFormat(
5949       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5950       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
5951   verifyFormat(
5952       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5953       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
5954   verifyFormat(
5955       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5956       "       aaaaaaaaaaaaaaaaaaaaaa();");
5957   verifyFormat(
5958       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5959       "        aaaaaaaaaaaaaaaaaaaaaa());");
5960   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5961                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5962   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5963                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
5964                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5965   verifyFormat("return\n"
5966                "    // true if code is one of a or b.\n"
5967                "    code == a || code == b;");
5968 }
5969 
5970 TEST_F(FormatTest, AlignsAfterOpenBracket) {
5971   verifyFormat(
5972       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5973       "                                                aaaaaaaaa aaaaaaa) {}");
5974   verifyFormat(
5975       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5976       "                                               aaaaaaaaaaa aaaaaaaaa);");
5977   verifyFormat(
5978       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5979       "                                             aaaaaaaaaaaaaaaaaaaaa));");
5980   FormatStyle Style = getLLVMStyle();
5981   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5982   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5983                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
5984                Style);
5985   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5986                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
5987                Style);
5988   verifyFormat("SomeLongVariableName->someFunction(\n"
5989                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
5990                Style);
5991   verifyFormat(
5992       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5993       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5994       Style);
5995   verifyFormat(
5996       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5997       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5998       Style);
5999   verifyFormat(
6000       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6001       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6002       Style);
6003 
6004   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
6005                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
6006                "        b));",
6007                Style);
6008 
6009   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6010   Style.BinPackArguments = false;
6011   Style.BinPackParameters = false;
6012   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6013                "    aaaaaaaaaaa aaaaaaaa,\n"
6014                "    aaaaaaaaa aaaaaaa,\n"
6015                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6016                Style);
6017   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6018                "    aaaaaaaaaaa aaaaaaaaa,\n"
6019                "    aaaaaaaaaaa aaaaaaaaa,\n"
6020                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6021                Style);
6022   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
6023                "    aaaaaaaaaaaaaaa,\n"
6024                "    aaaaaaaaaaaaaaaaaaaaa,\n"
6025                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6026                Style);
6027   verifyFormat(
6028       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
6029       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6030       Style);
6031   verifyFormat(
6032       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
6033       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6034       Style);
6035   verifyFormat(
6036       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6037       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6038       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
6039       "    aaaaaaaaaaaaaaaa);",
6040       Style);
6041   verifyFormat(
6042       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6043       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6044       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
6045       "    aaaaaaaaaaaaaaaa);",
6046       Style);
6047 }
6048 
6049 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
6050   FormatStyle Style = getLLVMStyleWithColumns(40);
6051   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6052                "          bbbbbbbbbbbbbbbbbbbbbb);",
6053                Style);
6054   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6055   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6056   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6057                "          bbbbbbbbbbbbbbbbbbbbbb);",
6058                Style);
6059   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6060   Style.AlignOperands = FormatStyle::OAS_Align;
6061   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6062                "          bbbbbbbbbbbbbbbbbbbbbb);",
6063                Style);
6064   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6065   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6066   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6067                "    bbbbbbbbbbbbbbbbbbbbbb);",
6068                Style);
6069 }
6070 
6071 TEST_F(FormatTest, BreaksConditionalExpressions) {
6072   verifyFormat(
6073       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6074       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6075       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6076   verifyFormat(
6077       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6078       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6079       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6080   verifyFormat(
6081       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6082       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6083   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6084                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6085                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6086   verifyFormat(
6087       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6088       "                                                    : aaaaaaaaaaaaa);");
6089   verifyFormat(
6090       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6091       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6092       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6093       "                   aaaaaaaaaaaaa);");
6094   verifyFormat(
6095       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6096       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6097       "                   aaaaaaaaaaaaa);");
6098   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6099                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6100                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6101                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6102                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6103   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6104                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6105                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6106                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6107                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6108                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6109                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6110   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6111                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6112                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6113                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6114                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6115   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6116                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6117                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6118   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6119                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6120                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6121                "        : aaaaaaaaaaaaaaaa;");
6122   verifyFormat(
6123       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6124       "    ? aaaaaaaaaaaaaaa\n"
6125       "    : aaaaaaaaaaaaaaa;");
6126   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6127                "          aaaaaaaaa\n"
6128                "      ? b\n"
6129                "      : c);");
6130   verifyFormat("return aaaa == bbbb\n"
6131                "           // comment\n"
6132                "           ? aaaa\n"
6133                "           : bbbb;");
6134   verifyFormat("unsigned Indent =\n"
6135                "    format(TheLine.First,\n"
6136                "           IndentForLevel[TheLine.Level] >= 0\n"
6137                "               ? IndentForLevel[TheLine.Level]\n"
6138                "               : TheLine * 2,\n"
6139                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6140                getLLVMStyleWithColumns(60));
6141   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6142                "                  ? aaaaaaaaaaaaaaa\n"
6143                "                  : bbbbbbbbbbbbbbb //\n"
6144                "                        ? ccccccccccccccc\n"
6145                "                        : ddddddddddddddd;");
6146   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6147                "                  ? aaaaaaaaaaaaaaa\n"
6148                "                  : (bbbbbbbbbbbbbbb //\n"
6149                "                         ? ccccccccccccccc\n"
6150                "                         : ddddddddddddddd);");
6151   verifyFormat(
6152       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6153       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6154       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
6155       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
6156       "                                      : aaaaaaaaaa;");
6157   verifyFormat(
6158       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6159       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
6160       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6161 
6162   FormatStyle NoBinPacking = getLLVMStyle();
6163   NoBinPacking.BinPackArguments = false;
6164   verifyFormat(
6165       "void f() {\n"
6166       "  g(aaa,\n"
6167       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6168       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6169       "        ? aaaaaaaaaaaaaaa\n"
6170       "        : aaaaaaaaaaaaaaa);\n"
6171       "}",
6172       NoBinPacking);
6173   verifyFormat(
6174       "void f() {\n"
6175       "  g(aaa,\n"
6176       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6177       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6178       "        ?: aaaaaaaaaaaaaaa);\n"
6179       "}",
6180       NoBinPacking);
6181 
6182   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6183                "             // comment.\n"
6184                "             ccccccccccccccccccccccccccccccccccccccc\n"
6185                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6186                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6187 
6188   // Assignments in conditional expressions. Apparently not uncommon :-(.
6189   verifyFormat("return a != b\n"
6190                "           // comment\n"
6191                "           ? a = b\n"
6192                "           : a = b;");
6193   verifyFormat("return a != b\n"
6194                "           // comment\n"
6195                "           ? a = a != b\n"
6196                "                     // comment\n"
6197                "                     ? a = b\n"
6198                "                     : a\n"
6199                "           : a;\n");
6200   verifyFormat("return a != b\n"
6201                "           // comment\n"
6202                "           ? a\n"
6203                "           : a = a != b\n"
6204                "                     // comment\n"
6205                "                     ? a = b\n"
6206                "                     : a;");
6207 
6208   // Chained conditionals
6209   FormatStyle Style = getLLVMStyle();
6210   Style.ColumnLimit = 70;
6211   Style.AlignOperands = FormatStyle::OAS_Align;
6212   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6213                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6214                "                        : 3333333333333333;",
6215                Style);
6216   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6217                "       : bbbbbbbbbb     ? 2222222222222222\n"
6218                "                        : 3333333333333333;",
6219                Style);
6220   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
6221                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6222                "                          : 3333333333333333;",
6223                Style);
6224   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6225                "       : bbbbbbbbbbbbbb ? 222222\n"
6226                "                        : 333333;",
6227                Style);
6228   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6229                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6230                "       : cccccccccccccc ? 3333333333333333\n"
6231                "                        : 4444444444444444;",
6232                Style);
6233   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6234                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6235                "                        : 3333333333333333;",
6236                Style);
6237   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6238                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6239                "                        : (aaa ? bbb : ccc);",
6240                Style);
6241   verifyFormat(
6242       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6243       "                                             : cccccccccccccccccc)\n"
6244       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6245       "                        : 3333333333333333;",
6246       Style);
6247   verifyFormat(
6248       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6249       "                                             : cccccccccccccccccc)\n"
6250       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6251       "                        : 3333333333333333;",
6252       Style);
6253   verifyFormat(
6254       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6255       "                                             : dddddddddddddddddd)\n"
6256       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6257       "                        : 3333333333333333;",
6258       Style);
6259   verifyFormat(
6260       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6261       "                                             : dddddddddddddddddd)\n"
6262       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6263       "                        : 3333333333333333;",
6264       Style);
6265   verifyFormat(
6266       "return aaaaaaaaa        ? 1111111111111111\n"
6267       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6268       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6269       "                                             : dddddddddddddddddd)\n",
6270       Style);
6271   verifyFormat(
6272       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6273       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6274       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6275       "                                             : cccccccccccccccccc);",
6276       Style);
6277   verifyFormat(
6278       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6279       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6280       "                                             : eeeeeeeeeeeeeeeeee)\n"
6281       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6282       "                        : 3333333333333333;",
6283       Style);
6284   verifyFormat(
6285       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
6286       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6287       "                                             : eeeeeeeeeeeeeeeeee)\n"
6288       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6289       "                        : 3333333333333333;",
6290       Style);
6291   verifyFormat(
6292       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6293       "                           : cccccccccccc    ? dddddddddddddddddd\n"
6294       "                                             : eeeeeeeeeeeeeeeeee)\n"
6295       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6296       "                        : 3333333333333333;",
6297       Style);
6298   verifyFormat(
6299       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6300       "                                             : cccccccccccccccccc\n"
6301       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6302       "                        : 3333333333333333;",
6303       Style);
6304   verifyFormat(
6305       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6306       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
6307       "                                             : eeeeeeeeeeeeeeeeee\n"
6308       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6309       "                        : 3333333333333333;",
6310       Style);
6311   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6312                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
6313                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
6314                "                                   : eeeeeeeeeeeeeeeeee)\n"
6315                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6316                "                             : 3333333333333333;",
6317                Style);
6318   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6319                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6320                "             : cccccccccccccccc ? dddddddddddddddddd\n"
6321                "                                : eeeeeeeeeeeeeeeeee\n"
6322                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6323                "                                 : 3333333333333333;",
6324                Style);
6325 
6326   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6327   Style.BreakBeforeTernaryOperators = false;
6328   // FIXME: Aligning the question marks is weird given DontAlign.
6329   // Consider disabling this alignment in this case. Also check whether this
6330   // will render the adjustment from https://reviews.llvm.org/D82199
6331   // unnecessary.
6332   verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
6333                "    bbbb                ? cccccccccccccccccc :\n"
6334                "                          ddddd;\n",
6335                Style);
6336 }
6337 
6338 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6339   FormatStyle Style = getLLVMStyle();
6340   Style.BreakBeforeTernaryOperators = false;
6341   Style.ColumnLimit = 70;
6342   verifyFormat(
6343       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6344       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6345       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6346       Style);
6347   verifyFormat(
6348       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6349       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6350       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6351       Style);
6352   verifyFormat(
6353       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6354       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6355       Style);
6356   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6357                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6358                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6359                Style);
6360   verifyFormat(
6361       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6362       "                                                      aaaaaaaaaaaaa);",
6363       Style);
6364   verifyFormat(
6365       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6366       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6367       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6368       "                   aaaaaaaaaaaaa);",
6369       Style);
6370   verifyFormat(
6371       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6372       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6373       "                   aaaaaaaaaaaaa);",
6374       Style);
6375   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6376                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6377                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6378                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6379                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6380                Style);
6381   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6382                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6383                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6384                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6385                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6386                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6387                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6388                Style);
6389   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6390                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6391                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6392                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6393                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6394                Style);
6395   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6396                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6397                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6398                Style);
6399   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6400                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6401                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6402                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6403                Style);
6404   verifyFormat(
6405       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6406       "    aaaaaaaaaaaaaaa :\n"
6407       "    aaaaaaaaaaaaaaa;",
6408       Style);
6409   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6410                "          aaaaaaaaa ?\n"
6411                "      b :\n"
6412                "      c);",
6413                Style);
6414   verifyFormat("unsigned Indent =\n"
6415                "    format(TheLine.First,\n"
6416                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
6417                "               IndentForLevel[TheLine.Level] :\n"
6418                "               TheLine * 2,\n"
6419                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6420                Style);
6421   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6422                "                  aaaaaaaaaaaaaaa :\n"
6423                "                  bbbbbbbbbbbbbbb ? //\n"
6424                "                      ccccccccccccccc :\n"
6425                "                      ddddddddddddddd;",
6426                Style);
6427   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6428                "                  aaaaaaaaaaaaaaa :\n"
6429                "                  (bbbbbbbbbbbbbbb ? //\n"
6430                "                       ccccccccccccccc :\n"
6431                "                       ddddddddddddddd);",
6432                Style);
6433   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6434                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6435                "            ccccccccccccccccccccccccccc;",
6436                Style);
6437   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6438                "           aaaaa :\n"
6439                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
6440                Style);
6441 
6442   // Chained conditionals
6443   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6444                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6445                "                          3333333333333333;",
6446                Style);
6447   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6448                "       bbbbbbbbbb       ? 2222222222222222 :\n"
6449                "                          3333333333333333;",
6450                Style);
6451   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
6452                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6453                "                          3333333333333333;",
6454                Style);
6455   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6456                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
6457                "                          333333;",
6458                Style);
6459   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6460                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6461                "       cccccccccccccccc ? 3333333333333333 :\n"
6462                "                          4444444444444444;",
6463                Style);
6464   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6465                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6466                "                          3333333333333333;",
6467                Style);
6468   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6469                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6470                "                          (aaa ? bbb : ccc);",
6471                Style);
6472   verifyFormat(
6473       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6474       "                                               cccccccccccccccccc) :\n"
6475       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6476       "                          3333333333333333;",
6477       Style);
6478   verifyFormat(
6479       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6480       "                                               cccccccccccccccccc) :\n"
6481       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6482       "                          3333333333333333;",
6483       Style);
6484   verifyFormat(
6485       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6486       "                                               dddddddddddddddddd) :\n"
6487       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6488       "                          3333333333333333;",
6489       Style);
6490   verifyFormat(
6491       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6492       "                                               dddddddddddddddddd) :\n"
6493       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6494       "                          3333333333333333;",
6495       Style);
6496   verifyFormat(
6497       "return aaaaaaaaa        ? 1111111111111111 :\n"
6498       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6499       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6500       "                                               dddddddddddddddddd)\n",
6501       Style);
6502   verifyFormat(
6503       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6504       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6505       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6506       "                                               cccccccccccccccccc);",
6507       Style);
6508   verifyFormat(
6509       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6510       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6511       "                                               eeeeeeeeeeeeeeeeee) :\n"
6512       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6513       "                          3333333333333333;",
6514       Style);
6515   verifyFormat(
6516       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6517       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
6518       "                                               eeeeeeeeeeeeeeeeee) :\n"
6519       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6520       "                          3333333333333333;",
6521       Style);
6522   verifyFormat(
6523       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
6524       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6525       "                                               eeeeeeeeeeeeeeeeee) :\n"
6526       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6527       "                          3333333333333333;",
6528       Style);
6529   verifyFormat(
6530       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6531       "                                               cccccccccccccccccc :\n"
6532       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6533       "                          3333333333333333;",
6534       Style);
6535   verifyFormat(
6536       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6537       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
6538       "                                               eeeeeeeeeeeeeeeeee :\n"
6539       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6540       "                          3333333333333333;",
6541       Style);
6542   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6543                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6544                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
6545                "                                 eeeeeeeeeeeeeeeeee) :\n"
6546                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6547                "                               3333333333333333;",
6548                Style);
6549   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6550                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6551                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
6552                "                                  eeeeeeeeeeeeeeeeee :\n"
6553                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6554                "                               3333333333333333;",
6555                Style);
6556 }
6557 
6558 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6559   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6560                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6561   verifyFormat("bool a = true, b = false;");
6562 
6563   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6564                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6565                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6566                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6567   verifyFormat(
6568       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6569       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6570       "     d = e && f;");
6571   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6572                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6573   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6574                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6575   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6576                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6577 
6578   FormatStyle Style = getGoogleStyle();
6579   Style.PointerAlignment = FormatStyle::PAS_Left;
6580   Style.DerivePointerAlignment = false;
6581   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6582                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6583                "    *b = bbbbbbbbbbbbbbbbbbb;",
6584                Style);
6585   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6586                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6587                Style);
6588   verifyFormat("vector<int*> a, b;", Style);
6589   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6590 }
6591 
6592 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6593   verifyFormat("arr[foo ? bar : baz];");
6594   verifyFormat("f()[foo ? bar : baz];");
6595   verifyFormat("(a + b)[foo ? bar : baz];");
6596   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6597 }
6598 
6599 TEST_F(FormatTest, AlignsStringLiterals) {
6600   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6601                "                                      \"short literal\");");
6602   verifyFormat(
6603       "looooooooooooooooooooooooongFunction(\n"
6604       "    \"short literal\"\n"
6605       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6606   verifyFormat("someFunction(\"Always break between multi-line\"\n"
6607                "             \" string literals\",\n"
6608                "             and, other, parameters);");
6609   EXPECT_EQ("fun + \"1243\" /* comment */\n"
6610             "      \"5678\";",
6611             format("fun + \"1243\" /* comment */\n"
6612                    "    \"5678\";",
6613                    getLLVMStyleWithColumns(28)));
6614   EXPECT_EQ(
6615       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6616       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6617       "         \"aaaaaaaaaaaaaaaa\";",
6618       format("aaaaaa ="
6619              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6620              "aaaaaaaaaaaaaaaaaaaaa\" "
6621              "\"aaaaaaaaaaaaaaaa\";"));
6622   verifyFormat("a = a + \"a\"\n"
6623                "        \"a\"\n"
6624                "        \"a\";");
6625   verifyFormat("f(\"a\", \"b\"\n"
6626                "       \"c\");");
6627 
6628   verifyFormat(
6629       "#define LL_FORMAT \"ll\"\n"
6630       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6631       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6632 
6633   verifyFormat("#define A(X)          \\\n"
6634                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
6635                "  \"ccccc\"",
6636                getLLVMStyleWithColumns(23));
6637   verifyFormat("#define A \"def\"\n"
6638                "f(\"abc\" A \"ghi\"\n"
6639                "  \"jkl\");");
6640 
6641   verifyFormat("f(L\"a\"\n"
6642                "  L\"b\");");
6643   verifyFormat("#define A(X)            \\\n"
6644                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6645                "  L\"ccccc\"",
6646                getLLVMStyleWithColumns(25));
6647 
6648   verifyFormat("f(@\"a\"\n"
6649                "  @\"b\");");
6650   verifyFormat("NSString s = @\"a\"\n"
6651                "             @\"b\"\n"
6652                "             @\"c\";");
6653   verifyFormat("NSString s = @\"a\"\n"
6654                "              \"b\"\n"
6655                "              \"c\";");
6656 }
6657 
6658 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6659   FormatStyle Style = getLLVMStyle();
6660   // No declarations or definitions should be moved to own line.
6661   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6662   verifyFormat("class A {\n"
6663                "  int f() { return 1; }\n"
6664                "  int g();\n"
6665                "};\n"
6666                "int f() { return 1; }\n"
6667                "int g();\n",
6668                Style);
6669 
6670   // All declarations and definitions should have the return type moved to its
6671   // own
6672   // line.
6673   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6674   verifyFormat("class E {\n"
6675                "  int\n"
6676                "  f() {\n"
6677                "    return 1;\n"
6678                "  }\n"
6679                "  int\n"
6680                "  g();\n"
6681                "};\n"
6682                "int\n"
6683                "f() {\n"
6684                "  return 1;\n"
6685                "}\n"
6686                "int\n"
6687                "g();\n",
6688                Style);
6689 
6690   // Top-level definitions, and no kinds of declarations should have the
6691   // return type moved to its own line.
6692   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6693   verifyFormat("class B {\n"
6694                "  int f() { return 1; }\n"
6695                "  int g();\n"
6696                "};\n"
6697                "int\n"
6698                "f() {\n"
6699                "  return 1;\n"
6700                "}\n"
6701                "int g();\n",
6702                Style);
6703 
6704   // Top-level definitions and declarations should have the return type moved
6705   // to its own line.
6706   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6707   verifyFormat("class C {\n"
6708                "  int f() { return 1; }\n"
6709                "  int g();\n"
6710                "};\n"
6711                "int\n"
6712                "f() {\n"
6713                "  return 1;\n"
6714                "}\n"
6715                "int\n"
6716                "g();\n",
6717                Style);
6718 
6719   // All definitions should have the return type moved to its own line, but no
6720   // kinds of declarations.
6721   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6722   verifyFormat("class D {\n"
6723                "  int\n"
6724                "  f() {\n"
6725                "    return 1;\n"
6726                "  }\n"
6727                "  int g();\n"
6728                "};\n"
6729                "int\n"
6730                "f() {\n"
6731                "  return 1;\n"
6732                "}\n"
6733                "int g();\n",
6734                Style);
6735   verifyFormat("const char *\n"
6736                "f(void) {\n" // Break here.
6737                "  return \"\";\n"
6738                "}\n"
6739                "const char *bar(void);\n", // No break here.
6740                Style);
6741   verifyFormat("template <class T>\n"
6742                "T *\n"
6743                "f(T &c) {\n" // Break here.
6744                "  return NULL;\n"
6745                "}\n"
6746                "template <class T> T *f(T &c);\n", // No break here.
6747                Style);
6748   verifyFormat("class C {\n"
6749                "  int\n"
6750                "  operator+() {\n"
6751                "    return 1;\n"
6752                "  }\n"
6753                "  int\n"
6754                "  operator()() {\n"
6755                "    return 1;\n"
6756                "  }\n"
6757                "};\n",
6758                Style);
6759   verifyFormat("void\n"
6760                "A::operator()() {}\n"
6761                "void\n"
6762                "A::operator>>() {}\n"
6763                "void\n"
6764                "A::operator+() {}\n"
6765                "void\n"
6766                "A::operator*() {}\n"
6767                "void\n"
6768                "A::operator->() {}\n"
6769                "void\n"
6770                "A::operator void *() {}\n"
6771                "void\n"
6772                "A::operator void &() {}\n"
6773                "void\n"
6774                "A::operator void &&() {}\n"
6775                "void\n"
6776                "A::operator char *() {}\n"
6777                "void\n"
6778                "A::operator[]() {}\n"
6779                "void\n"
6780                "A::operator!() {}\n"
6781                "void\n"
6782                "A::operator**() {}\n"
6783                "void\n"
6784                "A::operator<Foo> *() {}\n"
6785                "void\n"
6786                "A::operator<Foo> **() {}\n"
6787                "void\n"
6788                "A::operator<Foo> &() {}\n"
6789                "void\n"
6790                "A::operator void **() {}\n",
6791                Style);
6792   verifyFormat("constexpr auto\n"
6793                "operator()() const -> reference {}\n"
6794                "constexpr auto\n"
6795                "operator>>() const -> reference {}\n"
6796                "constexpr auto\n"
6797                "operator+() const -> reference {}\n"
6798                "constexpr auto\n"
6799                "operator*() const -> reference {}\n"
6800                "constexpr auto\n"
6801                "operator->() const -> reference {}\n"
6802                "constexpr auto\n"
6803                "operator++() const -> reference {}\n"
6804                "constexpr auto\n"
6805                "operator void *() const -> reference {}\n"
6806                "constexpr auto\n"
6807                "operator void **() const -> reference {}\n"
6808                "constexpr auto\n"
6809                "operator void *() const -> reference {}\n"
6810                "constexpr auto\n"
6811                "operator void &() const -> reference {}\n"
6812                "constexpr auto\n"
6813                "operator void &&() const -> reference {}\n"
6814                "constexpr auto\n"
6815                "operator char *() const -> reference {}\n"
6816                "constexpr auto\n"
6817                "operator!() const -> reference {}\n"
6818                "constexpr auto\n"
6819                "operator[]() const -> reference {}\n",
6820                Style);
6821   verifyFormat("void *operator new(std::size_t s);", // No break here.
6822                Style);
6823   verifyFormat("void *\n"
6824                "operator new(std::size_t s) {}",
6825                Style);
6826   verifyFormat("void *\n"
6827                "operator delete[](void *ptr) {}",
6828                Style);
6829   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6830   verifyFormat("const char *\n"
6831                "f(void)\n" // Break here.
6832                "{\n"
6833                "  return \"\";\n"
6834                "}\n"
6835                "const char *bar(void);\n", // No break here.
6836                Style);
6837   verifyFormat("template <class T>\n"
6838                "T *\n"     // Problem here: no line break
6839                "f(T &c)\n" // Break here.
6840                "{\n"
6841                "  return NULL;\n"
6842                "}\n"
6843                "template <class T> T *f(T &c);\n", // No break here.
6844                Style);
6845   verifyFormat("int\n"
6846                "foo(A<bool> a)\n"
6847                "{\n"
6848                "  return a;\n"
6849                "}\n",
6850                Style);
6851   verifyFormat("int\n"
6852                "foo(A<8> a)\n"
6853                "{\n"
6854                "  return a;\n"
6855                "}\n",
6856                Style);
6857   verifyFormat("int\n"
6858                "foo(A<B<bool>, 8> a)\n"
6859                "{\n"
6860                "  return a;\n"
6861                "}\n",
6862                Style);
6863   verifyFormat("int\n"
6864                "foo(A<B<8>, bool> a)\n"
6865                "{\n"
6866                "  return a;\n"
6867                "}\n",
6868                Style);
6869   verifyFormat("int\n"
6870                "foo(A<B<bool>, bool> a)\n"
6871                "{\n"
6872                "  return a;\n"
6873                "}\n",
6874                Style);
6875   verifyFormat("int\n"
6876                "foo(A<B<8>, 8> a)\n"
6877                "{\n"
6878                "  return a;\n"
6879                "}\n",
6880                Style);
6881 
6882   Style = getGNUStyle();
6883 
6884   // Test for comments at the end of function declarations.
6885   verifyFormat("void\n"
6886                "foo (int a, /*abc*/ int b) // def\n"
6887                "{\n"
6888                "}\n",
6889                Style);
6890 
6891   verifyFormat("void\n"
6892                "foo (int a, /* abc */ int b) /* def */\n"
6893                "{\n"
6894                "}\n",
6895                Style);
6896 
6897   // Definitions that should not break after return type
6898   verifyFormat("void foo (int a, int b); // def\n", Style);
6899   verifyFormat("void foo (int a, int b); /* def */\n", Style);
6900   verifyFormat("void foo (int a, int b);\n", Style);
6901 }
6902 
6903 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
6904   FormatStyle NoBreak = getLLVMStyle();
6905   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
6906   FormatStyle Break = getLLVMStyle();
6907   Break.AlwaysBreakBeforeMultilineStrings = true;
6908   verifyFormat("aaaa = \"bbbb\"\n"
6909                "       \"cccc\";",
6910                NoBreak);
6911   verifyFormat("aaaa =\n"
6912                "    \"bbbb\"\n"
6913                "    \"cccc\";",
6914                Break);
6915   verifyFormat("aaaa(\"bbbb\"\n"
6916                "     \"cccc\");",
6917                NoBreak);
6918   verifyFormat("aaaa(\n"
6919                "    \"bbbb\"\n"
6920                "    \"cccc\");",
6921                Break);
6922   verifyFormat("aaaa(qqq, \"bbbb\"\n"
6923                "          \"cccc\");",
6924                NoBreak);
6925   verifyFormat("aaaa(qqq,\n"
6926                "     \"bbbb\"\n"
6927                "     \"cccc\");",
6928                Break);
6929   verifyFormat("aaaa(qqq,\n"
6930                "     L\"bbbb\"\n"
6931                "     L\"cccc\");",
6932                Break);
6933   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
6934                "                      \"bbbb\"));",
6935                Break);
6936   verifyFormat("string s = someFunction(\n"
6937                "    \"abc\"\n"
6938                "    \"abc\");",
6939                Break);
6940 
6941   // As we break before unary operators, breaking right after them is bad.
6942   verifyFormat("string foo = abc ? \"x\"\n"
6943                "                   \"blah blah blah blah blah blah\"\n"
6944                "                 : \"y\";",
6945                Break);
6946 
6947   // Don't break if there is no column gain.
6948   verifyFormat("f(\"aaaa\"\n"
6949                "  \"bbbb\");",
6950                Break);
6951 
6952   // Treat literals with escaped newlines like multi-line string literals.
6953   EXPECT_EQ("x = \"a\\\n"
6954             "b\\\n"
6955             "c\";",
6956             format("x = \"a\\\n"
6957                    "b\\\n"
6958                    "c\";",
6959                    NoBreak));
6960   EXPECT_EQ("xxxx =\n"
6961             "    \"a\\\n"
6962             "b\\\n"
6963             "c\";",
6964             format("xxxx = \"a\\\n"
6965                    "b\\\n"
6966                    "c\";",
6967                    Break));
6968 
6969   EXPECT_EQ("NSString *const kString =\n"
6970             "    @\"aaaa\"\n"
6971             "    @\"bbbb\";",
6972             format("NSString *const kString = @\"aaaa\"\n"
6973                    "@\"bbbb\";",
6974                    Break));
6975 
6976   Break.ColumnLimit = 0;
6977   verifyFormat("const char *hello = \"hello llvm\";", Break);
6978 }
6979 
6980 TEST_F(FormatTest, AlignsPipes) {
6981   verifyFormat(
6982       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6983       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6984       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6985   verifyFormat(
6986       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
6987       "                     << aaaaaaaaaaaaaaaaaaaa;");
6988   verifyFormat(
6989       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6990       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6991   verifyFormat(
6992       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
6993       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6994   verifyFormat(
6995       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
6996       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
6997       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
6998   verifyFormat(
6999       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7000       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7001       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7002   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7003                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7004                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7005                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7006   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
7007                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
7008   verifyFormat(
7009       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7010       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7011   verifyFormat(
7012       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
7013       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
7014 
7015   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
7016                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
7017   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7018                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7019                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
7020                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
7021   verifyFormat("LOG_IF(aaa == //\n"
7022                "       bbb)\n"
7023                "    << a << b;");
7024 
7025   // But sometimes, breaking before the first "<<" is desirable.
7026   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7027                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
7028   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
7029                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7030                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7031   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
7032                "    << BEF << IsTemplate << Description << E->getType();");
7033   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7034                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7035                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7036   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7037                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7038                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7039                "    << aaa;");
7040 
7041   verifyFormat(
7042       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7043       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7044 
7045   // Incomplete string literal.
7046   EXPECT_EQ("llvm::errs() << \"\n"
7047             "             << a;",
7048             format("llvm::errs() << \"\n<<a;"));
7049 
7050   verifyFormat("void f() {\n"
7051                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
7052                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
7053                "}");
7054 
7055   // Handle 'endl'.
7056   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
7057                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7058   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7059 
7060   // Handle '\n'.
7061   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
7062                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7063   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
7064                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
7065   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
7066                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
7067   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7068 }
7069 
7070 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
7071   verifyFormat("return out << \"somepacket = {\\n\"\n"
7072                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
7073                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
7074                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
7075                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
7076                "           << \"}\";");
7077 
7078   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7079                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7080                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7081   verifyFormat(
7082       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7083       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7084       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7085       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7086       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7087   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7088                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7089   verifyFormat(
7090       "void f() {\n"
7091       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7092       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7093       "}");
7094 
7095   // Breaking before the first "<<" is generally not desirable.
7096   verifyFormat(
7097       "llvm::errs()\n"
7098       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7099       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7100       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7101       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7102       getLLVMStyleWithColumns(70));
7103   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7104                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7105                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7106                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7107                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7108                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7109                getLLVMStyleWithColumns(70));
7110 
7111   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7112                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7113                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7114   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7115                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7116                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7117   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7118                "           (aaaa + aaaa);",
7119                getLLVMStyleWithColumns(40));
7120   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7121                "                  (aaaaaaa + aaaaa));",
7122                getLLVMStyleWithColumns(40));
7123   verifyFormat(
7124       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7125       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7126       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
7127 }
7128 
7129 TEST_F(FormatTest, UnderstandsEquals) {
7130   verifyFormat(
7131       "aaaaaaaaaaaaaaaaa =\n"
7132       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7133   verifyFormat(
7134       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7135       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7136   verifyFormat(
7137       "if (a) {\n"
7138       "  f();\n"
7139       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7140       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7141       "}");
7142 
7143   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7144                "        100000000 + 10000000) {\n}");
7145 }
7146 
7147 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7148   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7149                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
7150 
7151   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7152                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
7153 
7154   verifyFormat(
7155       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7156       "                                                          Parameter2);");
7157 
7158   verifyFormat(
7159       "ShortObject->shortFunction(\n"
7160       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7161       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7162 
7163   verifyFormat("loooooooooooooongFunction(\n"
7164                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
7165 
7166   verifyFormat(
7167       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7168       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7169 
7170   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7171                "    .WillRepeatedly(Return(SomeValue));");
7172   verifyFormat("void f() {\n"
7173                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7174                "      .Times(2)\n"
7175                "      .WillRepeatedly(Return(SomeValue));\n"
7176                "}");
7177   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7178                "    ccccccccccccccccccccccc);");
7179   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7180                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7181                "          .aaaaa(aaaaa),\n"
7182                "      aaaaaaaaaaaaaaaaaaaaa);");
7183   verifyFormat("void f() {\n"
7184                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7185                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7186                "}");
7187   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7188                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7189                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7190                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7191                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7192   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7193                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7194                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7195                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7196                "}");
7197 
7198   // Here, it is not necessary to wrap at "." or "->".
7199   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7200                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7201   verifyFormat(
7202       "aaaaaaaaaaa->aaaaaaaaa(\n"
7203       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7204       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7205 
7206   verifyFormat(
7207       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7208       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7209   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7210                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7211   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7212                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7213 
7214   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7215                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7216                "    .a();");
7217 
7218   FormatStyle NoBinPacking = getLLVMStyle();
7219   NoBinPacking.BinPackParameters = false;
7220   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7221                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7222                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7223                "                         aaaaaaaaaaaaaaaaaaa,\n"
7224                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7225                NoBinPacking);
7226 
7227   // If there is a subsequent call, change to hanging indentation.
7228   verifyFormat(
7229       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7230       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7231       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7232   verifyFormat(
7233       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7234       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7235   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7236                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7237                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7238   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7239                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7240                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7241 }
7242 
7243 TEST_F(FormatTest, WrapsTemplateDeclarations) {
7244   verifyFormat("template <typename T>\n"
7245                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7246   verifyFormat("template <typename T>\n"
7247                "// T should be one of {A, B}.\n"
7248                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7249   verifyFormat(
7250       "template <typename T>\n"
7251       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7252   verifyFormat("template <typename T>\n"
7253                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7254                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7255   verifyFormat(
7256       "template <typename T>\n"
7257       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7258       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
7259   verifyFormat(
7260       "template <typename T>\n"
7261       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7262       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7263       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7264   verifyFormat("template <typename T>\n"
7265                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7266                "    int aaaaaaaaaaaaaaaaaaaaaa);");
7267   verifyFormat(
7268       "template <typename T1, typename T2 = char, typename T3 = char,\n"
7269       "          typename T4 = char>\n"
7270       "void f();");
7271   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7272                "          template <typename> class cccccccccccccccccccccc,\n"
7273                "          typename ddddddddddddd>\n"
7274                "class C {};");
7275   verifyFormat(
7276       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7277       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7278 
7279   verifyFormat("void f() {\n"
7280                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7281                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7282                "}");
7283 
7284   verifyFormat("template <typename T> class C {};");
7285   verifyFormat("template <typename T> void f();");
7286   verifyFormat("template <typename T> void f() {}");
7287   verifyFormat(
7288       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7289       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7290       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7291       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7292       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7293       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7294       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
7295       getLLVMStyleWithColumns(72));
7296   EXPECT_EQ("static_cast<A< //\n"
7297             "    B> *>(\n"
7298             "\n"
7299             ");",
7300             format("static_cast<A<//\n"
7301                    "    B>*>(\n"
7302                    "\n"
7303                    "    );"));
7304   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7305                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7306 
7307   FormatStyle AlwaysBreak = getLLVMStyle();
7308   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7309   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7310   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7311   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7312   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7313                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7314                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
7315   verifyFormat("template <template <typename> class Fooooooo,\n"
7316                "          template <typename> class Baaaaaaar>\n"
7317                "struct C {};",
7318                AlwaysBreak);
7319   verifyFormat("template <typename T> // T can be A, B or C.\n"
7320                "struct C {};",
7321                AlwaysBreak);
7322   verifyFormat("template <enum E> class A {\n"
7323                "public:\n"
7324                "  E *f();\n"
7325                "};");
7326 
7327   FormatStyle NeverBreak = getLLVMStyle();
7328   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7329   verifyFormat("template <typename T> class C {};", NeverBreak);
7330   verifyFormat("template <typename T> void f();", NeverBreak);
7331   verifyFormat("template <typename T> void f() {}", NeverBreak);
7332   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7333                "bbbbbbbbbbbbbbbbbbbb) {}",
7334                NeverBreak);
7335   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7336                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7337                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
7338                NeverBreak);
7339   verifyFormat("template <template <typename> class Fooooooo,\n"
7340                "          template <typename> class Baaaaaaar>\n"
7341                "struct C {};",
7342                NeverBreak);
7343   verifyFormat("template <typename T> // T can be A, B or C.\n"
7344                "struct C {};",
7345                NeverBreak);
7346   verifyFormat("template <enum E> class A {\n"
7347                "public:\n"
7348                "  E *f();\n"
7349                "};",
7350                NeverBreak);
7351   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7352   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7353                "bbbbbbbbbbbbbbbbbbbb) {}",
7354                NeverBreak);
7355 }
7356 
7357 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7358   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7359   Style.ColumnLimit = 60;
7360   EXPECT_EQ("// Baseline - no comments.\n"
7361             "template <\n"
7362             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7363             "void f() {}",
7364             format("// Baseline - no comments.\n"
7365                    "template <\n"
7366                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7367                    "void f() {}",
7368                    Style));
7369 
7370   EXPECT_EQ("template <\n"
7371             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7372             "void f() {}",
7373             format("template <\n"
7374                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7375                    "void f() {}",
7376                    Style));
7377 
7378   EXPECT_EQ(
7379       "template <\n"
7380       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7381       "void f() {}",
7382       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
7383              "void f() {}",
7384              Style));
7385 
7386   EXPECT_EQ(
7387       "template <\n"
7388       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7389       "                                               // multiline\n"
7390       "void f() {}",
7391       format("template <\n"
7392              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7393              "                                              // multiline\n"
7394              "void f() {}",
7395              Style));
7396 
7397   EXPECT_EQ(
7398       "template <typename aaaaaaaaaa<\n"
7399       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
7400       "void f() {}",
7401       format(
7402           "template <\n"
7403           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7404           "void f() {}",
7405           Style));
7406 }
7407 
7408 TEST_F(FormatTest, WrapsTemplateParameters) {
7409   FormatStyle Style = getLLVMStyle();
7410   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7411   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7412   verifyFormat(
7413       "template <typename... a> struct q {};\n"
7414       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7415       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7416       "    y;",
7417       Style);
7418   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7419   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7420   verifyFormat(
7421       "template <typename... a> struct r {};\n"
7422       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7423       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7424       "    y;",
7425       Style);
7426   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7427   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7428   verifyFormat("template <typename... a> struct s {};\n"
7429                "extern s<\n"
7430                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7431                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7432                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7433                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7434                "    y;",
7435                Style);
7436   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7437   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7438   verifyFormat("template <typename... a> struct t {};\n"
7439                "extern t<\n"
7440                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7441                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7442                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7443                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7444                "    y;",
7445                Style);
7446 }
7447 
7448 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7449   verifyFormat(
7450       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7451       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7452   verifyFormat(
7453       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7454       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7455       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7456 
7457   // FIXME: Should we have the extra indent after the second break?
7458   verifyFormat(
7459       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7460       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7461       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7462 
7463   verifyFormat(
7464       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7465       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
7466 
7467   // Breaking at nested name specifiers is generally not desirable.
7468   verifyFormat(
7469       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7470       "    aaaaaaaaaaaaaaaaaaaaaaa);");
7471 
7472   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7473                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7474                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7475                "                   aaaaaaaaaaaaaaaaaaaaa);",
7476                getLLVMStyleWithColumns(74));
7477 
7478   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7479                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7480                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7481 }
7482 
7483 TEST_F(FormatTest, UnderstandsTemplateParameters) {
7484   verifyFormat("A<int> a;");
7485   verifyFormat("A<A<A<int>>> a;");
7486   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7487   verifyFormat("bool x = a < 1 || 2 > a;");
7488   verifyFormat("bool x = 5 < f<int>();");
7489   verifyFormat("bool x = f<int>() > 5;");
7490   verifyFormat("bool x = 5 < a<int>::x;");
7491   verifyFormat("bool x = a < 4 ? a > 2 : false;");
7492   verifyFormat("bool x = f() ? a < 2 : a > 2;");
7493 
7494   verifyGoogleFormat("A<A<int>> a;");
7495   verifyGoogleFormat("A<A<A<int>>> a;");
7496   verifyGoogleFormat("A<A<A<A<int>>>> a;");
7497   verifyGoogleFormat("A<A<int> > a;");
7498   verifyGoogleFormat("A<A<A<int> > > a;");
7499   verifyGoogleFormat("A<A<A<A<int> > > > a;");
7500   verifyGoogleFormat("A<::A<int>> a;");
7501   verifyGoogleFormat("A<::A> a;");
7502   verifyGoogleFormat("A< ::A> a;");
7503   verifyGoogleFormat("A< ::A<int> > a;");
7504   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7505   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7506   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7507   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7508   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7509             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7510 
7511   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7512 
7513   // template closer followed by a token that starts with > or =
7514   verifyFormat("bool b = a<1> > 1;");
7515   verifyFormat("bool b = a<1> >= 1;");
7516   verifyFormat("int i = a<1> >> 1;");
7517   FormatStyle Style = getLLVMStyle();
7518   Style.SpaceBeforeAssignmentOperators = false;
7519   verifyFormat("bool b= a<1> == 1;", Style);
7520   verifyFormat("a<int> = 1;", Style);
7521   verifyFormat("a<int> >>= 1;", Style);
7522 
7523   verifyFormat("test >> a >> b;");
7524   verifyFormat("test << a >> b;");
7525 
7526   verifyFormat("f<int>();");
7527   verifyFormat("template <typename T> void f() {}");
7528   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7529   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7530                "sizeof(char)>::type>;");
7531   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7532   verifyFormat("f(a.operator()<A>());");
7533   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7534                "      .template operator()<A>());",
7535                getLLVMStyleWithColumns(35));
7536 
7537   // Not template parameters.
7538   verifyFormat("return a < b && c > d;");
7539   verifyFormat("void f() {\n"
7540                "  while (a < b && c > d) {\n"
7541                "  }\n"
7542                "}");
7543   verifyFormat("template <typename... Types>\n"
7544                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7545 
7546   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7547                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7548                getLLVMStyleWithColumns(60));
7549   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7550   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7551   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7552 }
7553 
7554 TEST_F(FormatTest, BitshiftOperatorWidth) {
7555   EXPECT_EQ("int a = 1 << 2; /* foo\n"
7556             "                   bar */",
7557             format("int    a=1<<2;  /* foo\n"
7558                    "                   bar */"));
7559 
7560   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7561             "                     bar */",
7562             format("int  b  =256>>1 ;  /* foo\n"
7563                    "                      bar */"));
7564 }
7565 
7566 TEST_F(FormatTest, UnderstandsBinaryOperators) {
7567   verifyFormat("COMPARE(a, ==, b);");
7568   verifyFormat("auto s = sizeof...(Ts) - 1;");
7569 }
7570 
7571 TEST_F(FormatTest, UnderstandsPointersToMembers) {
7572   verifyFormat("int A::*x;");
7573   verifyFormat("int (S::*func)(void *);");
7574   verifyFormat("void f() { int (S::*func)(void *); }");
7575   verifyFormat("typedef bool *(Class::*Member)() const;");
7576   verifyFormat("void f() {\n"
7577                "  (a->*f)();\n"
7578                "  a->*x;\n"
7579                "  (a.*f)();\n"
7580                "  ((*a).*f)();\n"
7581                "  a.*x;\n"
7582                "}");
7583   verifyFormat("void f() {\n"
7584                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7585                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7586                "}");
7587   verifyFormat(
7588       "(aaaaaaaaaa->*bbbbbbb)(\n"
7589       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7590   FormatStyle Style = getLLVMStyle();
7591   Style.PointerAlignment = FormatStyle::PAS_Left;
7592   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7593 }
7594 
7595 TEST_F(FormatTest, UnderstandsUnaryOperators) {
7596   verifyFormat("int a = -2;");
7597   verifyFormat("f(-1, -2, -3);");
7598   verifyFormat("a[-1] = 5;");
7599   verifyFormat("int a = 5 + -2;");
7600   verifyFormat("if (i == -1) {\n}");
7601   verifyFormat("if (i != -1) {\n}");
7602   verifyFormat("if (i > -1) {\n}");
7603   verifyFormat("if (i < -1) {\n}");
7604   verifyFormat("++(a->f());");
7605   verifyFormat("--(a->f());");
7606   verifyFormat("(a->f())++;");
7607   verifyFormat("a[42]++;");
7608   verifyFormat("if (!(a->f())) {\n}");
7609   verifyFormat("if (!+i) {\n}");
7610   verifyFormat("~&a;");
7611 
7612   verifyFormat("a-- > b;");
7613   verifyFormat("b ? -a : c;");
7614   verifyFormat("n * sizeof char16;");
7615   verifyFormat("n * alignof char16;", getGoogleStyle());
7616   verifyFormat("sizeof(char);");
7617   verifyFormat("alignof(char);", getGoogleStyle());
7618 
7619   verifyFormat("return -1;");
7620   verifyFormat("throw -1;");
7621   verifyFormat("switch (a) {\n"
7622                "case -1:\n"
7623                "  break;\n"
7624                "}");
7625   verifyFormat("#define X -1");
7626   verifyFormat("#define X -kConstant");
7627 
7628   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7629   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7630 
7631   verifyFormat("int a = /* confusing comment */ -1;");
7632   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7633   verifyFormat("int a = i /* confusing comment */++;");
7634 
7635   verifyFormat("co_yield -1;");
7636   verifyFormat("co_return -1;");
7637 }
7638 
7639 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7640   verifyFormat("if (!aaaaaaaaaa( // break\n"
7641                "        aaaaa)) {\n"
7642                "}");
7643   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7644                "    aaaaa));");
7645   verifyFormat("*aaa = aaaaaaa( // break\n"
7646                "    bbbbbb);");
7647 }
7648 
7649 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7650   verifyFormat("bool operator<();");
7651   verifyFormat("bool operator>();");
7652   verifyFormat("bool operator=();");
7653   verifyFormat("bool operator==();");
7654   verifyFormat("bool operator!=();");
7655   verifyFormat("int operator+();");
7656   verifyFormat("int operator++();");
7657   verifyFormat("int operator++(int) volatile noexcept;");
7658   verifyFormat("bool operator,();");
7659   verifyFormat("bool operator();");
7660   verifyFormat("bool operator()();");
7661   verifyFormat("bool operator[]();");
7662   verifyFormat("operator bool();");
7663   verifyFormat("operator int();");
7664   verifyFormat("operator void *();");
7665   verifyFormat("operator SomeType<int>();");
7666   verifyFormat("operator SomeType<int, int>();");
7667   verifyFormat("operator SomeType<SomeType<int>>();");
7668   verifyFormat("void *operator new(std::size_t size);");
7669   verifyFormat("void *operator new[](std::size_t size);");
7670   verifyFormat("void operator delete(void *ptr);");
7671   verifyFormat("void operator delete[](void *ptr);");
7672   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7673                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7674   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7675                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7676 
7677   verifyFormat(
7678       "ostream &operator<<(ostream &OutputStream,\n"
7679       "                    SomeReallyLongType WithSomeReallyLongValue);");
7680   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7681                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7682                "  return left.group < right.group;\n"
7683                "}");
7684   verifyFormat("SomeType &operator=(const SomeType &S);");
7685   verifyFormat("f.template operator()<int>();");
7686 
7687   verifyGoogleFormat("operator void*();");
7688   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7689   verifyGoogleFormat("operator ::A();");
7690 
7691   verifyFormat("using A::operator+;");
7692   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7693                "int i;");
7694 }
7695 
7696 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7697   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7698   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7699   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7700   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7701   verifyFormat("Deleted &operator=(const Deleted &) &;");
7702   verifyFormat("Deleted &operator=(const Deleted &) &&;");
7703   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7704   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7705   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7706   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7707   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7708   verifyFormat("void Fn(T const &) const &;");
7709   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7710   verifyFormat("template <typename T>\n"
7711                "void F(T) && = delete;",
7712                getGoogleStyle());
7713 
7714   FormatStyle AlignLeft = getLLVMStyle();
7715   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7716   verifyFormat("void A::b() && {}", AlignLeft);
7717   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7718   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7719                AlignLeft);
7720   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7721   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7722   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7723   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7724   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7725   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7726   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7727   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7728 
7729   FormatStyle Spaces = getLLVMStyle();
7730   Spaces.SpacesInCStyleCastParentheses = true;
7731   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7732   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7733   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7734   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7735 
7736   Spaces.SpacesInCStyleCastParentheses = false;
7737   Spaces.SpacesInParentheses = true;
7738   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7739   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7740                Spaces);
7741   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7742   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7743 
7744   FormatStyle BreakTemplate = getLLVMStyle();
7745   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7746 
7747   verifyFormat("struct f {\n"
7748                "  template <class T>\n"
7749                "  int &foo(const std::string &str) &noexcept {}\n"
7750                "};",
7751                BreakTemplate);
7752 
7753   verifyFormat("struct f {\n"
7754                "  template <class T>\n"
7755                "  int &foo(const std::string &str) &&noexcept {}\n"
7756                "};",
7757                BreakTemplate);
7758 
7759   verifyFormat("struct f {\n"
7760                "  template <class T>\n"
7761                "  int &foo(const std::string &str) const &noexcept {}\n"
7762                "};",
7763                BreakTemplate);
7764 
7765   verifyFormat("struct f {\n"
7766                "  template <class T>\n"
7767                "  int &foo(const std::string &str) const &noexcept {}\n"
7768                "};",
7769                BreakTemplate);
7770 
7771   verifyFormat("struct f {\n"
7772                "  template <class T>\n"
7773                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
7774                "};",
7775                BreakTemplate);
7776 
7777   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7778   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7779       FormatStyle::BTDS_Yes;
7780   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7781 
7782   verifyFormat("struct f {\n"
7783                "  template <class T>\n"
7784                "  int& foo(const std::string& str) & noexcept {}\n"
7785                "};",
7786                AlignLeftBreakTemplate);
7787 
7788   verifyFormat("struct f {\n"
7789                "  template <class T>\n"
7790                "  int& foo(const std::string& str) && noexcept {}\n"
7791                "};",
7792                AlignLeftBreakTemplate);
7793 
7794   verifyFormat("struct f {\n"
7795                "  template <class T>\n"
7796                "  int& foo(const std::string& str) const& noexcept {}\n"
7797                "};",
7798                AlignLeftBreakTemplate);
7799 
7800   verifyFormat("struct f {\n"
7801                "  template <class T>\n"
7802                "  int& foo(const std::string& str) const&& noexcept {}\n"
7803                "};",
7804                AlignLeftBreakTemplate);
7805 
7806   verifyFormat("struct f {\n"
7807                "  template <class T>\n"
7808                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7809                "};",
7810                AlignLeftBreakTemplate);
7811 
7812   // The `&` in `Type&` should not be confused with a trailing `&` of
7813   // DEPRECATED(reason) member function.
7814   verifyFormat("struct f {\n"
7815                "  template <class T>\n"
7816                "  DEPRECATED(reason)\n"
7817                "  Type &foo(arguments) {}\n"
7818                "};",
7819                BreakTemplate);
7820 
7821   verifyFormat("struct f {\n"
7822                "  template <class T>\n"
7823                "  DEPRECATED(reason)\n"
7824                "  Type& foo(arguments) {}\n"
7825                "};",
7826                AlignLeftBreakTemplate);
7827 
7828   verifyFormat("void (*foopt)(int) = &func;");
7829 }
7830 
7831 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7832   verifyFormat("void f() {\n"
7833                "  A *a = new A;\n"
7834                "  A *a = new (placement) A;\n"
7835                "  delete a;\n"
7836                "  delete (A *)a;\n"
7837                "}");
7838   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7839                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7840   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7841                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7842                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7843   verifyFormat("delete[] h->p;");
7844 }
7845 
7846 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
7847   verifyFormat("int *f(int *a) {}");
7848   verifyFormat("int main(int argc, char **argv) {}");
7849   verifyFormat("Test::Test(int b) : a(b * b) {}");
7850   verifyIndependentOfContext("f(a, *a);");
7851   verifyFormat("void g() { f(*a); }");
7852   verifyIndependentOfContext("int a = b * 10;");
7853   verifyIndependentOfContext("int a = 10 * b;");
7854   verifyIndependentOfContext("int a = b * c;");
7855   verifyIndependentOfContext("int a += b * c;");
7856   verifyIndependentOfContext("int a -= b * c;");
7857   verifyIndependentOfContext("int a *= b * c;");
7858   verifyIndependentOfContext("int a /= b * c;");
7859   verifyIndependentOfContext("int a = *b;");
7860   verifyIndependentOfContext("int a = *b * c;");
7861   verifyIndependentOfContext("int a = b * *c;");
7862   verifyIndependentOfContext("int a = b * (10);");
7863   verifyIndependentOfContext("S << b * (10);");
7864   verifyIndependentOfContext("return 10 * b;");
7865   verifyIndependentOfContext("return *b * *c;");
7866   verifyIndependentOfContext("return a & ~b;");
7867   verifyIndependentOfContext("f(b ? *c : *d);");
7868   verifyIndependentOfContext("int a = b ? *c : *d;");
7869   verifyIndependentOfContext("*b = a;");
7870   verifyIndependentOfContext("a * ~b;");
7871   verifyIndependentOfContext("a * !b;");
7872   verifyIndependentOfContext("a * +b;");
7873   verifyIndependentOfContext("a * -b;");
7874   verifyIndependentOfContext("a * ++b;");
7875   verifyIndependentOfContext("a * --b;");
7876   verifyIndependentOfContext("a[4] * b;");
7877   verifyIndependentOfContext("a[a * a] = 1;");
7878   verifyIndependentOfContext("f() * b;");
7879   verifyIndependentOfContext("a * [self dostuff];");
7880   verifyIndependentOfContext("int x = a * (a + b);");
7881   verifyIndependentOfContext("(a *)(a + b);");
7882   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
7883   verifyIndependentOfContext("int *pa = (int *)&a;");
7884   verifyIndependentOfContext("return sizeof(int **);");
7885   verifyIndependentOfContext("return sizeof(int ******);");
7886   verifyIndependentOfContext("return (int **&)a;");
7887   verifyIndependentOfContext("f((*PointerToArray)[10]);");
7888   verifyFormat("void f(Type (*parameter)[10]) {}");
7889   verifyFormat("void f(Type (&parameter)[10]) {}");
7890   verifyGoogleFormat("return sizeof(int**);");
7891   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
7892   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
7893   verifyFormat("auto a = [](int **&, int ***) {};");
7894   verifyFormat("auto PointerBinding = [](const char *S) {};");
7895   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
7896   verifyFormat("[](const decltype(*a) &value) {}");
7897   verifyFormat("decltype(a * b) F();");
7898   verifyFormat("#define MACRO() [](A *a) { return 1; }");
7899   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
7900   verifyIndependentOfContext("typedef void (*f)(int *a);");
7901   verifyIndependentOfContext("int i{a * b};");
7902   verifyIndependentOfContext("aaa && aaa->f();");
7903   verifyIndependentOfContext("int x = ~*p;");
7904   verifyFormat("Constructor() : a(a), area(width * height) {}");
7905   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
7906   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
7907   verifyFormat("void f() { f(a, c * d); }");
7908   verifyFormat("void f() { f(new a(), c * d); }");
7909   verifyFormat("void f(const MyOverride &override);");
7910   verifyFormat("void f(const MyFinal &final);");
7911   verifyIndependentOfContext("bool a = f() && override.f();");
7912   verifyIndependentOfContext("bool a = f() && final.f();");
7913 
7914   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
7915 
7916   verifyIndependentOfContext("A<int *> a;");
7917   verifyIndependentOfContext("A<int **> a;");
7918   verifyIndependentOfContext("A<int *, int *> a;");
7919   verifyIndependentOfContext("A<int *[]> a;");
7920   verifyIndependentOfContext(
7921       "const char *const p = reinterpret_cast<const char *const>(q);");
7922   verifyIndependentOfContext("A<int **, int **> a;");
7923   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
7924   verifyFormat("for (char **a = b; *a; ++a) {\n}");
7925   verifyFormat("for (; a && b;) {\n}");
7926   verifyFormat("bool foo = true && [] { return false; }();");
7927 
7928   verifyFormat(
7929       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7930       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7931 
7932   verifyGoogleFormat("int const* a = &b;");
7933   verifyGoogleFormat("**outparam = 1;");
7934   verifyGoogleFormat("*outparam = a * b;");
7935   verifyGoogleFormat("int main(int argc, char** argv) {}");
7936   verifyGoogleFormat("A<int*> a;");
7937   verifyGoogleFormat("A<int**> a;");
7938   verifyGoogleFormat("A<int*, int*> a;");
7939   verifyGoogleFormat("A<int**, int**> a;");
7940   verifyGoogleFormat("f(b ? *c : *d);");
7941   verifyGoogleFormat("int a = b ? *c : *d;");
7942   verifyGoogleFormat("Type* t = **x;");
7943   verifyGoogleFormat("Type* t = *++*x;");
7944   verifyGoogleFormat("*++*x;");
7945   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
7946   verifyGoogleFormat("Type* t = x++ * y;");
7947   verifyGoogleFormat(
7948       "const char* const p = reinterpret_cast<const char* const>(q);");
7949   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
7950   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
7951   verifyGoogleFormat("template <typename T>\n"
7952                      "void f(int i = 0, SomeType** temps = NULL);");
7953 
7954   FormatStyle Left = getLLVMStyle();
7955   Left.PointerAlignment = FormatStyle::PAS_Left;
7956   verifyFormat("x = *a(x) = *a(y);", Left);
7957   verifyFormat("for (;; *a = b) {\n}", Left);
7958   verifyFormat("return *this += 1;", Left);
7959   verifyFormat("throw *x;", Left);
7960   verifyFormat("delete *x;", Left);
7961   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
7962   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
7963   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
7964   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
7965   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
7966   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
7967 
7968   verifyIndependentOfContext("a = *(x + y);");
7969   verifyIndependentOfContext("a = &(x + y);");
7970   verifyIndependentOfContext("*(x + y).call();");
7971   verifyIndependentOfContext("&(x + y)->call();");
7972   verifyFormat("void f() { &(*I).first; }");
7973 
7974   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
7975   verifyFormat(
7976       "int *MyValues = {\n"
7977       "    *A, // Operator detection might be confused by the '{'\n"
7978       "    *BB // Operator detection might be confused by previous comment\n"
7979       "};");
7980 
7981   verifyIndependentOfContext("if (int *a = &b)");
7982   verifyIndependentOfContext("if (int &a = *b)");
7983   verifyIndependentOfContext("if (a & b[i])");
7984   verifyIndependentOfContext("if constexpr (a & b[i])");
7985   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
7986   verifyIndependentOfContext("if (a * (b * c))");
7987   verifyIndependentOfContext("if constexpr (a * (b * c))");
7988   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
7989   verifyIndependentOfContext("if (a::b::c::d & b[i])");
7990   verifyIndependentOfContext("if (*b[i])");
7991   verifyIndependentOfContext("if (int *a = (&b))");
7992   verifyIndependentOfContext("while (int *a = &b)");
7993   verifyIndependentOfContext("while (a * (b * c))");
7994   verifyIndependentOfContext("size = sizeof *a;");
7995   verifyIndependentOfContext("if (a && (b = c))");
7996   verifyFormat("void f() {\n"
7997                "  for (const int &v : Values) {\n"
7998                "  }\n"
7999                "}");
8000   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
8001   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
8002   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
8003 
8004   verifyFormat("#define A (!a * b)");
8005   verifyFormat("#define MACRO     \\\n"
8006                "  int *i = a * b; \\\n"
8007                "  void f(a *b);",
8008                getLLVMStyleWithColumns(19));
8009 
8010   verifyIndependentOfContext("A = new SomeType *[Length];");
8011   verifyIndependentOfContext("A = new SomeType *[Length]();");
8012   verifyIndependentOfContext("T **t = new T *;");
8013   verifyIndependentOfContext("T **t = new T *();");
8014   verifyGoogleFormat("A = new SomeType*[Length]();");
8015   verifyGoogleFormat("A = new SomeType*[Length];");
8016   verifyGoogleFormat("T** t = new T*;");
8017   verifyGoogleFormat("T** t = new T*();");
8018 
8019   verifyFormat("STATIC_ASSERT((a & b) == 0);");
8020   verifyFormat("STATIC_ASSERT(0 == (a & b));");
8021   verifyFormat("template <bool a, bool b> "
8022                "typename t::if<x && y>::type f() {}");
8023   verifyFormat("template <int *y> f() {}");
8024   verifyFormat("vector<int *> v;");
8025   verifyFormat("vector<int *const> v;");
8026   verifyFormat("vector<int *const **const *> v;");
8027   verifyFormat("vector<int *volatile> v;");
8028   verifyFormat("vector<a * b> v;");
8029   verifyFormat("foo<b && false>();");
8030   verifyFormat("foo<b & 1>();");
8031   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
8032   verifyFormat(
8033       "template <class T, class = typename std::enable_if<\n"
8034       "                       std::is_integral<T>::value &&\n"
8035       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
8036       "void F();",
8037       getLLVMStyleWithColumns(70));
8038   verifyFormat("template <class T,\n"
8039                "          class = typename std::enable_if<\n"
8040                "              std::is_integral<T>::value &&\n"
8041                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
8042                "          class U>\n"
8043                "void F();",
8044                getLLVMStyleWithColumns(70));
8045   verifyFormat(
8046       "template <class T,\n"
8047       "          class = typename ::std::enable_if<\n"
8048       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
8049       "void F();",
8050       getGoogleStyleWithColumns(68));
8051 
8052   verifyIndependentOfContext("MACRO(int *i);");
8053   verifyIndependentOfContext("MACRO(auto *a);");
8054   verifyIndependentOfContext("MACRO(const A *a);");
8055   verifyIndependentOfContext("MACRO(A *const a);");
8056   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
8057   verifyFormat("void f() { f(float{1}, a * a); }");
8058   // FIXME: Is there a way to make this work?
8059   // verifyIndependentOfContext("MACRO(A *a);");
8060 
8061   verifyFormat("DatumHandle const *operator->() const { return input_; }");
8062   verifyFormat("return options != nullptr && operator==(*options);");
8063 
8064   EXPECT_EQ("#define OP(x)                                    \\\n"
8065             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
8066             "    return s << a.DebugString();                 \\\n"
8067             "  }",
8068             format("#define OP(x) \\\n"
8069                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
8070                    "    return s << a.DebugString(); \\\n"
8071                    "  }",
8072                    getLLVMStyleWithColumns(50)));
8073 
8074   // FIXME: We cannot handle this case yet; we might be able to figure out that
8075   // foo<x> d > v; doesn't make sense.
8076   verifyFormat("foo<a<b && c> d> v;");
8077 
8078   FormatStyle PointerMiddle = getLLVMStyle();
8079   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8080   verifyFormat("delete *x;", PointerMiddle);
8081   verifyFormat("int * x;", PointerMiddle);
8082   verifyFormat("int *[] x;", PointerMiddle);
8083   verifyFormat("template <int * y> f() {}", PointerMiddle);
8084   verifyFormat("int * f(int * a) {}", PointerMiddle);
8085   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8086   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8087   verifyFormat("A<int *> a;", PointerMiddle);
8088   verifyFormat("A<int **> a;", PointerMiddle);
8089   verifyFormat("A<int *, int *> a;", PointerMiddle);
8090   verifyFormat("A<int *[]> a;", PointerMiddle);
8091   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8092   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8093   verifyFormat("T ** t = new T *;", PointerMiddle);
8094 
8095   // Member function reference qualifiers aren't binary operators.
8096   verifyFormat("string // break\n"
8097                "operator()() & {}");
8098   verifyFormat("string // break\n"
8099                "operator()() && {}");
8100   verifyGoogleFormat("template <typename T>\n"
8101                      "auto x() & -> int {}");
8102 }
8103 
8104 TEST_F(FormatTest, UnderstandsAttributes) {
8105   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8106   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8107                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8108   FormatStyle AfterType = getLLVMStyle();
8109   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
8110   verifyFormat("__attribute__((nodebug)) void\n"
8111                "foo() {}\n",
8112                AfterType);
8113 }
8114 
8115 TEST_F(FormatTest, UnderstandsSquareAttributes) {
8116   verifyFormat("SomeType s [[unused]] (InitValue);");
8117   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8118   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8119   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8120   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8121   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8122                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8123   verifyFormat("[[nodiscard]] bool f() { return false; }");
8124   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
8125   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
8126   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
8127 
8128   // Make sure we do not mistake attributes for array subscripts.
8129   verifyFormat("int a() {}\n"
8130                "[[unused]] int b() {}\n");
8131   verifyFormat("NSArray *arr;\n"
8132                "arr[[Foo() bar]];");
8133 
8134   // On the other hand, we still need to correctly find array subscripts.
8135   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8136 
8137   // Make sure that we do not mistake Objective-C method inside array literals
8138   // as attributes, even if those method names are also keywords.
8139   verifyFormat("@[ [foo bar] ];");
8140   verifyFormat("@[ [NSArray class] ];");
8141   verifyFormat("@[ [foo enum] ];");
8142 
8143   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8144 
8145   // Make sure we do not parse attributes as lambda introducers.
8146   FormatStyle MultiLineFunctions = getLLVMStyle();
8147   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8148   verifyFormat("[[unused]] int b() {\n"
8149                "  return 42;\n"
8150                "}\n",
8151                MultiLineFunctions);
8152 }
8153 
8154 TEST_F(FormatTest, AttributeClass) {
8155   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8156   verifyFormat("class S {\n"
8157                "  S(S&&) = default;\n"
8158                "};",
8159                Style);
8160   verifyFormat("class [[nodiscard]] S {\n"
8161                "  S(S&&) = default;\n"
8162                "};",
8163                Style);
8164   verifyFormat("class __attribute((maybeunused)) S {\n"
8165                "  S(S&&) = default;\n"
8166                "};",
8167                Style);
8168   verifyFormat("struct S {\n"
8169                "  S(S&&) = default;\n"
8170                "};",
8171                Style);
8172   verifyFormat("struct [[nodiscard]] S {\n"
8173                "  S(S&&) = default;\n"
8174                "};",
8175                Style);
8176 }
8177 
8178 TEST_F(FormatTest, AttributesAfterMacro) {
8179   FormatStyle Style = getLLVMStyle();
8180   verifyFormat("MACRO;\n"
8181                "__attribute__((maybe_unused)) int foo() {\n"
8182                "  //...\n"
8183                "}");
8184 
8185   verifyFormat("MACRO;\n"
8186                "[[nodiscard]] int foo() {\n"
8187                "  //...\n"
8188                "}");
8189 
8190   EXPECT_EQ("MACRO\n\n"
8191             "__attribute__((maybe_unused)) int foo() {\n"
8192             "  //...\n"
8193             "}",
8194             format("MACRO\n\n"
8195                    "__attribute__((maybe_unused)) int foo() {\n"
8196                    "  //...\n"
8197                    "}"));
8198 
8199   EXPECT_EQ("MACRO\n\n"
8200             "[[nodiscard]] int foo() {\n"
8201             "  //...\n"
8202             "}",
8203             format("MACRO\n\n"
8204                    "[[nodiscard]] int foo() {\n"
8205                    "  //...\n"
8206                    "}"));
8207 }
8208 
8209 TEST_F(FormatTest, AttributePenaltyBreaking) {
8210   FormatStyle Style = getLLVMStyle();
8211   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8212                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8213                Style);
8214   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8215                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8216                Style);
8217   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8218                "shared_ptr<ALongTypeName> &C d) {\n}",
8219                Style);
8220 }
8221 
8222 TEST_F(FormatTest, UnderstandsEllipsis) {
8223   FormatStyle Style = getLLVMStyle();
8224   verifyFormat("int printf(const char *fmt, ...);");
8225   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8226   verifyFormat("template <class... Ts> void Foo(Ts *...ts) {}");
8227 
8228   verifyFormat("template <int *...PP> a;", Style);
8229 
8230   Style.PointerAlignment = FormatStyle::PAS_Left;
8231   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", Style);
8232 
8233   verifyFormat("template <int*... PP> a;", Style);
8234 
8235   Style.PointerAlignment = FormatStyle::PAS_Middle;
8236   verifyFormat("template <int *... PP> a;", Style);
8237 }
8238 
8239 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8240   EXPECT_EQ("int *a;\n"
8241             "int *a;\n"
8242             "int *a;",
8243             format("int *a;\n"
8244                    "int* a;\n"
8245                    "int *a;",
8246                    getGoogleStyle()));
8247   EXPECT_EQ("int* a;\n"
8248             "int* a;\n"
8249             "int* a;",
8250             format("int* a;\n"
8251                    "int* a;\n"
8252                    "int *a;",
8253                    getGoogleStyle()));
8254   EXPECT_EQ("int *a;\n"
8255             "int *a;\n"
8256             "int *a;",
8257             format("int *a;\n"
8258                    "int * a;\n"
8259                    "int *  a;",
8260                    getGoogleStyle()));
8261   EXPECT_EQ("auto x = [] {\n"
8262             "  int *a;\n"
8263             "  int *a;\n"
8264             "  int *a;\n"
8265             "};",
8266             format("auto x=[]{int *a;\n"
8267                    "int * a;\n"
8268                    "int *  a;};",
8269                    getGoogleStyle()));
8270 }
8271 
8272 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8273   verifyFormat("int f(int &&a) {}");
8274   verifyFormat("int f(int a, char &&b) {}");
8275   verifyFormat("void f() { int &&a = b; }");
8276   verifyGoogleFormat("int f(int a, char&& b) {}");
8277   verifyGoogleFormat("void f() { int&& a = b; }");
8278 
8279   verifyIndependentOfContext("A<int &&> a;");
8280   verifyIndependentOfContext("A<int &&, int &&> a;");
8281   verifyGoogleFormat("A<int&&> a;");
8282   verifyGoogleFormat("A<int&&, int&&> a;");
8283 
8284   // Not rvalue references:
8285   verifyFormat("template <bool B, bool C> class A {\n"
8286                "  static_assert(B && C, \"Something is wrong\");\n"
8287                "};");
8288   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8289   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8290   verifyFormat("#define A(a, b) (a && b)");
8291 }
8292 
8293 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8294   verifyFormat("void f() {\n"
8295                "  x[aaaaaaaaa -\n"
8296                "    b] = 23;\n"
8297                "}",
8298                getLLVMStyleWithColumns(15));
8299 }
8300 
8301 TEST_F(FormatTest, FormatsCasts) {
8302   verifyFormat("Type *A = static_cast<Type *>(P);");
8303   verifyFormat("Type *A = (Type *)P;");
8304   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8305   verifyFormat("int a = (int)(2.0f);");
8306   verifyFormat("int a = (int)2.0f;");
8307   verifyFormat("x[(int32)y];");
8308   verifyFormat("x = (int32)y;");
8309   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8310   verifyFormat("int a = (int)*b;");
8311   verifyFormat("int a = (int)2.0f;");
8312   verifyFormat("int a = (int)~0;");
8313   verifyFormat("int a = (int)++a;");
8314   verifyFormat("int a = (int)sizeof(int);");
8315   verifyFormat("int a = (int)+2;");
8316   verifyFormat("my_int a = (my_int)2.0f;");
8317   verifyFormat("my_int a = (my_int)sizeof(int);");
8318   verifyFormat("return (my_int)aaa;");
8319   verifyFormat("#define x ((int)-1)");
8320   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8321   verifyFormat("#define p(q) ((int *)&q)");
8322   verifyFormat("fn(a)(b) + 1;");
8323 
8324   verifyFormat("void f() { my_int a = (my_int)*b; }");
8325   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8326   verifyFormat("my_int a = (my_int)~0;");
8327   verifyFormat("my_int a = (my_int)++a;");
8328   verifyFormat("my_int a = (my_int)-2;");
8329   verifyFormat("my_int a = (my_int)1;");
8330   verifyFormat("my_int a = (my_int *)1;");
8331   verifyFormat("my_int a = (const my_int)-1;");
8332   verifyFormat("my_int a = (const my_int *)-1;");
8333   verifyFormat("my_int a = (my_int)(my_int)-1;");
8334   verifyFormat("my_int a = (ns::my_int)-2;");
8335   verifyFormat("case (my_int)ONE:");
8336   verifyFormat("auto x = (X)this;");
8337   // Casts in Obj-C style calls used to not be recognized as such.
8338   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8339 
8340   // FIXME: single value wrapped with paren will be treated as cast.
8341   verifyFormat("void f(int i = (kValue)*kMask) {}");
8342 
8343   verifyFormat("{ (void)F; }");
8344 
8345   // Don't break after a cast's
8346   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8347                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8348                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8349 
8350   // These are not casts.
8351   verifyFormat("void f(int *) {}");
8352   verifyFormat("f(foo)->b;");
8353   verifyFormat("f(foo).b;");
8354   verifyFormat("f(foo)(b);");
8355   verifyFormat("f(foo)[b];");
8356   verifyFormat("[](foo) { return 4; }(bar);");
8357   verifyFormat("(*funptr)(foo)[4];");
8358   verifyFormat("funptrs[4](foo)[4];");
8359   verifyFormat("void f(int *);");
8360   verifyFormat("void f(int *) = 0;");
8361   verifyFormat("void f(SmallVector<int>) {}");
8362   verifyFormat("void f(SmallVector<int>);");
8363   verifyFormat("void f(SmallVector<int>) = 0;");
8364   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8365   verifyFormat("int a = sizeof(int) * b;");
8366   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8367   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8368   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8369   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8370 
8371   // These are not casts, but at some point were confused with casts.
8372   verifyFormat("virtual void foo(int *) override;");
8373   verifyFormat("virtual void foo(char &) const;");
8374   verifyFormat("virtual void foo(int *a, char *) const;");
8375   verifyFormat("int a = sizeof(int *) + b;");
8376   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8377   verifyFormat("bool b = f(g<int>) && c;");
8378   verifyFormat("typedef void (*f)(int i) func;");
8379   verifyFormat("void operator++(int) noexcept;");
8380   verifyFormat("void operator++(int &) noexcept;");
8381   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8382                "&) noexcept;");
8383   verifyFormat(
8384       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8385   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8386   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8387   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8388   verifyFormat("void operator delete(foo &) noexcept;");
8389   verifyFormat("void operator delete(foo) noexcept;");
8390   verifyFormat("void operator delete(int) noexcept;");
8391   verifyFormat("void operator delete(int &) noexcept;");
8392   verifyFormat("void operator delete(int &) volatile noexcept;");
8393   verifyFormat("void operator delete(int &) const");
8394   verifyFormat("void operator delete(int &) = default");
8395   verifyFormat("void operator delete(int &) = delete");
8396   verifyFormat("void operator delete(int &) [[noreturn]]");
8397   verifyFormat("void operator delete(int &) throw();");
8398   verifyFormat("void operator delete(int &) throw(int);");
8399   verifyFormat("auto operator delete(int &) -> int;");
8400   verifyFormat("auto operator delete(int &) override");
8401   verifyFormat("auto operator delete(int &) final");
8402 
8403   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8404                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8405   // FIXME: The indentation here is not ideal.
8406   verifyFormat(
8407       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8408       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8409       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8410 }
8411 
8412 TEST_F(FormatTest, FormatsFunctionTypes) {
8413   verifyFormat("A<bool()> a;");
8414   verifyFormat("A<SomeType()> a;");
8415   verifyFormat("A<void (*)(int, std::string)> a;");
8416   verifyFormat("A<void *(int)>;");
8417   verifyFormat("void *(*a)(int *, SomeType *);");
8418   verifyFormat("int (*func)(void *);");
8419   verifyFormat("void f() { int (*func)(void *); }");
8420   verifyFormat("template <class CallbackClass>\n"
8421                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8422 
8423   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8424   verifyGoogleFormat("void* (*a)(int);");
8425   verifyGoogleFormat(
8426       "template <class CallbackClass>\n"
8427       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8428 
8429   // Other constructs can look somewhat like function types:
8430   verifyFormat("A<sizeof(*x)> a;");
8431   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8432   verifyFormat("some_var = function(*some_pointer_var)[0];");
8433   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8434   verifyFormat("int x = f(&h)();");
8435   verifyFormat("returnsFunction(&param1, &param2)(param);");
8436   verifyFormat("std::function<\n"
8437                "    LooooooooooongTemplatedType<\n"
8438                "        SomeType>*(\n"
8439                "        LooooooooooooooooongType type)>\n"
8440                "    function;",
8441                getGoogleStyleWithColumns(40));
8442 }
8443 
8444 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8445   verifyFormat("A (*foo_)[6];");
8446   verifyFormat("vector<int> (*foo_)[6];");
8447 }
8448 
8449 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8450   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8451                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8452   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8453                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8454   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8455                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8456 
8457   // Different ways of ()-initializiation.
8458   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8459                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8460   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8461                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8462   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8463                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8464   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8465                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8466 
8467   // Lambdas should not confuse the variable declaration heuristic.
8468   verifyFormat("LooooooooooooooooongType\n"
8469                "    variable(nullptr, [](A *a) {});",
8470                getLLVMStyleWithColumns(40));
8471 }
8472 
8473 TEST_F(FormatTest, BreaksLongDeclarations) {
8474   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8475                "    AnotherNameForTheLongType;");
8476   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8477                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8478   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8479                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8480   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8481                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8482   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8483                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8484   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8485                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8486   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8487                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8488   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8489                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8490   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8491                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8492   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8493                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8494   FormatStyle Indented = getLLVMStyle();
8495   Indented.IndentWrappedFunctionNames = true;
8496   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8497                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8498                Indented);
8499   verifyFormat(
8500       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8501       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8502       Indented);
8503   verifyFormat(
8504       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8505       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8506       Indented);
8507   verifyFormat(
8508       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8509       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8510       Indented);
8511 
8512   // FIXME: Without the comment, this breaks after "(".
8513   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8514                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8515                getGoogleStyle());
8516 
8517   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8518                "                  int LoooooooooooooooooooongParam2) {}");
8519   verifyFormat(
8520       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8521       "                                   SourceLocation L, IdentifierIn *II,\n"
8522       "                                   Type *T) {}");
8523   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8524                "ReallyReaaallyLongFunctionName(\n"
8525                "    const std::string &SomeParameter,\n"
8526                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8527                "        &ReallyReallyLongParameterName,\n"
8528                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8529                "        &AnotherLongParameterName) {}");
8530   verifyFormat("template <typename A>\n"
8531                "SomeLoooooooooooooooooooooongType<\n"
8532                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8533                "Function() {}");
8534 
8535   verifyGoogleFormat(
8536       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8537       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8538   verifyGoogleFormat(
8539       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8540       "                                   SourceLocation L) {}");
8541   verifyGoogleFormat(
8542       "some_namespace::LongReturnType\n"
8543       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8544       "    int first_long_parameter, int second_parameter) {}");
8545 
8546   verifyGoogleFormat("template <typename T>\n"
8547                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8548                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8549   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8550                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8551 
8552   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8553                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8554                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8555   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8556                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8557                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8558   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8559                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8560                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8561                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8562 
8563   verifyFormat("template <typename T> // Templates on own line.\n"
8564                "static int            // Some comment.\n"
8565                "MyFunction(int a);",
8566                getLLVMStyle());
8567 }
8568 
8569 TEST_F(FormatTest, FormatsArrays) {
8570   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8571                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8572   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8573                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8574   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8575                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8576   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8577                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8578   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8579                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8580   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8581                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8582                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8583   verifyFormat(
8584       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8585       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8586       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8587   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8588                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8589 
8590   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8591                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8592   verifyFormat(
8593       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8594       "                                  .aaaaaaa[0]\n"
8595       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8596   verifyFormat("a[::b::c];");
8597 
8598   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8599 
8600   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8601   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8602 }
8603 
8604 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8605   verifyFormat("(a)->b();");
8606   verifyFormat("--a;");
8607 }
8608 
8609 TEST_F(FormatTest, HandlesIncludeDirectives) {
8610   verifyFormat("#include <string>\n"
8611                "#include <a/b/c.h>\n"
8612                "#include \"a/b/string\"\n"
8613                "#include \"string.h\"\n"
8614                "#include \"string.h\"\n"
8615                "#include <a-a>\n"
8616                "#include < path with space >\n"
8617                "#include_next <test.h>"
8618                "#include \"abc.h\" // this is included for ABC\n"
8619                "#include \"some long include\" // with a comment\n"
8620                "#include \"some very long include path\"\n"
8621                "#include <some/very/long/include/path>\n",
8622                getLLVMStyleWithColumns(35));
8623   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8624   EXPECT_EQ("#include <a>", format("#include<a>"));
8625 
8626   verifyFormat("#import <string>");
8627   verifyFormat("#import <a/b/c.h>");
8628   verifyFormat("#import \"a/b/string\"");
8629   verifyFormat("#import \"string.h\"");
8630   verifyFormat("#import \"string.h\"");
8631   verifyFormat("#if __has_include(<strstream>)\n"
8632                "#include <strstream>\n"
8633                "#endif");
8634 
8635   verifyFormat("#define MY_IMPORT <a/b>");
8636 
8637   verifyFormat("#if __has_include(<a/b>)");
8638   verifyFormat("#if __has_include_next(<a/b>)");
8639   verifyFormat("#define F __has_include(<a/b>)");
8640   verifyFormat("#define F __has_include_next(<a/b>)");
8641 
8642   // Protocol buffer definition or missing "#".
8643   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8644                getLLVMStyleWithColumns(30));
8645 
8646   FormatStyle Style = getLLVMStyle();
8647   Style.AlwaysBreakBeforeMultilineStrings = true;
8648   Style.ColumnLimit = 0;
8649   verifyFormat("#import \"abc.h\"", Style);
8650 
8651   // But 'import' might also be a regular C++ namespace.
8652   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8653                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8654 }
8655 
8656 //===----------------------------------------------------------------------===//
8657 // Error recovery tests.
8658 //===----------------------------------------------------------------------===//
8659 
8660 TEST_F(FormatTest, IncompleteParameterLists) {
8661   FormatStyle NoBinPacking = getLLVMStyle();
8662   NoBinPacking.BinPackParameters = false;
8663   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8664                "                        double *min_x,\n"
8665                "                        double *max_x,\n"
8666                "                        double *min_y,\n"
8667                "                        double *max_y,\n"
8668                "                        double *min_z,\n"
8669                "                        double *max_z, ) {}",
8670                NoBinPacking);
8671 }
8672 
8673 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8674   verifyFormat("void f() { return; }\n42");
8675   verifyFormat("void f() {\n"
8676                "  if (0)\n"
8677                "    return;\n"
8678                "}\n"
8679                "42");
8680   verifyFormat("void f() { return }\n42");
8681   verifyFormat("void f() {\n"
8682                "  if (0)\n"
8683                "    return\n"
8684                "}\n"
8685                "42");
8686 }
8687 
8688 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
8689   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
8690   EXPECT_EQ("void f() {\n"
8691             "  if (a)\n"
8692             "    return\n"
8693             "}",
8694             format("void  f  (  )  {  if  ( a )  return  }"));
8695   EXPECT_EQ("namespace N {\n"
8696             "void f()\n"
8697             "}",
8698             format("namespace  N  {  void f()  }"));
8699   EXPECT_EQ("namespace N {\n"
8700             "void f() {}\n"
8701             "void g()\n"
8702             "} // namespace N",
8703             format("namespace N  { void f( ) { } void g( ) }"));
8704 }
8705 
8706 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
8707   verifyFormat("int aaaaaaaa =\n"
8708                "    // Overlylongcomment\n"
8709                "    b;",
8710                getLLVMStyleWithColumns(20));
8711   verifyFormat("function(\n"
8712                "    ShortArgument,\n"
8713                "    LoooooooooooongArgument);\n",
8714                getLLVMStyleWithColumns(20));
8715 }
8716 
8717 TEST_F(FormatTest, IncorrectAccessSpecifier) {
8718   verifyFormat("public:");
8719   verifyFormat("class A {\n"
8720                "public\n"
8721                "  void f() {}\n"
8722                "};");
8723   verifyFormat("public\n"
8724                "int qwerty;");
8725   verifyFormat("public\n"
8726                "B {}");
8727   verifyFormat("public\n"
8728                "{}");
8729   verifyFormat("public\n"
8730                "B { int x; }");
8731 }
8732 
8733 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
8734   verifyFormat("{");
8735   verifyFormat("#})");
8736   verifyNoCrash("(/**/[:!] ?[).");
8737 }
8738 
8739 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
8740   // Found by oss-fuzz:
8741   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
8742   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
8743   Style.ColumnLimit = 60;
8744   verifyNoCrash(
8745       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
8746       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
8747       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
8748       Style);
8749 }
8750 
8751 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
8752   verifyFormat("do {\n}");
8753   verifyFormat("do {\n}\n"
8754                "f();");
8755   verifyFormat("do {\n}\n"
8756                "wheeee(fun);");
8757   verifyFormat("do {\n"
8758                "  f();\n"
8759                "}");
8760 }
8761 
8762 TEST_F(FormatTest, IncorrectCodeMissingParens) {
8763   verifyFormat("if {\n  foo;\n  foo();\n}");
8764   verifyFormat("switch {\n  foo;\n  foo();\n}");
8765   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
8766   verifyFormat("while {\n  foo;\n  foo();\n}");
8767   verifyFormat("do {\n  foo;\n  foo();\n} while;");
8768 }
8769 
8770 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
8771   verifyIncompleteFormat("namespace {\n"
8772                          "class Foo { Foo (\n"
8773                          "};\n"
8774                          "} // namespace");
8775 }
8776 
8777 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
8778   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
8779   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
8780   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
8781   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
8782 
8783   EXPECT_EQ("{\n"
8784             "  {\n"
8785             "    breakme(\n"
8786             "        qwe);\n"
8787             "  }\n",
8788             format("{\n"
8789                    "    {\n"
8790                    " breakme(qwe);\n"
8791                    "}\n",
8792                    getLLVMStyleWithColumns(10)));
8793 }
8794 
8795 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
8796   verifyFormat("int x = {\n"
8797                "    avariable,\n"
8798                "    b(alongervariable)};",
8799                getLLVMStyleWithColumns(25));
8800 }
8801 
8802 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
8803   verifyFormat("return (a)(b){1, 2, 3};");
8804 }
8805 
8806 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
8807   verifyFormat("vector<int> x{1, 2, 3, 4};");
8808   verifyFormat("vector<int> x{\n"
8809                "    1,\n"
8810                "    2,\n"
8811                "    3,\n"
8812                "    4,\n"
8813                "};");
8814   verifyFormat("vector<T> x{{}, {}, {}, {}};");
8815   verifyFormat("f({1, 2});");
8816   verifyFormat("auto v = Foo{-1};");
8817   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
8818   verifyFormat("Class::Class : member{1, 2, 3} {}");
8819   verifyFormat("new vector<int>{1, 2, 3};");
8820   verifyFormat("new int[3]{1, 2, 3};");
8821   verifyFormat("new int{1};");
8822   verifyFormat("return {arg1, arg2};");
8823   verifyFormat("return {arg1, SomeType{parameter}};");
8824   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
8825   verifyFormat("new T{arg1, arg2};");
8826   verifyFormat("f(MyMap[{composite, key}]);");
8827   verifyFormat("class Class {\n"
8828                "  T member = {arg1, arg2};\n"
8829                "};");
8830   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
8831   verifyFormat("const struct A a = {.a = 1, .b = 2};");
8832   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
8833   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
8834   verifyFormat("int a = std::is_integral<int>{} + 0;");
8835 
8836   verifyFormat("int foo(int i) { return fo1{}(i); }");
8837   verifyFormat("int foo(int i) { return fo1{}(i); }");
8838   verifyFormat("auto i = decltype(x){};");
8839   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
8840   verifyFormat("Node n{1, Node{1000}, //\n"
8841                "       2};");
8842   verifyFormat("Aaaa aaaaaaa{\n"
8843                "    {\n"
8844                "        aaaa,\n"
8845                "    },\n"
8846                "};");
8847   verifyFormat("class C : public D {\n"
8848                "  SomeClass SC{2};\n"
8849                "};");
8850   verifyFormat("class C : public A {\n"
8851                "  class D : public B {\n"
8852                "    void f() { int i{2}; }\n"
8853                "  };\n"
8854                "};");
8855   verifyFormat("#define A {a, a},");
8856 
8857   // Avoid breaking between equal sign and opening brace
8858   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
8859   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
8860   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
8861                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
8862                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
8863                "     {\"ccccccccccccccccccccc\", 2}};",
8864                AvoidBreakingFirstArgument);
8865 
8866   // Binpacking only if there is no trailing comma
8867   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
8868                "                      cccccccccc, dddddddddd};",
8869                getLLVMStyleWithColumns(50));
8870   verifyFormat("const Aaaaaa aaaaa = {\n"
8871                "    aaaaaaaaaaa,\n"
8872                "    bbbbbbbbbbb,\n"
8873                "    ccccccccccc,\n"
8874                "    ddddddddddd,\n"
8875                "};",
8876                getLLVMStyleWithColumns(50));
8877 
8878   // Cases where distinguising braced lists and blocks is hard.
8879   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
8880   verifyFormat("void f() {\n"
8881                "  return; // comment\n"
8882                "}\n"
8883                "SomeType t;");
8884   verifyFormat("void f() {\n"
8885                "  if (a) {\n"
8886                "    f();\n"
8887                "  }\n"
8888                "}\n"
8889                "SomeType t;");
8890 
8891   // In combination with BinPackArguments = false.
8892   FormatStyle NoBinPacking = getLLVMStyle();
8893   NoBinPacking.BinPackArguments = false;
8894   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
8895                "                      bbbbb,\n"
8896                "                      ccccc,\n"
8897                "                      ddddd,\n"
8898                "                      eeeee,\n"
8899                "                      ffffff,\n"
8900                "                      ggggg,\n"
8901                "                      hhhhhh,\n"
8902                "                      iiiiii,\n"
8903                "                      jjjjjj,\n"
8904                "                      kkkkkk};",
8905                NoBinPacking);
8906   verifyFormat("const Aaaaaa aaaaa = {\n"
8907                "    aaaaa,\n"
8908                "    bbbbb,\n"
8909                "    ccccc,\n"
8910                "    ddddd,\n"
8911                "    eeeee,\n"
8912                "    ffffff,\n"
8913                "    ggggg,\n"
8914                "    hhhhhh,\n"
8915                "    iiiiii,\n"
8916                "    jjjjjj,\n"
8917                "    kkkkkk,\n"
8918                "};",
8919                NoBinPacking);
8920   verifyFormat(
8921       "const Aaaaaa aaaaa = {\n"
8922       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
8923       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
8924       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
8925       "};",
8926       NoBinPacking);
8927 
8928   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
8929   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
8930             "    CDDDP83848_BMCR_REGISTER,\n"
8931             "    CDDDP83848_BMSR_REGISTER,\n"
8932             "    CDDDP83848_RBR_REGISTER};",
8933             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
8934                    "                                CDDDP83848_BMSR_REGISTER,\n"
8935                    "                                CDDDP83848_RBR_REGISTER};",
8936                    NoBinPacking));
8937 
8938   // FIXME: The alignment of these trailing comments might be bad. Then again,
8939   // this might be utterly useless in real code.
8940   verifyFormat("Constructor::Constructor()\n"
8941                "    : some_value{         //\n"
8942                "                 aaaaaaa, //\n"
8943                "                 bbbbbbb} {}");
8944 
8945   // In braced lists, the first comment is always assumed to belong to the
8946   // first element. Thus, it can be moved to the next or previous line as
8947   // appropriate.
8948   EXPECT_EQ("function({// First element:\n"
8949             "          1,\n"
8950             "          // Second element:\n"
8951             "          2});",
8952             format("function({\n"
8953                    "    // First element:\n"
8954                    "    1,\n"
8955                    "    // Second element:\n"
8956                    "    2});"));
8957   EXPECT_EQ("std::vector<int> MyNumbers{\n"
8958             "    // First element:\n"
8959             "    1,\n"
8960             "    // Second element:\n"
8961             "    2};",
8962             format("std::vector<int> MyNumbers{// First element:\n"
8963                    "                           1,\n"
8964                    "                           // Second element:\n"
8965                    "                           2};",
8966                    getLLVMStyleWithColumns(30)));
8967   // A trailing comma should still lead to an enforced line break and no
8968   // binpacking.
8969   EXPECT_EQ("vector<int> SomeVector = {\n"
8970             "    // aaa\n"
8971             "    1,\n"
8972             "    2,\n"
8973             "};",
8974             format("vector<int> SomeVector = { // aaa\n"
8975                    "    1, 2, };"));
8976 
8977   // C++11 brace initializer list l-braces should not be treated any differently
8978   // when breaking before lambda bodies is enabled
8979   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
8980   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
8981   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
8982   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
8983   verifyFormat(
8984       "std::runtime_error{\n"
8985       "    \"Long string which will force a break onto the next line...\"};",
8986       BreakBeforeLambdaBody);
8987 
8988   FormatStyle ExtraSpaces = getLLVMStyle();
8989   ExtraSpaces.Cpp11BracedListStyle = false;
8990   ExtraSpaces.ColumnLimit = 75;
8991   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
8992   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
8993   verifyFormat("f({ 1, 2 });", ExtraSpaces);
8994   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
8995   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
8996   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
8997   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
8998   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
8999   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
9000   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
9001   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
9002   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
9003   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
9004   verifyFormat("class Class {\n"
9005                "  T member = { arg1, arg2 };\n"
9006                "};",
9007                ExtraSpaces);
9008   verifyFormat(
9009       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9010       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
9011       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
9012       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
9013       ExtraSpaces);
9014   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
9015   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
9016                ExtraSpaces);
9017   verifyFormat(
9018       "someFunction(OtherParam,\n"
9019       "             BracedList{ // comment 1 (Forcing interesting break)\n"
9020       "                         param1, param2,\n"
9021       "                         // comment 2\n"
9022       "                         param3, param4 });",
9023       ExtraSpaces);
9024   verifyFormat(
9025       "std::this_thread::sleep_for(\n"
9026       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
9027       ExtraSpaces);
9028   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
9029                "    aaaaaaa,\n"
9030                "    aaaaaaaaaa,\n"
9031                "    aaaaa,\n"
9032                "    aaaaaaaaaaaaaaa,\n"
9033                "    aaa,\n"
9034                "    aaaaaaaaaa,\n"
9035                "    a,\n"
9036                "    aaaaaaaaaaaaaaaaaaaaa,\n"
9037                "    aaaaaaaaaaaa,\n"
9038                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
9039                "    aaaaaaa,\n"
9040                "    a};");
9041   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
9042   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
9043   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
9044 
9045   // Avoid breaking between initializer/equal sign and opening brace
9046   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
9047   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
9048                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9049                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9050                "  { \"ccccccccccccccccccccc\", 2 }\n"
9051                "};",
9052                ExtraSpaces);
9053   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
9054                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9055                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9056                "  { \"ccccccccccccccccccccc\", 2 }\n"
9057                "};",
9058                ExtraSpaces);
9059 
9060   FormatStyle SpaceBeforeBrace = getLLVMStyle();
9061   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9062   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9063   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9064 
9065   FormatStyle SpaceBetweenBraces = getLLVMStyle();
9066   SpaceBetweenBraces.SpacesInAngles = true;
9067   SpaceBetweenBraces.SpacesInParentheses = true;
9068   SpaceBetweenBraces.SpacesInSquareBrackets = true;
9069   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9070   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9071   verifyFormat("vector< int > x{ // comment 1\n"
9072                "                 1, 2, 3, 4 };",
9073                SpaceBetweenBraces);
9074   SpaceBetweenBraces.ColumnLimit = 20;
9075   EXPECT_EQ("vector< int > x{\n"
9076             "    1, 2, 3, 4 };",
9077             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9078   SpaceBetweenBraces.ColumnLimit = 24;
9079   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9080             "                 3, 4 };",
9081             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9082   EXPECT_EQ("vector< int > x{\n"
9083             "    1,\n"
9084             "    2,\n"
9085             "    3,\n"
9086             "    4,\n"
9087             "};",
9088             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9089   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9090   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9091   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9092 }
9093 
9094 TEST_F(FormatTest, FormatSpacesInAngles) {
9095   FormatStyle SpaceInAngles = getLLVMStyle();
9096   SpaceInAngles.SpacesInAngles = true;
9097   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9098   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9099   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9100 
9101   SpaceInAngles.SpacesInAngles = false;
9102   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9103   verifyFormat("vector<int> x5;", SpaceInAngles);
9104   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9105   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9106 }
9107 
9108 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9109   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9110                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9111                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9112                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9113                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9114                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9115   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9116                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9117                "                 1, 22, 333, 4444, 55555, //\n"
9118                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9119                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9120   verifyFormat(
9121       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9122       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9123       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9124       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9125       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9126       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9127       "                 7777777};");
9128   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9129                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9130                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9131   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9132                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9133                "    // Separating comment.\n"
9134                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9135   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9136                "    // Leading comment\n"
9137                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9138                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9139   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9140                "                 1, 1, 1, 1};",
9141                getLLVMStyleWithColumns(39));
9142   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9143                "                 1, 1, 1, 1};",
9144                getLLVMStyleWithColumns(38));
9145   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9146                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9147                getLLVMStyleWithColumns(43));
9148   verifyFormat(
9149       "static unsigned SomeValues[10][3] = {\n"
9150       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9151       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9152   verifyFormat("static auto fields = new vector<string>{\n"
9153                "    \"aaaaaaaaaaaaa\",\n"
9154                "    \"aaaaaaaaaaaaa\",\n"
9155                "    \"aaaaaaaaaaaa\",\n"
9156                "    \"aaaaaaaaaaaaaa\",\n"
9157                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9158                "    \"aaaaaaaaaaaa\",\n"
9159                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9160                "};");
9161   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9162   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9163                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9164                "                 3, cccccccccccccccccccccc};",
9165                getLLVMStyleWithColumns(60));
9166 
9167   // Trailing commas.
9168   verifyFormat("vector<int> x = {\n"
9169                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9170                "};",
9171                getLLVMStyleWithColumns(39));
9172   verifyFormat("vector<int> x = {\n"
9173                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9174                "};",
9175                getLLVMStyleWithColumns(39));
9176   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9177                "                 1, 1, 1, 1,\n"
9178                "                 /**/ /**/};",
9179                getLLVMStyleWithColumns(39));
9180 
9181   // Trailing comment in the first line.
9182   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9183                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9184                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9185                "    11111111,   22222222,   333333333,   44444444};");
9186   // Trailing comment in the last line.
9187   verifyFormat("int aaaaa[] = {\n"
9188                "    1, 2, 3, // comment\n"
9189                "    4, 5, 6  // comment\n"
9190                "};");
9191 
9192   // With nested lists, we should either format one item per line or all nested
9193   // lists one on line.
9194   // FIXME: For some nested lists, we can do better.
9195   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9196                "        {aaaaaaaaaaaaaaaaaaa},\n"
9197                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9198                "        {aaaaaaaaaaaaaaaaa}};",
9199                getLLVMStyleWithColumns(60));
9200   verifyFormat(
9201       "SomeStruct my_struct_array = {\n"
9202       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9203       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9204       "    {aaa, aaa},\n"
9205       "    {aaa, aaa},\n"
9206       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9207       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9208       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9209 
9210   // No column layout should be used here.
9211   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9212                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9213 
9214   verifyNoCrash("a<,");
9215 
9216   // No braced initializer here.
9217   verifyFormat("void f() {\n"
9218                "  struct Dummy {};\n"
9219                "  f(v);\n"
9220                "}");
9221 
9222   // Long lists should be formatted in columns even if they are nested.
9223   verifyFormat(
9224       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9225       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9226       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9227       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9228       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9229       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9230 
9231   // Allow "single-column" layout even if that violates the column limit. There
9232   // isn't going to be a better way.
9233   verifyFormat("std::vector<int> a = {\n"
9234                "    aaaaaaaa,\n"
9235                "    aaaaaaaa,\n"
9236                "    aaaaaaaa,\n"
9237                "    aaaaaaaa,\n"
9238                "    aaaaaaaaaa,\n"
9239                "    aaaaaaaa,\n"
9240                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9241                getLLVMStyleWithColumns(30));
9242   verifyFormat("vector<int> aaaa = {\n"
9243                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9244                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9245                "    aaaaaa.aaaaaaa,\n"
9246                "    aaaaaa.aaaaaaa,\n"
9247                "    aaaaaa.aaaaaaa,\n"
9248                "    aaaaaa.aaaaaaa,\n"
9249                "};");
9250 
9251   // Don't create hanging lists.
9252   verifyFormat("someFunction(Param, {List1, List2,\n"
9253                "                     List3});",
9254                getLLVMStyleWithColumns(35));
9255   verifyFormat("someFunction(Param, Param,\n"
9256                "             {List1, List2,\n"
9257                "              List3});",
9258                getLLVMStyleWithColumns(35));
9259   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9260                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9261 }
9262 
9263 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9264   FormatStyle DoNotMerge = getLLVMStyle();
9265   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9266 
9267   verifyFormat("void f() { return 42; }");
9268   verifyFormat("void f() {\n"
9269                "  return 42;\n"
9270                "}",
9271                DoNotMerge);
9272   verifyFormat("void f() {\n"
9273                "  // Comment\n"
9274                "}");
9275   verifyFormat("{\n"
9276                "#error {\n"
9277                "  int a;\n"
9278                "}");
9279   verifyFormat("{\n"
9280                "  int a;\n"
9281                "#error {\n"
9282                "}");
9283   verifyFormat("void f() {} // comment");
9284   verifyFormat("void f() { int a; } // comment");
9285   verifyFormat("void f() {\n"
9286                "} // comment",
9287                DoNotMerge);
9288   verifyFormat("void f() {\n"
9289                "  int a;\n"
9290                "} // comment",
9291                DoNotMerge);
9292   verifyFormat("void f() {\n"
9293                "} // comment",
9294                getLLVMStyleWithColumns(15));
9295 
9296   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9297   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9298 
9299   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9300   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9301   verifyFormat("class C {\n"
9302                "  C()\n"
9303                "      : iiiiiiii(nullptr),\n"
9304                "        kkkkkkk(nullptr),\n"
9305                "        mmmmmmm(nullptr),\n"
9306                "        nnnnnnn(nullptr) {}\n"
9307                "};",
9308                getGoogleStyle());
9309 
9310   FormatStyle NoColumnLimit = getLLVMStyle();
9311   NoColumnLimit.ColumnLimit = 0;
9312   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9313   EXPECT_EQ("class C {\n"
9314             "  A() : b(0) {}\n"
9315             "};",
9316             format("class C{A():b(0){}};", NoColumnLimit));
9317   EXPECT_EQ("A()\n"
9318             "    : b(0) {\n"
9319             "}",
9320             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9321 
9322   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9323   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9324       FormatStyle::SFS_None;
9325   EXPECT_EQ("A()\n"
9326             "    : b(0) {\n"
9327             "}",
9328             format("A():b(0){}", DoNotMergeNoColumnLimit));
9329   EXPECT_EQ("A()\n"
9330             "    : b(0) {\n"
9331             "}",
9332             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9333 
9334   verifyFormat("#define A          \\\n"
9335                "  void f() {       \\\n"
9336                "    int i;         \\\n"
9337                "  }",
9338                getLLVMStyleWithColumns(20));
9339   verifyFormat("#define A           \\\n"
9340                "  void f() { int i; }",
9341                getLLVMStyleWithColumns(21));
9342   verifyFormat("#define A            \\\n"
9343                "  void f() {         \\\n"
9344                "    int i;           \\\n"
9345                "  }                  \\\n"
9346                "  int j;",
9347                getLLVMStyleWithColumns(22));
9348   verifyFormat("#define A             \\\n"
9349                "  void f() { int i; } \\\n"
9350                "  int j;",
9351                getLLVMStyleWithColumns(23));
9352 }
9353 
9354 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9355   FormatStyle MergeEmptyOnly = getLLVMStyle();
9356   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9357   verifyFormat("class C {\n"
9358                "  int f() {}\n"
9359                "};",
9360                MergeEmptyOnly);
9361   verifyFormat("class C {\n"
9362                "  int f() {\n"
9363                "    return 42;\n"
9364                "  }\n"
9365                "};",
9366                MergeEmptyOnly);
9367   verifyFormat("int f() {}", MergeEmptyOnly);
9368   verifyFormat("int f() {\n"
9369                "  return 42;\n"
9370                "}",
9371                MergeEmptyOnly);
9372 
9373   // Also verify behavior when BraceWrapping.AfterFunction = true
9374   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9375   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9376   verifyFormat("int f() {}", MergeEmptyOnly);
9377   verifyFormat("class C {\n"
9378                "  int f() {}\n"
9379                "};",
9380                MergeEmptyOnly);
9381 }
9382 
9383 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9384   FormatStyle MergeInlineOnly = getLLVMStyle();
9385   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9386   verifyFormat("class C {\n"
9387                "  int f() { return 42; }\n"
9388                "};",
9389                MergeInlineOnly);
9390   verifyFormat("int f() {\n"
9391                "  return 42;\n"
9392                "}",
9393                MergeInlineOnly);
9394 
9395   // SFS_Inline implies SFS_Empty
9396   verifyFormat("class C {\n"
9397                "  int f() {}\n"
9398                "};",
9399                MergeInlineOnly);
9400   verifyFormat("int f() {}", MergeInlineOnly);
9401 
9402   // Also verify behavior when BraceWrapping.AfterFunction = true
9403   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9404   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9405   verifyFormat("class C {\n"
9406                "  int f() { return 42; }\n"
9407                "};",
9408                MergeInlineOnly);
9409   verifyFormat("int f()\n"
9410                "{\n"
9411                "  return 42;\n"
9412                "}",
9413                MergeInlineOnly);
9414 
9415   // SFS_Inline implies SFS_Empty
9416   verifyFormat("int f() {}", MergeInlineOnly);
9417   verifyFormat("class C {\n"
9418                "  int f() {}\n"
9419                "};",
9420                MergeInlineOnly);
9421 }
9422 
9423 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9424   FormatStyle MergeInlineOnly = getLLVMStyle();
9425   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9426       FormatStyle::SFS_InlineOnly;
9427   verifyFormat("class C {\n"
9428                "  int f() { return 42; }\n"
9429                "};",
9430                MergeInlineOnly);
9431   verifyFormat("int f() {\n"
9432                "  return 42;\n"
9433                "}",
9434                MergeInlineOnly);
9435 
9436   // SFS_InlineOnly does not imply SFS_Empty
9437   verifyFormat("class C {\n"
9438                "  int f() {}\n"
9439                "};",
9440                MergeInlineOnly);
9441   verifyFormat("int f() {\n"
9442                "}",
9443                MergeInlineOnly);
9444 
9445   // Also verify behavior when BraceWrapping.AfterFunction = true
9446   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9447   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9448   verifyFormat("class C {\n"
9449                "  int f() { return 42; }\n"
9450                "};",
9451                MergeInlineOnly);
9452   verifyFormat("int f()\n"
9453                "{\n"
9454                "  return 42;\n"
9455                "}",
9456                MergeInlineOnly);
9457 
9458   // SFS_InlineOnly does not imply SFS_Empty
9459   verifyFormat("int f()\n"
9460                "{\n"
9461                "}",
9462                MergeInlineOnly);
9463   verifyFormat("class C {\n"
9464                "  int f() {}\n"
9465                "};",
9466                MergeInlineOnly);
9467 }
9468 
9469 TEST_F(FormatTest, SplitEmptyFunction) {
9470   FormatStyle Style = getLLVMStyle();
9471   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9472   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9473   Style.BraceWrapping.AfterFunction = true;
9474   Style.BraceWrapping.SplitEmptyFunction = false;
9475   Style.ColumnLimit = 40;
9476 
9477   verifyFormat("int f()\n"
9478                "{}",
9479                Style);
9480   verifyFormat("int f()\n"
9481                "{\n"
9482                "  return 42;\n"
9483                "}",
9484                Style);
9485   verifyFormat("int f()\n"
9486                "{\n"
9487                "  // some comment\n"
9488                "}",
9489                Style);
9490 
9491   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9492   verifyFormat("int f() {}", Style);
9493   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9494                "{}",
9495                Style);
9496   verifyFormat("int f()\n"
9497                "{\n"
9498                "  return 0;\n"
9499                "}",
9500                Style);
9501 
9502   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9503   verifyFormat("class Foo {\n"
9504                "  int f() {}\n"
9505                "};\n",
9506                Style);
9507   verifyFormat("class Foo {\n"
9508                "  int f() { return 0; }\n"
9509                "};\n",
9510                Style);
9511   verifyFormat("class Foo {\n"
9512                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9513                "  {}\n"
9514                "};\n",
9515                Style);
9516   verifyFormat("class Foo {\n"
9517                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9518                "  {\n"
9519                "    return 0;\n"
9520                "  }\n"
9521                "};\n",
9522                Style);
9523 
9524   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9525   verifyFormat("int f() {}", Style);
9526   verifyFormat("int f() { return 0; }", Style);
9527   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9528                "{}",
9529                Style);
9530   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9531                "{\n"
9532                "  return 0;\n"
9533                "}",
9534                Style);
9535 }
9536 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9537   FormatStyle Style = getLLVMStyle();
9538   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9539   verifyFormat("#ifdef A\n"
9540                "int f() {}\n"
9541                "#else\n"
9542                "int g() {}\n"
9543                "#endif",
9544                Style);
9545 }
9546 
9547 TEST_F(FormatTest, SplitEmptyClass) {
9548   FormatStyle Style = getLLVMStyle();
9549   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9550   Style.BraceWrapping.AfterClass = true;
9551   Style.BraceWrapping.SplitEmptyRecord = false;
9552 
9553   verifyFormat("class Foo\n"
9554                "{};",
9555                Style);
9556   verifyFormat("/* something */ class Foo\n"
9557                "{};",
9558                Style);
9559   verifyFormat("template <typename X> class Foo\n"
9560                "{};",
9561                Style);
9562   verifyFormat("class Foo\n"
9563                "{\n"
9564                "  Foo();\n"
9565                "};",
9566                Style);
9567   verifyFormat("typedef class Foo\n"
9568                "{\n"
9569                "} Foo_t;",
9570                Style);
9571 }
9572 
9573 TEST_F(FormatTest, SplitEmptyStruct) {
9574   FormatStyle Style = getLLVMStyle();
9575   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9576   Style.BraceWrapping.AfterStruct = true;
9577   Style.BraceWrapping.SplitEmptyRecord = false;
9578 
9579   verifyFormat("struct Foo\n"
9580                "{};",
9581                Style);
9582   verifyFormat("/* something */ struct Foo\n"
9583                "{};",
9584                Style);
9585   verifyFormat("template <typename X> struct Foo\n"
9586                "{};",
9587                Style);
9588   verifyFormat("struct Foo\n"
9589                "{\n"
9590                "  Foo();\n"
9591                "};",
9592                Style);
9593   verifyFormat("typedef struct Foo\n"
9594                "{\n"
9595                "} Foo_t;",
9596                Style);
9597   // typedef struct Bar {} Bar_t;
9598 }
9599 
9600 TEST_F(FormatTest, SplitEmptyUnion) {
9601   FormatStyle Style = getLLVMStyle();
9602   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9603   Style.BraceWrapping.AfterUnion = true;
9604   Style.BraceWrapping.SplitEmptyRecord = false;
9605 
9606   verifyFormat("union Foo\n"
9607                "{};",
9608                Style);
9609   verifyFormat("/* something */ union Foo\n"
9610                "{};",
9611                Style);
9612   verifyFormat("union Foo\n"
9613                "{\n"
9614                "  A,\n"
9615                "};",
9616                Style);
9617   verifyFormat("typedef union Foo\n"
9618                "{\n"
9619                "} Foo_t;",
9620                Style);
9621 }
9622 
9623 TEST_F(FormatTest, SplitEmptyNamespace) {
9624   FormatStyle Style = getLLVMStyle();
9625   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9626   Style.BraceWrapping.AfterNamespace = true;
9627   Style.BraceWrapping.SplitEmptyNamespace = false;
9628 
9629   verifyFormat("namespace Foo\n"
9630                "{};",
9631                Style);
9632   verifyFormat("/* something */ namespace Foo\n"
9633                "{};",
9634                Style);
9635   verifyFormat("inline namespace Foo\n"
9636                "{};",
9637                Style);
9638   verifyFormat("/* something */ inline namespace Foo\n"
9639                "{};",
9640                Style);
9641   verifyFormat("export namespace Foo\n"
9642                "{};",
9643                Style);
9644   verifyFormat("namespace Foo\n"
9645                "{\n"
9646                "void Bar();\n"
9647                "};",
9648                Style);
9649 }
9650 
9651 TEST_F(FormatTest, NeverMergeShortRecords) {
9652   FormatStyle Style = getLLVMStyle();
9653 
9654   verifyFormat("class Foo {\n"
9655                "  Foo();\n"
9656                "};",
9657                Style);
9658   verifyFormat("typedef class Foo {\n"
9659                "  Foo();\n"
9660                "} Foo_t;",
9661                Style);
9662   verifyFormat("struct Foo {\n"
9663                "  Foo();\n"
9664                "};",
9665                Style);
9666   verifyFormat("typedef struct Foo {\n"
9667                "  Foo();\n"
9668                "} Foo_t;",
9669                Style);
9670   verifyFormat("union Foo {\n"
9671                "  A,\n"
9672                "};",
9673                Style);
9674   verifyFormat("typedef union Foo {\n"
9675                "  A,\n"
9676                "} Foo_t;",
9677                Style);
9678   verifyFormat("namespace Foo {\n"
9679                "void Bar();\n"
9680                "};",
9681                Style);
9682 
9683   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9684   Style.BraceWrapping.AfterClass = true;
9685   Style.BraceWrapping.AfterStruct = true;
9686   Style.BraceWrapping.AfterUnion = true;
9687   Style.BraceWrapping.AfterNamespace = true;
9688   verifyFormat("class Foo\n"
9689                "{\n"
9690                "  Foo();\n"
9691                "};",
9692                Style);
9693   verifyFormat("typedef class Foo\n"
9694                "{\n"
9695                "  Foo();\n"
9696                "} Foo_t;",
9697                Style);
9698   verifyFormat("struct Foo\n"
9699                "{\n"
9700                "  Foo();\n"
9701                "};",
9702                Style);
9703   verifyFormat("typedef struct Foo\n"
9704                "{\n"
9705                "  Foo();\n"
9706                "} Foo_t;",
9707                Style);
9708   verifyFormat("union Foo\n"
9709                "{\n"
9710                "  A,\n"
9711                "};",
9712                Style);
9713   verifyFormat("typedef union Foo\n"
9714                "{\n"
9715                "  A,\n"
9716                "} Foo_t;",
9717                Style);
9718   verifyFormat("namespace Foo\n"
9719                "{\n"
9720                "void Bar();\n"
9721                "};",
9722                Style);
9723 }
9724 
9725 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
9726   // Elaborate type variable declarations.
9727   verifyFormat("struct foo a = {bar};\nint n;");
9728   verifyFormat("class foo a = {bar};\nint n;");
9729   verifyFormat("union foo a = {bar};\nint n;");
9730 
9731   // Elaborate types inside function definitions.
9732   verifyFormat("struct foo f() {}\nint n;");
9733   verifyFormat("class foo f() {}\nint n;");
9734   verifyFormat("union foo f() {}\nint n;");
9735 
9736   // Templates.
9737   verifyFormat("template <class X> void f() {}\nint n;");
9738   verifyFormat("template <struct X> void f() {}\nint n;");
9739   verifyFormat("template <union X> void f() {}\nint n;");
9740 
9741   // Actual definitions...
9742   verifyFormat("struct {\n} n;");
9743   verifyFormat(
9744       "template <template <class T, class Y>, class Z> class X {\n} n;");
9745   verifyFormat("union Z {\n  int n;\n} x;");
9746   verifyFormat("class MACRO Z {\n} n;");
9747   verifyFormat("class MACRO(X) Z {\n} n;");
9748   verifyFormat("class __attribute__(X) Z {\n} n;");
9749   verifyFormat("class __declspec(X) Z {\n} n;");
9750   verifyFormat("class A##B##C {\n} n;");
9751   verifyFormat("class alignas(16) Z {\n} n;");
9752   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
9753   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
9754 
9755   // Redefinition from nested context:
9756   verifyFormat("class A::B::C {\n} n;");
9757 
9758   // Template definitions.
9759   verifyFormat(
9760       "template <typename F>\n"
9761       "Matcher(const Matcher<F> &Other,\n"
9762       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
9763       "                             !is_same<F, T>::value>::type * = 0)\n"
9764       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
9765 
9766   // FIXME: This is still incorrectly handled at the formatter side.
9767   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
9768   verifyFormat("int i = SomeFunction(a<b, a> b);");
9769 
9770   // FIXME:
9771   // This now gets parsed incorrectly as class definition.
9772   // verifyFormat("class A<int> f() {\n}\nint n;");
9773 
9774   // Elaborate types where incorrectly parsing the structural element would
9775   // break the indent.
9776   verifyFormat("if (true)\n"
9777                "  class X x;\n"
9778                "else\n"
9779                "  f();\n");
9780 
9781   // This is simply incomplete. Formatting is not important, but must not crash.
9782   verifyFormat("class A:");
9783 }
9784 
9785 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
9786   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
9787             format("#error Leave     all         white!!!!! space* alone!\n"));
9788   EXPECT_EQ(
9789       "#warning Leave     all         white!!!!! space* alone!\n",
9790       format("#warning Leave     all         white!!!!! space* alone!\n"));
9791   EXPECT_EQ("#error 1", format("  #  error   1"));
9792   EXPECT_EQ("#warning 1", format("  #  warning 1"));
9793 }
9794 
9795 TEST_F(FormatTest, FormatHashIfExpressions) {
9796   verifyFormat("#if AAAA && BBBB");
9797   verifyFormat("#if (AAAA && BBBB)");
9798   verifyFormat("#elif (AAAA && BBBB)");
9799   // FIXME: Come up with a better indentation for #elif.
9800   verifyFormat(
9801       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
9802       "    defined(BBBBBBBB)\n"
9803       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
9804       "    defined(BBBBBBBB)\n"
9805       "#endif",
9806       getLLVMStyleWithColumns(65));
9807 }
9808 
9809 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
9810   FormatStyle AllowsMergedIf = getGoogleStyle();
9811   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
9812       FormatStyle::SIS_WithoutElse;
9813   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
9814   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
9815   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
9816   EXPECT_EQ("if (true) return 42;",
9817             format("if (true)\nreturn 42;", AllowsMergedIf));
9818   FormatStyle ShortMergedIf = AllowsMergedIf;
9819   ShortMergedIf.ColumnLimit = 25;
9820   verifyFormat("#define A \\\n"
9821                "  if (true) return 42;",
9822                ShortMergedIf);
9823   verifyFormat("#define A \\\n"
9824                "  f();    \\\n"
9825                "  if (true)\n"
9826                "#define B",
9827                ShortMergedIf);
9828   verifyFormat("#define A \\\n"
9829                "  f();    \\\n"
9830                "  if (true)\n"
9831                "g();",
9832                ShortMergedIf);
9833   verifyFormat("{\n"
9834                "#ifdef A\n"
9835                "  // Comment\n"
9836                "  if (true) continue;\n"
9837                "#endif\n"
9838                "  // Comment\n"
9839                "  if (true) continue;\n"
9840                "}",
9841                ShortMergedIf);
9842   ShortMergedIf.ColumnLimit = 33;
9843   verifyFormat("#define A \\\n"
9844                "  if constexpr (true) return 42;",
9845                ShortMergedIf);
9846   verifyFormat("#define A \\\n"
9847                "  if CONSTEXPR (true) return 42;",
9848                ShortMergedIf);
9849   ShortMergedIf.ColumnLimit = 29;
9850   verifyFormat("#define A                   \\\n"
9851                "  if (aaaaaaaaaa) return 1; \\\n"
9852                "  return 2;",
9853                ShortMergedIf);
9854   ShortMergedIf.ColumnLimit = 28;
9855   verifyFormat("#define A         \\\n"
9856                "  if (aaaaaaaaaa) \\\n"
9857                "    return 1;     \\\n"
9858                "  return 2;",
9859                ShortMergedIf);
9860   verifyFormat("#define A                \\\n"
9861                "  if constexpr (aaaaaaa) \\\n"
9862                "    return 1;            \\\n"
9863                "  return 2;",
9864                ShortMergedIf);
9865   verifyFormat("#define A                \\\n"
9866                "  if CONSTEXPR (aaaaaaa) \\\n"
9867                "    return 1;            \\\n"
9868                "  return 2;",
9869                ShortMergedIf);
9870 }
9871 
9872 TEST_F(FormatTest, FormatStarDependingOnContext) {
9873   verifyFormat("void f(int *a);");
9874   verifyFormat("void f() { f(fint * b); }");
9875   verifyFormat("class A {\n  void f(int *a);\n};");
9876   verifyFormat("class A {\n  int *a;\n};");
9877   verifyFormat("namespace a {\n"
9878                "namespace b {\n"
9879                "class A {\n"
9880                "  void f() {}\n"
9881                "  int *a;\n"
9882                "};\n"
9883                "} // namespace b\n"
9884                "} // namespace a");
9885 }
9886 
9887 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
9888   verifyFormat("while");
9889   verifyFormat("operator");
9890 }
9891 
9892 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
9893   // This code would be painfully slow to format if we didn't skip it.
9894   std::string Code("A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n" // 20x
9895                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9896                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9897                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9898                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9899                    "A(1, 1)\n"
9900                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
9901                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9902                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9903                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9904                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9905                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9906                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9907                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9908                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9909                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
9910   // Deeply nested part is untouched, rest is formatted.
9911   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
9912             format(std::string("int    i;\n") + Code + "int    j;\n",
9913                    getLLVMStyle(), SC_ExpectIncomplete));
9914 }
9915 
9916 //===----------------------------------------------------------------------===//
9917 // Objective-C tests.
9918 //===----------------------------------------------------------------------===//
9919 
9920 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
9921   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
9922   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
9923             format("-(NSUInteger)indexOfObject:(id)anObject;"));
9924   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
9925   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
9926   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
9927             format("-(NSInteger)Method3:(id)anObject;"));
9928   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
9929             format("-(NSInteger)Method4:(id)anObject;"));
9930   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
9931             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
9932   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
9933             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
9934   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9935             "forAllCells:(BOOL)flag;",
9936             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9937                    "forAllCells:(BOOL)flag;"));
9938 
9939   // Very long objectiveC method declaration.
9940   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
9941                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
9942   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
9943                "                    inRange:(NSRange)range\n"
9944                "                   outRange:(NSRange)out_range\n"
9945                "                  outRange1:(NSRange)out_range1\n"
9946                "                  outRange2:(NSRange)out_range2\n"
9947                "                  outRange3:(NSRange)out_range3\n"
9948                "                  outRange4:(NSRange)out_range4\n"
9949                "                  outRange5:(NSRange)out_range5\n"
9950                "                  outRange6:(NSRange)out_range6\n"
9951                "                  outRange7:(NSRange)out_range7\n"
9952                "                  outRange8:(NSRange)out_range8\n"
9953                "                  outRange9:(NSRange)out_range9;");
9954 
9955   // When the function name has to be wrapped.
9956   FormatStyle Style = getLLVMStyle();
9957   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
9958   // and always indents instead.
9959   Style.IndentWrappedFunctionNames = false;
9960   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9961                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
9962                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
9963                "}",
9964                Style);
9965   Style.IndentWrappedFunctionNames = true;
9966   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9967                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
9968                "               anotherName:(NSString)dddddddddddddd {\n"
9969                "}",
9970                Style);
9971 
9972   verifyFormat("- (int)sum:(vector<int>)numbers;");
9973   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
9974   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
9975   // protocol lists (but not for template classes):
9976   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
9977 
9978   verifyFormat("- (int (*)())foo:(int (*)())f;");
9979   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
9980 
9981   // If there's no return type (very rare in practice!), LLVM and Google style
9982   // agree.
9983   verifyFormat("- foo;");
9984   verifyFormat("- foo:(int)f;");
9985   verifyGoogleFormat("- foo:(int)foo;");
9986 }
9987 
9988 TEST_F(FormatTest, BreaksStringLiterals) {
9989   EXPECT_EQ("\"some text \"\n"
9990             "\"other\";",
9991             format("\"some text other\";", getLLVMStyleWithColumns(12)));
9992   EXPECT_EQ("\"some text \"\n"
9993             "\"other\";",
9994             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
9995   EXPECT_EQ(
9996       "#define A  \\\n"
9997       "  \"some \"  \\\n"
9998       "  \"text \"  \\\n"
9999       "  \"other\";",
10000       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
10001   EXPECT_EQ(
10002       "#define A  \\\n"
10003       "  \"so \"    \\\n"
10004       "  \"text \"  \\\n"
10005       "  \"other\";",
10006       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
10007 
10008   EXPECT_EQ("\"some text\"",
10009             format("\"some text\"", getLLVMStyleWithColumns(1)));
10010   EXPECT_EQ("\"some text\"",
10011             format("\"some text\"", getLLVMStyleWithColumns(11)));
10012   EXPECT_EQ("\"some \"\n"
10013             "\"text\"",
10014             format("\"some text\"", getLLVMStyleWithColumns(10)));
10015   EXPECT_EQ("\"some \"\n"
10016             "\"text\"",
10017             format("\"some text\"", getLLVMStyleWithColumns(7)));
10018   EXPECT_EQ("\"some\"\n"
10019             "\" tex\"\n"
10020             "\"t\"",
10021             format("\"some text\"", getLLVMStyleWithColumns(6)));
10022   EXPECT_EQ("\"some\"\n"
10023             "\" tex\"\n"
10024             "\" and\"",
10025             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
10026   EXPECT_EQ("\"some\"\n"
10027             "\"/tex\"\n"
10028             "\"/and\"",
10029             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
10030 
10031   EXPECT_EQ("variable =\n"
10032             "    \"long string \"\n"
10033             "    \"literal\";",
10034             format("variable = \"long string literal\";",
10035                    getLLVMStyleWithColumns(20)));
10036 
10037   EXPECT_EQ("variable = f(\n"
10038             "    \"long string \"\n"
10039             "    \"literal\",\n"
10040             "    short,\n"
10041             "    loooooooooooooooooooong);",
10042             format("variable = f(\"long string literal\", short, "
10043                    "loooooooooooooooooooong);",
10044                    getLLVMStyleWithColumns(20)));
10045 
10046   EXPECT_EQ(
10047       "f(g(\"long string \"\n"
10048       "    \"literal\"),\n"
10049       "  b);",
10050       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
10051   EXPECT_EQ("f(g(\"long string \"\n"
10052             "    \"literal\",\n"
10053             "    a),\n"
10054             "  b);",
10055             format("f(g(\"long string literal\", a), b);",
10056                    getLLVMStyleWithColumns(20)));
10057   EXPECT_EQ(
10058       "f(\"one two\".split(\n"
10059       "    variable));",
10060       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10061   EXPECT_EQ("f(\"one two three four five six \"\n"
10062             "  \"seven\".split(\n"
10063             "      really_looooong_variable));",
10064             format("f(\"one two three four five six seven\"."
10065                    "split(really_looooong_variable));",
10066                    getLLVMStyleWithColumns(33)));
10067 
10068   EXPECT_EQ("f(\"some \"\n"
10069             "  \"text\",\n"
10070             "  other);",
10071             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10072 
10073   // Only break as a last resort.
10074   verifyFormat(
10075       "aaaaaaaaaaaaaaaaaaaa(\n"
10076       "    aaaaaaaaaaaaaaaaaaaa,\n"
10077       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10078 
10079   EXPECT_EQ("\"splitmea\"\n"
10080             "\"trandomp\"\n"
10081             "\"oint\"",
10082             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10083 
10084   EXPECT_EQ("\"split/\"\n"
10085             "\"pathat/\"\n"
10086             "\"slashes\"",
10087             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10088 
10089   EXPECT_EQ("\"split/\"\n"
10090             "\"pathat/\"\n"
10091             "\"slashes\"",
10092             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10093   EXPECT_EQ("\"split at \"\n"
10094             "\"spaces/at/\"\n"
10095             "\"slashes.at.any$\"\n"
10096             "\"non-alphanumeric%\"\n"
10097             "\"1111111111characte\"\n"
10098             "\"rs\"",
10099             format("\"split at "
10100                    "spaces/at/"
10101                    "slashes.at."
10102                    "any$non-"
10103                    "alphanumeric%"
10104                    "1111111111characte"
10105                    "rs\"",
10106                    getLLVMStyleWithColumns(20)));
10107 
10108   // Verify that splitting the strings understands
10109   // Style::AlwaysBreakBeforeMultilineStrings.
10110   EXPECT_EQ("aaaaaaaaaaaa(\n"
10111             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10112             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10113             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10114                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10115                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10116                    getGoogleStyle()));
10117   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10118             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10119             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10120                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10121                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10122                    getGoogleStyle()));
10123   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10124             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10125             format("llvm::outs() << "
10126                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10127                    "aaaaaaaaaaaaaaaaaaa\";"));
10128   EXPECT_EQ("ffff(\n"
10129             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10130             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10131             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10132                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10133                    getGoogleStyle()));
10134 
10135   FormatStyle Style = getLLVMStyleWithColumns(12);
10136   Style.BreakStringLiterals = false;
10137   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10138 
10139   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10140   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10141   EXPECT_EQ("#define A \\\n"
10142             "  \"some \" \\\n"
10143             "  \"text \" \\\n"
10144             "  \"other\";",
10145             format("#define A \"some text other\";", AlignLeft));
10146 }
10147 
10148 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10149   EXPECT_EQ("C a = \"some more \"\n"
10150             "      \"text\";",
10151             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10152 }
10153 
10154 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10155   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10156   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10157   EXPECT_EQ("int i = a(b());",
10158             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10159 }
10160 
10161 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10162   EXPECT_EQ(
10163       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10164       "(\n"
10165       "    \"x\t\");",
10166       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10167              "aaaaaaa("
10168              "\"x\t\");"));
10169 }
10170 
10171 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10172   EXPECT_EQ(
10173       "u8\"utf8 string \"\n"
10174       "u8\"literal\";",
10175       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10176   EXPECT_EQ(
10177       "u\"utf16 string \"\n"
10178       "u\"literal\";",
10179       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10180   EXPECT_EQ(
10181       "U\"utf32 string \"\n"
10182       "U\"literal\";",
10183       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10184   EXPECT_EQ("L\"wide string \"\n"
10185             "L\"literal\";",
10186             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10187   EXPECT_EQ("@\"NSString \"\n"
10188             "@\"literal\";",
10189             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10190   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10191 
10192   // This input makes clang-format try to split the incomplete unicode escape
10193   // sequence, which used to lead to a crasher.
10194   verifyNoCrash(
10195       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10196       getLLVMStyleWithColumns(60));
10197 }
10198 
10199 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10200   FormatStyle Style = getGoogleStyleWithColumns(15);
10201   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10202   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10203   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10204   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10205   EXPECT_EQ("u8R\"x(raw literal)x\";",
10206             format("u8R\"x(raw literal)x\";", Style));
10207 }
10208 
10209 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10210   FormatStyle Style = getLLVMStyleWithColumns(20);
10211   EXPECT_EQ(
10212       "_T(\"aaaaaaaaaaaaaa\")\n"
10213       "_T(\"aaaaaaaaaaaaaa\")\n"
10214       "_T(\"aaaaaaaaaaaa\")",
10215       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10216   EXPECT_EQ("f(x,\n"
10217             "  _T(\"aaaaaaaaaaaa\")\n"
10218             "  _T(\"aaa\"),\n"
10219             "  z);",
10220             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10221 
10222   // FIXME: Handle embedded spaces in one iteration.
10223   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10224   //            "_T(\"aaaaaaaaaaaaa\")\n"
10225   //            "_T(\"aaaaaaaaaaaaa\")\n"
10226   //            "_T(\"a\")",
10227   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10228   //                   getLLVMStyleWithColumns(20)));
10229   EXPECT_EQ(
10230       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10231       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10232   EXPECT_EQ("f(\n"
10233             "#if !TEST\n"
10234             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10235             "#endif\n"
10236             ");",
10237             format("f(\n"
10238                    "#if !TEST\n"
10239                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10240                    "#endif\n"
10241                    ");"));
10242   EXPECT_EQ("f(\n"
10243             "\n"
10244             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10245             format("f(\n"
10246                    "\n"
10247                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10248 }
10249 
10250 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10251   // In a function call with two operands, the second can be broken with no line
10252   // break before it.
10253   EXPECT_EQ(
10254       "func(a, \"long long \"\n"
10255       "        \"long long\");",
10256       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10257   // In a function call with three operands, the second must be broken with a
10258   // line break before it.
10259   EXPECT_EQ("func(a,\n"
10260             "     \"long long long \"\n"
10261             "     \"long\",\n"
10262             "     c);",
10263             format("func(a, \"long long long long\", c);",
10264                    getLLVMStyleWithColumns(24)));
10265   // In a function call with three operands, the third must be broken with a
10266   // line break before it.
10267   EXPECT_EQ("func(a, b,\n"
10268             "     \"long long long \"\n"
10269             "     \"long\");",
10270             format("func(a, b, \"long long long long\");",
10271                    getLLVMStyleWithColumns(24)));
10272   // In a function call with three operands, both the second and the third must
10273   // be broken with a line break before them.
10274   EXPECT_EQ("func(a,\n"
10275             "     \"long long long \"\n"
10276             "     \"long\",\n"
10277             "     \"long long long \"\n"
10278             "     \"long\");",
10279             format("func(a, \"long long long long\", \"long long long long\");",
10280                    getLLVMStyleWithColumns(24)));
10281   // In a chain of << with two operands, the second can be broken with no line
10282   // break before it.
10283   EXPECT_EQ("a << \"line line \"\n"
10284             "     \"line\";",
10285             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10286   // In a chain of << with three operands, the second can be broken with no line
10287   // break before it.
10288   EXPECT_EQ(
10289       "abcde << \"line \"\n"
10290       "         \"line line\"\n"
10291       "      << c;",
10292       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10293   // In a chain of << with three operands, the third must be broken with a line
10294   // break before it.
10295   EXPECT_EQ(
10296       "a << b\n"
10297       "  << \"line line \"\n"
10298       "     \"line\";",
10299       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10300   // In a chain of << with three operands, the second can be broken with no line
10301   // break before it and the third must be broken with a line break before it.
10302   EXPECT_EQ("abcd << \"line line \"\n"
10303             "        \"line\"\n"
10304             "     << \"line line \"\n"
10305             "        \"line\";",
10306             format("abcd << \"line line line\" << \"line line line\";",
10307                    getLLVMStyleWithColumns(20)));
10308   // In a chain of binary operators with two operands, the second can be broken
10309   // with no line break before it.
10310   EXPECT_EQ(
10311       "abcd + \"line line \"\n"
10312       "       \"line line\";",
10313       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10314   // In a chain of binary operators with three operands, the second must be
10315   // broken with a line break before it.
10316   EXPECT_EQ("abcd +\n"
10317             "    \"line line \"\n"
10318             "    \"line line\" +\n"
10319             "    e;",
10320             format("abcd + \"line line line line\" + e;",
10321                    getLLVMStyleWithColumns(20)));
10322   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10323   // the first must be broken with a line break before it.
10324   FormatStyle Style = getLLVMStyleWithColumns(25);
10325   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10326   EXPECT_EQ("someFunction(\n"
10327             "    \"long long long \"\n"
10328             "    \"long\",\n"
10329             "    a);",
10330             format("someFunction(\"long long long long\", a);", Style));
10331 }
10332 
10333 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10334   EXPECT_EQ(
10335       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10336       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10337       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10338       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10339              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10340              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10341 }
10342 
10343 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10344   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10345             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10346   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10347             "multiline raw string literal xxxxxxxxxxxxxx\n"
10348             ")x\",\n"
10349             "              a),\n"
10350             "            b);",
10351             format("fffffffffff(g(R\"x(\n"
10352                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10353                    ")x\", a), b);",
10354                    getGoogleStyleWithColumns(20)));
10355   EXPECT_EQ("fffffffffff(\n"
10356             "    g(R\"x(qqq\n"
10357             "multiline raw string literal xxxxxxxxxxxxxx\n"
10358             ")x\",\n"
10359             "      a),\n"
10360             "    b);",
10361             format("fffffffffff(g(R\"x(qqq\n"
10362                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10363                    ")x\", a), b);",
10364                    getGoogleStyleWithColumns(20)));
10365 
10366   EXPECT_EQ("fffffffffff(R\"x(\n"
10367             "multiline raw string literal xxxxxxxxxxxxxx\n"
10368             ")x\");",
10369             format("fffffffffff(R\"x(\n"
10370                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10371                    ")x\");",
10372                    getGoogleStyleWithColumns(20)));
10373   EXPECT_EQ("fffffffffff(R\"x(\n"
10374             "multiline raw string literal xxxxxxxxxxxxxx\n"
10375             ")x\" + bbbbbb);",
10376             format("fffffffffff(R\"x(\n"
10377                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10378                    ")x\" +   bbbbbb);",
10379                    getGoogleStyleWithColumns(20)));
10380   EXPECT_EQ("fffffffffff(\n"
10381             "    R\"x(\n"
10382             "multiline raw string literal xxxxxxxxxxxxxx\n"
10383             ")x\" +\n"
10384             "    bbbbbb);",
10385             format("fffffffffff(\n"
10386                    " R\"x(\n"
10387                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10388                    ")x\" + bbbbbb);",
10389                    getGoogleStyleWithColumns(20)));
10390   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10391             format("fffffffffff(\n"
10392                    " R\"(single line raw string)\" + bbbbbb);"));
10393 }
10394 
10395 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10396   verifyFormat("string a = \"unterminated;");
10397   EXPECT_EQ("function(\"unterminated,\n"
10398             "         OtherParameter);",
10399             format("function(  \"unterminated,\n"
10400                    "    OtherParameter);"));
10401 }
10402 
10403 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10404   FormatStyle Style = getLLVMStyle();
10405   Style.Standard = FormatStyle::LS_Cpp03;
10406   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10407             format("#define x(_a) printf(\"foo\"_a);", Style));
10408 }
10409 
10410 TEST_F(FormatTest, CppLexVersion) {
10411   FormatStyle Style = getLLVMStyle();
10412   // Formatting of x * y differs if x is a type.
10413   verifyFormat("void foo() { MACRO(a * b); }", Style);
10414   verifyFormat("void foo() { MACRO(int *b); }", Style);
10415 
10416   // LLVM style uses latest lexer.
10417   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10418   Style.Standard = FormatStyle::LS_Cpp17;
10419   // But in c++17, char8_t isn't a keyword.
10420   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10421 }
10422 
10423 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10424 
10425 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10426   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10427             "             \"ddeeefff\");",
10428             format("someFunction(\"aaabbbcccdddeeefff\");",
10429                    getLLVMStyleWithColumns(25)));
10430   EXPECT_EQ("someFunction1234567890(\n"
10431             "    \"aaabbbcccdddeeefff\");",
10432             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10433                    getLLVMStyleWithColumns(26)));
10434   EXPECT_EQ("someFunction1234567890(\n"
10435             "    \"aaabbbcccdddeeeff\"\n"
10436             "    \"f\");",
10437             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10438                    getLLVMStyleWithColumns(25)));
10439   EXPECT_EQ("someFunction1234567890(\n"
10440             "    \"aaabbbcccdddeeeff\"\n"
10441             "    \"f\");",
10442             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10443                    getLLVMStyleWithColumns(24)));
10444   EXPECT_EQ("someFunction(\n"
10445             "    \"aaabbbcc ddde \"\n"
10446             "    \"efff\");",
10447             format("someFunction(\"aaabbbcc ddde efff\");",
10448                    getLLVMStyleWithColumns(25)));
10449   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10450             "             \"ddeeefff\");",
10451             format("someFunction(\"aaabbbccc ddeeefff\");",
10452                    getLLVMStyleWithColumns(25)));
10453   EXPECT_EQ("someFunction1234567890(\n"
10454             "    \"aaabb \"\n"
10455             "    \"cccdddeeefff\");",
10456             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10457                    getLLVMStyleWithColumns(25)));
10458   EXPECT_EQ("#define A          \\\n"
10459             "  string s =       \\\n"
10460             "      \"123456789\"  \\\n"
10461             "      \"0\";         \\\n"
10462             "  int i;",
10463             format("#define A string s = \"1234567890\"; int i;",
10464                    getLLVMStyleWithColumns(20)));
10465   EXPECT_EQ("someFunction(\n"
10466             "    \"aaabbbcc \"\n"
10467             "    \"dddeeefff\");",
10468             format("someFunction(\"aaabbbcc dddeeefff\");",
10469                    getLLVMStyleWithColumns(25)));
10470 }
10471 
10472 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10473   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10474   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10475   EXPECT_EQ("\"test\"\n"
10476             "\"\\n\"",
10477             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10478   EXPECT_EQ("\"tes\\\\\"\n"
10479             "\"n\"",
10480             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10481   EXPECT_EQ("\"\\\\\\\\\"\n"
10482             "\"\\n\"",
10483             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10484   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10485   EXPECT_EQ("\"\\uff01\"\n"
10486             "\"test\"",
10487             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10488   EXPECT_EQ("\"\\Uff01ff02\"",
10489             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10490   EXPECT_EQ("\"\\x000000000001\"\n"
10491             "\"next\"",
10492             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10493   EXPECT_EQ("\"\\x000000000001next\"",
10494             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10495   EXPECT_EQ("\"\\x000000000001\"",
10496             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10497   EXPECT_EQ("\"test\"\n"
10498             "\"\\000000\"\n"
10499             "\"000001\"",
10500             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10501   EXPECT_EQ("\"test\\000\"\n"
10502             "\"00000000\"\n"
10503             "\"1\"",
10504             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10505 }
10506 
10507 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10508   verifyFormat("void f() {\n"
10509                "  return g() {}\n"
10510                "  void h() {}");
10511   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10512                "g();\n"
10513                "}");
10514 }
10515 
10516 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10517   verifyFormat(
10518       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10519 }
10520 
10521 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10522   verifyFormat("class X {\n"
10523                "  void f() {\n"
10524                "  }\n"
10525                "};",
10526                getLLVMStyleWithColumns(12));
10527 }
10528 
10529 TEST_F(FormatTest, ConfigurableIndentWidth) {
10530   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10531   EightIndent.IndentWidth = 8;
10532   EightIndent.ContinuationIndentWidth = 8;
10533   verifyFormat("void f() {\n"
10534                "        someFunction();\n"
10535                "        if (true) {\n"
10536                "                f();\n"
10537                "        }\n"
10538                "}",
10539                EightIndent);
10540   verifyFormat("class X {\n"
10541                "        void f() {\n"
10542                "        }\n"
10543                "};",
10544                EightIndent);
10545   verifyFormat("int x[] = {\n"
10546                "        call(),\n"
10547                "        call()};",
10548                EightIndent);
10549 }
10550 
10551 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10552   verifyFormat("double\n"
10553                "f();",
10554                getLLVMStyleWithColumns(8));
10555 }
10556 
10557 TEST_F(FormatTest, ConfigurableUseOfTab) {
10558   FormatStyle Tab = getLLVMStyleWithColumns(42);
10559   Tab.IndentWidth = 8;
10560   Tab.UseTab = FormatStyle::UT_Always;
10561   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10562 
10563   EXPECT_EQ("if (aaaaaaaa && // q\n"
10564             "    bb)\t\t// w\n"
10565             "\t;",
10566             format("if (aaaaaaaa &&// q\n"
10567                    "bb)// w\n"
10568                    ";",
10569                    Tab));
10570   EXPECT_EQ("if (aaa && bbb) // w\n"
10571             "\t;",
10572             format("if(aaa&&bbb)// w\n"
10573                    ";",
10574                    Tab));
10575 
10576   verifyFormat("class X {\n"
10577                "\tvoid f() {\n"
10578                "\t\tsomeFunction(parameter1,\n"
10579                "\t\t\t     parameter2);\n"
10580                "\t}\n"
10581                "};",
10582                Tab);
10583   verifyFormat("#define A                        \\\n"
10584                "\tvoid f() {               \\\n"
10585                "\t\tsomeFunction(    \\\n"
10586                "\t\t    parameter1,  \\\n"
10587                "\t\t    parameter2); \\\n"
10588                "\t}",
10589                Tab);
10590   verifyFormat("int a;\t      // x\n"
10591                "int bbbbbbbb; // x\n",
10592                Tab);
10593 
10594   Tab.TabWidth = 4;
10595   Tab.IndentWidth = 8;
10596   verifyFormat("class TabWidth4Indent8 {\n"
10597                "\t\tvoid f() {\n"
10598                "\t\t\t\tsomeFunction(parameter1,\n"
10599                "\t\t\t\t\t\t\t parameter2);\n"
10600                "\t\t}\n"
10601                "};",
10602                Tab);
10603 
10604   Tab.TabWidth = 4;
10605   Tab.IndentWidth = 4;
10606   verifyFormat("class TabWidth4Indent4 {\n"
10607                "\tvoid f() {\n"
10608                "\t\tsomeFunction(parameter1,\n"
10609                "\t\t\t\t\t parameter2);\n"
10610                "\t}\n"
10611                "};",
10612                Tab);
10613 
10614   Tab.TabWidth = 8;
10615   Tab.IndentWidth = 4;
10616   verifyFormat("class TabWidth8Indent4 {\n"
10617                "    void f() {\n"
10618                "\tsomeFunction(parameter1,\n"
10619                "\t\t     parameter2);\n"
10620                "    }\n"
10621                "};",
10622                Tab);
10623 
10624   Tab.TabWidth = 8;
10625   Tab.IndentWidth = 8;
10626   EXPECT_EQ("/*\n"
10627             "\t      a\t\tcomment\n"
10628             "\t      in multiple lines\n"
10629             "       */",
10630             format("   /*\t \t \n"
10631                    " \t \t a\t\tcomment\t \t\n"
10632                    " \t \t in multiple lines\t\n"
10633                    " \t  */",
10634                    Tab));
10635 
10636   Tab.UseTab = FormatStyle::UT_ForIndentation;
10637   verifyFormat("{\n"
10638                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10639                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10640                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10641                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10642                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10643                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10644                "};",
10645                Tab);
10646   verifyFormat("enum AA {\n"
10647                "\ta1, // Force multiple lines\n"
10648                "\ta2,\n"
10649                "\ta3\n"
10650                "};",
10651                Tab);
10652   EXPECT_EQ("if (aaaaaaaa && // q\n"
10653             "    bb)         // w\n"
10654             "\t;",
10655             format("if (aaaaaaaa &&// q\n"
10656                    "bb)// w\n"
10657                    ";",
10658                    Tab));
10659   verifyFormat("class X {\n"
10660                "\tvoid f() {\n"
10661                "\t\tsomeFunction(parameter1,\n"
10662                "\t\t             parameter2);\n"
10663                "\t}\n"
10664                "};",
10665                Tab);
10666   verifyFormat("{\n"
10667                "\tQ(\n"
10668                "\t    {\n"
10669                "\t\t    int a;\n"
10670                "\t\t    someFunction(aaaaaaaa,\n"
10671                "\t\t                 bbbbbbb);\n"
10672                "\t    },\n"
10673                "\t    p);\n"
10674                "}",
10675                Tab);
10676   EXPECT_EQ("{\n"
10677             "\t/* aaaa\n"
10678             "\t   bbbb */\n"
10679             "}",
10680             format("{\n"
10681                    "/* aaaa\n"
10682                    "   bbbb */\n"
10683                    "}",
10684                    Tab));
10685   EXPECT_EQ("{\n"
10686             "\t/*\n"
10687             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10688             "\t  bbbbbbbbbbbbb\n"
10689             "\t*/\n"
10690             "}",
10691             format("{\n"
10692                    "/*\n"
10693                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10694                    "*/\n"
10695                    "}",
10696                    Tab));
10697   EXPECT_EQ("{\n"
10698             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10699             "\t// bbbbbbbbbbbbb\n"
10700             "}",
10701             format("{\n"
10702                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10703                    "}",
10704                    Tab));
10705   EXPECT_EQ("{\n"
10706             "\t/*\n"
10707             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10708             "\t  bbbbbbbbbbbbb\n"
10709             "\t*/\n"
10710             "}",
10711             format("{\n"
10712                    "\t/*\n"
10713                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10714                    "\t*/\n"
10715                    "}",
10716                    Tab));
10717   EXPECT_EQ("{\n"
10718             "\t/*\n"
10719             "\n"
10720             "\t*/\n"
10721             "}",
10722             format("{\n"
10723                    "\t/*\n"
10724                    "\n"
10725                    "\t*/\n"
10726                    "}",
10727                    Tab));
10728   EXPECT_EQ("{\n"
10729             "\t/*\n"
10730             " asdf\n"
10731             "\t*/\n"
10732             "}",
10733             format("{\n"
10734                    "\t/*\n"
10735                    " asdf\n"
10736                    "\t*/\n"
10737                    "}",
10738                    Tab));
10739 
10740   Tab.UseTab = FormatStyle::UT_Never;
10741   EXPECT_EQ("/*\n"
10742             "              a\t\tcomment\n"
10743             "              in multiple lines\n"
10744             "       */",
10745             format("   /*\t \t \n"
10746                    " \t \t a\t\tcomment\t \t\n"
10747                    " \t \t in multiple lines\t\n"
10748                    " \t  */",
10749                    Tab));
10750   EXPECT_EQ("/* some\n"
10751             "   comment */",
10752             format(" \t \t /* some\n"
10753                    " \t \t    comment */",
10754                    Tab));
10755   EXPECT_EQ("int a; /* some\n"
10756             "   comment */",
10757             format(" \t \t int a; /* some\n"
10758                    " \t \t    comment */",
10759                    Tab));
10760 
10761   EXPECT_EQ("int a; /* some\n"
10762             "comment */",
10763             format(" \t \t int\ta; /* some\n"
10764                    " \t \t    comment */",
10765                    Tab));
10766   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10767             "    comment */",
10768             format(" \t \t f(\"\t\t\"); /* some\n"
10769                    " \t \t    comment */",
10770                    Tab));
10771   EXPECT_EQ("{\n"
10772             "        /*\n"
10773             "         * Comment\n"
10774             "         */\n"
10775             "        int i;\n"
10776             "}",
10777             format("{\n"
10778                    "\t/*\n"
10779                    "\t * Comment\n"
10780                    "\t */\n"
10781                    "\t int i;\n"
10782                    "}",
10783                    Tab));
10784 
10785   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
10786   Tab.TabWidth = 8;
10787   Tab.IndentWidth = 8;
10788   EXPECT_EQ("if (aaaaaaaa && // q\n"
10789             "    bb)         // w\n"
10790             "\t;",
10791             format("if (aaaaaaaa &&// q\n"
10792                    "bb)// w\n"
10793                    ";",
10794                    Tab));
10795   EXPECT_EQ("if (aaa && bbb) // w\n"
10796             "\t;",
10797             format("if(aaa&&bbb)// w\n"
10798                    ";",
10799                    Tab));
10800   verifyFormat("class X {\n"
10801                "\tvoid f() {\n"
10802                "\t\tsomeFunction(parameter1,\n"
10803                "\t\t\t     parameter2);\n"
10804                "\t}\n"
10805                "};",
10806                Tab);
10807   verifyFormat("#define A                        \\\n"
10808                "\tvoid f() {               \\\n"
10809                "\t\tsomeFunction(    \\\n"
10810                "\t\t    parameter1,  \\\n"
10811                "\t\t    parameter2); \\\n"
10812                "\t}",
10813                Tab);
10814   Tab.TabWidth = 4;
10815   Tab.IndentWidth = 8;
10816   verifyFormat("class TabWidth4Indent8 {\n"
10817                "\t\tvoid f() {\n"
10818                "\t\t\t\tsomeFunction(parameter1,\n"
10819                "\t\t\t\t\t\t\t parameter2);\n"
10820                "\t\t}\n"
10821                "};",
10822                Tab);
10823   Tab.TabWidth = 4;
10824   Tab.IndentWidth = 4;
10825   verifyFormat("class TabWidth4Indent4 {\n"
10826                "\tvoid f() {\n"
10827                "\t\tsomeFunction(parameter1,\n"
10828                "\t\t\t\t\t parameter2);\n"
10829                "\t}\n"
10830                "};",
10831                Tab);
10832   Tab.TabWidth = 8;
10833   Tab.IndentWidth = 4;
10834   verifyFormat("class TabWidth8Indent4 {\n"
10835                "    void f() {\n"
10836                "\tsomeFunction(parameter1,\n"
10837                "\t\t     parameter2);\n"
10838                "    }\n"
10839                "};",
10840                Tab);
10841   Tab.TabWidth = 8;
10842   Tab.IndentWidth = 8;
10843   EXPECT_EQ("/*\n"
10844             "\t      a\t\tcomment\n"
10845             "\t      in multiple lines\n"
10846             "       */",
10847             format("   /*\t \t \n"
10848                    " \t \t a\t\tcomment\t \t\n"
10849                    " \t \t in multiple lines\t\n"
10850                    " \t  */",
10851                    Tab));
10852   verifyFormat("{\n"
10853                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10854                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10855                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10856                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10857                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10858                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10859                "};",
10860                Tab);
10861   verifyFormat("enum AA {\n"
10862                "\ta1, // Force multiple lines\n"
10863                "\ta2,\n"
10864                "\ta3\n"
10865                "};",
10866                Tab);
10867   EXPECT_EQ("if (aaaaaaaa && // q\n"
10868             "    bb)         // w\n"
10869             "\t;",
10870             format("if (aaaaaaaa &&// q\n"
10871                    "bb)// w\n"
10872                    ";",
10873                    Tab));
10874   verifyFormat("class X {\n"
10875                "\tvoid f() {\n"
10876                "\t\tsomeFunction(parameter1,\n"
10877                "\t\t\t     parameter2);\n"
10878                "\t}\n"
10879                "};",
10880                Tab);
10881   verifyFormat("{\n"
10882                "\tQ(\n"
10883                "\t    {\n"
10884                "\t\t    int a;\n"
10885                "\t\t    someFunction(aaaaaaaa,\n"
10886                "\t\t\t\t bbbbbbb);\n"
10887                "\t    },\n"
10888                "\t    p);\n"
10889                "}",
10890                Tab);
10891   EXPECT_EQ("{\n"
10892             "\t/* aaaa\n"
10893             "\t   bbbb */\n"
10894             "}",
10895             format("{\n"
10896                    "/* aaaa\n"
10897                    "   bbbb */\n"
10898                    "}",
10899                    Tab));
10900   EXPECT_EQ("{\n"
10901             "\t/*\n"
10902             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10903             "\t  bbbbbbbbbbbbb\n"
10904             "\t*/\n"
10905             "}",
10906             format("{\n"
10907                    "/*\n"
10908                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10909                    "*/\n"
10910                    "}",
10911                    Tab));
10912   EXPECT_EQ("{\n"
10913             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10914             "\t// bbbbbbbbbbbbb\n"
10915             "}",
10916             format("{\n"
10917                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10918                    "}",
10919                    Tab));
10920   EXPECT_EQ("{\n"
10921             "\t/*\n"
10922             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10923             "\t  bbbbbbbbbbbbb\n"
10924             "\t*/\n"
10925             "}",
10926             format("{\n"
10927                    "\t/*\n"
10928                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10929                    "\t*/\n"
10930                    "}",
10931                    Tab));
10932   EXPECT_EQ("{\n"
10933             "\t/*\n"
10934             "\n"
10935             "\t*/\n"
10936             "}",
10937             format("{\n"
10938                    "\t/*\n"
10939                    "\n"
10940                    "\t*/\n"
10941                    "}",
10942                    Tab));
10943   EXPECT_EQ("{\n"
10944             "\t/*\n"
10945             " asdf\n"
10946             "\t*/\n"
10947             "}",
10948             format("{\n"
10949                    "\t/*\n"
10950                    " asdf\n"
10951                    "\t*/\n"
10952                    "}",
10953                    Tab));
10954   EXPECT_EQ("/* some\n"
10955             "   comment */",
10956             format(" \t \t /* some\n"
10957                    " \t \t    comment */",
10958                    Tab));
10959   EXPECT_EQ("int a; /* some\n"
10960             "   comment */",
10961             format(" \t \t int a; /* some\n"
10962                    " \t \t    comment */",
10963                    Tab));
10964   EXPECT_EQ("int a; /* some\n"
10965             "comment */",
10966             format(" \t \t int\ta; /* some\n"
10967                    " \t \t    comment */",
10968                    Tab));
10969   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10970             "    comment */",
10971             format(" \t \t f(\"\t\t\"); /* some\n"
10972                    " \t \t    comment */",
10973                    Tab));
10974   EXPECT_EQ("{\n"
10975             "\t/*\n"
10976             "\t * Comment\n"
10977             "\t */\n"
10978             "\tint i;\n"
10979             "}",
10980             format("{\n"
10981                    "\t/*\n"
10982                    "\t * Comment\n"
10983                    "\t */\n"
10984                    "\t int i;\n"
10985                    "}",
10986                    Tab));
10987   Tab.TabWidth = 2;
10988   Tab.IndentWidth = 2;
10989   EXPECT_EQ("{\n"
10990             "\t/* aaaa\n"
10991             "\t\t bbbb */\n"
10992             "}",
10993             format("{\n"
10994                    "/* aaaa\n"
10995                    "\t bbbb */\n"
10996                    "}",
10997                    Tab));
10998   EXPECT_EQ("{\n"
10999             "\t/*\n"
11000             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11001             "\t\tbbbbbbbbbbbbb\n"
11002             "\t*/\n"
11003             "}",
11004             format("{\n"
11005                    "/*\n"
11006                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11007                    "*/\n"
11008                    "}",
11009                    Tab));
11010   Tab.AlignConsecutiveAssignments = true;
11011   Tab.AlignConsecutiveDeclarations = true;
11012   Tab.TabWidth = 4;
11013   Tab.IndentWidth = 4;
11014   verifyFormat("class Assign {\n"
11015                "\tvoid f() {\n"
11016                "\t\tint         x      = 123;\n"
11017                "\t\tint         random = 4;\n"
11018                "\t\tstd::string alphabet =\n"
11019                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11020                "\t}\n"
11021                "};",
11022                Tab);
11023 
11024   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11025   Tab.TabWidth = 8;
11026   Tab.IndentWidth = 8;
11027   EXPECT_EQ("if (aaaaaaaa && // q\n"
11028             "    bb)         // w\n"
11029             "\t;",
11030             format("if (aaaaaaaa &&// q\n"
11031                    "bb)// w\n"
11032                    ";",
11033                    Tab));
11034   EXPECT_EQ("if (aaa && bbb) // w\n"
11035             "\t;",
11036             format("if(aaa&&bbb)// w\n"
11037                    ";",
11038                    Tab));
11039   verifyFormat("class X {\n"
11040                "\tvoid f() {\n"
11041                "\t\tsomeFunction(parameter1,\n"
11042                "\t\t             parameter2);\n"
11043                "\t}\n"
11044                "};",
11045                Tab);
11046   verifyFormat("#define A                        \\\n"
11047                "\tvoid f() {               \\\n"
11048                "\t\tsomeFunction(    \\\n"
11049                "\t\t    parameter1,  \\\n"
11050                "\t\t    parameter2); \\\n"
11051                "\t}",
11052                Tab);
11053   Tab.TabWidth = 4;
11054   Tab.IndentWidth = 8;
11055   verifyFormat("class TabWidth4Indent8 {\n"
11056                "\t\tvoid f() {\n"
11057                "\t\t\t\tsomeFunction(parameter1,\n"
11058                "\t\t\t\t             parameter2);\n"
11059                "\t\t}\n"
11060                "};",
11061                Tab);
11062   Tab.TabWidth = 4;
11063   Tab.IndentWidth = 4;
11064   verifyFormat("class TabWidth4Indent4 {\n"
11065                "\tvoid f() {\n"
11066                "\t\tsomeFunction(parameter1,\n"
11067                "\t\t             parameter2);\n"
11068                "\t}\n"
11069                "};",
11070                Tab);
11071   Tab.TabWidth = 8;
11072   Tab.IndentWidth = 4;
11073   verifyFormat("class TabWidth8Indent4 {\n"
11074                "    void f() {\n"
11075                "\tsomeFunction(parameter1,\n"
11076                "\t             parameter2);\n"
11077                "    }\n"
11078                "};",
11079                Tab);
11080   Tab.TabWidth = 8;
11081   Tab.IndentWidth = 8;
11082   EXPECT_EQ("/*\n"
11083             "              a\t\tcomment\n"
11084             "              in multiple lines\n"
11085             "       */",
11086             format("   /*\t \t \n"
11087                    " \t \t a\t\tcomment\t \t\n"
11088                    " \t \t in multiple lines\t\n"
11089                    " \t  */",
11090                    Tab));
11091   verifyFormat("{\n"
11092                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11093                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11094                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11095                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11096                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11097                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11098                "};",
11099                Tab);
11100   verifyFormat("enum AA {\n"
11101                "\ta1, // Force multiple lines\n"
11102                "\ta2,\n"
11103                "\ta3\n"
11104                "};",
11105                Tab);
11106   EXPECT_EQ("if (aaaaaaaa && // q\n"
11107             "    bb)         // w\n"
11108             "\t;",
11109             format("if (aaaaaaaa &&// q\n"
11110                    "bb)// w\n"
11111                    ";",
11112                    Tab));
11113   verifyFormat("class X {\n"
11114                "\tvoid f() {\n"
11115                "\t\tsomeFunction(parameter1,\n"
11116                "\t\t             parameter2);\n"
11117                "\t}\n"
11118                "};",
11119                Tab);
11120   verifyFormat("{\n"
11121                "\tQ(\n"
11122                "\t    {\n"
11123                "\t\t    int a;\n"
11124                "\t\t    someFunction(aaaaaaaa,\n"
11125                "\t\t                 bbbbbbb);\n"
11126                "\t    },\n"
11127                "\t    p);\n"
11128                "}",
11129                Tab);
11130   EXPECT_EQ("{\n"
11131             "\t/* aaaa\n"
11132             "\t   bbbb */\n"
11133             "}",
11134             format("{\n"
11135                    "/* aaaa\n"
11136                    "   bbbb */\n"
11137                    "}",
11138                    Tab));
11139   EXPECT_EQ("{\n"
11140             "\t/*\n"
11141             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11142             "\t  bbbbbbbbbbbbb\n"
11143             "\t*/\n"
11144             "}",
11145             format("{\n"
11146                    "/*\n"
11147                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11148                    "*/\n"
11149                    "}",
11150                    Tab));
11151   EXPECT_EQ("{\n"
11152             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11153             "\t// bbbbbbbbbbbbb\n"
11154             "}",
11155             format("{\n"
11156                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11157                    "}",
11158                    Tab));
11159   EXPECT_EQ("{\n"
11160             "\t/*\n"
11161             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11162             "\t  bbbbbbbbbbbbb\n"
11163             "\t*/\n"
11164             "}",
11165             format("{\n"
11166                    "\t/*\n"
11167                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11168                    "\t*/\n"
11169                    "}",
11170                    Tab));
11171   EXPECT_EQ("{\n"
11172             "\t/*\n"
11173             "\n"
11174             "\t*/\n"
11175             "}",
11176             format("{\n"
11177                    "\t/*\n"
11178                    "\n"
11179                    "\t*/\n"
11180                    "}",
11181                    Tab));
11182   EXPECT_EQ("{\n"
11183             "\t/*\n"
11184             " asdf\n"
11185             "\t*/\n"
11186             "}",
11187             format("{\n"
11188                    "\t/*\n"
11189                    " asdf\n"
11190                    "\t*/\n"
11191                    "}",
11192                    Tab));
11193   EXPECT_EQ("/* some\n"
11194             "   comment */",
11195             format(" \t \t /* some\n"
11196                    " \t \t    comment */",
11197                    Tab));
11198   EXPECT_EQ("int a; /* some\n"
11199             "   comment */",
11200             format(" \t \t int a; /* some\n"
11201                    " \t \t    comment */",
11202                    Tab));
11203   EXPECT_EQ("int a; /* some\n"
11204             "comment */",
11205             format(" \t \t int\ta; /* some\n"
11206                    " \t \t    comment */",
11207                    Tab));
11208   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11209             "    comment */",
11210             format(" \t \t f(\"\t\t\"); /* some\n"
11211                    " \t \t    comment */",
11212                    Tab));
11213   EXPECT_EQ("{\n"
11214             "\t/*\n"
11215             "\t * Comment\n"
11216             "\t */\n"
11217             "\tint i;\n"
11218             "}",
11219             format("{\n"
11220                    "\t/*\n"
11221                    "\t * Comment\n"
11222                    "\t */\n"
11223                    "\t int i;\n"
11224                    "}",
11225                    Tab));
11226   Tab.TabWidth = 2;
11227   Tab.IndentWidth = 2;
11228   EXPECT_EQ("{\n"
11229             "\t/* aaaa\n"
11230             "\t   bbbb */\n"
11231             "}",
11232             format("{\n"
11233                    "/* aaaa\n"
11234                    "   bbbb */\n"
11235                    "}",
11236                    Tab));
11237   EXPECT_EQ("{\n"
11238             "\t/*\n"
11239             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11240             "\t  bbbbbbbbbbbbb\n"
11241             "\t*/\n"
11242             "}",
11243             format("{\n"
11244                    "/*\n"
11245                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11246                    "*/\n"
11247                    "}",
11248                    Tab));
11249   Tab.AlignConsecutiveAssignments = true;
11250   Tab.AlignConsecutiveDeclarations = true;
11251   Tab.TabWidth = 4;
11252   Tab.IndentWidth = 4;
11253   verifyFormat("class Assign {\n"
11254                "\tvoid f() {\n"
11255                "\t\tint         x      = 123;\n"
11256                "\t\tint         random = 4;\n"
11257                "\t\tstd::string alphabet =\n"
11258                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11259                "\t}\n"
11260                "};",
11261                Tab);
11262 }
11263 
11264 TEST_F(FormatTest, ZeroTabWidth) {
11265   FormatStyle Tab = getLLVMStyleWithColumns(42);
11266   Tab.IndentWidth = 8;
11267   Tab.UseTab = FormatStyle::UT_Never;
11268   Tab.TabWidth = 0;
11269   EXPECT_EQ("void a(){\n"
11270             "    // line starts with '\t'\n"
11271             "};",
11272             format("void a(){\n"
11273                    "\t// line starts with '\t'\n"
11274                    "};",
11275                    Tab));
11276 
11277   EXPECT_EQ("void a(){\n"
11278             "    // line starts with '\t'\n"
11279             "};",
11280             format("void a(){\n"
11281                    "\t\t// line starts with '\t'\n"
11282                    "};",
11283                    Tab));
11284 
11285   Tab.UseTab = FormatStyle::UT_ForIndentation;
11286   EXPECT_EQ("void a(){\n"
11287             "    // line starts with '\t'\n"
11288             "};",
11289             format("void a(){\n"
11290                    "\t// line starts with '\t'\n"
11291                    "};",
11292                    Tab));
11293 
11294   EXPECT_EQ("void a(){\n"
11295             "    // line starts with '\t'\n"
11296             "};",
11297             format("void a(){\n"
11298                    "\t\t// line starts with '\t'\n"
11299                    "};",
11300                    Tab));
11301 
11302   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11303   EXPECT_EQ("void a(){\n"
11304             "    // line starts with '\t'\n"
11305             "};",
11306             format("void a(){\n"
11307                    "\t// line starts with '\t'\n"
11308                    "};",
11309                    Tab));
11310 
11311   EXPECT_EQ("void a(){\n"
11312             "    // line starts with '\t'\n"
11313             "};",
11314             format("void a(){\n"
11315                    "\t\t// line starts with '\t'\n"
11316                    "};",
11317                    Tab));
11318 
11319   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11320   EXPECT_EQ("void a(){\n"
11321             "    // line starts with '\t'\n"
11322             "};",
11323             format("void a(){\n"
11324                    "\t// line starts with '\t'\n"
11325                    "};",
11326                    Tab));
11327 
11328   EXPECT_EQ("void a(){\n"
11329             "    // line starts with '\t'\n"
11330             "};",
11331             format("void a(){\n"
11332                    "\t\t// line starts with '\t'\n"
11333                    "};",
11334                    Tab));
11335 
11336   Tab.UseTab = FormatStyle::UT_Always;
11337   EXPECT_EQ("void a(){\n"
11338             "// line starts with '\t'\n"
11339             "};",
11340             format("void a(){\n"
11341                    "\t// line starts with '\t'\n"
11342                    "};",
11343                    Tab));
11344 
11345   EXPECT_EQ("void a(){\n"
11346             "// line starts with '\t'\n"
11347             "};",
11348             format("void a(){\n"
11349                    "\t\t// line starts with '\t'\n"
11350                    "};",
11351                    Tab));
11352 }
11353 
11354 TEST_F(FormatTest, CalculatesOriginalColumn) {
11355   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11356             "q\"; /* some\n"
11357             "       comment */",
11358             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11359                    "q\"; /* some\n"
11360                    "       comment */",
11361                    getLLVMStyle()));
11362   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11363             "/* some\n"
11364             "   comment */",
11365             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11366                    " /* some\n"
11367                    "    comment */",
11368                    getLLVMStyle()));
11369   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11370             "qqq\n"
11371             "/* some\n"
11372             "   comment */",
11373             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11374                    "qqq\n"
11375                    " /* some\n"
11376                    "    comment */",
11377                    getLLVMStyle()));
11378   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11379             "wwww; /* some\n"
11380             "         comment */",
11381             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11382                    "wwww; /* some\n"
11383                    "         comment */",
11384                    getLLVMStyle()));
11385 }
11386 
11387 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11388   FormatStyle NoSpace = getLLVMStyle();
11389   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11390 
11391   verifyFormat("while(true)\n"
11392                "  continue;",
11393                NoSpace);
11394   verifyFormat("for(;;)\n"
11395                "  continue;",
11396                NoSpace);
11397   verifyFormat("if(true)\n"
11398                "  f();\n"
11399                "else if(true)\n"
11400                "  f();",
11401                NoSpace);
11402   verifyFormat("do {\n"
11403                "  do_something();\n"
11404                "} while(something());",
11405                NoSpace);
11406   verifyFormat("switch(x) {\n"
11407                "default:\n"
11408                "  break;\n"
11409                "}",
11410                NoSpace);
11411   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11412   verifyFormat("size_t x = sizeof(x);", NoSpace);
11413   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11414   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11415   verifyFormat("alignas(128) char a[128];", NoSpace);
11416   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11417   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11418   verifyFormat("int f() throw(Deprecated);", NoSpace);
11419   verifyFormat("typedef void (*cb)(int);", NoSpace);
11420   verifyFormat("T A::operator()();", NoSpace);
11421   verifyFormat("X A::operator++(T);", NoSpace);
11422   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11423 
11424   FormatStyle Space = getLLVMStyle();
11425   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11426 
11427   verifyFormat("int f ();", Space);
11428   verifyFormat("void f (int a, T b) {\n"
11429                "  while (true)\n"
11430                "    continue;\n"
11431                "}",
11432                Space);
11433   verifyFormat("if (true)\n"
11434                "  f ();\n"
11435                "else if (true)\n"
11436                "  f ();",
11437                Space);
11438   verifyFormat("do {\n"
11439                "  do_something ();\n"
11440                "} while (something ());",
11441                Space);
11442   verifyFormat("switch (x) {\n"
11443                "default:\n"
11444                "  break;\n"
11445                "}",
11446                Space);
11447   verifyFormat("A::A () : a (1) {}", Space);
11448   verifyFormat("void f () __attribute__ ((asdf));", Space);
11449   verifyFormat("*(&a + 1);\n"
11450                "&((&a)[1]);\n"
11451                "a[(b + c) * d];\n"
11452                "(((a + 1) * 2) + 3) * 4;",
11453                Space);
11454   verifyFormat("#define A(x) x", Space);
11455   verifyFormat("#define A (x) x", Space);
11456   verifyFormat("#if defined(x)\n"
11457                "#endif",
11458                Space);
11459   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11460   verifyFormat("size_t x = sizeof (x);", Space);
11461   verifyFormat("auto f (int x) -> decltype (x);", Space);
11462   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11463   verifyFormat("alignas (128) char a[128];", Space);
11464   verifyFormat("size_t x = alignof (MyType);", Space);
11465   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11466   verifyFormat("int f () throw (Deprecated);", Space);
11467   verifyFormat("typedef void (*cb) (int);", Space);
11468   verifyFormat("T A::operator() ();", Space);
11469   verifyFormat("X A::operator++ (T);", Space);
11470   verifyFormat("auto lambda = [] () { return 0; };", Space);
11471   verifyFormat("int x = int (y);", Space);
11472 
11473   FormatStyle SomeSpace = getLLVMStyle();
11474   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11475 
11476   verifyFormat("[]() -> float {}", SomeSpace);
11477   verifyFormat("[] (auto foo) {}", SomeSpace);
11478   verifyFormat("[foo]() -> int {}", SomeSpace);
11479   verifyFormat("int f();", SomeSpace);
11480   verifyFormat("void f (int a, T b) {\n"
11481                "  while (true)\n"
11482                "    continue;\n"
11483                "}",
11484                SomeSpace);
11485   verifyFormat("if (true)\n"
11486                "  f();\n"
11487                "else if (true)\n"
11488                "  f();",
11489                SomeSpace);
11490   verifyFormat("do {\n"
11491                "  do_something();\n"
11492                "} while (something());",
11493                SomeSpace);
11494   verifyFormat("switch (x) {\n"
11495                "default:\n"
11496                "  break;\n"
11497                "}",
11498                SomeSpace);
11499   verifyFormat("A::A() : a (1) {}", SomeSpace);
11500   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11501   verifyFormat("*(&a + 1);\n"
11502                "&((&a)[1]);\n"
11503                "a[(b + c) * d];\n"
11504                "(((a + 1) * 2) + 3) * 4;",
11505                SomeSpace);
11506   verifyFormat("#define A(x) x", SomeSpace);
11507   verifyFormat("#define A (x) x", SomeSpace);
11508   verifyFormat("#if defined(x)\n"
11509                "#endif",
11510                SomeSpace);
11511   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11512   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11513   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11514   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11515   verifyFormat("alignas (128) char a[128];", SomeSpace);
11516   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11517   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11518                SomeSpace);
11519   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11520   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11521   verifyFormat("T A::operator()();", SomeSpace);
11522   verifyFormat("X A::operator++ (T);", SomeSpace);
11523   verifyFormat("int x = int (y);", SomeSpace);
11524   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11525 }
11526 
11527 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11528   FormatStyle Spaces = getLLVMStyle();
11529   Spaces.SpaceAfterLogicalNot = true;
11530 
11531   verifyFormat("bool x = ! y", Spaces);
11532   verifyFormat("if (! isFailure())", Spaces);
11533   verifyFormat("if (! (a && b))", Spaces);
11534   verifyFormat("\"Error!\"", Spaces);
11535   verifyFormat("! ! x", Spaces);
11536 }
11537 
11538 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11539   FormatStyle Spaces = getLLVMStyle();
11540 
11541   Spaces.SpacesInParentheses = true;
11542   verifyFormat("do_something( ::globalVar );", Spaces);
11543   verifyFormat("call( x, y, z );", Spaces);
11544   verifyFormat("call();", Spaces);
11545   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11546   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11547                Spaces);
11548   verifyFormat("while ( (bool)1 )\n"
11549                "  continue;",
11550                Spaces);
11551   verifyFormat("for ( ;; )\n"
11552                "  continue;",
11553                Spaces);
11554   verifyFormat("if ( true )\n"
11555                "  f();\n"
11556                "else if ( true )\n"
11557                "  f();",
11558                Spaces);
11559   verifyFormat("do {\n"
11560                "  do_something( (int)i );\n"
11561                "} while ( something() );",
11562                Spaces);
11563   verifyFormat("switch ( x ) {\n"
11564                "default:\n"
11565                "  break;\n"
11566                "}",
11567                Spaces);
11568 
11569   Spaces.SpacesInParentheses = false;
11570   Spaces.SpacesInCStyleCastParentheses = true;
11571   verifyFormat("Type *A = ( Type * )P;", Spaces);
11572   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11573   verifyFormat("x = ( int32 )y;", Spaces);
11574   verifyFormat("int a = ( int )(2.0f);", Spaces);
11575   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11576   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11577   verifyFormat("#define x (( int )-1)", Spaces);
11578 
11579   // Run the first set of tests again with:
11580   Spaces.SpacesInParentheses = false;
11581   Spaces.SpaceInEmptyParentheses = true;
11582   Spaces.SpacesInCStyleCastParentheses = true;
11583   verifyFormat("call(x, y, z);", Spaces);
11584   verifyFormat("call( );", Spaces);
11585   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11586   verifyFormat("while (( bool )1)\n"
11587                "  continue;",
11588                Spaces);
11589   verifyFormat("for (;;)\n"
11590                "  continue;",
11591                Spaces);
11592   verifyFormat("if (true)\n"
11593                "  f( );\n"
11594                "else if (true)\n"
11595                "  f( );",
11596                Spaces);
11597   verifyFormat("do {\n"
11598                "  do_something(( int )i);\n"
11599                "} while (something( ));",
11600                Spaces);
11601   verifyFormat("switch (x) {\n"
11602                "default:\n"
11603                "  break;\n"
11604                "}",
11605                Spaces);
11606 
11607   // Run the first set of tests again with:
11608   Spaces.SpaceAfterCStyleCast = true;
11609   verifyFormat("call(x, y, z);", Spaces);
11610   verifyFormat("call( );", Spaces);
11611   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11612   verifyFormat("while (( bool ) 1)\n"
11613                "  continue;",
11614                Spaces);
11615   verifyFormat("for (;;)\n"
11616                "  continue;",
11617                Spaces);
11618   verifyFormat("if (true)\n"
11619                "  f( );\n"
11620                "else if (true)\n"
11621                "  f( );",
11622                Spaces);
11623   verifyFormat("do {\n"
11624                "  do_something(( int ) i);\n"
11625                "} while (something( ));",
11626                Spaces);
11627   verifyFormat("switch (x) {\n"
11628                "default:\n"
11629                "  break;\n"
11630                "}",
11631                Spaces);
11632 
11633   // Run subset of tests again with:
11634   Spaces.SpacesInCStyleCastParentheses = false;
11635   Spaces.SpaceAfterCStyleCast = true;
11636   verifyFormat("while ((bool) 1)\n"
11637                "  continue;",
11638                Spaces);
11639   verifyFormat("do {\n"
11640                "  do_something((int) i);\n"
11641                "} while (something( ));",
11642                Spaces);
11643 }
11644 
11645 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
11646   verifyFormat("int a[5];");
11647   verifyFormat("a[3] += 42;");
11648 
11649   FormatStyle Spaces = getLLVMStyle();
11650   Spaces.SpacesInSquareBrackets = true;
11651   // Not lambdas.
11652   verifyFormat("int a[ 5 ];", Spaces);
11653   verifyFormat("a[ 3 ] += 42;", Spaces);
11654   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
11655   verifyFormat("double &operator[](int i) { return 0; }\n"
11656                "int i;",
11657                Spaces);
11658   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
11659   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
11660   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
11661   // Lambdas.
11662   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
11663   verifyFormat("return [ i, args... ] {};", Spaces);
11664   verifyFormat("int foo = [ &bar ]() {};", Spaces);
11665   verifyFormat("int foo = [ = ]() {};", Spaces);
11666   verifyFormat("int foo = [ & ]() {};", Spaces);
11667   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
11668   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
11669 }
11670 
11671 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
11672   FormatStyle NoSpaceStyle = getLLVMStyle();
11673   verifyFormat("int a[5];", NoSpaceStyle);
11674   verifyFormat("a[3] += 42;", NoSpaceStyle);
11675 
11676   verifyFormat("int a[1];", NoSpaceStyle);
11677   verifyFormat("int 1 [a];", NoSpaceStyle);
11678   verifyFormat("int a[1][2];", NoSpaceStyle);
11679   verifyFormat("a[7] = 5;", NoSpaceStyle);
11680   verifyFormat("int a = (f())[23];", NoSpaceStyle);
11681   verifyFormat("f([] {})", NoSpaceStyle);
11682 
11683   FormatStyle Space = getLLVMStyle();
11684   Space.SpaceBeforeSquareBrackets = true;
11685   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
11686   verifyFormat("return [i, args...] {};", Space);
11687 
11688   verifyFormat("int a [5];", Space);
11689   verifyFormat("a [3] += 42;", Space);
11690   verifyFormat("constexpr char hello []{\"hello\"};", Space);
11691   verifyFormat("double &operator[](int i) { return 0; }\n"
11692                "int i;",
11693                Space);
11694   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
11695   verifyFormat("int i = a [a][a]->f();", Space);
11696   verifyFormat("int i = (*b) [a]->f();", Space);
11697 
11698   verifyFormat("int a [1];", Space);
11699   verifyFormat("int 1 [a];", Space);
11700   verifyFormat("int a [1][2];", Space);
11701   verifyFormat("a [7] = 5;", Space);
11702   verifyFormat("int a = (f()) [23];", Space);
11703   verifyFormat("f([] {})", Space);
11704 }
11705 
11706 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
11707   verifyFormat("int a = 5;");
11708   verifyFormat("a += 42;");
11709   verifyFormat("a or_eq 8;");
11710 
11711   FormatStyle Spaces = getLLVMStyle();
11712   Spaces.SpaceBeforeAssignmentOperators = false;
11713   verifyFormat("int a= 5;", Spaces);
11714   verifyFormat("a+= 42;", Spaces);
11715   verifyFormat("a or_eq 8;", Spaces);
11716 }
11717 
11718 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
11719   verifyFormat("class Foo : public Bar {};");
11720   verifyFormat("Foo::Foo() : foo(1) {}");
11721   verifyFormat("for (auto a : b) {\n}");
11722   verifyFormat("int x = a ? b : c;");
11723   verifyFormat("{\n"
11724                "label0:\n"
11725                "  int x = 0;\n"
11726                "}");
11727   verifyFormat("switch (x) {\n"
11728                "case 1:\n"
11729                "default:\n"
11730                "}");
11731 
11732   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
11733   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
11734   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
11735   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
11736   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
11737   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
11738   verifyFormat("{\n"
11739                "label1:\n"
11740                "  int x = 0;\n"
11741                "}",
11742                CtorInitializerStyle);
11743   verifyFormat("switch (x) {\n"
11744                "case 1:\n"
11745                "default:\n"
11746                "}",
11747                CtorInitializerStyle);
11748   CtorInitializerStyle.BreakConstructorInitializers =
11749       FormatStyle::BCIS_AfterColon;
11750   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
11751                "    aaaaaaaaaaaaaaaa(1),\n"
11752                "    bbbbbbbbbbbbbbbb(2) {}",
11753                CtorInitializerStyle);
11754   CtorInitializerStyle.BreakConstructorInitializers =
11755       FormatStyle::BCIS_BeforeComma;
11756   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11757                "    : aaaaaaaaaaaaaaaa(1)\n"
11758                "    , bbbbbbbbbbbbbbbb(2) {}",
11759                CtorInitializerStyle);
11760   CtorInitializerStyle.BreakConstructorInitializers =
11761       FormatStyle::BCIS_BeforeColon;
11762   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11763                "    : aaaaaaaaaaaaaaaa(1),\n"
11764                "      bbbbbbbbbbbbbbbb(2) {}",
11765                CtorInitializerStyle);
11766   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
11767   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
11768                ": aaaaaaaaaaaaaaaa(1),\n"
11769                "  bbbbbbbbbbbbbbbb(2) {}",
11770                CtorInitializerStyle);
11771 
11772   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
11773   InheritanceStyle.SpaceBeforeInheritanceColon = false;
11774   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
11775   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
11776   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
11777   verifyFormat("int x = a ? b : c;", InheritanceStyle);
11778   verifyFormat("{\n"
11779                "label2:\n"
11780                "  int x = 0;\n"
11781                "}",
11782                InheritanceStyle);
11783   verifyFormat("switch (x) {\n"
11784                "case 1:\n"
11785                "default:\n"
11786                "}",
11787                InheritanceStyle);
11788   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
11789   verifyFormat("class Foooooooooooooooooooooo:\n"
11790                "    public aaaaaaaaaaaaaaaaaa,\n"
11791                "    public bbbbbbbbbbbbbbbbbb {\n"
11792                "}",
11793                InheritanceStyle);
11794   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
11795   verifyFormat("class Foooooooooooooooooooooo\n"
11796                "    : public aaaaaaaaaaaaaaaaaa\n"
11797                "    , public bbbbbbbbbbbbbbbbbb {\n"
11798                "}",
11799                InheritanceStyle);
11800   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
11801   verifyFormat("class Foooooooooooooooooooooo\n"
11802                "    : public aaaaaaaaaaaaaaaaaa,\n"
11803                "      public bbbbbbbbbbbbbbbbbb {\n"
11804                "}",
11805                InheritanceStyle);
11806   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
11807   verifyFormat("class Foooooooooooooooooooooo\n"
11808                ": public aaaaaaaaaaaaaaaaaa,\n"
11809                "  public bbbbbbbbbbbbbbbbbb {}",
11810                InheritanceStyle);
11811 
11812   FormatStyle ForLoopStyle = getLLVMStyle();
11813   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
11814   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
11815   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
11816   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
11817   verifyFormat("int x = a ? b : c;", ForLoopStyle);
11818   verifyFormat("{\n"
11819                "label2:\n"
11820                "  int x = 0;\n"
11821                "}",
11822                ForLoopStyle);
11823   verifyFormat("switch (x) {\n"
11824                "case 1:\n"
11825                "default:\n"
11826                "}",
11827                ForLoopStyle);
11828 
11829   FormatStyle NoSpaceStyle = getLLVMStyle();
11830   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
11831   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
11832   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
11833   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
11834   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
11835   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
11836   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
11837   verifyFormat("{\n"
11838                "label3:\n"
11839                "  int x = 0;\n"
11840                "}",
11841                NoSpaceStyle);
11842   verifyFormat("switch (x) {\n"
11843                "case 1:\n"
11844                "default:\n"
11845                "}",
11846                NoSpaceStyle);
11847 }
11848 
11849 TEST_F(FormatTest, AlignConsecutiveMacros) {
11850   FormatStyle Style = getLLVMStyle();
11851   Style.AlignConsecutiveAssignments = true;
11852   Style.AlignConsecutiveDeclarations = true;
11853   Style.AlignConsecutiveMacros = false;
11854 
11855   verifyFormat("#define a 3\n"
11856                "#define bbbb 4\n"
11857                "#define ccc (5)",
11858                Style);
11859 
11860   verifyFormat("#define f(x) (x * x)\n"
11861                "#define fff(x, y, z) (x * y + z)\n"
11862                "#define ffff(x, y) (x - y)",
11863                Style);
11864 
11865   verifyFormat("#define foo(x, y) (x + y)\n"
11866                "#define bar (5, 6)(2 + 2)",
11867                Style);
11868 
11869   verifyFormat("#define a 3\n"
11870                "#define bbbb 4\n"
11871                "#define ccc (5)\n"
11872                "#define f(x) (x * x)\n"
11873                "#define fff(x, y, z) (x * y + z)\n"
11874                "#define ffff(x, y) (x - y)",
11875                Style);
11876 
11877   Style.AlignConsecutiveMacros = true;
11878   verifyFormat("#define a    3\n"
11879                "#define bbbb 4\n"
11880                "#define ccc  (5)",
11881                Style);
11882 
11883   verifyFormat("#define f(x)         (x * x)\n"
11884                "#define fff(x, y, z) (x * y + z)\n"
11885                "#define ffff(x, y)   (x - y)",
11886                Style);
11887 
11888   verifyFormat("#define foo(x, y) (x + y)\n"
11889                "#define bar       (5, 6)(2 + 2)",
11890                Style);
11891 
11892   verifyFormat("#define a            3\n"
11893                "#define bbbb         4\n"
11894                "#define ccc          (5)\n"
11895                "#define f(x)         (x * x)\n"
11896                "#define fff(x, y, z) (x * y + z)\n"
11897                "#define ffff(x, y)   (x - y)",
11898                Style);
11899 
11900   verifyFormat("#define a         5\n"
11901                "#define foo(x, y) (x + y)\n"
11902                "#define CCC       (6)\n"
11903                "auto lambda = []() {\n"
11904                "  auto  ii = 0;\n"
11905                "  float j  = 0;\n"
11906                "  return 0;\n"
11907                "};\n"
11908                "int   i  = 0;\n"
11909                "float i2 = 0;\n"
11910                "auto  v  = type{\n"
11911                "    i = 1,   //\n"
11912                "    (i = 2), //\n"
11913                "    i = 3    //\n"
11914                "};",
11915                Style);
11916 
11917   Style.AlignConsecutiveMacros = false;
11918   Style.ColumnLimit = 20;
11919 
11920   verifyFormat("#define a          \\\n"
11921                "  \"aabbbbbbbbbbbb\"\n"
11922                "#define D          \\\n"
11923                "  \"aabbbbbbbbbbbb\" \\\n"
11924                "  \"ccddeeeeeeeee\"\n"
11925                "#define B          \\\n"
11926                "  \"QQQQQQQQQQQQQ\"  \\\n"
11927                "  \"FFFFFFFFFFFFF\"  \\\n"
11928                "  \"LLLLLLLL\"\n",
11929                Style);
11930 
11931   Style.AlignConsecutiveMacros = true;
11932   verifyFormat("#define a          \\\n"
11933                "  \"aabbbbbbbbbbbb\"\n"
11934                "#define D          \\\n"
11935                "  \"aabbbbbbbbbbbb\" \\\n"
11936                "  \"ccddeeeeeeeee\"\n"
11937                "#define B          \\\n"
11938                "  \"QQQQQQQQQQQQQ\"  \\\n"
11939                "  \"FFFFFFFFFFFFF\"  \\\n"
11940                "  \"LLLLLLLL\"\n",
11941                Style);
11942 }
11943 
11944 TEST_F(FormatTest, AlignConsecutiveAssignments) {
11945   FormatStyle Alignment = getLLVMStyle();
11946   Alignment.AlignConsecutiveMacros = true;
11947   Alignment.AlignConsecutiveAssignments = false;
11948   verifyFormat("int a = 5;\n"
11949                "int oneTwoThree = 123;",
11950                Alignment);
11951   verifyFormat("int a = 5;\n"
11952                "int oneTwoThree = 123;",
11953                Alignment);
11954 
11955   Alignment.AlignConsecutiveAssignments = true;
11956   verifyFormat("int a           = 5;\n"
11957                "int oneTwoThree = 123;",
11958                Alignment);
11959   verifyFormat("int a           = method();\n"
11960                "int oneTwoThree = 133;",
11961                Alignment);
11962   verifyFormat("a &= 5;\n"
11963                "bcd *= 5;\n"
11964                "ghtyf += 5;\n"
11965                "dvfvdb -= 5;\n"
11966                "a /= 5;\n"
11967                "vdsvsv %= 5;\n"
11968                "sfdbddfbdfbb ^= 5;\n"
11969                "dvsdsv |= 5;\n"
11970                "int dsvvdvsdvvv = 123;",
11971                Alignment);
11972   verifyFormat("int i = 1, j = 10;\n"
11973                "something = 2000;",
11974                Alignment);
11975   verifyFormat("something = 2000;\n"
11976                "int i = 1, j = 10;\n",
11977                Alignment);
11978   verifyFormat("something = 2000;\n"
11979                "another   = 911;\n"
11980                "int i = 1, j = 10;\n"
11981                "oneMore = 1;\n"
11982                "i       = 2;",
11983                Alignment);
11984   verifyFormat("int a   = 5;\n"
11985                "int one = 1;\n"
11986                "method();\n"
11987                "int oneTwoThree = 123;\n"
11988                "int oneTwo      = 12;",
11989                Alignment);
11990   verifyFormat("int oneTwoThree = 123;\n"
11991                "int oneTwo      = 12;\n"
11992                "method();\n",
11993                Alignment);
11994   verifyFormat("int oneTwoThree = 123; // comment\n"
11995                "int oneTwo      = 12;  // comment",
11996                Alignment);
11997 
11998   // Bug 25167
11999   verifyFormat("#if A\n"
12000                "#else\n"
12001                "int aaaaaaaa = 12;\n"
12002                "#endif\n"
12003                "#if B\n"
12004                "#else\n"
12005                "int a = 12;\n"
12006                "#endif\n",
12007                Alignment);
12008   verifyFormat("enum foo {\n"
12009                "#if A\n"
12010                "#else\n"
12011                "  aaaaaaaa = 12;\n"
12012                "#endif\n"
12013                "#if B\n"
12014                "#else\n"
12015                "  a = 12;\n"
12016                "#endif\n"
12017                "};\n",
12018                Alignment);
12019 
12020   EXPECT_EQ("int a = 5;\n"
12021             "\n"
12022             "int oneTwoThree = 123;",
12023             format("int a       = 5;\n"
12024                    "\n"
12025                    "int oneTwoThree= 123;",
12026                    Alignment));
12027   EXPECT_EQ("int a   = 5;\n"
12028             "int one = 1;\n"
12029             "\n"
12030             "int oneTwoThree = 123;",
12031             format("int a = 5;\n"
12032                    "int one = 1;\n"
12033                    "\n"
12034                    "int oneTwoThree = 123;",
12035                    Alignment));
12036   EXPECT_EQ("int a   = 5;\n"
12037             "int one = 1;\n"
12038             "\n"
12039             "int oneTwoThree = 123;\n"
12040             "int oneTwo      = 12;",
12041             format("int a = 5;\n"
12042                    "int one = 1;\n"
12043                    "\n"
12044                    "int oneTwoThree = 123;\n"
12045                    "int oneTwo = 12;",
12046                    Alignment));
12047   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12048   verifyFormat("#define A \\\n"
12049                "  int aaaa       = 12; \\\n"
12050                "  int b          = 23; \\\n"
12051                "  int ccc        = 234; \\\n"
12052                "  int dddddddddd = 2345;",
12053                Alignment);
12054   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12055   verifyFormat("#define A               \\\n"
12056                "  int aaaa       = 12;  \\\n"
12057                "  int b          = 23;  \\\n"
12058                "  int ccc        = 234; \\\n"
12059                "  int dddddddddd = 2345;",
12060                Alignment);
12061   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12062   verifyFormat("#define A                                                      "
12063                "                \\\n"
12064                "  int aaaa       = 12;                                         "
12065                "                \\\n"
12066                "  int b          = 23;                                         "
12067                "                \\\n"
12068                "  int ccc        = 234;                                        "
12069                "                \\\n"
12070                "  int dddddddddd = 2345;",
12071                Alignment);
12072   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12073                "k = 4, int l = 5,\n"
12074                "                  int m = 6) {\n"
12075                "  int j      = 10;\n"
12076                "  otherThing = 1;\n"
12077                "}",
12078                Alignment);
12079   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12080                "  int i   = 1;\n"
12081                "  int j   = 2;\n"
12082                "  int big = 10000;\n"
12083                "}",
12084                Alignment);
12085   verifyFormat("class C {\n"
12086                "public:\n"
12087                "  int i            = 1;\n"
12088                "  virtual void f() = 0;\n"
12089                "};",
12090                Alignment);
12091   verifyFormat("int i = 1;\n"
12092                "if (SomeType t = getSomething()) {\n"
12093                "}\n"
12094                "int j   = 2;\n"
12095                "int big = 10000;",
12096                Alignment);
12097   verifyFormat("int j = 7;\n"
12098                "for (int k = 0; k < N; ++k) {\n"
12099                "}\n"
12100                "int j   = 2;\n"
12101                "int big = 10000;\n"
12102                "}",
12103                Alignment);
12104   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12105   verifyFormat("int i = 1;\n"
12106                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12107                "    = someLooooooooooooooooongFunction();\n"
12108                "int j = 2;",
12109                Alignment);
12110   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12111   verifyFormat("int i = 1;\n"
12112                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12113                "    someLooooooooooooooooongFunction();\n"
12114                "int j = 2;",
12115                Alignment);
12116 
12117   verifyFormat("auto lambda = []() {\n"
12118                "  auto i = 0;\n"
12119                "  return 0;\n"
12120                "};\n"
12121                "int i  = 0;\n"
12122                "auto v = type{\n"
12123                "    i = 1,   //\n"
12124                "    (i = 2), //\n"
12125                "    i = 3    //\n"
12126                "};",
12127                Alignment);
12128 
12129   verifyFormat(
12130       "int i      = 1;\n"
12131       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12132       "                          loooooooooooooooooooooongParameterB);\n"
12133       "int j      = 2;",
12134       Alignment);
12135 
12136   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12137                "          typename B   = very_long_type_name_1,\n"
12138                "          typename T_2 = very_long_type_name_2>\n"
12139                "auto foo() {}\n",
12140                Alignment);
12141   verifyFormat("int a, b = 1;\n"
12142                "int c  = 2;\n"
12143                "int dd = 3;\n",
12144                Alignment);
12145   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12146                "float b[1][] = {{3.f}};\n",
12147                Alignment);
12148   verifyFormat("for (int i = 0; i < 1; i++)\n"
12149                "  int x = 1;\n",
12150                Alignment);
12151   verifyFormat("for (i = 0; i < 1; i++)\n"
12152                "  x = 1;\n"
12153                "y = 1;\n",
12154                Alignment);
12155 
12156   Alignment.ReflowComments = true;
12157   Alignment.ColumnLimit = 50;
12158   EXPECT_EQ("int x   = 0;\n"
12159             "int yy  = 1; /// specificlennospace\n"
12160             "int zzz = 2;\n",
12161             format("int x   = 0;\n"
12162                    "int yy  = 1; ///specificlennospace\n"
12163                    "int zzz = 2;\n",
12164                    Alignment));
12165 }
12166 
12167 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12168   FormatStyle Alignment = getLLVMStyle();
12169   Alignment.AlignConsecutiveBitFields = true;
12170   verifyFormat("int const a     : 5;\n"
12171                "int oneTwoThree : 23;",
12172                Alignment);
12173 
12174   // Initializers are allowed starting with c++2a
12175   verifyFormat("int const a     : 5 = 1;\n"
12176                "int oneTwoThree : 23 = 0;",
12177                Alignment);
12178 
12179   Alignment.AlignConsecutiveDeclarations = true;
12180   verifyFormat("int const a           : 5;\n"
12181                "int       oneTwoThree : 23;",
12182                Alignment);
12183 
12184   verifyFormat("int const a           : 5;  // comment\n"
12185                "int       oneTwoThree : 23; // comment",
12186                Alignment);
12187 
12188   verifyFormat("int const a           : 5 = 1;\n"
12189                "int       oneTwoThree : 23 = 0;",
12190                Alignment);
12191 
12192   Alignment.AlignConsecutiveAssignments = true;
12193   verifyFormat("int const a           : 5  = 1;\n"
12194                "int       oneTwoThree : 23 = 0;",
12195                Alignment);
12196   verifyFormat("int const a           : 5  = {1};\n"
12197                "int       oneTwoThree : 23 = 0;",
12198                Alignment);
12199 
12200   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_None;
12201   verifyFormat("int const a          :5;\n"
12202                "int       oneTwoThree:23;",
12203                Alignment);
12204 
12205   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_Before;
12206   verifyFormat("int const a           :5;\n"
12207                "int       oneTwoThree :23;",
12208                Alignment);
12209 
12210   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_After;
12211   verifyFormat("int const a          : 5;\n"
12212                "int       oneTwoThree: 23;",
12213                Alignment);
12214 
12215   // Known limitations: ':' is only recognized as a bitfield colon when
12216   // followed by a number.
12217   /*
12218   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12219                "int a           : 5;",
12220                Alignment);
12221   */
12222 }
12223 
12224 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12225   FormatStyle Alignment = getLLVMStyle();
12226   Alignment.AlignConsecutiveMacros = true;
12227   Alignment.AlignConsecutiveDeclarations = false;
12228   verifyFormat("float const a = 5;\n"
12229                "int oneTwoThree = 123;",
12230                Alignment);
12231   verifyFormat("int a = 5;\n"
12232                "float const oneTwoThree = 123;",
12233                Alignment);
12234 
12235   Alignment.AlignConsecutiveDeclarations = true;
12236   verifyFormat("float const a = 5;\n"
12237                "int         oneTwoThree = 123;",
12238                Alignment);
12239   verifyFormat("int         a = method();\n"
12240                "float const oneTwoThree = 133;",
12241                Alignment);
12242   verifyFormat("int i = 1, j = 10;\n"
12243                "something = 2000;",
12244                Alignment);
12245   verifyFormat("something = 2000;\n"
12246                "int i = 1, j = 10;\n",
12247                Alignment);
12248   verifyFormat("float      something = 2000;\n"
12249                "double     another = 911;\n"
12250                "int        i = 1, j = 10;\n"
12251                "const int *oneMore = 1;\n"
12252                "unsigned   i = 2;",
12253                Alignment);
12254   verifyFormat("float a = 5;\n"
12255                "int   one = 1;\n"
12256                "method();\n"
12257                "const double       oneTwoThree = 123;\n"
12258                "const unsigned int oneTwo = 12;",
12259                Alignment);
12260   verifyFormat("int      oneTwoThree{0}; // comment\n"
12261                "unsigned oneTwo;         // comment",
12262                Alignment);
12263   EXPECT_EQ("float const a = 5;\n"
12264             "\n"
12265             "int oneTwoThree = 123;",
12266             format("float const   a = 5;\n"
12267                    "\n"
12268                    "int           oneTwoThree= 123;",
12269                    Alignment));
12270   EXPECT_EQ("float a = 5;\n"
12271             "int   one = 1;\n"
12272             "\n"
12273             "unsigned oneTwoThree = 123;",
12274             format("float    a = 5;\n"
12275                    "int      one = 1;\n"
12276                    "\n"
12277                    "unsigned oneTwoThree = 123;",
12278                    Alignment));
12279   EXPECT_EQ("float a = 5;\n"
12280             "int   one = 1;\n"
12281             "\n"
12282             "unsigned oneTwoThree = 123;\n"
12283             "int      oneTwo = 12;",
12284             format("float    a = 5;\n"
12285                    "int one = 1;\n"
12286                    "\n"
12287                    "unsigned oneTwoThree = 123;\n"
12288                    "int oneTwo = 12;",
12289                    Alignment));
12290   // Function prototype alignment
12291   verifyFormat("int    a();\n"
12292                "double b();",
12293                Alignment);
12294   verifyFormat("int    a(int x);\n"
12295                "double b();",
12296                Alignment);
12297   unsigned OldColumnLimit = Alignment.ColumnLimit;
12298   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12299   // otherwise the function parameters will be re-flowed onto a single line.
12300   Alignment.ColumnLimit = 0;
12301   EXPECT_EQ("int    a(int   x,\n"
12302             "         float y);\n"
12303             "double b(int    x,\n"
12304             "         double y);",
12305             format("int a(int x,\n"
12306                    " float y);\n"
12307                    "double b(int x,\n"
12308                    " double y);",
12309                    Alignment));
12310   // This ensures that function parameters of function declarations are
12311   // correctly indented when their owning functions are indented.
12312   // The failure case here is for 'double y' to not be indented enough.
12313   EXPECT_EQ("double a(int x);\n"
12314             "int    b(int    y,\n"
12315             "         double z);",
12316             format("double a(int x);\n"
12317                    "int b(int y,\n"
12318                    " double z);",
12319                    Alignment));
12320   // Set ColumnLimit low so that we induce wrapping immediately after
12321   // the function name and opening paren.
12322   Alignment.ColumnLimit = 13;
12323   verifyFormat("int function(\n"
12324                "    int  x,\n"
12325                "    bool y);",
12326                Alignment);
12327   Alignment.ColumnLimit = OldColumnLimit;
12328   // Ensure function pointers don't screw up recursive alignment
12329   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12330                "double b();",
12331                Alignment);
12332   Alignment.AlignConsecutiveAssignments = true;
12333   // Ensure recursive alignment is broken by function braces, so that the
12334   // "a = 1" does not align with subsequent assignments inside the function
12335   // body.
12336   verifyFormat("int func(int a = 1) {\n"
12337                "  int b  = 2;\n"
12338                "  int cc = 3;\n"
12339                "}",
12340                Alignment);
12341   verifyFormat("float      something = 2000;\n"
12342                "double     another   = 911;\n"
12343                "int        i = 1, j = 10;\n"
12344                "const int *oneMore = 1;\n"
12345                "unsigned   i       = 2;",
12346                Alignment);
12347   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12348                "unsigned oneTwo      = 0;   // comment",
12349                Alignment);
12350   // Make sure that scope is correctly tracked, in the absence of braces
12351   verifyFormat("for (int i = 0; i < n; i++)\n"
12352                "  j = i;\n"
12353                "double x = 1;\n",
12354                Alignment);
12355   verifyFormat("if (int i = 0)\n"
12356                "  j = i;\n"
12357                "double x = 1;\n",
12358                Alignment);
12359   // Ensure operator[] and operator() are comprehended
12360   verifyFormat("struct test {\n"
12361                "  long long int foo();\n"
12362                "  int           operator[](int a);\n"
12363                "  double        bar();\n"
12364                "};\n",
12365                Alignment);
12366   verifyFormat("struct test {\n"
12367                "  long long int foo();\n"
12368                "  int           operator()(int a);\n"
12369                "  double        bar();\n"
12370                "};\n",
12371                Alignment);
12372   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12373             "  int const i   = 1;\n"
12374             "  int *     j   = 2;\n"
12375             "  int       big = 10000;\n"
12376             "\n"
12377             "  unsigned oneTwoThree = 123;\n"
12378             "  int      oneTwo      = 12;\n"
12379             "  method();\n"
12380             "  float k  = 2;\n"
12381             "  int   ll = 10000;\n"
12382             "}",
12383             format("void SomeFunction(int parameter= 0) {\n"
12384                    " int const  i= 1;\n"
12385                    "  int *j=2;\n"
12386                    " int big  =  10000;\n"
12387                    "\n"
12388                    "unsigned oneTwoThree  =123;\n"
12389                    "int oneTwo = 12;\n"
12390                    "  method();\n"
12391                    "float k= 2;\n"
12392                    "int ll=10000;\n"
12393                    "}",
12394                    Alignment));
12395   Alignment.AlignConsecutiveAssignments = false;
12396   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12397   verifyFormat("#define A \\\n"
12398                "  int       aaaa = 12; \\\n"
12399                "  float     b = 23; \\\n"
12400                "  const int ccc = 234; \\\n"
12401                "  unsigned  dddddddddd = 2345;",
12402                Alignment);
12403   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12404   verifyFormat("#define A              \\\n"
12405                "  int       aaaa = 12; \\\n"
12406                "  float     b = 23;    \\\n"
12407                "  const int ccc = 234; \\\n"
12408                "  unsigned  dddddddddd = 2345;",
12409                Alignment);
12410   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12411   Alignment.ColumnLimit = 30;
12412   verifyFormat("#define A                    \\\n"
12413                "  int       aaaa = 12;       \\\n"
12414                "  float     b = 23;          \\\n"
12415                "  const int ccc = 234;       \\\n"
12416                "  int       dddddddddd = 2345;",
12417                Alignment);
12418   Alignment.ColumnLimit = 80;
12419   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12420                "k = 4, int l = 5,\n"
12421                "                  int m = 6) {\n"
12422                "  const int j = 10;\n"
12423                "  otherThing = 1;\n"
12424                "}",
12425                Alignment);
12426   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12427                "  int const i = 1;\n"
12428                "  int *     j = 2;\n"
12429                "  int       big = 10000;\n"
12430                "}",
12431                Alignment);
12432   verifyFormat("class C {\n"
12433                "public:\n"
12434                "  int          i = 1;\n"
12435                "  virtual void f() = 0;\n"
12436                "};",
12437                Alignment);
12438   verifyFormat("float i = 1;\n"
12439                "if (SomeType t = getSomething()) {\n"
12440                "}\n"
12441                "const unsigned j = 2;\n"
12442                "int            big = 10000;",
12443                Alignment);
12444   verifyFormat("float j = 7;\n"
12445                "for (int k = 0; k < N; ++k) {\n"
12446                "}\n"
12447                "unsigned j = 2;\n"
12448                "int      big = 10000;\n"
12449                "}",
12450                Alignment);
12451   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12452   verifyFormat("float              i = 1;\n"
12453                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12454                "    = someLooooooooooooooooongFunction();\n"
12455                "int j = 2;",
12456                Alignment);
12457   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12458   verifyFormat("int                i = 1;\n"
12459                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12460                "    someLooooooooooooooooongFunction();\n"
12461                "int j = 2;",
12462                Alignment);
12463 
12464   Alignment.AlignConsecutiveAssignments = true;
12465   verifyFormat("auto lambda = []() {\n"
12466                "  auto  ii = 0;\n"
12467                "  float j  = 0;\n"
12468                "  return 0;\n"
12469                "};\n"
12470                "int   i  = 0;\n"
12471                "float i2 = 0;\n"
12472                "auto  v  = type{\n"
12473                "    i = 1,   //\n"
12474                "    (i = 2), //\n"
12475                "    i = 3    //\n"
12476                "};",
12477                Alignment);
12478   Alignment.AlignConsecutiveAssignments = false;
12479 
12480   verifyFormat(
12481       "int      i = 1;\n"
12482       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12483       "                          loooooooooooooooooooooongParameterB);\n"
12484       "int      j = 2;",
12485       Alignment);
12486 
12487   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12488   // We expect declarations and assignments to align, as long as it doesn't
12489   // exceed the column limit, starting a new alignment sequence whenever it
12490   // happens.
12491   Alignment.AlignConsecutiveAssignments = true;
12492   Alignment.ColumnLimit = 30;
12493   verifyFormat("float    ii              = 1;\n"
12494                "unsigned j               = 2;\n"
12495                "int someVerylongVariable = 1;\n"
12496                "AnotherLongType  ll = 123456;\n"
12497                "VeryVeryLongType k  = 2;\n"
12498                "int              myvar = 1;",
12499                Alignment);
12500   Alignment.ColumnLimit = 80;
12501   Alignment.AlignConsecutiveAssignments = false;
12502 
12503   verifyFormat(
12504       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12505       "          typename LongType, typename B>\n"
12506       "auto foo() {}\n",
12507       Alignment);
12508   verifyFormat("float a, b = 1;\n"
12509                "int   c = 2;\n"
12510                "int   dd = 3;\n",
12511                Alignment);
12512   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12513                "float b[1][] = {{3.f}};\n",
12514                Alignment);
12515   Alignment.AlignConsecutiveAssignments = true;
12516   verifyFormat("float a, b = 1;\n"
12517                "int   c  = 2;\n"
12518                "int   dd = 3;\n",
12519                Alignment);
12520   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12521                "float b[1][] = {{3.f}};\n",
12522                Alignment);
12523   Alignment.AlignConsecutiveAssignments = false;
12524 
12525   Alignment.ColumnLimit = 30;
12526   Alignment.BinPackParameters = false;
12527   verifyFormat("void foo(float     a,\n"
12528                "         float     b,\n"
12529                "         int       c,\n"
12530                "         uint32_t *d) {\n"
12531                "  int *  e = 0;\n"
12532                "  float  f = 0;\n"
12533                "  double g = 0;\n"
12534                "}\n"
12535                "void bar(ino_t     a,\n"
12536                "         int       b,\n"
12537                "         uint32_t *c,\n"
12538                "         bool      d) {}\n",
12539                Alignment);
12540   Alignment.BinPackParameters = true;
12541   Alignment.ColumnLimit = 80;
12542 
12543   // Bug 33507
12544   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12545   verifyFormat(
12546       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12547       "  static const Version verVs2017;\n"
12548       "  return true;\n"
12549       "});\n",
12550       Alignment);
12551   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12552 
12553   // See llvm.org/PR35641
12554   Alignment.AlignConsecutiveDeclarations = true;
12555   verifyFormat("int func() { //\n"
12556                "  int      b;\n"
12557                "  unsigned c;\n"
12558                "}",
12559                Alignment);
12560 
12561   // See PR37175
12562   FormatStyle Style = getMozillaStyle();
12563   Style.AlignConsecutiveDeclarations = true;
12564   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12565             "foo(int a);",
12566             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12567 }
12568 
12569 TEST_F(FormatTest, LinuxBraceBreaking) {
12570   FormatStyle LinuxBraceStyle = getLLVMStyle();
12571   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12572   verifyFormat("namespace a\n"
12573                "{\n"
12574                "class A\n"
12575                "{\n"
12576                "  void f()\n"
12577                "  {\n"
12578                "    if (true) {\n"
12579                "      a();\n"
12580                "      b();\n"
12581                "    } else {\n"
12582                "      a();\n"
12583                "    }\n"
12584                "  }\n"
12585                "  void g() { return; }\n"
12586                "};\n"
12587                "struct B {\n"
12588                "  int x;\n"
12589                "};\n"
12590                "} // namespace a\n",
12591                LinuxBraceStyle);
12592   verifyFormat("enum X {\n"
12593                "  Y = 0,\n"
12594                "}\n",
12595                LinuxBraceStyle);
12596   verifyFormat("struct S {\n"
12597                "  int Type;\n"
12598                "  union {\n"
12599                "    int x;\n"
12600                "    double y;\n"
12601                "  } Value;\n"
12602                "  class C\n"
12603                "  {\n"
12604                "    MyFavoriteType Value;\n"
12605                "  } Class;\n"
12606                "}\n",
12607                LinuxBraceStyle);
12608 }
12609 
12610 TEST_F(FormatTest, MozillaBraceBreaking) {
12611   FormatStyle MozillaBraceStyle = getLLVMStyle();
12612   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
12613   MozillaBraceStyle.FixNamespaceComments = false;
12614   verifyFormat("namespace a {\n"
12615                "class A\n"
12616                "{\n"
12617                "  void f()\n"
12618                "  {\n"
12619                "    if (true) {\n"
12620                "      a();\n"
12621                "      b();\n"
12622                "    }\n"
12623                "  }\n"
12624                "  void g() { return; }\n"
12625                "};\n"
12626                "enum E\n"
12627                "{\n"
12628                "  A,\n"
12629                "  // foo\n"
12630                "  B,\n"
12631                "  C\n"
12632                "};\n"
12633                "struct B\n"
12634                "{\n"
12635                "  int x;\n"
12636                "};\n"
12637                "}\n",
12638                MozillaBraceStyle);
12639   verifyFormat("struct S\n"
12640                "{\n"
12641                "  int Type;\n"
12642                "  union\n"
12643                "  {\n"
12644                "    int x;\n"
12645                "    double y;\n"
12646                "  } Value;\n"
12647                "  class C\n"
12648                "  {\n"
12649                "    MyFavoriteType Value;\n"
12650                "  } Class;\n"
12651                "}\n",
12652                MozillaBraceStyle);
12653 }
12654 
12655 TEST_F(FormatTest, StroustrupBraceBreaking) {
12656   FormatStyle StroustrupBraceStyle = getLLVMStyle();
12657   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12658   verifyFormat("namespace a {\n"
12659                "class A {\n"
12660                "  void f()\n"
12661                "  {\n"
12662                "    if (true) {\n"
12663                "      a();\n"
12664                "      b();\n"
12665                "    }\n"
12666                "  }\n"
12667                "  void g() { return; }\n"
12668                "};\n"
12669                "struct B {\n"
12670                "  int x;\n"
12671                "};\n"
12672                "} // namespace a\n",
12673                StroustrupBraceStyle);
12674 
12675   verifyFormat("void foo()\n"
12676                "{\n"
12677                "  if (a) {\n"
12678                "    a();\n"
12679                "  }\n"
12680                "  else {\n"
12681                "    b();\n"
12682                "  }\n"
12683                "}\n",
12684                StroustrupBraceStyle);
12685 
12686   verifyFormat("#ifdef _DEBUG\n"
12687                "int foo(int i = 0)\n"
12688                "#else\n"
12689                "int foo(int i = 5)\n"
12690                "#endif\n"
12691                "{\n"
12692                "  return i;\n"
12693                "}",
12694                StroustrupBraceStyle);
12695 
12696   verifyFormat("void foo() {}\n"
12697                "void bar()\n"
12698                "#ifdef _DEBUG\n"
12699                "{\n"
12700                "  foo();\n"
12701                "}\n"
12702                "#else\n"
12703                "{\n"
12704                "}\n"
12705                "#endif",
12706                StroustrupBraceStyle);
12707 
12708   verifyFormat("void foobar() { int i = 5; }\n"
12709                "#ifdef _DEBUG\n"
12710                "void bar() {}\n"
12711                "#else\n"
12712                "void bar() { foobar(); }\n"
12713                "#endif",
12714                StroustrupBraceStyle);
12715 }
12716 
12717 TEST_F(FormatTest, AllmanBraceBreaking) {
12718   FormatStyle AllmanBraceStyle = getLLVMStyle();
12719   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
12720 
12721   EXPECT_EQ("namespace a\n"
12722             "{\n"
12723             "void f();\n"
12724             "void g();\n"
12725             "} // namespace a\n",
12726             format("namespace a\n"
12727                    "{\n"
12728                    "void f();\n"
12729                    "void g();\n"
12730                    "}\n",
12731                    AllmanBraceStyle));
12732 
12733   verifyFormat("namespace a\n"
12734                "{\n"
12735                "class A\n"
12736                "{\n"
12737                "  void f()\n"
12738                "  {\n"
12739                "    if (true)\n"
12740                "    {\n"
12741                "      a();\n"
12742                "      b();\n"
12743                "    }\n"
12744                "  }\n"
12745                "  void g() { return; }\n"
12746                "};\n"
12747                "struct B\n"
12748                "{\n"
12749                "  int x;\n"
12750                "};\n"
12751                "union C\n"
12752                "{\n"
12753                "};\n"
12754                "} // namespace a",
12755                AllmanBraceStyle);
12756 
12757   verifyFormat("void f()\n"
12758                "{\n"
12759                "  if (true)\n"
12760                "  {\n"
12761                "    a();\n"
12762                "  }\n"
12763                "  else if (false)\n"
12764                "  {\n"
12765                "    b();\n"
12766                "  }\n"
12767                "  else\n"
12768                "  {\n"
12769                "    c();\n"
12770                "  }\n"
12771                "}\n",
12772                AllmanBraceStyle);
12773 
12774   verifyFormat("void f()\n"
12775                "{\n"
12776                "  for (int i = 0; i < 10; ++i)\n"
12777                "  {\n"
12778                "    a();\n"
12779                "  }\n"
12780                "  while (false)\n"
12781                "  {\n"
12782                "    b();\n"
12783                "  }\n"
12784                "  do\n"
12785                "  {\n"
12786                "    c();\n"
12787                "  } while (false)\n"
12788                "}\n",
12789                AllmanBraceStyle);
12790 
12791   verifyFormat("void f(int a)\n"
12792                "{\n"
12793                "  switch (a)\n"
12794                "  {\n"
12795                "  case 0:\n"
12796                "    break;\n"
12797                "  case 1:\n"
12798                "  {\n"
12799                "    break;\n"
12800                "  }\n"
12801                "  case 2:\n"
12802                "  {\n"
12803                "  }\n"
12804                "  break;\n"
12805                "  default:\n"
12806                "    break;\n"
12807                "  }\n"
12808                "}\n",
12809                AllmanBraceStyle);
12810 
12811   verifyFormat("enum X\n"
12812                "{\n"
12813                "  Y = 0,\n"
12814                "}\n",
12815                AllmanBraceStyle);
12816   verifyFormat("enum X\n"
12817                "{\n"
12818                "  Y = 0\n"
12819                "}\n",
12820                AllmanBraceStyle);
12821 
12822   verifyFormat("@interface BSApplicationController ()\n"
12823                "{\n"
12824                "@private\n"
12825                "  id _extraIvar;\n"
12826                "}\n"
12827                "@end\n",
12828                AllmanBraceStyle);
12829 
12830   verifyFormat("#ifdef _DEBUG\n"
12831                "int foo(int i = 0)\n"
12832                "#else\n"
12833                "int foo(int i = 5)\n"
12834                "#endif\n"
12835                "{\n"
12836                "  return i;\n"
12837                "}",
12838                AllmanBraceStyle);
12839 
12840   verifyFormat("void foo() {}\n"
12841                "void bar()\n"
12842                "#ifdef _DEBUG\n"
12843                "{\n"
12844                "  foo();\n"
12845                "}\n"
12846                "#else\n"
12847                "{\n"
12848                "}\n"
12849                "#endif",
12850                AllmanBraceStyle);
12851 
12852   verifyFormat("void foobar() { int i = 5; }\n"
12853                "#ifdef _DEBUG\n"
12854                "void bar() {}\n"
12855                "#else\n"
12856                "void bar() { foobar(); }\n"
12857                "#endif",
12858                AllmanBraceStyle);
12859 
12860   // This shouldn't affect ObjC blocks..
12861   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
12862                "  // ...\n"
12863                "  int i;\n"
12864                "}];",
12865                AllmanBraceStyle);
12866   verifyFormat("void (^block)(void) = ^{\n"
12867                "  // ...\n"
12868                "  int i;\n"
12869                "};",
12870                AllmanBraceStyle);
12871   // .. or dict literals.
12872   verifyFormat("void f()\n"
12873                "{\n"
12874                "  // ...\n"
12875                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
12876                "}",
12877                AllmanBraceStyle);
12878   verifyFormat("void f()\n"
12879                "{\n"
12880                "  // ...\n"
12881                "  [object someMethod:@{a : @\"b\"}];\n"
12882                "}",
12883                AllmanBraceStyle);
12884   verifyFormat("int f()\n"
12885                "{ // comment\n"
12886                "  return 42;\n"
12887                "}",
12888                AllmanBraceStyle);
12889 
12890   AllmanBraceStyle.ColumnLimit = 19;
12891   verifyFormat("void f() { int i; }", AllmanBraceStyle);
12892   AllmanBraceStyle.ColumnLimit = 18;
12893   verifyFormat("void f()\n"
12894                "{\n"
12895                "  int i;\n"
12896                "}",
12897                AllmanBraceStyle);
12898   AllmanBraceStyle.ColumnLimit = 80;
12899 
12900   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
12901   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
12902       FormatStyle::SIS_WithoutElse;
12903   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
12904   verifyFormat("void f(bool b)\n"
12905                "{\n"
12906                "  if (b)\n"
12907                "  {\n"
12908                "    return;\n"
12909                "  }\n"
12910                "}\n",
12911                BreakBeforeBraceShortIfs);
12912   verifyFormat("void f(bool b)\n"
12913                "{\n"
12914                "  if constexpr (b)\n"
12915                "  {\n"
12916                "    return;\n"
12917                "  }\n"
12918                "}\n",
12919                BreakBeforeBraceShortIfs);
12920   verifyFormat("void f(bool b)\n"
12921                "{\n"
12922                "  if CONSTEXPR (b)\n"
12923                "  {\n"
12924                "    return;\n"
12925                "  }\n"
12926                "}\n",
12927                BreakBeforeBraceShortIfs);
12928   verifyFormat("void f(bool b)\n"
12929                "{\n"
12930                "  if (b) return;\n"
12931                "}\n",
12932                BreakBeforeBraceShortIfs);
12933   verifyFormat("void f(bool b)\n"
12934                "{\n"
12935                "  if constexpr (b) return;\n"
12936                "}\n",
12937                BreakBeforeBraceShortIfs);
12938   verifyFormat("void f(bool b)\n"
12939                "{\n"
12940                "  if CONSTEXPR (b) return;\n"
12941                "}\n",
12942                BreakBeforeBraceShortIfs);
12943   verifyFormat("void f(bool b)\n"
12944                "{\n"
12945                "  while (b)\n"
12946                "  {\n"
12947                "    return;\n"
12948                "  }\n"
12949                "}\n",
12950                BreakBeforeBraceShortIfs);
12951 }
12952 
12953 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
12954   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
12955   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
12956 
12957   // Make a few changes to the style for testing purposes
12958   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
12959       FormatStyle::SFS_Empty;
12960   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
12961   WhitesmithsBraceStyle.ColumnLimit = 0;
12962 
12963   // FIXME: this test case can't decide whether there should be a blank line
12964   // after the ~D() line or not. It adds one if one doesn't exist in the test
12965   // and it removes the line if one exists.
12966   /*
12967   verifyFormat("class A;\n"
12968                "namespace B\n"
12969                "  {\n"
12970                "class C;\n"
12971                "// Comment\n"
12972                "class D\n"
12973                "  {\n"
12974                "public:\n"
12975                "  D();\n"
12976                "  ~D() {}\n"
12977                "private:\n"
12978                "  enum E\n"
12979                "    {\n"
12980                "    F\n"
12981                "    }\n"
12982                "  };\n"
12983                "  } // namespace B\n",
12984                WhitesmithsBraceStyle);
12985   */
12986 
12987   verifyFormat("namespace a\n"
12988                "  {\n"
12989                "class A\n"
12990                "  {\n"
12991                "  void f()\n"
12992                "    {\n"
12993                "    if (true)\n"
12994                "      {\n"
12995                "      a();\n"
12996                "      b();\n"
12997                "      }\n"
12998                "    }\n"
12999                "  void g()\n"
13000                "    {\n"
13001                "    return;\n"
13002                "    }\n"
13003                "  };\n"
13004                "struct B\n"
13005                "  {\n"
13006                "  int x;\n"
13007                "  };\n"
13008                "  } // namespace a",
13009                WhitesmithsBraceStyle);
13010 
13011   verifyFormat("void f()\n"
13012                "  {\n"
13013                "  if (true)\n"
13014                "    {\n"
13015                "    a();\n"
13016                "    }\n"
13017                "  else if (false)\n"
13018                "    {\n"
13019                "    b();\n"
13020                "    }\n"
13021                "  else\n"
13022                "    {\n"
13023                "    c();\n"
13024                "    }\n"
13025                "  }\n",
13026                WhitesmithsBraceStyle);
13027 
13028   verifyFormat("void f()\n"
13029                "  {\n"
13030                "  for (int i = 0; i < 10; ++i)\n"
13031                "    {\n"
13032                "    a();\n"
13033                "    }\n"
13034                "  while (false)\n"
13035                "    {\n"
13036                "    b();\n"
13037                "    }\n"
13038                "  do\n"
13039                "    {\n"
13040                "    c();\n"
13041                "    } while (false)\n"
13042                "  }\n",
13043                WhitesmithsBraceStyle);
13044 
13045   WhitesmithsBraceStyle.IndentCaseBlocks = true;
13046   verifyFormat("void switchTest1(int a)\n"
13047                "  {\n"
13048                "  switch (a)\n"
13049                "    {\n"
13050                "    case 2:\n"
13051                "      {\n"
13052                "      }\n"
13053                "    break;\n"
13054                "    }\n"
13055                "  }\n",
13056                WhitesmithsBraceStyle);
13057 
13058   verifyFormat("void switchTest2(int a)\n"
13059                "  {\n"
13060                "  switch (a)\n"
13061                "    {\n"
13062                "    case 0:\n"
13063                "    break;\n"
13064                "    case 1:\n"
13065                "      {\n"
13066                "      break;\n"
13067                "      }\n"
13068                "    case 2:\n"
13069                "      {\n"
13070                "      }\n"
13071                "    break;\n"
13072                "    default:\n"
13073                "    break;\n"
13074                "    }\n"
13075                "  }\n",
13076                WhitesmithsBraceStyle);
13077 
13078   verifyFormat("void switchTest3(int a)\n"
13079                "  {\n"
13080                "  switch (a)\n"
13081                "    {\n"
13082                "    case 0:\n"
13083                "      {\n"
13084                "      foo(x);\n"
13085                "      }\n"
13086                "    break;\n"
13087                "    default:\n"
13088                "      {\n"
13089                "      foo(1);\n"
13090                "      }\n"
13091                "    break;\n"
13092                "    }\n"
13093                "  }\n",
13094                WhitesmithsBraceStyle);
13095 
13096   WhitesmithsBraceStyle.IndentCaseBlocks = false;
13097 
13098   verifyFormat("void switchTest4(int a)\n"
13099                "  {\n"
13100                "  switch (a)\n"
13101                "    {\n"
13102                "    case 2:\n"
13103                "    {\n"
13104                "    }\n"
13105                "    break;\n"
13106                "    }\n"
13107                "  }\n",
13108                WhitesmithsBraceStyle);
13109 
13110   verifyFormat("void switchTest5(int a)\n"
13111                "  {\n"
13112                "  switch (a)\n"
13113                "    {\n"
13114                "    case 0:\n"
13115                "    break;\n"
13116                "    case 1:\n"
13117                "    {\n"
13118                "    foo();\n"
13119                "    break;\n"
13120                "    }\n"
13121                "    case 2:\n"
13122                "    {\n"
13123                "    }\n"
13124                "    break;\n"
13125                "    default:\n"
13126                "    break;\n"
13127                "    }\n"
13128                "  }\n",
13129                WhitesmithsBraceStyle);
13130 
13131   verifyFormat("void switchTest6(int a)\n"
13132                "  {\n"
13133                "  switch (a)\n"
13134                "    {\n"
13135                "    case 0:\n"
13136                "    {\n"
13137                "    foo(x);\n"
13138                "    }\n"
13139                "    break;\n"
13140                "    default:\n"
13141                "    {\n"
13142                "    foo(1);\n"
13143                "    }\n"
13144                "    break;\n"
13145                "    }\n"
13146                "  }\n",
13147                WhitesmithsBraceStyle);
13148 
13149   verifyFormat("enum X\n"
13150                "  {\n"
13151                "  Y = 0, // testing\n"
13152                "  }\n",
13153                WhitesmithsBraceStyle);
13154 
13155   verifyFormat("enum X\n"
13156                "  {\n"
13157                "  Y = 0\n"
13158                "  }\n",
13159                WhitesmithsBraceStyle);
13160   verifyFormat("enum X\n"
13161                "  {\n"
13162                "  Y = 0,\n"
13163                "  Z = 1\n"
13164                "  };\n",
13165                WhitesmithsBraceStyle);
13166 
13167   verifyFormat("@interface BSApplicationController ()\n"
13168                "  {\n"
13169                "@private\n"
13170                "  id _extraIvar;\n"
13171                "  }\n"
13172                "@end\n",
13173                WhitesmithsBraceStyle);
13174 
13175   verifyFormat("#ifdef _DEBUG\n"
13176                "int foo(int i = 0)\n"
13177                "#else\n"
13178                "int foo(int i = 5)\n"
13179                "#endif\n"
13180                "  {\n"
13181                "  return i;\n"
13182                "  }",
13183                WhitesmithsBraceStyle);
13184 
13185   verifyFormat("void foo() {}\n"
13186                "void bar()\n"
13187                "#ifdef _DEBUG\n"
13188                "  {\n"
13189                "  foo();\n"
13190                "  }\n"
13191                "#else\n"
13192                "  {\n"
13193                "  }\n"
13194                "#endif",
13195                WhitesmithsBraceStyle);
13196 
13197   verifyFormat("void foobar()\n"
13198                "  {\n"
13199                "  int i = 5;\n"
13200                "  }\n"
13201                "#ifdef _DEBUG\n"
13202                "void bar()\n"
13203                "  {\n"
13204                "  }\n"
13205                "#else\n"
13206                "void bar()\n"
13207                "  {\n"
13208                "  foobar();\n"
13209                "  }\n"
13210                "#endif",
13211                WhitesmithsBraceStyle);
13212 
13213   // This shouldn't affect ObjC blocks..
13214   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13215                "  // ...\n"
13216                "  int i;\n"
13217                "}];",
13218                WhitesmithsBraceStyle);
13219   verifyFormat("void (^block)(void) = ^{\n"
13220                "  // ...\n"
13221                "  int i;\n"
13222                "};",
13223                WhitesmithsBraceStyle);
13224   // .. or dict literals.
13225   verifyFormat("void f()\n"
13226                "  {\n"
13227                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13228                "  }",
13229                WhitesmithsBraceStyle);
13230 
13231   verifyFormat("int f()\n"
13232                "  { // comment\n"
13233                "  return 42;\n"
13234                "  }",
13235                WhitesmithsBraceStyle);
13236 
13237   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13238   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13239       FormatStyle::SIS_Always;
13240   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13241   verifyFormat("void f(bool b)\n"
13242                "  {\n"
13243                "  if (b)\n"
13244                "    {\n"
13245                "    return;\n"
13246                "    }\n"
13247                "  }\n",
13248                BreakBeforeBraceShortIfs);
13249   verifyFormat("void f(bool b)\n"
13250                "  {\n"
13251                "  if (b) return;\n"
13252                "  }\n",
13253                BreakBeforeBraceShortIfs);
13254   verifyFormat("void f(bool b)\n"
13255                "  {\n"
13256                "  while (b)\n"
13257                "    {\n"
13258                "    return;\n"
13259                "    }\n"
13260                "  }\n",
13261                BreakBeforeBraceShortIfs);
13262 }
13263 
13264 TEST_F(FormatTest, GNUBraceBreaking) {
13265   FormatStyle GNUBraceStyle = getLLVMStyle();
13266   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13267   verifyFormat("namespace a\n"
13268                "{\n"
13269                "class A\n"
13270                "{\n"
13271                "  void f()\n"
13272                "  {\n"
13273                "    int a;\n"
13274                "    {\n"
13275                "      int b;\n"
13276                "    }\n"
13277                "    if (true)\n"
13278                "      {\n"
13279                "        a();\n"
13280                "        b();\n"
13281                "      }\n"
13282                "  }\n"
13283                "  void g() { return; }\n"
13284                "}\n"
13285                "} // namespace a",
13286                GNUBraceStyle);
13287 
13288   verifyFormat("void f()\n"
13289                "{\n"
13290                "  if (true)\n"
13291                "    {\n"
13292                "      a();\n"
13293                "    }\n"
13294                "  else if (false)\n"
13295                "    {\n"
13296                "      b();\n"
13297                "    }\n"
13298                "  else\n"
13299                "    {\n"
13300                "      c();\n"
13301                "    }\n"
13302                "}\n",
13303                GNUBraceStyle);
13304 
13305   verifyFormat("void f()\n"
13306                "{\n"
13307                "  for (int i = 0; i < 10; ++i)\n"
13308                "    {\n"
13309                "      a();\n"
13310                "    }\n"
13311                "  while (false)\n"
13312                "    {\n"
13313                "      b();\n"
13314                "    }\n"
13315                "  do\n"
13316                "    {\n"
13317                "      c();\n"
13318                "    }\n"
13319                "  while (false);\n"
13320                "}\n",
13321                GNUBraceStyle);
13322 
13323   verifyFormat("void f(int a)\n"
13324                "{\n"
13325                "  switch (a)\n"
13326                "    {\n"
13327                "    case 0:\n"
13328                "      break;\n"
13329                "    case 1:\n"
13330                "      {\n"
13331                "        break;\n"
13332                "      }\n"
13333                "    case 2:\n"
13334                "      {\n"
13335                "      }\n"
13336                "      break;\n"
13337                "    default:\n"
13338                "      break;\n"
13339                "    }\n"
13340                "}\n",
13341                GNUBraceStyle);
13342 
13343   verifyFormat("enum X\n"
13344                "{\n"
13345                "  Y = 0,\n"
13346                "}\n",
13347                GNUBraceStyle);
13348 
13349   verifyFormat("@interface BSApplicationController ()\n"
13350                "{\n"
13351                "@private\n"
13352                "  id _extraIvar;\n"
13353                "}\n"
13354                "@end\n",
13355                GNUBraceStyle);
13356 
13357   verifyFormat("#ifdef _DEBUG\n"
13358                "int foo(int i = 0)\n"
13359                "#else\n"
13360                "int foo(int i = 5)\n"
13361                "#endif\n"
13362                "{\n"
13363                "  return i;\n"
13364                "}",
13365                GNUBraceStyle);
13366 
13367   verifyFormat("void foo() {}\n"
13368                "void bar()\n"
13369                "#ifdef _DEBUG\n"
13370                "{\n"
13371                "  foo();\n"
13372                "}\n"
13373                "#else\n"
13374                "{\n"
13375                "}\n"
13376                "#endif",
13377                GNUBraceStyle);
13378 
13379   verifyFormat("void foobar() { int i = 5; }\n"
13380                "#ifdef _DEBUG\n"
13381                "void bar() {}\n"
13382                "#else\n"
13383                "void bar() { foobar(); }\n"
13384                "#endif",
13385                GNUBraceStyle);
13386 }
13387 
13388 TEST_F(FormatTest, WebKitBraceBreaking) {
13389   FormatStyle WebKitBraceStyle = getLLVMStyle();
13390   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13391   WebKitBraceStyle.FixNamespaceComments = false;
13392   verifyFormat("namespace a {\n"
13393                "class A {\n"
13394                "  void f()\n"
13395                "  {\n"
13396                "    if (true) {\n"
13397                "      a();\n"
13398                "      b();\n"
13399                "    }\n"
13400                "  }\n"
13401                "  void g() { return; }\n"
13402                "};\n"
13403                "enum E {\n"
13404                "  A,\n"
13405                "  // foo\n"
13406                "  B,\n"
13407                "  C\n"
13408                "};\n"
13409                "struct B {\n"
13410                "  int x;\n"
13411                "};\n"
13412                "}\n",
13413                WebKitBraceStyle);
13414   verifyFormat("struct S {\n"
13415                "  int Type;\n"
13416                "  union {\n"
13417                "    int x;\n"
13418                "    double y;\n"
13419                "  } Value;\n"
13420                "  class C {\n"
13421                "    MyFavoriteType Value;\n"
13422                "  } Class;\n"
13423                "};\n",
13424                WebKitBraceStyle);
13425 }
13426 
13427 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13428   verifyFormat("void f() {\n"
13429                "  try {\n"
13430                "  } catch (const Exception &e) {\n"
13431                "  }\n"
13432                "}\n",
13433                getLLVMStyle());
13434 }
13435 
13436 TEST_F(FormatTest, UnderstandsPragmas) {
13437   verifyFormat("#pragma omp reduction(| : var)");
13438   verifyFormat("#pragma omp reduction(+ : var)");
13439 
13440   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13441             "(including parentheses).",
13442             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13443                    "(including parentheses)."));
13444 }
13445 
13446 TEST_F(FormatTest, UnderstandPragmaOption) {
13447   verifyFormat("#pragma option -C -A");
13448 
13449   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13450 }
13451 
13452 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13453   FormatStyle Style = getLLVMStyle();
13454   Style.ColumnLimit = 20;
13455 
13456   // See PR41213
13457   EXPECT_EQ("/*\n"
13458             " *\t9012345\n"
13459             " * /8901\n"
13460             " */",
13461             format("/*\n"
13462                    " *\t9012345 /8901\n"
13463                    " */",
13464                    Style));
13465   EXPECT_EQ("/*\n"
13466             " *345678\n"
13467             " *\t/8901\n"
13468             " */",
13469             format("/*\n"
13470                    " *345678\t/8901\n"
13471                    " */",
13472                    Style));
13473 
13474   verifyFormat("int a; // the\n"
13475                "       // comment",
13476                Style);
13477   EXPECT_EQ("int a; /* first line\n"
13478             "        * second\n"
13479             "        * line third\n"
13480             "        * line\n"
13481             "        */",
13482             format("int a; /* first line\n"
13483                    "        * second\n"
13484                    "        * line third\n"
13485                    "        * line\n"
13486                    "        */",
13487                    Style));
13488   EXPECT_EQ("int a; // first line\n"
13489             "       // second\n"
13490             "       // line third\n"
13491             "       // line",
13492             format("int a; // first line\n"
13493                    "       // second line\n"
13494                    "       // third line",
13495                    Style));
13496 
13497   Style.PenaltyExcessCharacter = 90;
13498   verifyFormat("int a; // the comment", Style);
13499   EXPECT_EQ("int a; // the comment\n"
13500             "       // aaa",
13501             format("int a; // the comment aaa", Style));
13502   EXPECT_EQ("int a; /* first line\n"
13503             "        * second line\n"
13504             "        * third line\n"
13505             "        */",
13506             format("int a; /* first line\n"
13507                    "        * second line\n"
13508                    "        * third line\n"
13509                    "        */",
13510                    Style));
13511   EXPECT_EQ("int a; // first line\n"
13512             "       // second line\n"
13513             "       // third line",
13514             format("int a; // first line\n"
13515                    "       // second line\n"
13516                    "       // third line",
13517                    Style));
13518   // FIXME: Investigate why this is not getting the same layout as the test
13519   // above.
13520   EXPECT_EQ("int a; /* first line\n"
13521             "        * second line\n"
13522             "        * third line\n"
13523             "        */",
13524             format("int a; /* first line second line third line"
13525                    "\n*/",
13526                    Style));
13527 
13528   EXPECT_EQ("// foo bar baz bazfoo\n"
13529             "// foo bar foo bar\n",
13530             format("// foo bar baz bazfoo\n"
13531                    "// foo bar foo           bar\n",
13532                    Style));
13533   EXPECT_EQ("// foo bar baz bazfoo\n"
13534             "// foo bar foo bar\n",
13535             format("// foo bar baz      bazfoo\n"
13536                    "// foo            bar foo bar\n",
13537                    Style));
13538 
13539   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13540   // next one.
13541   EXPECT_EQ("// foo bar baz bazfoo\n"
13542             "// bar foo bar\n",
13543             format("// foo bar baz      bazfoo bar\n"
13544                    "// foo            bar\n",
13545                    Style));
13546 
13547   EXPECT_EQ("// foo bar baz bazfoo\n"
13548             "// foo bar baz bazfoo\n"
13549             "// bar foo bar\n",
13550             format("// foo bar baz      bazfoo\n"
13551                    "// foo bar baz      bazfoo bar\n"
13552                    "// foo bar\n",
13553                    Style));
13554 
13555   EXPECT_EQ("// foo bar baz bazfoo\n"
13556             "// foo bar baz bazfoo\n"
13557             "// bar foo bar\n",
13558             format("// foo bar baz      bazfoo\n"
13559                    "// foo bar baz      bazfoo bar\n"
13560                    "// foo           bar\n",
13561                    Style));
13562 
13563   // Make sure we do not keep protruding characters if strict mode reflow is
13564   // cheaper than keeping protruding characters.
13565   Style.ColumnLimit = 21;
13566   EXPECT_EQ(
13567       "// foo foo foo foo\n"
13568       "// foo foo foo foo\n"
13569       "// foo foo foo foo\n",
13570       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13571 
13572   EXPECT_EQ("int a = /* long block\n"
13573             "           comment */\n"
13574             "    42;",
13575             format("int a = /* long block comment */ 42;", Style));
13576 }
13577 
13578 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13579   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13580   EXPECT_EQ(Styles[0], Styles[i])                                              \
13581       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13582 
13583 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13584   SmallVector<FormatStyle, 3> Styles;
13585   Styles.resize(3);
13586 
13587   Styles[0] = getLLVMStyle();
13588   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13589   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13590   EXPECT_ALL_STYLES_EQUAL(Styles);
13591 
13592   Styles[0] = getGoogleStyle();
13593   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13594   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13595   EXPECT_ALL_STYLES_EQUAL(Styles);
13596 
13597   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13598   EXPECT_TRUE(
13599       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13600   EXPECT_TRUE(
13601       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13602   EXPECT_ALL_STYLES_EQUAL(Styles);
13603 
13604   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13605   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13606   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
13607   EXPECT_ALL_STYLES_EQUAL(Styles);
13608 
13609   Styles[0] = getMozillaStyle();
13610   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
13611   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
13612   EXPECT_ALL_STYLES_EQUAL(Styles);
13613 
13614   Styles[0] = getWebKitStyle();
13615   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
13616   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
13617   EXPECT_ALL_STYLES_EQUAL(Styles);
13618 
13619   Styles[0] = getGNUStyle();
13620   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
13621   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
13622   EXPECT_ALL_STYLES_EQUAL(Styles);
13623 
13624   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
13625 }
13626 
13627 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
13628   SmallVector<FormatStyle, 8> Styles;
13629   Styles.resize(2);
13630 
13631   Styles[0] = getGoogleStyle();
13632   Styles[1] = getLLVMStyle();
13633   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13634   EXPECT_ALL_STYLES_EQUAL(Styles);
13635 
13636   Styles.resize(5);
13637   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13638   Styles[1] = getLLVMStyle();
13639   Styles[1].Language = FormatStyle::LK_JavaScript;
13640   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13641 
13642   Styles[2] = getLLVMStyle();
13643   Styles[2].Language = FormatStyle::LK_JavaScript;
13644   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
13645                                   "BasedOnStyle: Google",
13646                                   &Styles[2])
13647                    .value());
13648 
13649   Styles[3] = getLLVMStyle();
13650   Styles[3].Language = FormatStyle::LK_JavaScript;
13651   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
13652                                   "Language: JavaScript",
13653                                   &Styles[3])
13654                    .value());
13655 
13656   Styles[4] = getLLVMStyle();
13657   Styles[4].Language = FormatStyle::LK_JavaScript;
13658   EXPECT_EQ(0, parseConfiguration("---\n"
13659                                   "BasedOnStyle: LLVM\n"
13660                                   "IndentWidth: 123\n"
13661                                   "---\n"
13662                                   "BasedOnStyle: Google\n"
13663                                   "Language: JavaScript",
13664                                   &Styles[4])
13665                    .value());
13666   EXPECT_ALL_STYLES_EQUAL(Styles);
13667 }
13668 
13669 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
13670   Style.FIELD = false;                                                         \
13671   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
13672   EXPECT_TRUE(Style.FIELD);                                                    \
13673   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
13674   EXPECT_FALSE(Style.FIELD);
13675 
13676 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
13677 
13678 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
13679   Style.STRUCT.FIELD = false;                                                  \
13680   EXPECT_EQ(0,                                                                 \
13681             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
13682                 .value());                                                     \
13683   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
13684   EXPECT_EQ(0,                                                                 \
13685             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
13686                 .value());                                                     \
13687   EXPECT_FALSE(Style.STRUCT.FIELD);
13688 
13689 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
13690   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
13691 
13692 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
13693   EXPECT_NE(VALUE, Style.FIELD);                                               \
13694   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
13695   EXPECT_EQ(VALUE, Style.FIELD)
13696 
13697 TEST_F(FormatTest, ParsesConfigurationBools) {
13698   FormatStyle Style = {};
13699   Style.Language = FormatStyle::LK_Cpp;
13700   CHECK_PARSE_BOOL(AlignTrailingComments);
13701   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
13702   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
13703   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
13704   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
13705   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
13706   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
13707   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
13708   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
13709   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
13710   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
13711   CHECK_PARSE_BOOL(BinPackArguments);
13712   CHECK_PARSE_BOOL(BinPackParameters);
13713   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
13714   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
13715   CHECK_PARSE_BOOL(BreakStringLiterals);
13716   CHECK_PARSE_BOOL(CompactNamespaces);
13717   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
13718   CHECK_PARSE_BOOL(DeriveLineEnding);
13719   CHECK_PARSE_BOOL(DerivePointerAlignment);
13720   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
13721   CHECK_PARSE_BOOL(DisableFormat);
13722   CHECK_PARSE_BOOL(IndentCaseLabels);
13723   CHECK_PARSE_BOOL(IndentCaseBlocks);
13724   CHECK_PARSE_BOOL(IndentGotoLabels);
13725   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
13726   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
13727   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
13728   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
13729   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
13730   CHECK_PARSE_BOOL(ReflowComments);
13731   CHECK_PARSE_BOOL(SortIncludes);
13732   CHECK_PARSE_BOOL(SortUsingDeclarations);
13733   CHECK_PARSE_BOOL(SpacesInParentheses);
13734   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
13735   CHECK_PARSE_BOOL(SpacesInAngles);
13736   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
13737   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
13738   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
13739   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
13740   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
13741   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
13742   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
13743   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
13744   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
13745   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
13746   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
13747   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
13748   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
13749   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
13750   CHECK_PARSE_BOOL(UseCRLF);
13751 
13752   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
13753   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
13754   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
13755   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
13756   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
13757   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
13758   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
13759   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
13760   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
13761   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
13762   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
13763   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
13764   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
13765   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
13766   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
13767   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
13768   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
13769 }
13770 
13771 #undef CHECK_PARSE_BOOL
13772 
13773 TEST_F(FormatTest, ParsesConfiguration) {
13774   FormatStyle Style = {};
13775   Style.Language = FormatStyle::LK_Cpp;
13776   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
13777   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
13778               ConstructorInitializerIndentWidth, 1234u);
13779   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
13780   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
13781   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
13782   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
13783   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
13784               PenaltyBreakBeforeFirstCallParameter, 1234u);
13785   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
13786               PenaltyBreakTemplateDeclaration, 1234u);
13787   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
13788   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
13789               PenaltyReturnTypeOnItsOwnLine, 1234u);
13790   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
13791               SpacesBeforeTrailingComments, 1234u);
13792   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
13793   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
13794   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
13795 
13796   Style.PointerAlignment = FormatStyle::PAS_Middle;
13797   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
13798               FormatStyle::PAS_Left);
13799   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
13800               FormatStyle::PAS_Right);
13801   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
13802               FormatStyle::PAS_Middle);
13803   // For backward compatibility:
13804   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
13805               FormatStyle::PAS_Left);
13806   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
13807               FormatStyle::PAS_Right);
13808   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
13809               FormatStyle::PAS_Middle);
13810 
13811   Style.Standard = FormatStyle::LS_Auto;
13812   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
13813   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
13814   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
13815   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
13816   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
13817   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
13818   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
13819   // Legacy aliases:
13820   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
13821   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
13822   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
13823   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
13824 
13825   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13826   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
13827               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
13828   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
13829               FormatStyle::BOS_None);
13830   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
13831               FormatStyle::BOS_All);
13832   // For backward compatibility:
13833   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
13834               FormatStyle::BOS_None);
13835   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
13836               FormatStyle::BOS_All);
13837 
13838   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
13839   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
13840               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13841   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
13842               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
13843   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
13844               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
13845   // For backward compatibility:
13846   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
13847               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
13848 
13849   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
13850   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
13851               FormatStyle::BILS_BeforeComma);
13852   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
13853               FormatStyle::BILS_AfterColon);
13854   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
13855               FormatStyle::BILS_BeforeColon);
13856   // For backward compatibility:
13857   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
13858               FormatStyle::BILS_BeforeComma);
13859 
13860   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
13861   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
13862               FormatStyle::BAS_Align);
13863   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
13864               FormatStyle::BAS_DontAlign);
13865   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
13866               FormatStyle::BAS_AlwaysBreak);
13867   // For backward compatibility:
13868   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
13869               FormatStyle::BAS_DontAlign);
13870   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
13871               FormatStyle::BAS_Align);
13872 
13873   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13874   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
13875               FormatStyle::ENAS_DontAlign);
13876   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
13877               FormatStyle::ENAS_Left);
13878   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
13879               FormatStyle::ENAS_Right);
13880   // For backward compatibility:
13881   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
13882               FormatStyle::ENAS_Left);
13883   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
13884               FormatStyle::ENAS_Right);
13885 
13886   Style.AlignOperands = FormatStyle::OAS_Align;
13887   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
13888               FormatStyle::OAS_DontAlign);
13889   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
13890   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
13891               FormatStyle::OAS_AlignAfterOperator);
13892   // For backward compatibility:
13893   CHECK_PARSE("AlignOperands: false", AlignOperands,
13894               FormatStyle::OAS_DontAlign);
13895   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
13896 
13897   Style.UseTab = FormatStyle::UT_ForIndentation;
13898   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
13899   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
13900   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
13901   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
13902               FormatStyle::UT_ForContinuationAndIndentation);
13903   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
13904               FormatStyle::UT_AlignWithSpaces);
13905   // For backward compatibility:
13906   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
13907   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
13908 
13909   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
13910   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
13911               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13912   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
13913               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
13914   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
13915               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13916   // For backward compatibility:
13917   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
13918               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
13919   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
13920               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
13921 
13922   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
13923   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
13924               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13925   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
13926               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
13927   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
13928               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
13929   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
13930               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13931   // For backward compatibility:
13932   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
13933               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
13934   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
13935               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
13936 
13937   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
13938   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
13939               FormatStyle::SBPO_Never);
13940   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
13941               FormatStyle::SBPO_Always);
13942   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
13943               FormatStyle::SBPO_ControlStatements);
13944   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
13945               FormatStyle::SBPO_NonEmptyParentheses);
13946   // For backward compatibility:
13947   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
13948               FormatStyle::SBPO_Never);
13949   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
13950               FormatStyle::SBPO_ControlStatements);
13951 
13952   Style.ColumnLimit = 123;
13953   FormatStyle BaseStyle = getLLVMStyle();
13954   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
13955   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
13956 
13957   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
13958   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
13959               FormatStyle::BS_Attach);
13960   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
13961               FormatStyle::BS_Linux);
13962   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
13963               FormatStyle::BS_Mozilla);
13964   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
13965               FormatStyle::BS_Stroustrup);
13966   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
13967               FormatStyle::BS_Allman);
13968   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
13969               FormatStyle::BS_Whitesmiths);
13970   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
13971   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
13972               FormatStyle::BS_WebKit);
13973   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
13974               FormatStyle::BS_Custom);
13975 
13976   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
13977   CHECK_PARSE("BraceWrapping:\n"
13978               "  AfterControlStatement: MultiLine",
13979               BraceWrapping.AfterControlStatement,
13980               FormatStyle::BWACS_MultiLine);
13981   CHECK_PARSE("BraceWrapping:\n"
13982               "  AfterControlStatement: Always",
13983               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13984   CHECK_PARSE("BraceWrapping:\n"
13985               "  AfterControlStatement: Never",
13986               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13987   // For backward compatibility:
13988   CHECK_PARSE("BraceWrapping:\n"
13989               "  AfterControlStatement: true",
13990               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
13991   CHECK_PARSE("BraceWrapping:\n"
13992               "  AfterControlStatement: false",
13993               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
13994 
13995   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
13996   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
13997               FormatStyle::RTBS_None);
13998   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
13999               FormatStyle::RTBS_All);
14000   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
14001               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
14002   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
14003               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
14004   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
14005               AlwaysBreakAfterReturnType,
14006               FormatStyle::RTBS_TopLevelDefinitions);
14007 
14008   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
14009   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
14010               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
14011   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
14012               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14013   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
14014               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14015   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
14016               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14017   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
14018               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14019 
14020   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
14021   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
14022               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
14023   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
14024               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
14025   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
14026               AlwaysBreakAfterDefinitionReturnType,
14027               FormatStyle::DRTBS_TopLevel);
14028 
14029   Style.NamespaceIndentation = FormatStyle::NI_All;
14030   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
14031               FormatStyle::NI_None);
14032   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
14033               FormatStyle::NI_Inner);
14034   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
14035               FormatStyle::NI_All);
14036 
14037   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
14038   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
14039               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14040   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
14041               AllowShortIfStatementsOnASingleLine,
14042               FormatStyle::SIS_WithoutElse);
14043   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
14044               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
14045   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
14046               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14047   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
14048               AllowShortIfStatementsOnASingleLine,
14049               FormatStyle::SIS_WithoutElse);
14050 
14051   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
14052   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
14053               FormatStyle::IEBS_AfterExternBlock);
14054   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
14055               FormatStyle::IEBS_Indent);
14056   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
14057               FormatStyle::IEBS_NoIndent);
14058   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
14059               FormatStyle::IEBS_Indent);
14060   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
14061               FormatStyle::IEBS_NoIndent);
14062 
14063   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
14064   CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
14065               FormatStyle::BFCS_Both);
14066   CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
14067               FormatStyle::BFCS_None);
14068   CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
14069               FormatStyle::BFCS_Before);
14070   CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
14071               FormatStyle::BFCS_After);
14072 
14073   // FIXME: This is required because parsing a configuration simply overwrites
14074   // the first N elements of the list instead of resetting it.
14075   Style.ForEachMacros.clear();
14076   std::vector<std::string> BoostForeach;
14077   BoostForeach.push_back("BOOST_FOREACH");
14078   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
14079   std::vector<std::string> BoostAndQForeach;
14080   BoostAndQForeach.push_back("BOOST_FOREACH");
14081   BoostAndQForeach.push_back("Q_FOREACH");
14082   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
14083               BoostAndQForeach);
14084 
14085   Style.StatementMacros.clear();
14086   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
14087               std::vector<std::string>{"QUNUSED"});
14088   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
14089               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
14090 
14091   Style.NamespaceMacros.clear();
14092   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
14093               std::vector<std::string>{"TESTSUITE"});
14094   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
14095               std::vector<std::string>({"TESTSUITE", "SUITE"}));
14096 
14097   Style.WhitespaceSensitiveMacros.clear();
14098   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
14099               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14100   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
14101               WhitespaceSensitiveMacros,
14102               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14103   Style.WhitespaceSensitiveMacros.clear();
14104   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
14105               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14106   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
14107               WhitespaceSensitiveMacros,
14108               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14109 
14110   Style.IncludeStyle.IncludeCategories.clear();
14111   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
14112       {"abc/.*", 2, 0}, {".*", 1, 0}};
14113   CHECK_PARSE("IncludeCategories:\n"
14114               "  - Regex: abc/.*\n"
14115               "    Priority: 2\n"
14116               "  - Regex: .*\n"
14117               "    Priority: 1",
14118               IncludeStyle.IncludeCategories, ExpectedCategories);
14119   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
14120               "abc$");
14121   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
14122               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
14123 
14124   Style.RawStringFormats.clear();
14125   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
14126       {
14127           FormatStyle::LK_TextProto,
14128           {"pb", "proto"},
14129           {"PARSE_TEXT_PROTO"},
14130           /*CanonicalDelimiter=*/"",
14131           "llvm",
14132       },
14133       {
14134           FormatStyle::LK_Cpp,
14135           {"cc", "cpp"},
14136           {"C_CODEBLOCK", "CPPEVAL"},
14137           /*CanonicalDelimiter=*/"cc",
14138           /*BasedOnStyle=*/"",
14139       },
14140   };
14141 
14142   CHECK_PARSE("RawStringFormats:\n"
14143               "  - Language: TextProto\n"
14144               "    Delimiters:\n"
14145               "      - 'pb'\n"
14146               "      - 'proto'\n"
14147               "    EnclosingFunctions:\n"
14148               "      - 'PARSE_TEXT_PROTO'\n"
14149               "    BasedOnStyle: llvm\n"
14150               "  - Language: Cpp\n"
14151               "    Delimiters:\n"
14152               "      - 'cc'\n"
14153               "      - 'cpp'\n"
14154               "    EnclosingFunctions:\n"
14155               "      - 'C_CODEBLOCK'\n"
14156               "      - 'CPPEVAL'\n"
14157               "    CanonicalDelimiter: 'cc'",
14158               RawStringFormats, ExpectedRawStringFormats);
14159 }
14160 
14161 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
14162   FormatStyle Style = {};
14163   Style.Language = FormatStyle::LK_Cpp;
14164   CHECK_PARSE("Language: Cpp\n"
14165               "IndentWidth: 12",
14166               IndentWidth, 12u);
14167   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
14168                                "IndentWidth: 34",
14169                                &Style),
14170             ParseError::Unsuitable);
14171   FormatStyle BinPackedTCS = {};
14172   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
14173   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
14174                                "InsertTrailingCommas: Wrapped",
14175                                &BinPackedTCS),
14176             ParseError::BinPackTrailingCommaConflict);
14177   EXPECT_EQ(12u, Style.IndentWidth);
14178   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14179   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14180 
14181   Style.Language = FormatStyle::LK_JavaScript;
14182   CHECK_PARSE("Language: JavaScript\n"
14183               "IndentWidth: 12",
14184               IndentWidth, 12u);
14185   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14186   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14187                                "IndentWidth: 34",
14188                                &Style),
14189             ParseError::Unsuitable);
14190   EXPECT_EQ(23u, Style.IndentWidth);
14191   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14192   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14193 
14194   CHECK_PARSE("BasedOnStyle: LLVM\n"
14195               "IndentWidth: 67",
14196               IndentWidth, 67u);
14197 
14198   CHECK_PARSE("---\n"
14199               "Language: JavaScript\n"
14200               "IndentWidth: 12\n"
14201               "---\n"
14202               "Language: Cpp\n"
14203               "IndentWidth: 34\n"
14204               "...\n",
14205               IndentWidth, 12u);
14206 
14207   Style.Language = FormatStyle::LK_Cpp;
14208   CHECK_PARSE("---\n"
14209               "Language: JavaScript\n"
14210               "IndentWidth: 12\n"
14211               "---\n"
14212               "Language: Cpp\n"
14213               "IndentWidth: 34\n"
14214               "...\n",
14215               IndentWidth, 34u);
14216   CHECK_PARSE("---\n"
14217               "IndentWidth: 78\n"
14218               "---\n"
14219               "Language: JavaScript\n"
14220               "IndentWidth: 56\n"
14221               "...\n",
14222               IndentWidth, 78u);
14223 
14224   Style.ColumnLimit = 123;
14225   Style.IndentWidth = 234;
14226   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14227   Style.TabWidth = 345;
14228   EXPECT_FALSE(parseConfiguration("---\n"
14229                                   "IndentWidth: 456\n"
14230                                   "BreakBeforeBraces: Allman\n"
14231                                   "---\n"
14232                                   "Language: JavaScript\n"
14233                                   "IndentWidth: 111\n"
14234                                   "TabWidth: 111\n"
14235                                   "---\n"
14236                                   "Language: Cpp\n"
14237                                   "BreakBeforeBraces: Stroustrup\n"
14238                                   "TabWidth: 789\n"
14239                                   "...\n",
14240                                   &Style));
14241   EXPECT_EQ(123u, Style.ColumnLimit);
14242   EXPECT_EQ(456u, Style.IndentWidth);
14243   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14244   EXPECT_EQ(789u, Style.TabWidth);
14245 
14246   EXPECT_EQ(parseConfiguration("---\n"
14247                                "Language: JavaScript\n"
14248                                "IndentWidth: 56\n"
14249                                "---\n"
14250                                "IndentWidth: 78\n"
14251                                "...\n",
14252                                &Style),
14253             ParseError::Error);
14254   EXPECT_EQ(parseConfiguration("---\n"
14255                                "Language: JavaScript\n"
14256                                "IndentWidth: 56\n"
14257                                "---\n"
14258                                "Language: JavaScript\n"
14259                                "IndentWidth: 78\n"
14260                                "...\n",
14261                                &Style),
14262             ParseError::Error);
14263 
14264   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14265 }
14266 
14267 #undef CHECK_PARSE
14268 
14269 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14270   FormatStyle Style = {};
14271   Style.Language = FormatStyle::LK_JavaScript;
14272   Style.BreakBeforeTernaryOperators = true;
14273   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14274   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14275 
14276   Style.BreakBeforeTernaryOperators = true;
14277   EXPECT_EQ(0, parseConfiguration("---\n"
14278                                   "BasedOnStyle: Google\n"
14279                                   "---\n"
14280                                   "Language: JavaScript\n"
14281                                   "IndentWidth: 76\n"
14282                                   "...\n",
14283                                   &Style)
14284                    .value());
14285   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14286   EXPECT_EQ(76u, Style.IndentWidth);
14287   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14288 }
14289 
14290 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14291   FormatStyle Style = getLLVMStyle();
14292   std::string YAML = configurationAsText(Style);
14293   FormatStyle ParsedStyle = {};
14294   ParsedStyle.Language = FormatStyle::LK_Cpp;
14295   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14296   EXPECT_EQ(Style, ParsedStyle);
14297 }
14298 
14299 TEST_F(FormatTest, WorksFor8bitEncodings) {
14300   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14301             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14302             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14303             "\"\xef\xee\xf0\xf3...\"",
14304             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14305                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14306                    "\xef\xee\xf0\xf3...\"",
14307                    getLLVMStyleWithColumns(12)));
14308 }
14309 
14310 TEST_F(FormatTest, HandlesUTF8BOM) {
14311   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14312   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14313             format("\xef\xbb\xbf#include <iostream>"));
14314   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14315             format("\xef\xbb\xbf\n#include <iostream>"));
14316 }
14317 
14318 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14319 #if !defined(_MSC_VER)
14320 
14321 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14322   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14323                getLLVMStyleWithColumns(35));
14324   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14325                getLLVMStyleWithColumns(31));
14326   verifyFormat("// Однажды в студёную зимнюю пору...",
14327                getLLVMStyleWithColumns(36));
14328   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14329   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14330                getLLVMStyleWithColumns(39));
14331   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14332                getLLVMStyleWithColumns(35));
14333 }
14334 
14335 TEST_F(FormatTest, SplitsUTF8Strings) {
14336   // Non-printable characters' width is currently considered to be the length in
14337   // bytes in UTF8. The characters can be displayed in very different manner
14338   // (zero-width, single width with a substitution glyph, expanded to their code
14339   // (e.g. "<8d>"), so there's no single correct way to handle them.
14340   EXPECT_EQ("\"aaaaÄ\"\n"
14341             "\"\xc2\x8d\";",
14342             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14343   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14344             "\"\xc2\x8d\";",
14345             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14346   EXPECT_EQ("\"Однажды, в \"\n"
14347             "\"студёную \"\n"
14348             "\"зимнюю \"\n"
14349             "\"пору,\"",
14350             format("\"Однажды, в студёную зимнюю пору,\"",
14351                    getLLVMStyleWithColumns(13)));
14352   EXPECT_EQ(
14353       "\"一 二 三 \"\n"
14354       "\"四 五六 \"\n"
14355       "\"七 八 九 \"\n"
14356       "\"十\"",
14357       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14358   EXPECT_EQ("\"一\t\"\n"
14359             "\"二 \t\"\n"
14360             "\"三 四 \"\n"
14361             "\"五\t\"\n"
14362             "\"六 \t\"\n"
14363             "\"七 \"\n"
14364             "\"八九十\tqq\"",
14365             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14366                    getLLVMStyleWithColumns(11)));
14367 
14368   // UTF8 character in an escape sequence.
14369   EXPECT_EQ("\"aaaaaa\"\n"
14370             "\"\\\xC2\x8D\"",
14371             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14372 }
14373 
14374 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14375   EXPECT_EQ("const char *sssss =\n"
14376             "    \"一二三四五六七八\\\n"
14377             " 九 十\";",
14378             format("const char *sssss = \"一二三四五六七八\\\n"
14379                    " 九 十\";",
14380                    getLLVMStyleWithColumns(30)));
14381 }
14382 
14383 TEST_F(FormatTest, SplitsUTF8LineComments) {
14384   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14385             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14386   EXPECT_EQ("// Я из лесу\n"
14387             "// вышел; был\n"
14388             "// сильный\n"
14389             "// мороз.",
14390             format("// Я из лесу вышел; был сильный мороз.",
14391                    getLLVMStyleWithColumns(13)));
14392   EXPECT_EQ("// 一二三\n"
14393             "// 四五六七\n"
14394             "// 八  九\n"
14395             "// 十",
14396             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14397 }
14398 
14399 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14400   EXPECT_EQ("/* Гляжу,\n"
14401             " * поднимается\n"
14402             " * медленно в\n"
14403             " * гору\n"
14404             " * Лошадка,\n"
14405             " * везущая\n"
14406             " * хворосту\n"
14407             " * воз. */",
14408             format("/* Гляжу, поднимается медленно в гору\n"
14409                    " * Лошадка, везущая хворосту воз. */",
14410                    getLLVMStyleWithColumns(13)));
14411   EXPECT_EQ(
14412       "/* 一二三\n"
14413       " * 四五六七\n"
14414       " * 八  九\n"
14415       " * 十  */",
14416       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14417   EXPECT_EQ("/* �������� ��������\n"
14418             " * ��������\n"
14419             " * ������-�� */",
14420             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14421 }
14422 
14423 #endif // _MSC_VER
14424 
14425 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14426   FormatStyle Style = getLLVMStyle();
14427 
14428   Style.ConstructorInitializerIndentWidth = 4;
14429   verifyFormat(
14430       "SomeClass::Constructor()\n"
14431       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14432       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14433       Style);
14434 
14435   Style.ConstructorInitializerIndentWidth = 2;
14436   verifyFormat(
14437       "SomeClass::Constructor()\n"
14438       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14439       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14440       Style);
14441 
14442   Style.ConstructorInitializerIndentWidth = 0;
14443   verifyFormat(
14444       "SomeClass::Constructor()\n"
14445       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14446       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14447       Style);
14448   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14449   verifyFormat(
14450       "SomeLongTemplateVariableName<\n"
14451       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14452       Style);
14453   verifyFormat("bool smaller = 1 < "
14454                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14455                "                       "
14456                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14457                Style);
14458 
14459   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14460   verifyFormat("SomeClass::Constructor() :\n"
14461                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14462                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14463                Style);
14464 }
14465 
14466 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14467   FormatStyle Style = getLLVMStyle();
14468   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14469   Style.ConstructorInitializerIndentWidth = 4;
14470   verifyFormat("SomeClass::Constructor()\n"
14471                "    : a(a)\n"
14472                "    , b(b)\n"
14473                "    , c(c) {}",
14474                Style);
14475   verifyFormat("SomeClass::Constructor()\n"
14476                "    : a(a) {}",
14477                Style);
14478 
14479   Style.ColumnLimit = 0;
14480   verifyFormat("SomeClass::Constructor()\n"
14481                "    : a(a) {}",
14482                Style);
14483   verifyFormat("SomeClass::Constructor() noexcept\n"
14484                "    : a(a) {}",
14485                Style);
14486   verifyFormat("SomeClass::Constructor()\n"
14487                "    : a(a)\n"
14488                "    , b(b)\n"
14489                "    , c(c) {}",
14490                Style);
14491   verifyFormat("SomeClass::Constructor()\n"
14492                "    : a(a) {\n"
14493                "  foo();\n"
14494                "  bar();\n"
14495                "}",
14496                Style);
14497 
14498   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14499   verifyFormat("SomeClass::Constructor()\n"
14500                "    : a(a)\n"
14501                "    , b(b)\n"
14502                "    , c(c) {\n}",
14503                Style);
14504   verifyFormat("SomeClass::Constructor()\n"
14505                "    : a(a) {\n}",
14506                Style);
14507 
14508   Style.ColumnLimit = 80;
14509   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14510   Style.ConstructorInitializerIndentWidth = 2;
14511   verifyFormat("SomeClass::Constructor()\n"
14512                "  : a(a)\n"
14513                "  , b(b)\n"
14514                "  , c(c) {}",
14515                Style);
14516 
14517   Style.ConstructorInitializerIndentWidth = 0;
14518   verifyFormat("SomeClass::Constructor()\n"
14519                ": a(a)\n"
14520                ", b(b)\n"
14521                ", c(c) {}",
14522                Style);
14523 
14524   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14525   Style.ConstructorInitializerIndentWidth = 4;
14526   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14527   verifyFormat(
14528       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14529       Style);
14530   verifyFormat(
14531       "SomeClass::Constructor()\n"
14532       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14533       Style);
14534   Style.ConstructorInitializerIndentWidth = 4;
14535   Style.ColumnLimit = 60;
14536   verifyFormat("SomeClass::Constructor()\n"
14537                "    : aaaaaaaa(aaaaaaaa)\n"
14538                "    , aaaaaaaa(aaaaaaaa)\n"
14539                "    , aaaaaaaa(aaaaaaaa) {}",
14540                Style);
14541 }
14542 
14543 TEST_F(FormatTest, Destructors) {
14544   verifyFormat("void F(int &i) { i.~int(); }");
14545   verifyFormat("void F(int &i) { i->~int(); }");
14546 }
14547 
14548 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14549   FormatStyle Style = getWebKitStyle();
14550 
14551   // Don't indent in outer namespaces.
14552   verifyFormat("namespace outer {\n"
14553                "int i;\n"
14554                "namespace inner {\n"
14555                "    int i;\n"
14556                "} // namespace inner\n"
14557                "} // namespace outer\n"
14558                "namespace other_outer {\n"
14559                "int i;\n"
14560                "}",
14561                Style);
14562 
14563   // Don't indent case labels.
14564   verifyFormat("switch (variable) {\n"
14565                "case 1:\n"
14566                "case 2:\n"
14567                "    doSomething();\n"
14568                "    break;\n"
14569                "default:\n"
14570                "    ++variable;\n"
14571                "}",
14572                Style);
14573 
14574   // Wrap before binary operators.
14575   EXPECT_EQ("void f()\n"
14576             "{\n"
14577             "    if (aaaaaaaaaaaaaaaa\n"
14578             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14579             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14580             "        return;\n"
14581             "}",
14582             format("void f() {\n"
14583                    "if (aaaaaaaaaaaaaaaa\n"
14584                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
14585                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14586                    "return;\n"
14587                    "}",
14588                    Style));
14589 
14590   // Allow functions on a single line.
14591   verifyFormat("void f() { return; }", Style);
14592 
14593   // Allow empty blocks on a single line and insert a space in empty blocks.
14594   EXPECT_EQ("void f() { }", format("void f() {}", Style));
14595   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
14596   // However, don't merge non-empty short loops.
14597   EXPECT_EQ("while (true) {\n"
14598             "    continue;\n"
14599             "}",
14600             format("while (true) { continue; }", Style));
14601 
14602   // Constructor initializers are formatted one per line with the "," on the
14603   // new line.
14604   verifyFormat("Constructor()\n"
14605                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
14606                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
14607                "          aaaaaaaaaaaaaa)\n"
14608                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
14609                "{\n"
14610                "}",
14611                Style);
14612   verifyFormat("SomeClass::Constructor()\n"
14613                "    : a(a)\n"
14614                "{\n"
14615                "}",
14616                Style);
14617   EXPECT_EQ("SomeClass::Constructor()\n"
14618             "    : a(a)\n"
14619             "{\n"
14620             "}",
14621             format("SomeClass::Constructor():a(a){}", Style));
14622   verifyFormat("SomeClass::Constructor()\n"
14623                "    : a(a)\n"
14624                "    , b(b)\n"
14625                "    , c(c)\n"
14626                "{\n"
14627                "}",
14628                Style);
14629   verifyFormat("SomeClass::Constructor()\n"
14630                "    : a(a)\n"
14631                "{\n"
14632                "    foo();\n"
14633                "    bar();\n"
14634                "}",
14635                Style);
14636 
14637   // Access specifiers should be aligned left.
14638   verifyFormat("class C {\n"
14639                "public:\n"
14640                "    int i;\n"
14641                "};",
14642                Style);
14643 
14644   // Do not align comments.
14645   verifyFormat("int a; // Do not\n"
14646                "double b; // align comments.",
14647                Style);
14648 
14649   // Do not align operands.
14650   EXPECT_EQ("ASSERT(aaaa\n"
14651             "    || bbbb);",
14652             format("ASSERT ( aaaa\n||bbbb);", Style));
14653 
14654   // Accept input's line breaks.
14655   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
14656             "    || bbbbbbbbbbbbbbb) {\n"
14657             "    i++;\n"
14658             "}",
14659             format("if (aaaaaaaaaaaaaaa\n"
14660                    "|| bbbbbbbbbbbbbbb) { i++; }",
14661                    Style));
14662   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
14663             "    i++;\n"
14664             "}",
14665             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
14666 
14667   // Don't automatically break all macro definitions (llvm.org/PR17842).
14668   verifyFormat("#define aNumber 10", Style);
14669   // However, generally keep the line breaks that the user authored.
14670   EXPECT_EQ("#define aNumber \\\n"
14671             "    10",
14672             format("#define aNumber \\\n"
14673                    " 10",
14674                    Style));
14675 
14676   // Keep empty and one-element array literals on a single line.
14677   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
14678             "                                  copyItems:YES];",
14679             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
14680                    "copyItems:YES];",
14681                    Style));
14682   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
14683             "                                  copyItems:YES];",
14684             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
14685                    "             copyItems:YES];",
14686                    Style));
14687   // FIXME: This does not seem right, there should be more indentation before
14688   // the array literal's entries. Nested blocks have the same problem.
14689   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14690             "    @\"a\",\n"
14691             "    @\"a\"\n"
14692             "]\n"
14693             "                                  copyItems:YES];",
14694             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
14695                    "     @\"a\",\n"
14696                    "     @\"a\"\n"
14697                    "     ]\n"
14698                    "       copyItems:YES];",
14699                    Style));
14700   EXPECT_EQ(
14701       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14702       "                                  copyItems:YES];",
14703       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
14704              "   copyItems:YES];",
14705              Style));
14706 
14707   verifyFormat("[self.a b:c c:d];", Style);
14708   EXPECT_EQ("[self.a b:c\n"
14709             "        c:d];",
14710             format("[self.a b:c\n"
14711                    "c:d];",
14712                    Style));
14713 }
14714 
14715 TEST_F(FormatTest, FormatsLambdas) {
14716   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
14717   verifyFormat(
14718       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
14719   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
14720   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
14721   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
14722   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
14723   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
14724   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
14725   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
14726   verifyFormat("int x = f(*+[] {});");
14727   verifyFormat("void f() {\n"
14728                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
14729                "}\n");
14730   verifyFormat("void f() {\n"
14731                "  other(x.begin(), //\n"
14732                "        x.end(),   //\n"
14733                "        [&](int, int) { return 1; });\n"
14734                "}\n");
14735   verifyFormat("void f() {\n"
14736                "  other.other.other.other.other(\n"
14737                "      x.begin(), x.end(),\n"
14738                "      [something, rather](int, int, int, int, int, int, int) { "
14739                "return 1; });\n"
14740                "}\n");
14741   verifyFormat(
14742       "void f() {\n"
14743       "  other.other.other.other.other(\n"
14744       "      x.begin(), x.end(),\n"
14745       "      [something, rather](int, int, int, int, int, int, int) {\n"
14746       "        //\n"
14747       "      });\n"
14748       "}\n");
14749   verifyFormat("SomeFunction([]() { // A cool function...\n"
14750                "  return 43;\n"
14751                "});");
14752   EXPECT_EQ("SomeFunction([]() {\n"
14753             "#define A a\n"
14754             "  return 43;\n"
14755             "});",
14756             format("SomeFunction([](){\n"
14757                    "#define A a\n"
14758                    "return 43;\n"
14759                    "});"));
14760   verifyFormat("void f() {\n"
14761                "  SomeFunction([](decltype(x), A *a) {});\n"
14762                "}");
14763   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14764                "    [](const aaaaaaaaaa &a) { return a; });");
14765   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
14766                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
14767                "});");
14768   verifyFormat("Constructor()\n"
14769                "    : Field([] { // comment\n"
14770                "        int i;\n"
14771                "      }) {}");
14772   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
14773                "  return some_parameter.size();\n"
14774                "};");
14775   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
14776                "    [](const string &s) { return s; };");
14777   verifyFormat("int i = aaaaaa ? 1 //\n"
14778                "               : [] {\n"
14779                "                   return 2; //\n"
14780                "                 }();");
14781   verifyFormat("llvm::errs() << \"number of twos is \"\n"
14782                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
14783                "                  return x == 2; // force break\n"
14784                "                });");
14785   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
14786                "    [=](int iiiiiiiiiiii) {\n"
14787                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
14788                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
14789                "    });",
14790                getLLVMStyleWithColumns(60));
14791   verifyFormat("SomeFunction({[&] {\n"
14792                "                // comment\n"
14793                "              },\n"
14794                "              [&] {\n"
14795                "                // comment\n"
14796                "              }});");
14797   verifyFormat("SomeFunction({[&] {\n"
14798                "  // comment\n"
14799                "}});");
14800   verifyFormat(
14801       "virtual aaaaaaaaaaaaaaaa(\n"
14802       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
14803       "    aaaaa aaaaaaaaa);");
14804 
14805   // Lambdas with return types.
14806   verifyFormat("int c = []() -> int { return 2; }();\n");
14807   verifyFormat("int c = []() -> int * { return 2; }();\n");
14808   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
14809   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
14810   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
14811   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
14812   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
14813   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
14814   verifyFormat("[a, a]() -> a<1> {};");
14815   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
14816   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
14817   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
14818   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
14819   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
14820   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
14821   verifyFormat("[]() -> foo<!5> { return {}; };");
14822   verifyFormat("[]() -> foo<~5> { return {}; };");
14823   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
14824   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
14825   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
14826   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
14827   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
14828   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
14829   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
14830   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
14831   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
14832   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
14833   verifyFormat("namespace bar {\n"
14834                "// broken:\n"
14835                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
14836                "} // namespace bar");
14837   verifyFormat("namespace bar {\n"
14838                "// broken:\n"
14839                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
14840                "} // namespace bar");
14841   verifyFormat("namespace bar {\n"
14842                "// broken:\n"
14843                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
14844                "} // namespace bar");
14845   verifyFormat("namespace bar {\n"
14846                "// broken:\n"
14847                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
14848                "} // namespace bar");
14849   verifyFormat("namespace bar {\n"
14850                "// broken:\n"
14851                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
14852                "} // namespace bar");
14853   verifyFormat("namespace bar {\n"
14854                "// broken:\n"
14855                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
14856                "} // namespace bar");
14857   verifyFormat("namespace bar {\n"
14858                "// broken:\n"
14859                "auto foo{[]() -> foo<!5> { return {}; }};\n"
14860                "} // namespace bar");
14861   verifyFormat("namespace bar {\n"
14862                "// broken:\n"
14863                "auto foo{[]() -> foo<~5> { return {}; }};\n"
14864                "} // namespace bar");
14865   verifyFormat("namespace bar {\n"
14866                "// broken:\n"
14867                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
14868                "} // namespace bar");
14869   verifyFormat("namespace bar {\n"
14870                "// broken:\n"
14871                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
14872                "} // namespace bar");
14873   verifyFormat("namespace bar {\n"
14874                "// broken:\n"
14875                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
14876                "} // namespace bar");
14877   verifyFormat("namespace bar {\n"
14878                "// broken:\n"
14879                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
14880                "} // namespace bar");
14881   verifyFormat("namespace bar {\n"
14882                "// broken:\n"
14883                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
14884                "} // namespace bar");
14885   verifyFormat("namespace bar {\n"
14886                "// broken:\n"
14887                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
14888                "} // namespace bar");
14889   verifyFormat("namespace bar {\n"
14890                "// broken:\n"
14891                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
14892                "} // namespace bar");
14893   verifyFormat("namespace bar {\n"
14894                "// broken:\n"
14895                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
14896                "} // namespace bar");
14897   verifyFormat("namespace bar {\n"
14898                "// broken:\n"
14899                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
14900                "} // namespace bar");
14901   verifyFormat("namespace bar {\n"
14902                "// broken:\n"
14903                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
14904                "} // namespace bar");
14905   verifyFormat("[]() -> a<1> {};");
14906   verifyFormat("[]() -> a<1> { ; };");
14907   verifyFormat("[]() -> a<1> { ; }();");
14908   verifyFormat("[a, a]() -> a<true> {};");
14909   verifyFormat("[]() -> a<true> {};");
14910   verifyFormat("[]() -> a<true> { ; };");
14911   verifyFormat("[]() -> a<true> { ; }();");
14912   verifyFormat("[a, a]() -> a<false> {};");
14913   verifyFormat("[]() -> a<false> {};");
14914   verifyFormat("[]() -> a<false> { ; };");
14915   verifyFormat("[]() -> a<false> { ; }();");
14916   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
14917   verifyFormat("namespace bar {\n"
14918                "auto foo{[]() -> foo<false> { ; }};\n"
14919                "} // namespace bar");
14920   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
14921                "                   int j) -> int {\n"
14922                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
14923                "};");
14924   verifyFormat(
14925       "aaaaaaaaaaaaaaaaaaaaaa(\n"
14926       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
14927       "      return aaaaaaaaaaaaaaaaa;\n"
14928       "    });",
14929       getLLVMStyleWithColumns(70));
14930   verifyFormat("[]() //\n"
14931                "    -> int {\n"
14932                "  return 1; //\n"
14933                "};");
14934   verifyFormat("[]() -> Void<T...> {};");
14935   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
14936 
14937   // Lambdas with explicit template argument lists.
14938   verifyFormat(
14939       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
14940 
14941   // Multiple lambdas in the same parentheses change indentation rules. These
14942   // lambdas are forced to start on new lines.
14943   verifyFormat("SomeFunction(\n"
14944                "    []() {\n"
14945                "      //\n"
14946                "    },\n"
14947                "    []() {\n"
14948                "      //\n"
14949                "    });");
14950 
14951   // A lambda passed as arg0 is always pushed to the next line.
14952   verifyFormat("SomeFunction(\n"
14953                "    [this] {\n"
14954                "      //\n"
14955                "    },\n"
14956                "    1);\n");
14957 
14958   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
14959   // the arg0 case above.
14960   auto Style = getGoogleStyle();
14961   Style.BinPackArguments = false;
14962   verifyFormat("SomeFunction(\n"
14963                "    a,\n"
14964                "    [this] {\n"
14965                "      //\n"
14966                "    },\n"
14967                "    b);\n",
14968                Style);
14969   verifyFormat("SomeFunction(\n"
14970                "    a,\n"
14971                "    [this] {\n"
14972                "      //\n"
14973                "    },\n"
14974                "    b);\n");
14975 
14976   // A lambda with a very long line forces arg0 to be pushed out irrespective of
14977   // the BinPackArguments value (as long as the code is wide enough).
14978   verifyFormat(
14979       "something->SomeFunction(\n"
14980       "    a,\n"
14981       "    [this] {\n"
14982       "      "
14983       "D0000000000000000000000000000000000000000000000000000000000001();\n"
14984       "    },\n"
14985       "    b);\n");
14986 
14987   // A multi-line lambda is pulled up as long as the introducer fits on the
14988   // previous line and there are no further args.
14989   verifyFormat("function(1, [this, that] {\n"
14990                "  //\n"
14991                "});\n");
14992   verifyFormat("function([this, that] {\n"
14993                "  //\n"
14994                "});\n");
14995   // FIXME: this format is not ideal and we should consider forcing the first
14996   // arg onto its own line.
14997   verifyFormat("function(a, b, c, //\n"
14998                "         d, [this, that] {\n"
14999                "           //\n"
15000                "         });\n");
15001 
15002   // Multiple lambdas are treated correctly even when there is a short arg0.
15003   verifyFormat("SomeFunction(\n"
15004                "    1,\n"
15005                "    [this] {\n"
15006                "      //\n"
15007                "    },\n"
15008                "    [this] {\n"
15009                "      //\n"
15010                "    },\n"
15011                "    1);\n");
15012 
15013   // More complex introducers.
15014   verifyFormat("return [i, args...] {};");
15015 
15016   // Not lambdas.
15017   verifyFormat("constexpr char hello[]{\"hello\"};");
15018   verifyFormat("double &operator[](int i) { return 0; }\n"
15019                "int i;");
15020   verifyFormat("std::unique_ptr<int[]> foo() {}");
15021   verifyFormat("int i = a[a][a]->f();");
15022   verifyFormat("int i = (*b)[a]->f();");
15023 
15024   // Other corner cases.
15025   verifyFormat("void f() {\n"
15026                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
15027                "  );\n"
15028                "}");
15029 
15030   // Lambdas created through weird macros.
15031   verifyFormat("void f() {\n"
15032                "  MACRO((const AA &a) { return 1; });\n"
15033                "  MACRO((AA &a) { return 1; });\n"
15034                "}");
15035 
15036   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
15037                "      doo_dah();\n"
15038                "      doo_dah();\n"
15039                "    })) {\n"
15040                "}");
15041   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
15042                "                doo_dah();\n"
15043                "                doo_dah();\n"
15044                "              })) {\n"
15045                "}");
15046   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
15047                "                doo_dah();\n"
15048                "                doo_dah();\n"
15049                "              })) {\n"
15050                "}");
15051   verifyFormat("auto lambda = []() {\n"
15052                "  int a = 2\n"
15053                "#if A\n"
15054                "          + 2\n"
15055                "#endif\n"
15056                "      ;\n"
15057                "};");
15058 
15059   // Lambdas with complex multiline introducers.
15060   verifyFormat(
15061       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15062       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
15063       "        -> ::std::unordered_set<\n"
15064       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
15065       "      //\n"
15066       "    });");
15067 
15068   FormatStyle DoNotMerge = getLLVMStyle();
15069   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
15070   verifyFormat("auto c = []() {\n"
15071                "  return b;\n"
15072                "};",
15073                "auto c = []() { return b; };", DoNotMerge);
15074   verifyFormat("auto c = []() {\n"
15075                "};",
15076                " auto c = []() {};", DoNotMerge);
15077 
15078   FormatStyle MergeEmptyOnly = getLLVMStyle();
15079   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
15080   verifyFormat("auto c = []() {\n"
15081                "  return b;\n"
15082                "};",
15083                "auto c = []() {\n"
15084                "  return b;\n"
15085                " };",
15086                MergeEmptyOnly);
15087   verifyFormat("auto c = []() {};",
15088                "auto c = []() {\n"
15089                "};",
15090                MergeEmptyOnly);
15091 
15092   FormatStyle MergeInline = getLLVMStyle();
15093   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
15094   verifyFormat("auto c = []() {\n"
15095                "  return b;\n"
15096                "};",
15097                "auto c = []() { return b; };", MergeInline);
15098   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
15099                MergeInline);
15100   verifyFormat("function([]() { return b; }, a)",
15101                "function([]() { return b; }, a)", MergeInline);
15102   verifyFormat("function(a, []() { return b; })",
15103                "function(a, []() { return b; })", MergeInline);
15104 
15105   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
15106   // AllowShortLambdasOnASingleLine
15107   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15108   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15109   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15110   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15111       FormatStyle::ShortLambdaStyle::SLS_None;
15112   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
15113                "    []()\n"
15114                "    {\n"
15115                "      return 17;\n"
15116                "    });",
15117                LLVMWithBeforeLambdaBody);
15118   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
15119                "    []()\n"
15120                "    {\n"
15121                "    });",
15122                LLVMWithBeforeLambdaBody);
15123   verifyFormat("auto fct_SLS_None = []()\n"
15124                "{\n"
15125                "  return 17;\n"
15126                "};",
15127                LLVMWithBeforeLambdaBody);
15128   verifyFormat("TwoNestedLambdas_SLS_None(\n"
15129                "    []()\n"
15130                "    {\n"
15131                "      return Call(\n"
15132                "          []()\n"
15133                "          {\n"
15134                "            return 17;\n"
15135                "          });\n"
15136                "    });",
15137                LLVMWithBeforeLambdaBody);
15138   verifyFormat("void Fct()\n"
15139                "{\n"
15140                "  return {[]()\n"
15141                "          {\n"
15142                "            return 17;\n"
15143                "          }};\n"
15144                "}",
15145                LLVMWithBeforeLambdaBody);
15146 
15147   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15148       FormatStyle::ShortLambdaStyle::SLS_Empty;
15149   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
15150                "    []()\n"
15151                "    {\n"
15152                "      return 17;\n"
15153                "    });",
15154                LLVMWithBeforeLambdaBody);
15155   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
15156                LLVMWithBeforeLambdaBody);
15157   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
15158                "ongFunctionName_SLS_Empty(\n"
15159                "    []() {});",
15160                LLVMWithBeforeLambdaBody);
15161   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
15162                "                                []()\n"
15163                "                                {\n"
15164                "                                  return 17;\n"
15165                "                                });",
15166                LLVMWithBeforeLambdaBody);
15167   verifyFormat("auto fct_SLS_Empty = []()\n"
15168                "{\n"
15169                "  return 17;\n"
15170                "};",
15171                LLVMWithBeforeLambdaBody);
15172   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
15173                "    []()\n"
15174                "    {\n"
15175                "      return Call([]() {});\n"
15176                "    });",
15177                LLVMWithBeforeLambdaBody);
15178   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15179                "                           []()\n"
15180                "                           {\n"
15181                "                             return Call([]() {});\n"
15182                "                           });",
15183                LLVMWithBeforeLambdaBody);
15184   verifyFormat(
15185       "FctWithLongLineInLambda_SLS_Empty(\n"
15186       "    []()\n"
15187       "    {\n"
15188       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15189       "                               AndShouldNotBeConsiderAsInline,\n"
15190       "                               LambdaBodyMustBeBreak);\n"
15191       "    });",
15192       LLVMWithBeforeLambdaBody);
15193 
15194   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15195       FormatStyle::ShortLambdaStyle::SLS_Inline;
15196   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15197                LLVMWithBeforeLambdaBody);
15198   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15199                LLVMWithBeforeLambdaBody);
15200   verifyFormat("auto fct_SLS_Inline = []()\n"
15201                "{\n"
15202                "  return 17;\n"
15203                "};",
15204                LLVMWithBeforeLambdaBody);
15205   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15206                "17; }); });",
15207                LLVMWithBeforeLambdaBody);
15208   verifyFormat(
15209       "FctWithLongLineInLambda_SLS_Inline(\n"
15210       "    []()\n"
15211       "    {\n"
15212       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15213       "                               AndShouldNotBeConsiderAsInline,\n"
15214       "                               LambdaBodyMustBeBreak);\n"
15215       "    });",
15216       LLVMWithBeforeLambdaBody);
15217   verifyFormat("FctWithMultipleParams_SLS_Inline("
15218                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15219                "                                 []() { return 17; });",
15220                LLVMWithBeforeLambdaBody);
15221   verifyFormat(
15222       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15223       LLVMWithBeforeLambdaBody);
15224 
15225   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15226       FormatStyle::ShortLambdaStyle::SLS_All;
15227   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15228                LLVMWithBeforeLambdaBody);
15229   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15230                LLVMWithBeforeLambdaBody);
15231   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15232                LLVMWithBeforeLambdaBody);
15233   verifyFormat("FctWithOneParam_SLS_All(\n"
15234                "    []()\n"
15235                "    {\n"
15236                "      // A cool function...\n"
15237                "      return 43;\n"
15238                "    });",
15239                LLVMWithBeforeLambdaBody);
15240   verifyFormat("FctWithMultipleParams_SLS_All("
15241                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15242                "                              []() { return 17; });",
15243                LLVMWithBeforeLambdaBody);
15244   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15245                LLVMWithBeforeLambdaBody);
15246   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15247                LLVMWithBeforeLambdaBody);
15248   verifyFormat(
15249       "FctWithLongLineInLambda_SLS_All(\n"
15250       "    []()\n"
15251       "    {\n"
15252       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15253       "                               AndShouldNotBeConsiderAsInline,\n"
15254       "                               LambdaBodyMustBeBreak);\n"
15255       "    });",
15256       LLVMWithBeforeLambdaBody);
15257   verifyFormat(
15258       "auto fct_SLS_All = []()\n"
15259       "{\n"
15260       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15261       "                           AndShouldNotBeConsiderAsInline,\n"
15262       "                           LambdaBodyMustBeBreak);\n"
15263       "};",
15264       LLVMWithBeforeLambdaBody);
15265   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15266   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15267                LLVMWithBeforeLambdaBody);
15268   verifyFormat(
15269       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15270       "                                FirstParam,\n"
15271       "                                SecondParam,\n"
15272       "                                ThirdParam,\n"
15273       "                                FourthParam);",
15274       LLVMWithBeforeLambdaBody);
15275   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15276                "    []() { return "
15277                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15278                "    FirstParam,\n"
15279                "    SecondParam,\n"
15280                "    ThirdParam,\n"
15281                "    FourthParam);",
15282                LLVMWithBeforeLambdaBody);
15283   verifyFormat(
15284       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15285       "                                SecondParam,\n"
15286       "                                ThirdParam,\n"
15287       "                                FourthParam,\n"
15288       "                                []() { return SomeValueNotSoLong; });",
15289       LLVMWithBeforeLambdaBody);
15290   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15291                "    []()\n"
15292                "    {\n"
15293                "      return "
15294                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15295                "eConsiderAsInline;\n"
15296                "    });",
15297                LLVMWithBeforeLambdaBody);
15298   verifyFormat(
15299       "FctWithLongLineInLambda_SLS_All(\n"
15300       "    []()\n"
15301       "    {\n"
15302       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15303       "                               AndShouldNotBeConsiderAsInline,\n"
15304       "                               LambdaBodyMustBeBreak);\n"
15305       "    });",
15306       LLVMWithBeforeLambdaBody);
15307   verifyFormat("FctWithTwoParams_SLS_All(\n"
15308                "    []()\n"
15309                "    {\n"
15310                "      // A cool function...\n"
15311                "      return 43;\n"
15312                "    },\n"
15313                "    87);",
15314                LLVMWithBeforeLambdaBody);
15315   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15316                LLVMWithBeforeLambdaBody);
15317   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15318                LLVMWithBeforeLambdaBody);
15319   verifyFormat(
15320       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15321       LLVMWithBeforeLambdaBody);
15322   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15323                "}); }, x);",
15324                LLVMWithBeforeLambdaBody);
15325   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15326                "    []()\n"
15327                "    {\n"
15328                "      // A cool function...\n"
15329                "      return Call([]() { return 17; });\n"
15330                "    });",
15331                LLVMWithBeforeLambdaBody);
15332   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15333                "    []()\n"
15334                "    {\n"
15335                "      return Call(\n"
15336                "          []()\n"
15337                "          {\n"
15338                "            // A cool function...\n"
15339                "            return 17;\n"
15340                "          });\n"
15341                "    });",
15342                LLVMWithBeforeLambdaBody);
15343 }
15344 
15345 TEST_F(FormatTest, LambdaWithLineComments) {
15346   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15347   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15348   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15349   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15350       FormatStyle::ShortLambdaStyle::SLS_All;
15351 
15352   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15353   verifyFormat("auto k = []() // comment\n"
15354                "{ return; }",
15355                LLVMWithBeforeLambdaBody);
15356   verifyFormat("auto k = []() /* comment */ { return; }",
15357                LLVMWithBeforeLambdaBody);
15358   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15359                LLVMWithBeforeLambdaBody);
15360   verifyFormat("auto k = []() // X\n"
15361                "{ return; }",
15362                LLVMWithBeforeLambdaBody);
15363   verifyFormat(
15364       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15365       "{ return; }",
15366       LLVMWithBeforeLambdaBody);
15367 }
15368 
15369 TEST_F(FormatTest, EmptyLinesInLambdas) {
15370   verifyFormat("auto lambda = []() {\n"
15371                "  x(); //\n"
15372                "};",
15373                "auto lambda = []() {\n"
15374                "\n"
15375                "  x(); //\n"
15376                "\n"
15377                "};");
15378 }
15379 
15380 TEST_F(FormatTest, FormatsBlocks) {
15381   FormatStyle ShortBlocks = getLLVMStyle();
15382   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15383   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15384   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15385   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15386   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15387   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15388   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15389 
15390   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15391   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15392   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15393 
15394   verifyFormat("[operation setCompletionBlock:^{\n"
15395                "  [self onOperationDone];\n"
15396                "}];");
15397   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15398                "  [self onOperationDone];\n"
15399                "}]};");
15400   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15401                "  f();\n"
15402                "}];");
15403   verifyFormat("int a = [operation block:^int(int *i) {\n"
15404                "  return 1;\n"
15405                "}];");
15406   verifyFormat("[myObject doSomethingWith:arg1\n"
15407                "                      aaa:^int(int *a) {\n"
15408                "                        return 1;\n"
15409                "                      }\n"
15410                "                      bbb:f(a * bbbbbbbb)];");
15411 
15412   verifyFormat("[operation setCompletionBlock:^{\n"
15413                "  [self.delegate newDataAvailable];\n"
15414                "}];",
15415                getLLVMStyleWithColumns(60));
15416   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15417                "  NSString *path = [self sessionFilePath];\n"
15418                "  if (path) {\n"
15419                "    // ...\n"
15420                "  }\n"
15421                "});");
15422   verifyFormat("[[SessionService sharedService]\n"
15423                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15424                "      if (window) {\n"
15425                "        [self windowDidLoad:window];\n"
15426                "      } else {\n"
15427                "        [self errorLoadingWindow];\n"
15428                "      }\n"
15429                "    }];");
15430   verifyFormat("void (^largeBlock)(void) = ^{\n"
15431                "  // ...\n"
15432                "};\n",
15433                getLLVMStyleWithColumns(40));
15434   verifyFormat("[[SessionService sharedService]\n"
15435                "    loadWindowWithCompletionBlock: //\n"
15436                "        ^(SessionWindow *window) {\n"
15437                "          if (window) {\n"
15438                "            [self windowDidLoad:window];\n"
15439                "          } else {\n"
15440                "            [self errorLoadingWindow];\n"
15441                "          }\n"
15442                "        }];",
15443                getLLVMStyleWithColumns(60));
15444   verifyFormat("[myObject doSomethingWith:arg1\n"
15445                "    firstBlock:^(Foo *a) {\n"
15446                "      // ...\n"
15447                "      int i;\n"
15448                "    }\n"
15449                "    secondBlock:^(Bar *b) {\n"
15450                "      // ...\n"
15451                "      int i;\n"
15452                "    }\n"
15453                "    thirdBlock:^Foo(Bar *b) {\n"
15454                "      // ...\n"
15455                "      int i;\n"
15456                "    }];");
15457   verifyFormat("[myObject doSomethingWith:arg1\n"
15458                "               firstBlock:-1\n"
15459                "              secondBlock:^(Bar *b) {\n"
15460                "                // ...\n"
15461                "                int i;\n"
15462                "              }];");
15463 
15464   verifyFormat("f(^{\n"
15465                "  @autoreleasepool {\n"
15466                "    if (a) {\n"
15467                "      g();\n"
15468                "    }\n"
15469                "  }\n"
15470                "});");
15471   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15472   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15473                "};");
15474 
15475   FormatStyle FourIndent = getLLVMStyle();
15476   FourIndent.ObjCBlockIndentWidth = 4;
15477   verifyFormat("[operation setCompletionBlock:^{\n"
15478                "    [self onOperationDone];\n"
15479                "}];",
15480                FourIndent);
15481 }
15482 
15483 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15484   FormatStyle ZeroColumn = getLLVMStyle();
15485   ZeroColumn.ColumnLimit = 0;
15486 
15487   verifyFormat("[[SessionService sharedService] "
15488                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15489                "  if (window) {\n"
15490                "    [self windowDidLoad:window];\n"
15491                "  } else {\n"
15492                "    [self errorLoadingWindow];\n"
15493                "  }\n"
15494                "}];",
15495                ZeroColumn);
15496   EXPECT_EQ("[[SessionService sharedService]\n"
15497             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15498             "      if (window) {\n"
15499             "        [self windowDidLoad:window];\n"
15500             "      } else {\n"
15501             "        [self errorLoadingWindow];\n"
15502             "      }\n"
15503             "    }];",
15504             format("[[SessionService sharedService]\n"
15505                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15506                    "                if (window) {\n"
15507                    "    [self windowDidLoad:window];\n"
15508                    "  } else {\n"
15509                    "    [self errorLoadingWindow];\n"
15510                    "  }\n"
15511                    "}];",
15512                    ZeroColumn));
15513   verifyFormat("[myObject doSomethingWith:arg1\n"
15514                "    firstBlock:^(Foo *a) {\n"
15515                "      // ...\n"
15516                "      int i;\n"
15517                "    }\n"
15518                "    secondBlock:^(Bar *b) {\n"
15519                "      // ...\n"
15520                "      int i;\n"
15521                "    }\n"
15522                "    thirdBlock:^Foo(Bar *b) {\n"
15523                "      // ...\n"
15524                "      int i;\n"
15525                "    }];",
15526                ZeroColumn);
15527   verifyFormat("f(^{\n"
15528                "  @autoreleasepool {\n"
15529                "    if (a) {\n"
15530                "      g();\n"
15531                "    }\n"
15532                "  }\n"
15533                "});",
15534                ZeroColumn);
15535   verifyFormat("void (^largeBlock)(void) = ^{\n"
15536                "  // ...\n"
15537                "};",
15538                ZeroColumn);
15539 
15540   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15541   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15542             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15543   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15544   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15545             "  int i;\n"
15546             "};",
15547             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15548 }
15549 
15550 TEST_F(FormatTest, SupportsCRLF) {
15551   EXPECT_EQ("int a;\r\n"
15552             "int b;\r\n"
15553             "int c;\r\n",
15554             format("int a;\r\n"
15555                    "  int b;\r\n"
15556                    "    int c;\r\n",
15557                    getLLVMStyle()));
15558   EXPECT_EQ("int a;\r\n"
15559             "int b;\r\n"
15560             "int c;\r\n",
15561             format("int a;\r\n"
15562                    "  int b;\n"
15563                    "    int c;\r\n",
15564                    getLLVMStyle()));
15565   EXPECT_EQ("int a;\n"
15566             "int b;\n"
15567             "int c;\n",
15568             format("int a;\r\n"
15569                    "  int b;\n"
15570                    "    int c;\n",
15571                    getLLVMStyle()));
15572   EXPECT_EQ("\"aaaaaaa \"\r\n"
15573             "\"bbbbbbb\";\r\n",
15574             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15575   EXPECT_EQ("#define A \\\r\n"
15576             "  b;      \\\r\n"
15577             "  c;      \\\r\n"
15578             "  d;\r\n",
15579             format("#define A \\\r\n"
15580                    "  b; \\\r\n"
15581                    "  c; d; \r\n",
15582                    getGoogleStyle()));
15583 
15584   EXPECT_EQ("/*\r\n"
15585             "multi line block comments\r\n"
15586             "should not introduce\r\n"
15587             "an extra carriage return\r\n"
15588             "*/\r\n",
15589             format("/*\r\n"
15590                    "multi line block comments\r\n"
15591                    "should not introduce\r\n"
15592                    "an extra carriage return\r\n"
15593                    "*/\r\n"));
15594   EXPECT_EQ("/*\r\n"
15595             "\r\n"
15596             "*/",
15597             format("/*\r\n"
15598                    "    \r\r\r\n"
15599                    "*/"));
15600 
15601   FormatStyle style = getLLVMStyle();
15602 
15603   style.DeriveLineEnding = true;
15604   style.UseCRLF = false;
15605   EXPECT_EQ("union FooBarBazQux {\n"
15606             "  int foo;\n"
15607             "  int bar;\n"
15608             "  int baz;\n"
15609             "};",
15610             format("union FooBarBazQux {\r\n"
15611                    "  int foo;\n"
15612                    "  int bar;\r\n"
15613                    "  int baz;\n"
15614                    "};",
15615                    style));
15616   style.UseCRLF = true;
15617   EXPECT_EQ("union FooBarBazQux {\r\n"
15618             "  int foo;\r\n"
15619             "  int bar;\r\n"
15620             "  int baz;\r\n"
15621             "};",
15622             format("union FooBarBazQux {\r\n"
15623                    "  int foo;\n"
15624                    "  int bar;\r\n"
15625                    "  int baz;\n"
15626                    "};",
15627                    style));
15628 
15629   style.DeriveLineEnding = false;
15630   style.UseCRLF = false;
15631   EXPECT_EQ("union FooBarBazQux {\n"
15632             "  int foo;\n"
15633             "  int bar;\n"
15634             "  int baz;\n"
15635             "  int qux;\n"
15636             "};",
15637             format("union FooBarBazQux {\r\n"
15638                    "  int foo;\n"
15639                    "  int bar;\r\n"
15640                    "  int baz;\n"
15641                    "  int qux;\r\n"
15642                    "};",
15643                    style));
15644   style.UseCRLF = true;
15645   EXPECT_EQ("union FooBarBazQux {\r\n"
15646             "  int foo;\r\n"
15647             "  int bar;\r\n"
15648             "  int baz;\r\n"
15649             "  int qux;\r\n"
15650             "};",
15651             format("union FooBarBazQux {\r\n"
15652                    "  int foo;\n"
15653                    "  int bar;\r\n"
15654                    "  int baz;\n"
15655                    "  int qux;\n"
15656                    "};",
15657                    style));
15658 
15659   style.DeriveLineEnding = true;
15660   style.UseCRLF = false;
15661   EXPECT_EQ("union FooBarBazQux {\r\n"
15662             "  int foo;\r\n"
15663             "  int bar;\r\n"
15664             "  int baz;\r\n"
15665             "  int qux;\r\n"
15666             "};",
15667             format("union FooBarBazQux {\r\n"
15668                    "  int foo;\n"
15669                    "  int bar;\r\n"
15670                    "  int baz;\n"
15671                    "  int qux;\r\n"
15672                    "};",
15673                    style));
15674   style.UseCRLF = true;
15675   EXPECT_EQ("union FooBarBazQux {\n"
15676             "  int foo;\n"
15677             "  int bar;\n"
15678             "  int baz;\n"
15679             "  int qux;\n"
15680             "};",
15681             format("union FooBarBazQux {\r\n"
15682                    "  int foo;\n"
15683                    "  int bar;\r\n"
15684                    "  int baz;\n"
15685                    "  int qux;\n"
15686                    "};",
15687                    style));
15688 }
15689 
15690 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
15691   verifyFormat("MY_CLASS(C) {\n"
15692                "  int i;\n"
15693                "  int j;\n"
15694                "};");
15695 }
15696 
15697 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
15698   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
15699   TwoIndent.ContinuationIndentWidth = 2;
15700 
15701   EXPECT_EQ("int i =\n"
15702             "  longFunction(\n"
15703             "    arg);",
15704             format("int i = longFunction(arg);", TwoIndent));
15705 
15706   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
15707   SixIndent.ContinuationIndentWidth = 6;
15708 
15709   EXPECT_EQ("int i =\n"
15710             "      longFunction(\n"
15711             "            arg);",
15712             format("int i = longFunction(arg);", SixIndent));
15713 }
15714 
15715 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
15716   FormatStyle Style = getLLVMStyle();
15717   verifyFormat("int Foo::getter(\n"
15718                "    //\n"
15719                ") const {\n"
15720                "  return foo;\n"
15721                "}",
15722                Style);
15723   verifyFormat("void Foo::setter(\n"
15724                "    //\n"
15725                ") {\n"
15726                "  foo = 1;\n"
15727                "}",
15728                Style);
15729 }
15730 
15731 TEST_F(FormatTest, SpacesInAngles) {
15732   FormatStyle Spaces = getLLVMStyle();
15733   Spaces.SpacesInAngles = true;
15734 
15735   verifyFormat("static_cast< int >(arg);", Spaces);
15736   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
15737   verifyFormat("f< int, float >();", Spaces);
15738   verifyFormat("template <> g() {}", Spaces);
15739   verifyFormat("template < std::vector< int > > f() {}", Spaces);
15740   verifyFormat("std::function< void(int, int) > fct;", Spaces);
15741   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
15742                Spaces);
15743 
15744   Spaces.Standard = FormatStyle::LS_Cpp03;
15745   Spaces.SpacesInAngles = true;
15746   verifyFormat("A< A< int > >();", Spaces);
15747 
15748   Spaces.SpacesInAngles = false;
15749   verifyFormat("A<A<int> >();", Spaces);
15750 
15751   Spaces.Standard = FormatStyle::LS_Cpp11;
15752   Spaces.SpacesInAngles = true;
15753   verifyFormat("A< A< int > >();", Spaces);
15754 
15755   Spaces.SpacesInAngles = false;
15756   verifyFormat("A<A<int>>();", Spaces);
15757 }
15758 
15759 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
15760   FormatStyle Style = getLLVMStyle();
15761   Style.SpaceAfterTemplateKeyword = false;
15762   verifyFormat("template<int> void foo();", Style);
15763 }
15764 
15765 TEST_F(FormatTest, TripleAngleBrackets) {
15766   verifyFormat("f<<<1, 1>>>();");
15767   verifyFormat("f<<<1, 1, 1, s>>>();");
15768   verifyFormat("f<<<a, b, c, d>>>();");
15769   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
15770   verifyFormat("f<param><<<1, 1>>>();");
15771   verifyFormat("f<1><<<1, 1>>>();");
15772   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
15773   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15774                "aaaaaaaaaaa<<<\n    1, 1>>>();");
15775   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
15776                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
15777 }
15778 
15779 TEST_F(FormatTest, MergeLessLessAtEnd) {
15780   verifyFormat("<<");
15781   EXPECT_EQ("< < <", format("\\\n<<<"));
15782   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15783                "aaallvm::outs() <<");
15784   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
15785                "aaaallvm::outs()\n    <<");
15786 }
15787 
15788 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
15789   std::string code = "#if A\n"
15790                      "#if B\n"
15791                      "a.\n"
15792                      "#endif\n"
15793                      "    a = 1;\n"
15794                      "#else\n"
15795                      "#endif\n"
15796                      "#if C\n"
15797                      "#else\n"
15798                      "#endif\n";
15799   EXPECT_EQ(code, format(code));
15800 }
15801 
15802 TEST_F(FormatTest, HandleConflictMarkers) {
15803   // Git/SVN conflict markers.
15804   EXPECT_EQ("int a;\n"
15805             "void f() {\n"
15806             "  callme(some(parameter1,\n"
15807             "<<<<<<< text by the vcs\n"
15808             "              parameter2),\n"
15809             "||||||| text by the vcs\n"
15810             "              parameter2),\n"
15811             "         parameter3,\n"
15812             "======= text by the vcs\n"
15813             "              parameter2, parameter3),\n"
15814             ">>>>>>> text by the vcs\n"
15815             "         otherparameter);\n",
15816             format("int a;\n"
15817                    "void f() {\n"
15818                    "  callme(some(parameter1,\n"
15819                    "<<<<<<< text by the vcs\n"
15820                    "  parameter2),\n"
15821                    "||||||| text by the vcs\n"
15822                    "  parameter2),\n"
15823                    "  parameter3,\n"
15824                    "======= text by the vcs\n"
15825                    "  parameter2,\n"
15826                    "  parameter3),\n"
15827                    ">>>>>>> text by the vcs\n"
15828                    "  otherparameter);\n"));
15829 
15830   // Perforce markers.
15831   EXPECT_EQ("void f() {\n"
15832             "  function(\n"
15833             ">>>> text by the vcs\n"
15834             "      parameter,\n"
15835             "==== text by the vcs\n"
15836             "      parameter,\n"
15837             "==== text by the vcs\n"
15838             "      parameter,\n"
15839             "<<<< text by the vcs\n"
15840             "      parameter);\n",
15841             format("void f() {\n"
15842                    "  function(\n"
15843                    ">>>> text by the vcs\n"
15844                    "  parameter,\n"
15845                    "==== text by the vcs\n"
15846                    "  parameter,\n"
15847                    "==== text by the vcs\n"
15848                    "  parameter,\n"
15849                    "<<<< text by the vcs\n"
15850                    "  parameter);\n"));
15851 
15852   EXPECT_EQ("<<<<<<<\n"
15853             "|||||||\n"
15854             "=======\n"
15855             ">>>>>>>",
15856             format("<<<<<<<\n"
15857                    "|||||||\n"
15858                    "=======\n"
15859                    ">>>>>>>"));
15860 
15861   EXPECT_EQ("<<<<<<<\n"
15862             "|||||||\n"
15863             "int i;\n"
15864             "=======\n"
15865             ">>>>>>>",
15866             format("<<<<<<<\n"
15867                    "|||||||\n"
15868                    "int i;\n"
15869                    "=======\n"
15870                    ">>>>>>>"));
15871 
15872   // FIXME: Handle parsing of macros around conflict markers correctly:
15873   EXPECT_EQ("#define Macro \\\n"
15874             "<<<<<<<\n"
15875             "Something \\\n"
15876             "|||||||\n"
15877             "Else \\\n"
15878             "=======\n"
15879             "Other \\\n"
15880             ">>>>>>>\n"
15881             "    End int i;\n",
15882             format("#define Macro \\\n"
15883                    "<<<<<<<\n"
15884                    "  Something \\\n"
15885                    "|||||||\n"
15886                    "  Else \\\n"
15887                    "=======\n"
15888                    "  Other \\\n"
15889                    ">>>>>>>\n"
15890                    "  End\n"
15891                    "int i;\n"));
15892 }
15893 
15894 TEST_F(FormatTest, DisableRegions) {
15895   EXPECT_EQ("int i;\n"
15896             "// clang-format off\n"
15897             "  int j;\n"
15898             "// clang-format on\n"
15899             "int k;",
15900             format(" int  i;\n"
15901                    "   // clang-format off\n"
15902                    "  int j;\n"
15903                    " // clang-format on\n"
15904                    "   int   k;"));
15905   EXPECT_EQ("int i;\n"
15906             "/* clang-format off */\n"
15907             "  int j;\n"
15908             "/* clang-format on */\n"
15909             "int k;",
15910             format(" int  i;\n"
15911                    "   /* clang-format off */\n"
15912                    "  int j;\n"
15913                    " /* clang-format on */\n"
15914                    "   int   k;"));
15915 
15916   // Don't reflow comments within disabled regions.
15917   EXPECT_EQ("// clang-format off\n"
15918             "// long long long long long long line\n"
15919             "/* clang-format on */\n"
15920             "/* long long long\n"
15921             " * long long long\n"
15922             " * line */\n"
15923             "int i;\n"
15924             "/* clang-format off */\n"
15925             "/* long long long long long long line */\n",
15926             format("// clang-format off\n"
15927                    "// long long long long long long line\n"
15928                    "/* clang-format on */\n"
15929                    "/* long long long long long long line */\n"
15930                    "int i;\n"
15931                    "/* clang-format off */\n"
15932                    "/* long long long long long long line */\n",
15933                    getLLVMStyleWithColumns(20)));
15934 }
15935 
15936 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
15937   format("? ) =");
15938   verifyNoCrash("#define a\\\n /**/}");
15939 }
15940 
15941 TEST_F(FormatTest, FormatsTableGenCode) {
15942   FormatStyle Style = getLLVMStyle();
15943   Style.Language = FormatStyle::LK_TableGen;
15944   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
15945 }
15946 
15947 TEST_F(FormatTest, ArrayOfTemplates) {
15948   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
15949             format("auto a = new unique_ptr<int > [ 10];"));
15950 
15951   FormatStyle Spaces = getLLVMStyle();
15952   Spaces.SpacesInSquareBrackets = true;
15953   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
15954             format("auto a = new unique_ptr<int > [10];", Spaces));
15955 }
15956 
15957 TEST_F(FormatTest, ArrayAsTemplateType) {
15958   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
15959             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
15960 
15961   FormatStyle Spaces = getLLVMStyle();
15962   Spaces.SpacesInSquareBrackets = true;
15963   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
15964             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
15965 }
15966 
15967 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
15968 
15969 TEST(FormatStyle, GetStyleWithEmptyFileName) {
15970   llvm::vfs::InMemoryFileSystem FS;
15971   auto Style1 = getStyle("file", "", "Google", "", &FS);
15972   ASSERT_TRUE((bool)Style1);
15973   ASSERT_EQ(*Style1, getGoogleStyle());
15974 }
15975 
15976 TEST(FormatStyle, GetStyleOfFile) {
15977   llvm::vfs::InMemoryFileSystem FS;
15978   // Test 1: format file in the same directory.
15979   ASSERT_TRUE(
15980       FS.addFile("/a/.clang-format", 0,
15981                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
15982   ASSERT_TRUE(
15983       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15984   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
15985   ASSERT_TRUE((bool)Style1);
15986   ASSERT_EQ(*Style1, getLLVMStyle());
15987 
15988   // Test 2.1: fallback to default.
15989   ASSERT_TRUE(
15990       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
15991   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
15992   ASSERT_TRUE((bool)Style2);
15993   ASSERT_EQ(*Style2, getMozillaStyle());
15994 
15995   // Test 2.2: no format on 'none' fallback style.
15996   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
15997   ASSERT_TRUE((bool)Style2);
15998   ASSERT_EQ(*Style2, getNoStyle());
15999 
16000   // Test 2.3: format if config is found with no based style while fallback is
16001   // 'none'.
16002   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
16003                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
16004   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16005   ASSERT_TRUE((bool)Style2);
16006   ASSERT_EQ(*Style2, getLLVMStyle());
16007 
16008   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
16009   Style2 = getStyle("{}", "a.h", "none", "", &FS);
16010   ASSERT_TRUE((bool)Style2);
16011   ASSERT_EQ(*Style2, getLLVMStyle());
16012 
16013   // Test 3: format file in parent directory.
16014   ASSERT_TRUE(
16015       FS.addFile("/c/.clang-format", 0,
16016                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
16017   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
16018                          llvm::MemoryBuffer::getMemBuffer("int i;")));
16019   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
16020   ASSERT_TRUE((bool)Style3);
16021   ASSERT_EQ(*Style3, getGoogleStyle());
16022 
16023   // Test 4: error on invalid fallback style
16024   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
16025   ASSERT_FALSE((bool)Style4);
16026   llvm::consumeError(Style4.takeError());
16027 
16028   // Test 5: error on invalid yaml on command line
16029   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
16030   ASSERT_FALSE((bool)Style5);
16031   llvm::consumeError(Style5.takeError());
16032 
16033   // Test 6: error on invalid style
16034   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
16035   ASSERT_FALSE((bool)Style6);
16036   llvm::consumeError(Style6.takeError());
16037 
16038   // Test 7: found config file, error on parsing it
16039   ASSERT_TRUE(
16040       FS.addFile("/d/.clang-format", 0,
16041                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
16042                                                   "InvalidKey: InvalidValue")));
16043   ASSERT_TRUE(
16044       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16045   auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
16046   ASSERT_FALSE((bool)Style7);
16047   llvm::consumeError(Style7.takeError());
16048 
16049   // Test 8: inferred per-language defaults apply.
16050   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
16051   ASSERT_TRUE((bool)StyleTd);
16052   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
16053 }
16054 
16055 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
16056   // Column limit is 20.
16057   std::string Code = "Type *a =\n"
16058                      "    new Type();\n"
16059                      "g(iiiii, 0, jjjjj,\n"
16060                      "  0, kkkkk, 0, mm);\n"
16061                      "int  bad     = format   ;";
16062   std::string Expected = "auto a = new Type();\n"
16063                          "g(iiiii, nullptr,\n"
16064                          "  jjjjj, nullptr,\n"
16065                          "  kkkkk, nullptr,\n"
16066                          "  mm);\n"
16067                          "int  bad     = format   ;";
16068   FileID ID = Context.createInMemoryFile("format.cpp", Code);
16069   tooling::Replacements Replaces = toReplacements(
16070       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
16071                             "auto "),
16072        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
16073                             "nullptr"),
16074        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
16075                             "nullptr"),
16076        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
16077                             "nullptr")});
16078 
16079   format::FormatStyle Style = format::getLLVMStyle();
16080   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
16081   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16082   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16083       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16084   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16085   EXPECT_TRUE(static_cast<bool>(Result));
16086   EXPECT_EQ(Expected, *Result);
16087 }
16088 
16089 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
16090   std::string Code = "#include \"a.h\"\n"
16091                      "#include \"c.h\"\n"
16092                      "\n"
16093                      "int main() {\n"
16094                      "  return 0;\n"
16095                      "}";
16096   std::string Expected = "#include \"a.h\"\n"
16097                          "#include \"b.h\"\n"
16098                          "#include \"c.h\"\n"
16099                          "\n"
16100                          "int main() {\n"
16101                          "  return 0;\n"
16102                          "}";
16103   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
16104   tooling::Replacements Replaces = toReplacements(
16105       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
16106                             "#include \"b.h\"\n")});
16107 
16108   format::FormatStyle Style = format::getLLVMStyle();
16109   Style.SortIncludes = true;
16110   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16111   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16112       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16113   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16114   EXPECT_TRUE(static_cast<bool>(Result));
16115   EXPECT_EQ(Expected, *Result);
16116 }
16117 
16118 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
16119   EXPECT_EQ("using std::cin;\n"
16120             "using std::cout;",
16121             format("using std::cout;\n"
16122                    "using std::cin;",
16123                    getGoogleStyle()));
16124 }
16125 
16126 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
16127   format::FormatStyle Style = format::getLLVMStyle();
16128   Style.Standard = FormatStyle::LS_Cpp03;
16129   // cpp03 recognize this string as identifier u8 and literal character 'a'
16130   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
16131 }
16132 
16133 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
16134   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
16135   // all modes, including C++11, C++14 and C++17
16136   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
16137 }
16138 
16139 TEST_F(FormatTest, DoNotFormatLikelyXml) {
16140   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
16141   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
16142 }
16143 
16144 TEST_F(FormatTest, StructuredBindings) {
16145   // Structured bindings is a C++17 feature.
16146   // all modes, including C++11, C++14 and C++17
16147   verifyFormat("auto [a, b] = f();");
16148   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
16149   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
16150   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
16151   EXPECT_EQ("auto const volatile [a, b] = f();",
16152             format("auto  const   volatile[a, b] = f();"));
16153   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
16154   EXPECT_EQ("auto &[a, b, c] = f();",
16155             format("auto   &[  a  ,  b,c   ] = f();"));
16156   EXPECT_EQ("auto &&[a, b, c] = f();",
16157             format("auto   &&[  a  ,  b,c   ] = f();"));
16158   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
16159   EXPECT_EQ("auto const volatile &&[a, b] = f();",
16160             format("auto  const  volatile  &&[a, b] = f();"));
16161   EXPECT_EQ("auto const &&[a, b] = f();",
16162             format("auto  const   &&  [a, b] = f();"));
16163   EXPECT_EQ("const auto &[a, b] = f();",
16164             format("const  auto  &  [a, b] = f();"));
16165   EXPECT_EQ("const auto volatile &&[a, b] = f();",
16166             format("const  auto   volatile  &&[a, b] = f();"));
16167   EXPECT_EQ("volatile const auto &&[a, b] = f();",
16168             format("volatile  const  auto   &&[a, b] = f();"));
16169   EXPECT_EQ("const auto &&[a, b] = f();",
16170             format("const  auto  &&  [a, b] = f();"));
16171 
16172   // Make sure we don't mistake structured bindings for lambdas.
16173   FormatStyle PointerMiddle = getLLVMStyle();
16174   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16175   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16176   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16177   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16178   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16179   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16180   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16181   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16182   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16183   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16184   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16185   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16186   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16187 
16188   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16189             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16190   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16191             format("for (const auto   &   [a, b] : some_range) {\n}"));
16192   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16193             format("for (const auto[a, b] : some_range) {\n}"));
16194   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16195   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16196   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16197   EXPECT_EQ("auto const &[x, y](expr);",
16198             format("auto  const  &  [x,y]  (expr);"));
16199   EXPECT_EQ("auto const &&[x, y](expr);",
16200             format("auto  const  &&  [x,y]  (expr);"));
16201   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16202   EXPECT_EQ("auto const &[x, y]{expr};",
16203             format("auto  const  &  [x,y]  {expr};"));
16204   EXPECT_EQ("auto const &&[x, y]{expr};",
16205             format("auto  const  &&  [x,y]  {expr};"));
16206 
16207   format::FormatStyle Spaces = format::getLLVMStyle();
16208   Spaces.SpacesInSquareBrackets = true;
16209   verifyFormat("auto [ a, b ] = f();", Spaces);
16210   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16211   verifyFormat("auto &[ a, b ] = f();", Spaces);
16212   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16213   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16214 }
16215 
16216 TEST_F(FormatTest, FileAndCode) {
16217   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16218   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16219   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16220   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16221   EXPECT_EQ(FormatStyle::LK_ObjC,
16222             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16223   EXPECT_EQ(
16224       FormatStyle::LK_ObjC,
16225       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16226   EXPECT_EQ(FormatStyle::LK_ObjC,
16227             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16228   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16229   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16230   EXPECT_EQ(FormatStyle::LK_ObjC,
16231             guessLanguage("foo", "@interface Foo\n@end\n"));
16232   EXPECT_EQ(FormatStyle::LK_ObjC,
16233             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16234   EXPECT_EQ(
16235       FormatStyle::LK_ObjC,
16236       guessLanguage("foo.h",
16237                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16238   EXPECT_EQ(
16239       FormatStyle::LK_Cpp,
16240       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16241 }
16242 
16243 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16244   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16245   EXPECT_EQ(FormatStyle::LK_ObjC,
16246             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16247   EXPECT_EQ(FormatStyle::LK_Cpp,
16248             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16249   EXPECT_EQ(
16250       FormatStyle::LK_Cpp,
16251       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16252   EXPECT_EQ(FormatStyle::LK_ObjC,
16253             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16254   EXPECT_EQ(FormatStyle::LK_Cpp,
16255             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16256   EXPECT_EQ(FormatStyle::LK_ObjC,
16257             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16258   EXPECT_EQ(FormatStyle::LK_Cpp,
16259             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16260   EXPECT_EQ(FormatStyle::LK_Cpp,
16261             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16262   EXPECT_EQ(FormatStyle::LK_ObjC,
16263             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16264   EXPECT_EQ(FormatStyle::LK_Cpp,
16265             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16266   EXPECT_EQ(
16267       FormatStyle::LK_Cpp,
16268       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16269   EXPECT_EQ(
16270       FormatStyle::LK_Cpp,
16271       guessLanguage("foo.h",
16272                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16273   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16274 }
16275 
16276 TEST_F(FormatTest, GuessLanguageWithCaret) {
16277   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16278   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16279   EXPECT_EQ(FormatStyle::LK_ObjC,
16280             guessLanguage("foo.h", "int(^)(char, float);"));
16281   EXPECT_EQ(FormatStyle::LK_ObjC,
16282             guessLanguage("foo.h", "int(^foo)(char, float);"));
16283   EXPECT_EQ(FormatStyle::LK_ObjC,
16284             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16285   EXPECT_EQ(FormatStyle::LK_ObjC,
16286             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16287   EXPECT_EQ(
16288       FormatStyle::LK_ObjC,
16289       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16290 }
16291 
16292 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16293   // ASM symbolic names are identifiers that must be surrounded by [] without
16294   // space in between:
16295   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16296 
16297   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16298   verifyFormat(R"(//
16299 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16300 )");
16301 
16302   // A list of several ASM symbolic names.
16303   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16304 
16305   // ASM symbolic names in inline ASM with inputs and outputs.
16306   verifyFormat(R"(//
16307 asm("cmoveq %1, %2, %[result]"
16308     : [result] "=r"(result)
16309     : "r"(test), "r"(new), "[result]"(old));
16310 )");
16311 
16312   // ASM symbolic names in inline ASM with no outputs.
16313   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16314 }
16315 
16316 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
16317   EXPECT_EQ(FormatStyle::LK_Cpp,
16318             guessLanguage("foo.h", "void f() {\n"
16319                                    "  asm (\"mov %[e], %[d]\"\n"
16320                                    "     : [d] \"=rm\" (d)\n"
16321                                    "       [e] \"rm\" (*e));\n"
16322                                    "}"));
16323   EXPECT_EQ(FormatStyle::LK_Cpp,
16324             guessLanguage("foo.h", "void f() {\n"
16325                                    "  _asm (\"mov %[e], %[d]\"\n"
16326                                    "     : [d] \"=rm\" (d)\n"
16327                                    "       [e] \"rm\" (*e));\n"
16328                                    "}"));
16329   EXPECT_EQ(FormatStyle::LK_Cpp,
16330             guessLanguage("foo.h", "void f() {\n"
16331                                    "  __asm (\"mov %[e], %[d]\"\n"
16332                                    "     : [d] \"=rm\" (d)\n"
16333                                    "       [e] \"rm\" (*e));\n"
16334                                    "}"));
16335   EXPECT_EQ(FormatStyle::LK_Cpp,
16336             guessLanguage("foo.h", "void f() {\n"
16337                                    "  __asm__ (\"mov %[e], %[d]\"\n"
16338                                    "     : [d] \"=rm\" (d)\n"
16339                                    "       [e] \"rm\" (*e));\n"
16340                                    "}"));
16341   EXPECT_EQ(FormatStyle::LK_Cpp,
16342             guessLanguage("foo.h", "void f() {\n"
16343                                    "  asm (\"mov %[e], %[d]\"\n"
16344                                    "     : [d] \"=rm\" (d),\n"
16345                                    "       [e] \"rm\" (*e));\n"
16346                                    "}"));
16347   EXPECT_EQ(FormatStyle::LK_Cpp,
16348             guessLanguage("foo.h", "void f() {\n"
16349                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16350                                    "     : [d] \"=rm\" (d)\n"
16351                                    "       [e] \"rm\" (*e));\n"
16352                                    "}"));
16353 }
16354 
16355 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16356   EXPECT_EQ(FormatStyle::LK_Cpp,
16357             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16358   EXPECT_EQ(FormatStyle::LK_ObjC,
16359             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16360   EXPECT_EQ(
16361       FormatStyle::LK_Cpp,
16362       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16363   EXPECT_EQ(
16364       FormatStyle::LK_ObjC,
16365       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16366 }
16367 
16368 TEST_F(FormatTest, TypenameMacros) {
16369   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16370 
16371   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16372   FormatStyle Google = getGoogleStyleWithColumns(0);
16373   Google.TypenameMacros = TypenameMacros;
16374   verifyFormat("struct foo {\n"
16375                "  int bar;\n"
16376                "  TAILQ_ENTRY(a) bleh;\n"
16377                "};",
16378                Google);
16379 
16380   FormatStyle Macros = getLLVMStyle();
16381   Macros.TypenameMacros = TypenameMacros;
16382 
16383   verifyFormat("STACK_OF(int) a;", Macros);
16384   verifyFormat("STACK_OF(int) *a;", Macros);
16385   verifyFormat("STACK_OF(int const *) *a;", Macros);
16386   verifyFormat("STACK_OF(int *const) *a;", Macros);
16387   verifyFormat("STACK_OF(int, string) a;", Macros);
16388   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16389   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16390   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16391   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16392 
16393   Macros.PointerAlignment = FormatStyle::PAS_Left;
16394   verifyFormat("STACK_OF(int)* a;", Macros);
16395   verifyFormat("STACK_OF(int*)* a;", Macros);
16396 }
16397 
16398 TEST_F(FormatTest, AmbersandInLamda) {
16399   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16400   FormatStyle AlignStyle = getLLVMStyle();
16401   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16402   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16403   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16404   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16405 }
16406 
16407 TEST_F(FormatTest, SpacesInConditionalStatement) {
16408   FormatStyle Spaces = getLLVMStyle();
16409   Spaces.SpacesInConditionalStatement = true;
16410   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16411   verifyFormat("if ( !a )\n  return;", Spaces);
16412   verifyFormat("if ( a )\n  return;", Spaces);
16413   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16414   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16415   verifyFormat("while ( a )\n  return;", Spaces);
16416   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16417   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16418   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16419   // Check that space on the left of "::" is inserted as expected at beginning
16420   // of condition.
16421   verifyFormat("while ( ::func() )\n  return;", Spaces);
16422 }
16423 
16424 TEST_F(FormatTest, AlternativeOperators) {
16425   // Test case for ensuring alternate operators are not
16426   // combined with their right most neighbour.
16427   verifyFormat("int a and b;");
16428   verifyFormat("int a and_eq b;");
16429   verifyFormat("int a bitand b;");
16430   verifyFormat("int a bitor b;");
16431   verifyFormat("int a compl b;");
16432   verifyFormat("int a not b;");
16433   verifyFormat("int a not_eq b;");
16434   verifyFormat("int a or b;");
16435   verifyFormat("int a xor b;");
16436   verifyFormat("int a xor_eq b;");
16437   verifyFormat("return this not_eq bitand other;");
16438   verifyFormat("bool operator not_eq(const X bitand other)");
16439 
16440   verifyFormat("int a and 5;");
16441   verifyFormat("int a and_eq 5;");
16442   verifyFormat("int a bitand 5;");
16443   verifyFormat("int a bitor 5;");
16444   verifyFormat("int a compl 5;");
16445   verifyFormat("int a not 5;");
16446   verifyFormat("int a not_eq 5;");
16447   verifyFormat("int a or 5;");
16448   verifyFormat("int a xor 5;");
16449   verifyFormat("int a xor_eq 5;");
16450 
16451   verifyFormat("int a compl(5);");
16452   verifyFormat("int a not(5);");
16453 
16454   /* FIXME handle alternate tokens
16455    * https://en.cppreference.com/w/cpp/language/operator_alternative
16456   // alternative tokens
16457   verifyFormat("compl foo();");     //  ~foo();
16458   verifyFormat("foo() <%%>;");      // foo();
16459   verifyFormat("void foo() <%%>;"); // void foo(){}
16460   verifyFormat("int a <:1:>;");     // int a[1];[
16461   verifyFormat("%:define ABC abc"); // #define ABC abc
16462   verifyFormat("%:%:");             // ##
16463   */
16464 }
16465 
16466 TEST_F(FormatTest, STLWhileNotDefineChed) {
16467   verifyFormat("#if defined(while)\n"
16468                "#define while EMIT WARNING C4005\n"
16469                "#endif // while");
16470 }
16471 
16472 TEST_F(FormatTest, OperatorSpacing) {
16473   FormatStyle Style = getLLVMStyle();
16474   Style.PointerAlignment = FormatStyle::PAS_Right;
16475   verifyFormat("Foo::operator*();", Style);
16476   verifyFormat("Foo::operator void *();", Style);
16477   verifyFormat("Foo::operator void **();", Style);
16478   verifyFormat("Foo::operator void *&();", Style);
16479   verifyFormat("Foo::operator void *&&();", Style);
16480   verifyFormat("Foo::operator()(void *);", Style);
16481   verifyFormat("Foo::operator*(void *);", Style);
16482   verifyFormat("Foo::operator*();", Style);
16483   verifyFormat("Foo::operator**();", Style);
16484   verifyFormat("Foo::operator&();", Style);
16485   verifyFormat("Foo::operator<int> *();", Style);
16486   verifyFormat("Foo::operator<Foo> *();", Style);
16487   verifyFormat("Foo::operator<int> **();", Style);
16488   verifyFormat("Foo::operator<Foo> **();", Style);
16489   verifyFormat("Foo::operator<int> &();", Style);
16490   verifyFormat("Foo::operator<Foo> &();", Style);
16491   verifyFormat("Foo::operator<int> &&();", Style);
16492   verifyFormat("Foo::operator<Foo> &&();", Style);
16493   verifyFormat("Foo::operator<int> *&();", Style);
16494   verifyFormat("Foo::operator<Foo> *&();", Style);
16495   verifyFormat("Foo::operator<int> *&&();", Style);
16496   verifyFormat("Foo::operator<Foo> *&&();", Style);
16497   verifyFormat("operator*(int (*)(), class Foo);", Style);
16498 
16499   verifyFormat("Foo::operator&();", Style);
16500   verifyFormat("Foo::operator void &();", Style);
16501   verifyFormat("Foo::operator()(void &);", Style);
16502   verifyFormat("Foo::operator&(void &);", Style);
16503   verifyFormat("Foo::operator&();", Style);
16504   verifyFormat("operator&(int (&)(), class Foo);", Style);
16505 
16506   verifyFormat("Foo::operator&&();", Style);
16507   verifyFormat("Foo::operator**();", Style);
16508   verifyFormat("Foo::operator void &&();", Style);
16509   verifyFormat("Foo::operator()(void &&);", Style);
16510   verifyFormat("Foo::operator&&(void &&);", Style);
16511   verifyFormat("Foo::operator&&();", Style);
16512   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16513   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16514   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16515                Style);
16516   verifyFormat("operator void **()", Style);
16517   verifyFormat("operator const FooRight<Object> &()", Style);
16518   verifyFormat("operator const FooRight<Object> *()", Style);
16519   verifyFormat("operator const FooRight<Object> **()", Style);
16520   verifyFormat("operator const FooRight<Object> *&()", Style);
16521   verifyFormat("operator const FooRight<Object> *&&()", Style);
16522 
16523   Style.PointerAlignment = FormatStyle::PAS_Left;
16524   verifyFormat("Foo::operator*();", Style);
16525   verifyFormat("Foo::operator**();", Style);
16526   verifyFormat("Foo::operator void*();", Style);
16527   verifyFormat("Foo::operator void**();", Style);
16528   verifyFormat("Foo::operator void*&();", Style);
16529   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16530   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16531   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16532   verifyFormat("Foo::operator()(void*);", Style);
16533   verifyFormat("Foo::operator*(void*);", Style);
16534   verifyFormat("Foo::operator*();", Style);
16535   verifyFormat("Foo::operator<int>*();", Style);
16536   verifyFormat("Foo::operator<Foo>*();", Style);
16537   verifyFormat("Foo::operator<int>**();", Style);
16538   verifyFormat("Foo::operator<Foo>**();", Style);
16539   verifyFormat("Foo::operator<Foo>*&();", Style);
16540   verifyFormat("Foo::operator<int>&();", Style);
16541   verifyFormat("Foo::operator<Foo>&();", Style);
16542   verifyFormat("Foo::operator<int>&&();", Style);
16543   verifyFormat("Foo::operator<Foo>&&();", Style);
16544   verifyFormat("Foo::operator<int>*&();", Style);
16545   verifyFormat("Foo::operator<Foo>*&();", Style);
16546   verifyFormat("operator*(int (*)(), class Foo);", Style);
16547 
16548   verifyFormat("Foo::operator&();", Style);
16549   verifyFormat("Foo::operator void&();", Style);
16550   verifyFormat("Foo::operator/*comment*/ void&();", Style);
16551   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
16552   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
16553   verifyFormat("Foo::operator()(void&);", Style);
16554   verifyFormat("Foo::operator&(void&);", Style);
16555   verifyFormat("Foo::operator&();", Style);
16556   verifyFormat("operator&(int (&)(), class Foo);", Style);
16557 
16558   verifyFormat("Foo::operator&&();", Style);
16559   verifyFormat("Foo::operator void&&();", Style);
16560   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
16561   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
16562   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
16563   verifyFormat("Foo::operator()(void&&);", Style);
16564   verifyFormat("Foo::operator&&(void&&);", Style);
16565   verifyFormat("Foo::operator&&();", Style);
16566   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16567   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
16568   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
16569                Style);
16570   verifyFormat("operator void**()", Style);
16571   verifyFormat("operator const FooLeft<Object>&()", Style);
16572   verifyFormat("operator const FooLeft<Object>*()", Style);
16573   verifyFormat("operator const FooLeft<Object>**()", Style);
16574   verifyFormat("operator const FooLeft<Object>*&()", Style);
16575   verifyFormat("operator const FooLeft<Object>*&&()", Style);
16576 
16577   // PR45107
16578   verifyFormat("operator Vector<String>&();", Style);
16579   verifyFormat("operator const Vector<String>&();", Style);
16580   verifyFormat("operator foo::Bar*();", Style);
16581   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
16582   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
16583                Style);
16584 
16585   Style.PointerAlignment = FormatStyle::PAS_Middle;
16586   verifyFormat("Foo::operator*();", Style);
16587   verifyFormat("Foo::operator void *();", Style);
16588   verifyFormat("Foo::operator()(void *);", Style);
16589   verifyFormat("Foo::operator*(void *);", Style);
16590   verifyFormat("Foo::operator*();", Style);
16591   verifyFormat("operator*(int (*)(), class Foo);", Style);
16592 
16593   verifyFormat("Foo::operator&();", Style);
16594   verifyFormat("Foo::operator void &();", Style);
16595   verifyFormat("Foo::operator()(void &);", Style);
16596   verifyFormat("Foo::operator&(void &);", Style);
16597   verifyFormat("Foo::operator&();", Style);
16598   verifyFormat("operator&(int (&)(), class Foo);", Style);
16599 
16600   verifyFormat("Foo::operator&&();", Style);
16601   verifyFormat("Foo::operator void &&();", Style);
16602   verifyFormat("Foo::operator()(void &&);", Style);
16603   verifyFormat("Foo::operator&&(void &&);", Style);
16604   verifyFormat("Foo::operator&&();", Style);
16605   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16606 }
16607 
16608 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
16609   FormatStyle Style = getLLVMStyle();
16610   // PR46157
16611   verifyFormat("foo(operator+, -42);", Style);
16612   verifyFormat("foo(operator++, -42);", Style);
16613   verifyFormat("foo(operator--, -42);", Style);
16614   verifyFormat("foo(-42, operator--);", Style);
16615   verifyFormat("foo(-42, operator, );", Style);
16616   verifyFormat("foo(operator, , -42);", Style);
16617 }
16618 
16619 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
16620   FormatStyle Style = getLLVMStyle();
16621   Style.WhitespaceSensitiveMacros.push_back("FOO");
16622 
16623   // Don't use the helpers here, since 'mess up' will change the whitespace
16624   // and these are all whitespace sensitive by definition
16625   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
16626             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
16627   EXPECT_EQ(
16628       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
16629       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
16630   EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
16631             format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
16632   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
16633             "       Still=Intentional);",
16634             format("FOO(String-ized&Messy+But,: :\n"
16635                    "       Still=Intentional);",
16636                    Style));
16637   Style.AlignConsecutiveAssignments = true;
16638   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
16639             "       Still=Intentional);",
16640             format("FOO(String-ized=&Messy+But,: :\n"
16641                    "       Still=Intentional);",
16642                    Style));
16643 
16644   Style.ColumnLimit = 21;
16645   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
16646             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
16647 }
16648 
16649 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
16650   // These tests are not in NamespaceFixer because that doesn't
16651   // test its interaction with line wrapping
16652   FormatStyle Style = getLLVMStyle();
16653   Style.ColumnLimit = 80;
16654   verifyFormat("namespace {\n"
16655                "int i;\n"
16656                "int j;\n"
16657                "} // namespace",
16658                Style);
16659 
16660   verifyFormat("namespace AAA {\n"
16661                "int i;\n"
16662                "int j;\n"
16663                "} // namespace AAA",
16664                Style);
16665 
16666   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
16667             "int i;\n"
16668             "int j;\n"
16669             "} // namespace Averyveryveryverylongnamespace",
16670             format("namespace Averyveryveryverylongnamespace {\n"
16671                    "int i;\n"
16672                    "int j;\n"
16673                    "}",
16674                    Style));
16675 
16676   EXPECT_EQ(
16677       "namespace "
16678       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16679       "    went::mad::now {\n"
16680       "int i;\n"
16681       "int j;\n"
16682       "} // namespace\n"
16683       "  // "
16684       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16685       "went::mad::now",
16686       format("namespace "
16687              "would::it::save::you::a::lot::of::time::if_::i::"
16688              "just::gave::up::and_::went::mad::now {\n"
16689              "int i;\n"
16690              "int j;\n"
16691              "}",
16692              Style));
16693 
16694   // This used to duplicate the comment again and again on subsequent runs
16695   EXPECT_EQ(
16696       "namespace "
16697       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
16698       "    went::mad::now {\n"
16699       "int i;\n"
16700       "int j;\n"
16701       "} // namespace\n"
16702       "  // "
16703       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
16704       "went::mad::now",
16705       format("namespace "
16706              "would::it::save::you::a::lot::of::time::if_::i::"
16707              "just::gave::up::and_::went::mad::now {\n"
16708              "int i;\n"
16709              "int j;\n"
16710              "} // namespace\n"
16711              "  // "
16712              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
16713              "and_::went::mad::now",
16714              Style));
16715 }
16716 
16717 TEST_F(FormatTest, LikelyUnlikely) {
16718   FormatStyle Style = getLLVMStyle();
16719 
16720   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16721                "  return 29;\n"
16722                "}",
16723                Style);
16724 
16725   verifyFormat("if (argc > 5) [[likely]] {\n"
16726                "  return 29;\n"
16727                "}",
16728                Style);
16729 
16730   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16731                "  return 29;\n"
16732                "} else [[likely]] {\n"
16733                "  return 42;\n"
16734                "}\n",
16735                Style);
16736 
16737   verifyFormat("if (argc > 5) [[unlikely]] {\n"
16738                "  return 29;\n"
16739                "} else if (argc > 10) [[likely]] {\n"
16740                "  return 99;\n"
16741                "} else {\n"
16742                "  return 42;\n"
16743                "}\n",
16744                Style);
16745 
16746   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
16747                "  return 29;\n"
16748                "}",
16749                Style);
16750 }
16751 
16752 TEST_F(FormatTest, LLVMDefaultStyle) {
16753   FormatStyle Style = getLLVMStyle();
16754   verifyFormat("extern \"C\" {\n"
16755                "int foo();\n"
16756                "}",
16757                Style);
16758 }
16759 TEST_F(FormatTest, GNUDefaultStyle) {
16760   FormatStyle Style = getGNUStyle();
16761   verifyFormat("extern \"C\"\n"
16762                "{\n"
16763                "  int foo ();\n"
16764                "}",
16765                Style);
16766 }
16767 TEST_F(FormatTest, MozillaDefaultStyle) {
16768   FormatStyle Style = getMozillaStyle();
16769   verifyFormat("extern \"C\"\n"
16770                "{\n"
16771                "  int foo();\n"
16772                "}",
16773                Style);
16774 }
16775 TEST_F(FormatTest, GoogleDefaultStyle) {
16776   FormatStyle Style = getGoogleStyle();
16777   verifyFormat("extern \"C\" {\n"
16778                "int foo();\n"
16779                "}",
16780                Style);
16781 }
16782 TEST_F(FormatTest, ChromiumDefaultStyle) {
16783   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
16784   verifyFormat("extern \"C\" {\n"
16785                "int foo();\n"
16786                "}",
16787                Style);
16788 }
16789 TEST_F(FormatTest, MicrosoftDefaultStyle) {
16790   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
16791   verifyFormat("extern \"C\"\n"
16792                "{\n"
16793                "    int foo();\n"
16794                "}",
16795                Style);
16796 }
16797 TEST_F(FormatTest, WebKitDefaultStyle) {
16798   FormatStyle Style = getWebKitStyle();
16799   verifyFormat("extern \"C\" {\n"
16800                "int foo();\n"
16801                "}",
16802                Style);
16803 }
16804 } // namespace
16805 } // namespace format
16806 } // namespace clang
16807