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 }
560 
561 TEST_F(FormatTest, FormatShortBracedStatements) {
562   FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
563   AllowSimpleBracedStatements.ColumnLimit = 40;
564   AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine =
565       FormatStyle::SBS_Always;
566 
567   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
568       FormatStyle::SIS_WithoutElse;
569   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
570 
571   AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom;
572   AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true;
573   AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false;
574 
575   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
576   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
577   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
578   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
579   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
580   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
581   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
582   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
583   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
584   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
585   verifyFormat("if (true) {\n"
586                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
587                "}",
588                AllowSimpleBracedStatements);
589   verifyFormat("if (true) { //\n"
590                "  f();\n"
591                "}",
592                AllowSimpleBracedStatements);
593   verifyFormat("if (true) {\n"
594                "  f();\n"
595                "  f();\n"
596                "}",
597                AllowSimpleBracedStatements);
598   verifyFormat("if (true) {\n"
599                "  f();\n"
600                "} else {\n"
601                "  f();\n"
602                "}",
603                AllowSimpleBracedStatements);
604 
605   verifyFormat("struct A2 {\n"
606                "  int X;\n"
607                "};",
608                AllowSimpleBracedStatements);
609   verifyFormat("typedef struct A2 {\n"
610                "  int X;\n"
611                "} A2_t;",
612                AllowSimpleBracedStatements);
613   verifyFormat("template <int> struct A2 {\n"
614                "  struct B {};\n"
615                "};",
616                AllowSimpleBracedStatements);
617 
618   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
619       FormatStyle::SIS_Never;
620   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
621   verifyFormat("if (true) {\n"
622                "  f();\n"
623                "}",
624                AllowSimpleBracedStatements);
625   verifyFormat("if (true) {\n"
626                "  f();\n"
627                "} else {\n"
628                "  f();\n"
629                "}",
630                AllowSimpleBracedStatements);
631 
632   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
633   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
634   verifyFormat("while (true) {\n"
635                "  f();\n"
636                "}",
637                AllowSimpleBracedStatements);
638   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
639   verifyFormat("for (;;) {\n"
640                "  f();\n"
641                "}",
642                AllowSimpleBracedStatements);
643 
644   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
645       FormatStyle::SIS_WithoutElse;
646   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
647   AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement =
648       FormatStyle::BWACS_Always;
649 
650   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
651   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
652   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
653   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
654   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
655   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
656   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
657   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
658   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
659   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
660   verifyFormat("if (true)\n"
661                "{\n"
662                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
663                "}",
664                AllowSimpleBracedStatements);
665   verifyFormat("if (true)\n"
666                "{ //\n"
667                "  f();\n"
668                "}",
669                AllowSimpleBracedStatements);
670   verifyFormat("if (true)\n"
671                "{\n"
672                "  f();\n"
673                "  f();\n"
674                "}",
675                AllowSimpleBracedStatements);
676   verifyFormat("if (true)\n"
677                "{\n"
678                "  f();\n"
679                "} else\n"
680                "{\n"
681                "  f();\n"
682                "}",
683                AllowSimpleBracedStatements);
684 
685   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
686       FormatStyle::SIS_Never;
687   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
688   verifyFormat("if (true)\n"
689                "{\n"
690                "  f();\n"
691                "}",
692                AllowSimpleBracedStatements);
693   verifyFormat("if (true)\n"
694                "{\n"
695                "  f();\n"
696                "} else\n"
697                "{\n"
698                "  f();\n"
699                "}",
700                AllowSimpleBracedStatements);
701 
702   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
703   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
704   verifyFormat("while (true)\n"
705                "{\n"
706                "  f();\n"
707                "}",
708                AllowSimpleBracedStatements);
709   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
710   verifyFormat("for (;;)\n"
711                "{\n"
712                "  f();\n"
713                "}",
714                AllowSimpleBracedStatements);
715 }
716 
717 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) {
718   FormatStyle Style = getLLVMStyleWithColumns(60);
719   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
720   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
721   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
722   EXPECT_EQ("#define A                                                  \\\n"
723             "  if (HANDLEwernufrnuLwrmviferuvnierv)                     \\\n"
724             "  { RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; }\n"
725             "X;",
726             format("#define A \\\n"
727                    "   if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"
728                    "      RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
729                    "   }\n"
730                    "X;",
731                    Style));
732 }
733 
734 TEST_F(FormatTest, ParseIfElse) {
735   verifyFormat("if (true)\n"
736                "  if (true)\n"
737                "    if (true)\n"
738                "      f();\n"
739                "    else\n"
740                "      g();\n"
741                "  else\n"
742                "    h();\n"
743                "else\n"
744                "  i();");
745   verifyFormat("if (true)\n"
746                "  if (true)\n"
747                "    if (true) {\n"
748                "      if (true)\n"
749                "        f();\n"
750                "    } else {\n"
751                "      g();\n"
752                "    }\n"
753                "  else\n"
754                "    h();\n"
755                "else {\n"
756                "  i();\n"
757                "}");
758   verifyFormat("if (true)\n"
759                "  if constexpr (true)\n"
760                "    if (true) {\n"
761                "      if constexpr (true)\n"
762                "        f();\n"
763                "    } else {\n"
764                "      g();\n"
765                "    }\n"
766                "  else\n"
767                "    h();\n"
768                "else {\n"
769                "  i();\n"
770                "}");
771   verifyFormat("if (true)\n"
772                "  if CONSTEXPR (true)\n"
773                "    if (true) {\n"
774                "      if CONSTEXPR (true)\n"
775                "        f();\n"
776                "    } else {\n"
777                "      g();\n"
778                "    }\n"
779                "  else\n"
780                "    h();\n"
781                "else {\n"
782                "  i();\n"
783                "}");
784   verifyFormat("void f() {\n"
785                "  if (a) {\n"
786                "  } else {\n"
787                "  }\n"
788                "}");
789 }
790 
791 TEST_F(FormatTest, ElseIf) {
792   verifyFormat("if (a) {\n} else if (b) {\n}");
793   verifyFormat("if (a)\n"
794                "  f();\n"
795                "else if (b)\n"
796                "  g();\n"
797                "else\n"
798                "  h();");
799   verifyFormat("if constexpr (a)\n"
800                "  f();\n"
801                "else if constexpr (b)\n"
802                "  g();\n"
803                "else\n"
804                "  h();");
805   verifyFormat("if CONSTEXPR (a)\n"
806                "  f();\n"
807                "else if CONSTEXPR (b)\n"
808                "  g();\n"
809                "else\n"
810                "  h();");
811   verifyFormat("if (a) {\n"
812                "  f();\n"
813                "}\n"
814                "// or else ..\n"
815                "else {\n"
816                "  g()\n"
817                "}");
818 
819   verifyFormat("if (a) {\n"
820                "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
821                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
822                "}");
823   verifyFormat("if (a) {\n"
824                "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
825                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
826                "}");
827   verifyFormat("if (a) {\n"
828                "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
829                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
830                "}");
831   verifyFormat("if (a) {\n"
832                "} else if (\n"
833                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
834                "}",
835                getLLVMStyleWithColumns(62));
836   verifyFormat("if (a) {\n"
837                "} else if constexpr (\n"
838                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
839                "}",
840                getLLVMStyleWithColumns(62));
841   verifyFormat("if (a) {\n"
842                "} else if CONSTEXPR (\n"
843                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
844                "}",
845                getLLVMStyleWithColumns(62));
846 }
847 
848 TEST_F(FormatTest, FormatsForLoop) {
849   verifyFormat(
850       "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
851       "     ++VeryVeryLongLoopVariable)\n"
852       "  ;");
853   verifyFormat("for (;;)\n"
854                "  f();");
855   verifyFormat("for (;;) {\n}");
856   verifyFormat("for (;;) {\n"
857                "  f();\n"
858                "}");
859   verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
860 
861   verifyFormat(
862       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
863       "                                          E = UnwrappedLines.end();\n"
864       "     I != E; ++I) {\n}");
865 
866   verifyFormat(
867       "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
868       "     ++IIIII) {\n}");
869   verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
870                "         aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
871                "     aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
872   verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
873                "         I = FD->getDeclsInPrototypeScope().begin(),\n"
874                "         E = FD->getDeclsInPrototypeScope().end();\n"
875                "     I != E; ++I) {\n}");
876   verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
877                "         I = Container.begin(),\n"
878                "         E = Container.end();\n"
879                "     I != E; ++I) {\n}",
880                getLLVMStyleWithColumns(76));
881 
882   verifyFormat(
883       "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
884       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
885       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
886       "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
887       "     ++aaaaaaaaaaa) {\n}");
888   verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
889                "                bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
890                "     ++i) {\n}");
891   verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
892                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
893                "}");
894   verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
895                "         aaaaaaaaaa);\n"
896                "     iter; ++iter) {\n"
897                "}");
898   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
899                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
900                "     aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
901                "     ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
902 
903   // These should not be formatted as Objective-C for-in loops.
904   verifyFormat("for (Foo *x = 0; x != in; x++) {\n}");
905   verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}");
906   verifyFormat("Foo *x;\nfor (x in y) {\n}");
907   verifyFormat(
908       "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}");
909 
910   FormatStyle NoBinPacking = getLLVMStyle();
911   NoBinPacking.BinPackParameters = false;
912   verifyFormat("for (int aaaaaaaaaaa = 1;\n"
913                "     aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
914                "                                           aaaaaaaaaaaaaaaa,\n"
915                "                                           aaaaaaaaaaaaaaaa,\n"
916                "                                           aaaaaaaaaaaaaaaa);\n"
917                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
918                "}",
919                NoBinPacking);
920   verifyFormat(
921       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
922       "                                          E = UnwrappedLines.end();\n"
923       "     I != E;\n"
924       "     ++I) {\n}",
925       NoBinPacking);
926 
927   FormatStyle AlignLeft = getLLVMStyle();
928   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
929   verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
930 }
931 
932 TEST_F(FormatTest, RangeBasedForLoops) {
933   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
934                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
935   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
936                "     aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
937   verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
938                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
939   verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
940                "     aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
941 }
942 
943 TEST_F(FormatTest, ForEachLoops) {
944   verifyFormat("void f() {\n"
945                "  foreach (Item *item, itemlist) {}\n"
946                "  Q_FOREACH (Item *item, itemlist) {}\n"
947                "  BOOST_FOREACH (Item *item, itemlist) {}\n"
948                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
949                "}");
950 
951   // As function-like macros.
952   verifyFormat("#define foreach(x, y)\n"
953                "#define Q_FOREACH(x, y)\n"
954                "#define BOOST_FOREACH(x, y)\n"
955                "#define UNKNOWN_FOREACH(x, y)\n");
956 
957   // Not as function-like macros.
958   verifyFormat("#define foreach (x, y)\n"
959                "#define Q_FOREACH (x, y)\n"
960                "#define BOOST_FOREACH (x, y)\n"
961                "#define UNKNOWN_FOREACH (x, y)\n");
962 }
963 
964 TEST_F(FormatTest, FormatsWhileLoop) {
965   verifyFormat("while (true) {\n}");
966   verifyFormat("while (true)\n"
967                "  f();");
968   verifyFormat("while () {\n}");
969   verifyFormat("while () {\n"
970                "  f();\n"
971                "}");
972 }
973 
974 TEST_F(FormatTest, FormatsDoWhile) {
975   verifyFormat("do {\n"
976                "  do_something();\n"
977                "} while (something());");
978   verifyFormat("do\n"
979                "  do_something();\n"
980                "while (something());");
981 }
982 
983 TEST_F(FormatTest, FormatsSwitchStatement) {
984   verifyFormat("switch (x) {\n"
985                "case 1:\n"
986                "  f();\n"
987                "  break;\n"
988                "case kFoo:\n"
989                "case ns::kBar:\n"
990                "case kBaz:\n"
991                "  break;\n"
992                "default:\n"
993                "  g();\n"
994                "  break;\n"
995                "}");
996   verifyFormat("switch (x) {\n"
997                "case 1: {\n"
998                "  f();\n"
999                "  break;\n"
1000                "}\n"
1001                "case 2: {\n"
1002                "  break;\n"
1003                "}\n"
1004                "}");
1005   verifyFormat("switch (x) {\n"
1006                "case 1: {\n"
1007                "  f();\n"
1008                "  {\n"
1009                "    g();\n"
1010                "    h();\n"
1011                "  }\n"
1012                "  break;\n"
1013                "}\n"
1014                "}");
1015   verifyFormat("switch (x) {\n"
1016                "case 1: {\n"
1017                "  f();\n"
1018                "  if (foo) {\n"
1019                "    g();\n"
1020                "    h();\n"
1021                "  }\n"
1022                "  break;\n"
1023                "}\n"
1024                "}");
1025   verifyFormat("switch (x) {\n"
1026                "case 1: {\n"
1027                "  f();\n"
1028                "  g();\n"
1029                "} break;\n"
1030                "}");
1031   verifyFormat("switch (test)\n"
1032                "  ;");
1033   verifyFormat("switch (x) {\n"
1034                "default: {\n"
1035                "  // Do nothing.\n"
1036                "}\n"
1037                "}");
1038   verifyFormat("switch (x) {\n"
1039                "// comment\n"
1040                "// if 1, do f()\n"
1041                "case 1:\n"
1042                "  f();\n"
1043                "}");
1044   verifyFormat("switch (x) {\n"
1045                "case 1:\n"
1046                "  // Do amazing stuff\n"
1047                "  {\n"
1048                "    f();\n"
1049                "    g();\n"
1050                "  }\n"
1051                "  break;\n"
1052                "}");
1053   verifyFormat("#define A          \\\n"
1054                "  switch (x) {     \\\n"
1055                "  case a:          \\\n"
1056                "    foo = b;       \\\n"
1057                "  }",
1058                getLLVMStyleWithColumns(20));
1059   verifyFormat("#define OPERATION_CASE(name)           \\\n"
1060                "  case OP_name:                        \\\n"
1061                "    return operations::Operation##name\n",
1062                getLLVMStyleWithColumns(40));
1063   verifyFormat("switch (x) {\n"
1064                "case 1:;\n"
1065                "default:;\n"
1066                "  int i;\n"
1067                "}");
1068 
1069   verifyGoogleFormat("switch (x) {\n"
1070                      "  case 1:\n"
1071                      "    f();\n"
1072                      "    break;\n"
1073                      "  case kFoo:\n"
1074                      "  case ns::kBar:\n"
1075                      "  case kBaz:\n"
1076                      "    break;\n"
1077                      "  default:\n"
1078                      "    g();\n"
1079                      "    break;\n"
1080                      "}");
1081   verifyGoogleFormat("switch (x) {\n"
1082                      "  case 1: {\n"
1083                      "    f();\n"
1084                      "    break;\n"
1085                      "  }\n"
1086                      "}");
1087   verifyGoogleFormat("switch (test)\n"
1088                      "  ;");
1089 
1090   verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
1091                      "  case OP_name:              \\\n"
1092                      "    return operations::Operation##name\n");
1093   verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
1094                      "  // Get the correction operation class.\n"
1095                      "  switch (OpCode) {\n"
1096                      "    CASE(Add);\n"
1097                      "    CASE(Subtract);\n"
1098                      "    default:\n"
1099                      "      return operations::Unknown;\n"
1100                      "  }\n"
1101                      "#undef OPERATION_CASE\n"
1102                      "}");
1103   verifyFormat("DEBUG({\n"
1104                "  switch (x) {\n"
1105                "  case A:\n"
1106                "    f();\n"
1107                "    break;\n"
1108                "    // fallthrough\n"
1109                "  case B:\n"
1110                "    g();\n"
1111                "    break;\n"
1112                "  }\n"
1113                "});");
1114   EXPECT_EQ("DEBUG({\n"
1115             "  switch (x) {\n"
1116             "  case A:\n"
1117             "    f();\n"
1118             "    break;\n"
1119             "  // On B:\n"
1120             "  case B:\n"
1121             "    g();\n"
1122             "    break;\n"
1123             "  }\n"
1124             "});",
1125             format("DEBUG({\n"
1126                    "  switch (x) {\n"
1127                    "  case A:\n"
1128                    "    f();\n"
1129                    "    break;\n"
1130                    "  // On B:\n"
1131                    "  case B:\n"
1132                    "    g();\n"
1133                    "    break;\n"
1134                    "  }\n"
1135                    "});",
1136                    getLLVMStyle()));
1137   EXPECT_EQ("switch (n) {\n"
1138             "case 0: {\n"
1139             "  return false;\n"
1140             "}\n"
1141             "default: {\n"
1142             "  return true;\n"
1143             "}\n"
1144             "}",
1145             format("switch (n)\n"
1146                    "{\n"
1147                    "case 0: {\n"
1148                    "  return false;\n"
1149                    "}\n"
1150                    "default: {\n"
1151                    "  return true;\n"
1152                    "}\n"
1153                    "}",
1154                    getLLVMStyle()));
1155   verifyFormat("switch (a) {\n"
1156                "case (b):\n"
1157                "  return;\n"
1158                "}");
1159 
1160   verifyFormat("switch (a) {\n"
1161                "case some_namespace::\n"
1162                "    some_constant:\n"
1163                "  return;\n"
1164                "}",
1165                getLLVMStyleWithColumns(34));
1166 
1167   FormatStyle Style = getLLVMStyle();
1168   Style.IndentCaseLabels = true;
1169   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
1170   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1171   Style.BraceWrapping.AfterCaseLabel = true;
1172   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1173   EXPECT_EQ("switch (n)\n"
1174             "{\n"
1175             "  case 0:\n"
1176             "  {\n"
1177             "    return false;\n"
1178             "  }\n"
1179             "  default:\n"
1180             "  {\n"
1181             "    return true;\n"
1182             "  }\n"
1183             "}",
1184             format("switch (n) {\n"
1185                    "  case 0: {\n"
1186                    "    return false;\n"
1187                    "  }\n"
1188                    "  default: {\n"
1189                    "    return true;\n"
1190                    "  }\n"
1191                    "}",
1192                    Style));
1193   Style.BraceWrapping.AfterCaseLabel = false;
1194   EXPECT_EQ("switch (n)\n"
1195             "{\n"
1196             "  case 0: {\n"
1197             "    return false;\n"
1198             "  }\n"
1199             "  default: {\n"
1200             "    return true;\n"
1201             "  }\n"
1202             "}",
1203             format("switch (n) {\n"
1204                    "  case 0:\n"
1205                    "  {\n"
1206                    "    return false;\n"
1207                    "  }\n"
1208                    "  default:\n"
1209                    "  {\n"
1210                    "    return true;\n"
1211                    "  }\n"
1212                    "}",
1213                    Style));
1214 }
1215 
1216 TEST_F(FormatTest, CaseRanges) {
1217   verifyFormat("switch (x) {\n"
1218                "case 'A' ... 'Z':\n"
1219                "case 1 ... 5:\n"
1220                "case a ... b:\n"
1221                "  break;\n"
1222                "}");
1223 }
1224 
1225 TEST_F(FormatTest, ShortCaseLabels) {
1226   FormatStyle Style = getLLVMStyle();
1227   Style.AllowShortCaseLabelsOnASingleLine = true;
1228   verifyFormat("switch (a) {\n"
1229                "case 1: x = 1; break;\n"
1230                "case 2: return;\n"
1231                "case 3:\n"
1232                "case 4:\n"
1233                "case 5: return;\n"
1234                "case 6: // comment\n"
1235                "  return;\n"
1236                "case 7:\n"
1237                "  // comment\n"
1238                "  return;\n"
1239                "case 8:\n"
1240                "  x = 8; // comment\n"
1241                "  break;\n"
1242                "default: y = 1; break;\n"
1243                "}",
1244                Style);
1245   verifyFormat("switch (a) {\n"
1246                "case 0: return; // comment\n"
1247                "case 1: break;  // comment\n"
1248                "case 2: return;\n"
1249                "// comment\n"
1250                "case 3: return;\n"
1251                "// comment 1\n"
1252                "// comment 2\n"
1253                "// comment 3\n"
1254                "case 4: break; /* comment */\n"
1255                "case 5:\n"
1256                "  // comment\n"
1257                "  break;\n"
1258                "case 6: /* comment */ x = 1; break;\n"
1259                "case 7: x = /* comment */ 1; break;\n"
1260                "case 8:\n"
1261                "  x = 1; /* comment */\n"
1262                "  break;\n"
1263                "case 9:\n"
1264                "  break; // comment line 1\n"
1265                "         // comment line 2\n"
1266                "}",
1267                Style);
1268   EXPECT_EQ("switch (a) {\n"
1269             "case 1:\n"
1270             "  x = 8;\n"
1271             "  // fall through\n"
1272             "case 2: x = 8;\n"
1273             "// comment\n"
1274             "case 3:\n"
1275             "  return; /* comment line 1\n"
1276             "           * comment line 2 */\n"
1277             "case 4: i = 8;\n"
1278             "// something else\n"
1279             "#if FOO\n"
1280             "case 5: break;\n"
1281             "#endif\n"
1282             "}",
1283             format("switch (a) {\n"
1284                    "case 1: x = 8;\n"
1285                    "  // fall through\n"
1286                    "case 2:\n"
1287                    "  x = 8;\n"
1288                    "// comment\n"
1289                    "case 3:\n"
1290                    "  return; /* comment line 1\n"
1291                    "           * comment line 2 */\n"
1292                    "case 4:\n"
1293                    "  i = 8;\n"
1294                    "// something else\n"
1295                    "#if FOO\n"
1296                    "case 5: break;\n"
1297                    "#endif\n"
1298                    "}",
1299                    Style));
1300   EXPECT_EQ("switch (a) {\n"
1301             "case 0:\n"
1302             "  return; // long long long long long long long long long long "
1303             "long long comment\n"
1304             "          // line\n"
1305             "}",
1306             format("switch (a) {\n"
1307                    "case 0: return; // long long long long long long long long "
1308                    "long long long long comment line\n"
1309                    "}",
1310                    Style));
1311   EXPECT_EQ("switch (a) {\n"
1312             "case 0:\n"
1313             "  return; /* long long long long long long long long long long "
1314             "long long comment\n"
1315             "             line */\n"
1316             "}",
1317             format("switch (a) {\n"
1318                    "case 0: return; /* long long long long long long long long "
1319                    "long long long long comment line */\n"
1320                    "}",
1321                    Style));
1322   verifyFormat("switch (a) {\n"
1323                "#if FOO\n"
1324                "case 0: return 0;\n"
1325                "#endif\n"
1326                "}",
1327                Style);
1328   verifyFormat("switch (a) {\n"
1329                "case 1: {\n"
1330                "}\n"
1331                "case 2: {\n"
1332                "  return;\n"
1333                "}\n"
1334                "case 3: {\n"
1335                "  x = 1;\n"
1336                "  return;\n"
1337                "}\n"
1338                "case 4:\n"
1339                "  if (x)\n"
1340                "    return;\n"
1341                "}",
1342                Style);
1343   Style.ColumnLimit = 21;
1344   verifyFormat("switch (a) {\n"
1345                "case 1: x = 1; break;\n"
1346                "case 2: return;\n"
1347                "case 3:\n"
1348                "case 4:\n"
1349                "case 5: return;\n"
1350                "default:\n"
1351                "  y = 1;\n"
1352                "  break;\n"
1353                "}",
1354                Style);
1355   Style.ColumnLimit = 80;
1356   Style.AllowShortCaseLabelsOnASingleLine = false;
1357   Style.IndentCaseLabels = true;
1358   EXPECT_EQ("switch (n) {\n"
1359             "  default /*comments*/:\n"
1360             "    return true;\n"
1361             "  case 0:\n"
1362             "    return false;\n"
1363             "}",
1364             format("switch (n) {\n"
1365                    "default/*comments*/:\n"
1366                    "  return true;\n"
1367                    "case 0:\n"
1368                    "  return false;\n"
1369                    "}",
1370                    Style));
1371   Style.AllowShortCaseLabelsOnASingleLine = true;
1372   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1373   Style.BraceWrapping.AfterCaseLabel = true;
1374   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1375   EXPECT_EQ("switch (n)\n"
1376             "{\n"
1377             "  case 0:\n"
1378             "  {\n"
1379             "    return false;\n"
1380             "  }\n"
1381             "  default:\n"
1382             "  {\n"
1383             "    return true;\n"
1384             "  }\n"
1385             "}",
1386             format("switch (n) {\n"
1387                    "  case 0: {\n"
1388                    "    return false;\n"
1389                    "  }\n"
1390                    "  default:\n"
1391                    "  {\n"
1392                    "    return true;\n"
1393                    "  }\n"
1394                    "}",
1395                    Style));
1396 }
1397 
1398 TEST_F(FormatTest, FormatsLabels) {
1399   verifyFormat("void f() {\n"
1400                "  some_code();\n"
1401                "test_label:\n"
1402                "  some_other_code();\n"
1403                "  {\n"
1404                "    some_more_code();\n"
1405                "  another_label:\n"
1406                "    some_more_code();\n"
1407                "  }\n"
1408                "}");
1409   verifyFormat("{\n"
1410                "  some_code();\n"
1411                "test_label:\n"
1412                "  some_other_code();\n"
1413                "}");
1414   verifyFormat("{\n"
1415                "  some_code();\n"
1416                "test_label:;\n"
1417                "  int i = 0;\n"
1418                "}");
1419   FormatStyle Style = getLLVMStyle();
1420   Style.IndentGotoLabels = false;
1421   verifyFormat("void f() {\n"
1422                "  some_code();\n"
1423                "test_label:\n"
1424                "  some_other_code();\n"
1425                "  {\n"
1426                "    some_more_code();\n"
1427                "another_label:\n"
1428                "    some_more_code();\n"
1429                "  }\n"
1430                "}",
1431                Style);
1432   verifyFormat("{\n"
1433                "  some_code();\n"
1434                "test_label:\n"
1435                "  some_other_code();\n"
1436                "}",
1437                Style);
1438   verifyFormat("{\n"
1439                "  some_code();\n"
1440                "test_label:;\n"
1441                "  int i = 0;\n"
1442                "}");
1443 }
1444 
1445 TEST_F(FormatTest, MultiLineControlStatements) {
1446   FormatStyle Style = getLLVMStyle();
1447   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1448   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine;
1449   Style.ColumnLimit = 20;
1450   // Short lines should keep opening brace on same line.
1451   EXPECT_EQ("if (foo) {\n"
1452             "  bar();\n"
1453             "}",
1454             format("if(foo){bar();}", Style));
1455   EXPECT_EQ("if (foo) {\n"
1456             "  bar();\n"
1457             "} else {\n"
1458             "  baz();\n"
1459             "}",
1460             format("if(foo){bar();}else{baz();}", Style));
1461   EXPECT_EQ("if (foo && bar) {\n"
1462             "  baz();\n"
1463             "}",
1464             format("if(foo&&bar){baz();}", Style));
1465   EXPECT_EQ("if (foo) {\n"
1466             "  bar();\n"
1467             "} else if (baz) {\n"
1468             "  quux();\n"
1469             "}",
1470             format("if(foo){bar();}else if(baz){quux();}", Style));
1471   EXPECT_EQ(
1472       "if (foo) {\n"
1473       "  bar();\n"
1474       "} else if (baz) {\n"
1475       "  quux();\n"
1476       "} else {\n"
1477       "  foobar();\n"
1478       "}",
1479       format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style));
1480   EXPECT_EQ("for (;;) {\n"
1481             "  foo();\n"
1482             "}",
1483             format("for(;;){foo();}"));
1484   EXPECT_EQ("while (1) {\n"
1485             "  foo();\n"
1486             "}",
1487             format("while(1){foo();}", Style));
1488   EXPECT_EQ("switch (foo) {\n"
1489             "case bar:\n"
1490             "  return;\n"
1491             "}",
1492             format("switch(foo){case bar:return;}", Style));
1493   EXPECT_EQ("try {\n"
1494             "  foo();\n"
1495             "} catch (...) {\n"
1496             "  bar();\n"
1497             "}",
1498             format("try{foo();}catch(...){bar();}", Style));
1499   EXPECT_EQ("do {\n"
1500             "  foo();\n"
1501             "} while (bar &&\n"
1502             "         baz);",
1503             format("do{foo();}while(bar&&baz);", Style));
1504   // Long lines should put opening brace on new line.
1505   EXPECT_EQ("if (foo && bar &&\n"
1506             "    baz)\n"
1507             "{\n"
1508             "  quux();\n"
1509             "}",
1510             format("if(foo&&bar&&baz){quux();}", Style));
1511   EXPECT_EQ("if (foo && bar &&\n"
1512             "    baz)\n"
1513             "{\n"
1514             "  quux();\n"
1515             "}",
1516             format("if (foo && bar &&\n"
1517                    "    baz) {\n"
1518                    "  quux();\n"
1519                    "}",
1520                    Style));
1521   EXPECT_EQ("if (foo) {\n"
1522             "  bar();\n"
1523             "} else if (baz ||\n"
1524             "           quux)\n"
1525             "{\n"
1526             "  foobar();\n"
1527             "}",
1528             format("if(foo){bar();}else if(baz||quux){foobar();}", Style));
1529   EXPECT_EQ(
1530       "if (foo) {\n"
1531       "  bar();\n"
1532       "} else if (baz ||\n"
1533       "           quux)\n"
1534       "{\n"
1535       "  foobar();\n"
1536       "} else {\n"
1537       "  barbaz();\n"
1538       "}",
1539       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1540              Style));
1541   EXPECT_EQ("for (int i = 0;\n"
1542             "     i < 10; ++i)\n"
1543             "{\n"
1544             "  foo();\n"
1545             "}",
1546             format("for(int i=0;i<10;++i){foo();}", Style));
1547   EXPECT_EQ("while (foo || bar ||\n"
1548             "       baz)\n"
1549             "{\n"
1550             "  quux();\n"
1551             "}",
1552             format("while(foo||bar||baz){quux();}", Style));
1553   EXPECT_EQ("switch (\n"
1554             "    foo = barbaz)\n"
1555             "{\n"
1556             "case quux:\n"
1557             "  return;\n"
1558             "}",
1559             format("switch(foo=barbaz){case quux:return;}", Style));
1560   EXPECT_EQ("try {\n"
1561             "  foo();\n"
1562             "} catch (\n"
1563             "    Exception &bar)\n"
1564             "{\n"
1565             "  baz();\n"
1566             "}",
1567             format("try{foo();}catch(Exception&bar){baz();}", Style));
1568 }
1569 
1570 //===----------------------------------------------------------------------===//
1571 // Tests for classes, namespaces, etc.
1572 //===----------------------------------------------------------------------===//
1573 
1574 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
1575   verifyFormat("class A {};");
1576 }
1577 
1578 TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1579   verifyFormat("class A {\n"
1580                "public:\n"
1581                "public: // comment\n"
1582                "protected:\n"
1583                "private:\n"
1584                "  void f() {}\n"
1585                "};");
1586   verifyFormat("export class A {\n"
1587                "public:\n"
1588                "public: // comment\n"
1589                "protected:\n"
1590                "private:\n"
1591                "  void f() {}\n"
1592                "};");
1593   verifyGoogleFormat("class A {\n"
1594                      " public:\n"
1595                      " protected:\n"
1596                      " private:\n"
1597                      "  void f() {}\n"
1598                      "};");
1599   verifyGoogleFormat("export class A {\n"
1600                      " public:\n"
1601                      " protected:\n"
1602                      " private:\n"
1603                      "  void f() {}\n"
1604                      "};");
1605   verifyFormat("class A {\n"
1606                "public slots:\n"
1607                "  void f1() {}\n"
1608                "public Q_SLOTS:\n"
1609                "  void f2() {}\n"
1610                "protected slots:\n"
1611                "  void f3() {}\n"
1612                "protected Q_SLOTS:\n"
1613                "  void f4() {}\n"
1614                "private slots:\n"
1615                "  void f5() {}\n"
1616                "private Q_SLOTS:\n"
1617                "  void f6() {}\n"
1618                "signals:\n"
1619                "  void g1();\n"
1620                "Q_SIGNALS:\n"
1621                "  void g2();\n"
1622                "};");
1623 
1624   // Don't interpret 'signals' the wrong way.
1625   verifyFormat("signals.set();");
1626   verifyFormat("for (Signals signals : f()) {\n}");
1627   verifyFormat("{\n"
1628                "  signals.set(); // This needs indentation.\n"
1629                "}");
1630   verifyFormat("void f() {\n"
1631                "label:\n"
1632                "  signals.baz();\n"
1633                "}");
1634 }
1635 
1636 TEST_F(FormatTest, SeparatesLogicalBlocks) {
1637   EXPECT_EQ("class A {\n"
1638             "public:\n"
1639             "  void f();\n"
1640             "\n"
1641             "private:\n"
1642             "  void g() {}\n"
1643             "  // test\n"
1644             "protected:\n"
1645             "  int h;\n"
1646             "};",
1647             format("class A {\n"
1648                    "public:\n"
1649                    "void f();\n"
1650                    "private:\n"
1651                    "void g() {}\n"
1652                    "// test\n"
1653                    "protected:\n"
1654                    "int h;\n"
1655                    "};"));
1656   EXPECT_EQ("class A {\n"
1657             "protected:\n"
1658             "public:\n"
1659             "  void f();\n"
1660             "};",
1661             format("class A {\n"
1662                    "protected:\n"
1663                    "\n"
1664                    "public:\n"
1665                    "\n"
1666                    "  void f();\n"
1667                    "};"));
1668 
1669   // Even ensure proper spacing inside macros.
1670   EXPECT_EQ("#define B     \\\n"
1671             "  class A {   \\\n"
1672             "   protected: \\\n"
1673             "   public:    \\\n"
1674             "    void f(); \\\n"
1675             "  };",
1676             format("#define B     \\\n"
1677                    "  class A {   \\\n"
1678                    "   protected: \\\n"
1679                    "              \\\n"
1680                    "   public:    \\\n"
1681                    "              \\\n"
1682                    "    void f(); \\\n"
1683                    "  };",
1684                    getGoogleStyle()));
1685   // But don't remove empty lines after macros ending in access specifiers.
1686   EXPECT_EQ("#define A private:\n"
1687             "\n"
1688             "int i;",
1689             format("#define A         private:\n"
1690                    "\n"
1691                    "int              i;"));
1692 }
1693 
1694 TEST_F(FormatTest, FormatsClasses) {
1695   verifyFormat("class A : public B {};");
1696   verifyFormat("class A : public ::B {};");
1697 
1698   verifyFormat(
1699       "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1700       "                             public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1701   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1702                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1703                "      public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1704   verifyFormat(
1705       "class A : public B, public C, public D, public E, public F {};");
1706   verifyFormat("class AAAAAAAAAAAA : public B,\n"
1707                "                     public C,\n"
1708                "                     public D,\n"
1709                "                     public E,\n"
1710                "                     public F,\n"
1711                "                     public G {};");
1712 
1713   verifyFormat("class\n"
1714                "    ReallyReallyLongClassName {\n"
1715                "  int i;\n"
1716                "};",
1717                getLLVMStyleWithColumns(32));
1718   verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1719                "                           aaaaaaaaaaaaaaaa> {};");
1720   verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1721                "    : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1722                "                                 aaaaaaaaaaaaaaaaaaaaaa> {};");
1723   verifyFormat("template <class R, class C>\n"
1724                "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1725                "    : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
1726   verifyFormat("class ::A::B {};");
1727 }
1728 
1729 TEST_F(FormatTest, BreakInheritanceStyle) {
1730   FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle();
1731   StyleWithInheritanceBreakBeforeComma.BreakInheritanceList =
1732       FormatStyle::BILS_BeforeComma;
1733   verifyFormat("class MyClass : public X {};",
1734                StyleWithInheritanceBreakBeforeComma);
1735   verifyFormat("class MyClass\n"
1736                "    : public X\n"
1737                "    , public Y {};",
1738                StyleWithInheritanceBreakBeforeComma);
1739   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
1740                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"
1741                "    , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1742                StyleWithInheritanceBreakBeforeComma);
1743   verifyFormat("struct aaaaaaaaaaaaa\n"
1744                "    : public aaaaaaaaaaaaaaaaaaa< // break\n"
1745                "          aaaaaaaaaaaaaaaa> {};",
1746                StyleWithInheritanceBreakBeforeComma);
1747 
1748   FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle();
1749   StyleWithInheritanceBreakAfterColon.BreakInheritanceList =
1750       FormatStyle::BILS_AfterColon;
1751   verifyFormat("class MyClass : public X {};",
1752                StyleWithInheritanceBreakAfterColon);
1753   verifyFormat("class MyClass : public X, public Y {};",
1754                StyleWithInheritanceBreakAfterColon);
1755   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
1756                "    public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1757                "    public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1758                StyleWithInheritanceBreakAfterColon);
1759   verifyFormat("struct aaaaaaaaaaaaa :\n"
1760                "    public aaaaaaaaaaaaaaaaaaa< // break\n"
1761                "        aaaaaaaaaaaaaaaa> {};",
1762                StyleWithInheritanceBreakAfterColon);
1763 }
1764 
1765 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
1766   verifyFormat("class A {\n} a, b;");
1767   verifyFormat("struct A {\n} a, b;");
1768   verifyFormat("union A {\n} a;");
1769 }
1770 
1771 TEST_F(FormatTest, FormatsEnum) {
1772   verifyFormat("enum {\n"
1773                "  Zero,\n"
1774                "  One = 1,\n"
1775                "  Two = One + 1,\n"
1776                "  Three = (One + Two),\n"
1777                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1778                "  Five = (One, Two, Three, Four, 5)\n"
1779                "};");
1780   verifyGoogleFormat("enum {\n"
1781                      "  Zero,\n"
1782                      "  One = 1,\n"
1783                      "  Two = One + 1,\n"
1784                      "  Three = (One + Two),\n"
1785                      "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1786                      "  Five = (One, Two, Three, Four, 5)\n"
1787                      "};");
1788   verifyFormat("enum Enum {};");
1789   verifyFormat("enum {};");
1790   verifyFormat("enum X E {} d;");
1791   verifyFormat("enum __attribute__((...)) E {} d;");
1792   verifyFormat("enum __declspec__((...)) E {} d;");
1793   verifyFormat("enum {\n"
1794                "  Bar = Foo<int, int>::value\n"
1795                "};",
1796                getLLVMStyleWithColumns(30));
1797 
1798   verifyFormat("enum ShortEnum { A, B, C };");
1799   verifyGoogleFormat("enum ShortEnum { A, B, C };");
1800 
1801   EXPECT_EQ("enum KeepEmptyLines {\n"
1802             "  ONE,\n"
1803             "\n"
1804             "  TWO,\n"
1805             "\n"
1806             "  THREE\n"
1807             "}",
1808             format("enum KeepEmptyLines {\n"
1809                    "  ONE,\n"
1810                    "\n"
1811                    "  TWO,\n"
1812                    "\n"
1813                    "\n"
1814                    "  THREE\n"
1815                    "}"));
1816   verifyFormat("enum E { // comment\n"
1817                "  ONE,\n"
1818                "  TWO\n"
1819                "};\n"
1820                "int i;");
1821   // Not enums.
1822   verifyFormat("enum X f() {\n"
1823                "  a();\n"
1824                "  return 42;\n"
1825                "}");
1826   verifyFormat("enum X Type::f() {\n"
1827                "  a();\n"
1828                "  return 42;\n"
1829                "}");
1830   verifyFormat("enum ::X f() {\n"
1831                "  a();\n"
1832                "  return 42;\n"
1833                "}");
1834   verifyFormat("enum ns::X f() {\n"
1835                "  a();\n"
1836                "  return 42;\n"
1837                "}");
1838 }
1839 
1840 TEST_F(FormatTest, FormatsEnumsWithErrors) {
1841   verifyFormat("enum Type {\n"
1842                "  One = 0; // These semicolons should be commas.\n"
1843                "  Two = 1;\n"
1844                "};");
1845   verifyFormat("namespace n {\n"
1846                "enum Type {\n"
1847                "  One,\n"
1848                "  Two, // missing };\n"
1849                "  int i;\n"
1850                "}\n"
1851                "void g() {}");
1852 }
1853 
1854 TEST_F(FormatTest, FormatsEnumStruct) {
1855   verifyFormat("enum struct {\n"
1856                "  Zero,\n"
1857                "  One = 1,\n"
1858                "  Two = One + 1,\n"
1859                "  Three = (One + Two),\n"
1860                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1861                "  Five = (One, Two, Three, Four, 5)\n"
1862                "};");
1863   verifyFormat("enum struct Enum {};");
1864   verifyFormat("enum struct {};");
1865   verifyFormat("enum struct X E {} d;");
1866   verifyFormat("enum struct __attribute__((...)) E {} d;");
1867   verifyFormat("enum struct __declspec__((...)) E {} d;");
1868   verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
1869 }
1870 
1871 TEST_F(FormatTest, FormatsEnumClass) {
1872   verifyFormat("enum class {\n"
1873                "  Zero,\n"
1874                "  One = 1,\n"
1875                "  Two = One + 1,\n"
1876                "  Three = (One + Two),\n"
1877                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1878                "  Five = (One, Two, Three, Four, 5)\n"
1879                "};");
1880   verifyFormat("enum class Enum {};");
1881   verifyFormat("enum class {};");
1882   verifyFormat("enum class X E {} d;");
1883   verifyFormat("enum class __attribute__((...)) E {} d;");
1884   verifyFormat("enum class __declspec__((...)) E {} d;");
1885   verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
1886 }
1887 
1888 TEST_F(FormatTest, FormatsEnumTypes) {
1889   verifyFormat("enum X : int {\n"
1890                "  A, // Force multiple lines.\n"
1891                "  B\n"
1892                "};");
1893   verifyFormat("enum X : int { A, B };");
1894   verifyFormat("enum X : std::uint32_t { A, B };");
1895 }
1896 
1897 TEST_F(FormatTest, FormatsTypedefEnum) {
1898   FormatStyle Style = getLLVMStyle();
1899   Style.ColumnLimit = 40;
1900   verifyFormat("typedef enum {} EmptyEnum;");
1901   verifyFormat("typedef enum { A, B, C } ShortEnum;");
1902   verifyFormat("typedef enum {\n"
1903                "  ZERO = 0,\n"
1904                "  ONE = 1,\n"
1905                "  TWO = 2,\n"
1906                "  THREE = 3\n"
1907                "} LongEnum;",
1908                Style);
1909   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1910   Style.BraceWrapping.AfterEnum = true;
1911   verifyFormat("typedef enum {} EmptyEnum;");
1912   verifyFormat("typedef enum { A, B, C } ShortEnum;");
1913   verifyFormat("typedef enum\n"
1914                "{\n"
1915                "  ZERO = 0,\n"
1916                "  ONE = 1,\n"
1917                "  TWO = 2,\n"
1918                "  THREE = 3\n"
1919                "} LongEnum;",
1920                Style);
1921 }
1922 
1923 TEST_F(FormatTest, FormatsNSEnums) {
1924   verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
1925   verifyGoogleFormat(
1926       "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }");
1927   verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
1928                      "  // Information about someDecentlyLongValue.\n"
1929                      "  someDecentlyLongValue,\n"
1930                      "  // Information about anotherDecentlyLongValue.\n"
1931                      "  anotherDecentlyLongValue,\n"
1932                      "  // Information about aThirdDecentlyLongValue.\n"
1933                      "  aThirdDecentlyLongValue\n"
1934                      "};");
1935   verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n"
1936                      "  // Information about someDecentlyLongValue.\n"
1937                      "  someDecentlyLongValue,\n"
1938                      "  // Information about anotherDecentlyLongValue.\n"
1939                      "  anotherDecentlyLongValue,\n"
1940                      "  // Information about aThirdDecentlyLongValue.\n"
1941                      "  aThirdDecentlyLongValue\n"
1942                      "};");
1943   verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
1944                      "  a = 1,\n"
1945                      "  b = 2,\n"
1946                      "  c = 3,\n"
1947                      "};");
1948   verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
1949                      "  a = 1,\n"
1950                      "  b = 2,\n"
1951                      "  c = 3,\n"
1952                      "};");
1953   verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n"
1954                      "  a = 1,\n"
1955                      "  b = 2,\n"
1956                      "  c = 3,\n"
1957                      "};");
1958   verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
1959                      "  a = 1,\n"
1960                      "  b = 2,\n"
1961                      "  c = 3,\n"
1962                      "};");
1963 }
1964 
1965 TEST_F(FormatTest, FormatsBitfields) {
1966   verifyFormat("struct Bitfields {\n"
1967                "  unsigned sClass : 8;\n"
1968                "  unsigned ValueKind : 2;\n"
1969                "};");
1970   verifyFormat("struct A {\n"
1971                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
1972                "      bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
1973                "};");
1974   verifyFormat("struct MyStruct {\n"
1975                "  uchar data;\n"
1976                "  uchar : 8;\n"
1977                "  uchar : 8;\n"
1978                "  uchar other;\n"
1979                "};");
1980 }
1981 
1982 TEST_F(FormatTest, FormatsNamespaces) {
1983   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
1984   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
1985 
1986   verifyFormat("namespace some_namespace {\n"
1987                "class A {};\n"
1988                "void f() { f(); }\n"
1989                "}",
1990                LLVMWithNoNamespaceFix);
1991   verifyFormat("namespace N::inline D {\n"
1992                "class A {};\n"
1993                "void f() { f(); }\n"
1994                "}",
1995                LLVMWithNoNamespaceFix);
1996   verifyFormat("namespace N::inline D::E {\n"
1997                "class A {};\n"
1998                "void f() { f(); }\n"
1999                "}",
2000                LLVMWithNoNamespaceFix);
2001   verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
2002                "class A {};\n"
2003                "void f() { f(); }\n"
2004                "}",
2005                LLVMWithNoNamespaceFix);
2006   verifyFormat("/* something */ namespace some_namespace {\n"
2007                "class A {};\n"
2008                "void f() { f(); }\n"
2009                "}",
2010                LLVMWithNoNamespaceFix);
2011   verifyFormat("namespace {\n"
2012                "class A {};\n"
2013                "void f() { f(); }\n"
2014                "}",
2015                LLVMWithNoNamespaceFix);
2016   verifyFormat("/* something */ namespace {\n"
2017                "class A {};\n"
2018                "void f() { f(); }\n"
2019                "}",
2020                LLVMWithNoNamespaceFix);
2021   verifyFormat("inline namespace X {\n"
2022                "class A {};\n"
2023                "void f() { f(); }\n"
2024                "}",
2025                LLVMWithNoNamespaceFix);
2026   verifyFormat("/* something */ inline namespace X {\n"
2027                "class A {};\n"
2028                "void f() { f(); }\n"
2029                "}",
2030                LLVMWithNoNamespaceFix);
2031   verifyFormat("export namespace X {\n"
2032                "class A {};\n"
2033                "void f() { f(); }\n"
2034                "}",
2035                LLVMWithNoNamespaceFix);
2036   verifyFormat("using namespace some_namespace;\n"
2037                "class A {};\n"
2038                "void f() { f(); }",
2039                LLVMWithNoNamespaceFix);
2040 
2041   // This code is more common than we thought; if we
2042   // layout this correctly the semicolon will go into
2043   // its own line, which is undesirable.
2044   verifyFormat("namespace {};", LLVMWithNoNamespaceFix);
2045   verifyFormat("namespace {\n"
2046                "class A {};\n"
2047                "};",
2048                LLVMWithNoNamespaceFix);
2049 
2050   verifyFormat("namespace {\n"
2051                "int SomeVariable = 0; // comment\n"
2052                "} // namespace",
2053                LLVMWithNoNamespaceFix);
2054   EXPECT_EQ("#ifndef HEADER_GUARD\n"
2055             "#define HEADER_GUARD\n"
2056             "namespace my_namespace {\n"
2057             "int i;\n"
2058             "} // my_namespace\n"
2059             "#endif // HEADER_GUARD",
2060             format("#ifndef HEADER_GUARD\n"
2061                    " #define HEADER_GUARD\n"
2062                    "   namespace my_namespace {\n"
2063                    "int i;\n"
2064                    "}    // my_namespace\n"
2065                    "#endif    // HEADER_GUARD",
2066                    LLVMWithNoNamespaceFix));
2067 
2068   EXPECT_EQ("namespace A::B {\n"
2069             "class C {};\n"
2070             "}",
2071             format("namespace A::B {\n"
2072                    "class C {};\n"
2073                    "}",
2074                    LLVMWithNoNamespaceFix));
2075 
2076   FormatStyle Style = getLLVMStyle();
2077   Style.NamespaceIndentation = FormatStyle::NI_All;
2078   EXPECT_EQ("namespace out {\n"
2079             "  int i;\n"
2080             "  namespace in {\n"
2081             "    int i;\n"
2082             "  } // namespace in\n"
2083             "} // namespace out",
2084             format("namespace out {\n"
2085                    "int i;\n"
2086                    "namespace in {\n"
2087                    "int i;\n"
2088                    "} // namespace in\n"
2089                    "} // namespace out",
2090                    Style));
2091 
2092   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2093   EXPECT_EQ("namespace out {\n"
2094             "int i;\n"
2095             "namespace in {\n"
2096             "  int i;\n"
2097             "} // namespace in\n"
2098             "} // namespace out",
2099             format("namespace out {\n"
2100                    "int i;\n"
2101                    "namespace in {\n"
2102                    "int i;\n"
2103                    "} // namespace in\n"
2104                    "} // namespace out",
2105                    Style));
2106 }
2107 
2108 TEST_F(FormatTest, NamespaceMacros) {
2109   FormatStyle Style = getLLVMStyle();
2110   Style.NamespaceMacros.push_back("TESTSUITE");
2111 
2112   verifyFormat("TESTSUITE(A) {\n"
2113                "int foo();\n"
2114                "} // TESTSUITE(A)",
2115                Style);
2116 
2117   verifyFormat("TESTSUITE(A, B) {\n"
2118                "int foo();\n"
2119                "} // TESTSUITE(A)",
2120                Style);
2121 
2122   // Properly indent according to NamespaceIndentation style
2123   Style.NamespaceIndentation = FormatStyle::NI_All;
2124   verifyFormat("TESTSUITE(A) {\n"
2125                "  int foo();\n"
2126                "} // TESTSUITE(A)",
2127                Style);
2128   verifyFormat("TESTSUITE(A) {\n"
2129                "  namespace B {\n"
2130                "    int foo();\n"
2131                "  } // namespace B\n"
2132                "} // TESTSUITE(A)",
2133                Style);
2134   verifyFormat("namespace A {\n"
2135                "  TESTSUITE(B) {\n"
2136                "    int foo();\n"
2137                "  } // TESTSUITE(B)\n"
2138                "} // namespace A",
2139                Style);
2140 
2141   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2142   verifyFormat("TESTSUITE(A) {\n"
2143                "TESTSUITE(B) {\n"
2144                "  int foo();\n"
2145                "} // TESTSUITE(B)\n"
2146                "} // TESTSUITE(A)",
2147                Style);
2148   verifyFormat("TESTSUITE(A) {\n"
2149                "namespace B {\n"
2150                "  int foo();\n"
2151                "} // namespace B\n"
2152                "} // TESTSUITE(A)",
2153                Style);
2154   verifyFormat("namespace A {\n"
2155                "TESTSUITE(B) {\n"
2156                "  int foo();\n"
2157                "} // TESTSUITE(B)\n"
2158                "} // namespace A",
2159                Style);
2160 
2161   // Properly merge namespace-macros blocks in CompactNamespaces mode
2162   Style.NamespaceIndentation = FormatStyle::NI_None;
2163   Style.CompactNamespaces = true;
2164   verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
2165                "}} // TESTSUITE(A::B)",
2166                Style);
2167 
2168   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2169             "}} // TESTSUITE(out::in)",
2170             format("TESTSUITE(out) {\n"
2171                    "TESTSUITE(in) {\n"
2172                    "} // TESTSUITE(in)\n"
2173                    "} // TESTSUITE(out)",
2174                    Style));
2175 
2176   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2177             "}} // TESTSUITE(out::in)",
2178             format("TESTSUITE(out) {\n"
2179                    "TESTSUITE(in) {\n"
2180                    "} // TESTSUITE(in)\n"
2181                    "} // TESTSUITE(out)",
2182                    Style));
2183 
2184   // Do not merge different namespaces/macros
2185   EXPECT_EQ("namespace out {\n"
2186             "TESTSUITE(in) {\n"
2187             "} // TESTSUITE(in)\n"
2188             "} // namespace out",
2189             format("namespace out {\n"
2190                    "TESTSUITE(in) {\n"
2191                    "} // TESTSUITE(in)\n"
2192                    "} // namespace out",
2193                    Style));
2194   EXPECT_EQ("TESTSUITE(out) {\n"
2195             "namespace in {\n"
2196             "} // namespace in\n"
2197             "} // TESTSUITE(out)",
2198             format("TESTSUITE(out) {\n"
2199                    "namespace in {\n"
2200                    "} // namespace in\n"
2201                    "} // TESTSUITE(out)",
2202                    Style));
2203   Style.NamespaceMacros.push_back("FOOBAR");
2204   EXPECT_EQ("TESTSUITE(out) {\n"
2205             "FOOBAR(in) {\n"
2206             "} // FOOBAR(in)\n"
2207             "} // TESTSUITE(out)",
2208             format("TESTSUITE(out) {\n"
2209                    "FOOBAR(in) {\n"
2210                    "} // FOOBAR(in)\n"
2211                    "} // TESTSUITE(out)",
2212                    Style));
2213 }
2214 
2215 TEST_F(FormatTest, FormatsCompactNamespaces) {
2216   FormatStyle Style = getLLVMStyle();
2217   Style.CompactNamespaces = true;
2218   Style.NamespaceMacros.push_back("TESTSUITE");
2219 
2220   verifyFormat("namespace A { namespace B {\n"
2221                "}} // namespace A::B",
2222                Style);
2223 
2224   EXPECT_EQ("namespace out { namespace in {\n"
2225             "}} // namespace out::in",
2226             format("namespace out {\n"
2227                    "namespace in {\n"
2228                    "} // namespace in\n"
2229                    "} // namespace out",
2230                    Style));
2231 
2232   // Only namespaces which have both consecutive opening and end get compacted
2233   EXPECT_EQ("namespace out {\n"
2234             "namespace in1 {\n"
2235             "} // namespace in1\n"
2236             "namespace in2 {\n"
2237             "} // namespace in2\n"
2238             "} // namespace out",
2239             format("namespace out {\n"
2240                    "namespace in1 {\n"
2241                    "} // namespace in1\n"
2242                    "namespace in2 {\n"
2243                    "} // namespace in2\n"
2244                    "} // namespace out",
2245                    Style));
2246 
2247   EXPECT_EQ("namespace out {\n"
2248             "int i;\n"
2249             "namespace in {\n"
2250             "int j;\n"
2251             "} // namespace in\n"
2252             "int k;\n"
2253             "} // namespace out",
2254             format("namespace out { int i;\n"
2255                    "namespace in { int j; } // namespace in\n"
2256                    "int k; } // namespace out",
2257                    Style));
2258 
2259   EXPECT_EQ("namespace A { namespace B { namespace C {\n"
2260             "}}} // namespace A::B::C\n",
2261             format("namespace A { namespace B {\n"
2262                    "namespace C {\n"
2263                    "}} // namespace B::C\n"
2264                    "} // namespace A\n",
2265                    Style));
2266 
2267   Style.ColumnLimit = 40;
2268   EXPECT_EQ("namespace aaaaaaaaaa {\n"
2269             "namespace bbbbbbbbbb {\n"
2270             "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
2271             format("namespace aaaaaaaaaa {\n"
2272                    "namespace bbbbbbbbbb {\n"
2273                    "} // namespace bbbbbbbbbb\n"
2274                    "} // namespace aaaaaaaaaa",
2275                    Style));
2276 
2277   EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
2278             "namespace cccccc {\n"
2279             "}}} // namespace aaaaaa::bbbbbb::cccccc",
2280             format("namespace aaaaaa {\n"
2281                    "namespace bbbbbb {\n"
2282                    "namespace cccccc {\n"
2283                    "} // namespace cccccc\n"
2284                    "} // namespace bbbbbb\n"
2285                    "} // namespace aaaaaa",
2286                    Style));
2287   Style.ColumnLimit = 80;
2288 
2289   // Extra semicolon after 'inner' closing brace prevents merging
2290   EXPECT_EQ("namespace out { namespace in {\n"
2291             "}; } // namespace out::in",
2292             format("namespace out {\n"
2293                    "namespace in {\n"
2294                    "}; // namespace in\n"
2295                    "} // namespace out",
2296                    Style));
2297 
2298   // Extra semicolon after 'outer' closing brace is conserved
2299   EXPECT_EQ("namespace out { namespace in {\n"
2300             "}}; // namespace out::in",
2301             format("namespace out {\n"
2302                    "namespace in {\n"
2303                    "} // namespace in\n"
2304                    "}; // namespace out",
2305                    Style));
2306 
2307   Style.NamespaceIndentation = FormatStyle::NI_All;
2308   EXPECT_EQ("namespace out { namespace in {\n"
2309             "  int i;\n"
2310             "}} // namespace out::in",
2311             format("namespace out {\n"
2312                    "namespace in {\n"
2313                    "int i;\n"
2314                    "} // namespace in\n"
2315                    "} // namespace out",
2316                    Style));
2317   EXPECT_EQ("namespace out { namespace mid {\n"
2318             "  namespace in {\n"
2319             "    int j;\n"
2320             "  } // namespace in\n"
2321             "  int k;\n"
2322             "}} // namespace out::mid",
2323             format("namespace out { namespace mid {\n"
2324                    "namespace in { int j; } // namespace in\n"
2325                    "int k; }} // namespace out::mid",
2326                    Style));
2327 
2328   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2329   EXPECT_EQ("namespace out { namespace in {\n"
2330             "  int i;\n"
2331             "}} // namespace out::in",
2332             format("namespace out {\n"
2333                    "namespace in {\n"
2334                    "int i;\n"
2335                    "} // namespace in\n"
2336                    "} // namespace out",
2337                    Style));
2338   EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
2339             "  int i;\n"
2340             "}}} // namespace out::mid::in",
2341             format("namespace out {\n"
2342                    "namespace mid {\n"
2343                    "namespace in {\n"
2344                    "int i;\n"
2345                    "} // namespace in\n"
2346                    "} // namespace mid\n"
2347                    "} // namespace out",
2348                    Style));
2349 }
2350 
2351 TEST_F(FormatTest, FormatsExternC) {
2352   verifyFormat("extern \"C\" {\nint a;");
2353   verifyFormat("extern \"C\" {}");
2354   verifyFormat("extern \"C\" {\n"
2355                "int foo();\n"
2356                "}");
2357   verifyFormat("extern \"C\" int foo() {}");
2358   verifyFormat("extern \"C\" int foo();");
2359   verifyFormat("extern \"C\" int foo() {\n"
2360                "  int i = 42;\n"
2361                "  return i;\n"
2362                "}");
2363 
2364   FormatStyle Style = getLLVMStyle();
2365   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2366   Style.BraceWrapping.AfterFunction = true;
2367   verifyFormat("extern \"C\" int foo() {}", Style);
2368   verifyFormat("extern \"C\" int foo();", Style);
2369   verifyFormat("extern \"C\" int foo()\n"
2370                "{\n"
2371                "  int i = 42;\n"
2372                "  return i;\n"
2373                "}",
2374                Style);
2375 
2376   Style.BraceWrapping.AfterExternBlock = true;
2377   Style.BraceWrapping.SplitEmptyRecord = false;
2378   verifyFormat("extern \"C\"\n"
2379                "{}",
2380                Style);
2381   verifyFormat("extern \"C\"\n"
2382                "{\n"
2383                "  int foo();\n"
2384                "}",
2385                Style);
2386 }
2387 
2388 TEST_F(FormatTest, FormatsInlineASM) {
2389   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
2390   verifyFormat("asm(\"nop\" ::: \"memory\");");
2391   verifyFormat(
2392       "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
2393       "    \"cpuid\\n\\t\"\n"
2394       "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
2395       "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
2396       "    : \"a\"(value));");
2397   EXPECT_EQ(
2398       "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
2399       "  __asm {\n"
2400       "        mov     edx,[that] // vtable in edx\n"
2401       "        mov     eax,methodIndex\n"
2402       "        call    [edx][eax*4] // stdcall\n"
2403       "  }\n"
2404       "}",
2405       format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
2406              "    __asm {\n"
2407              "        mov     edx,[that] // vtable in edx\n"
2408              "        mov     eax,methodIndex\n"
2409              "        call    [edx][eax*4] // stdcall\n"
2410              "    }\n"
2411              "}"));
2412   EXPECT_EQ("_asm {\n"
2413             "  xor eax, eax;\n"
2414             "  cpuid;\n"
2415             "}",
2416             format("_asm {\n"
2417                    "  xor eax, eax;\n"
2418                    "  cpuid;\n"
2419                    "}"));
2420   verifyFormat("void function() {\n"
2421                "  // comment\n"
2422                "  asm(\"\");\n"
2423                "}");
2424   EXPECT_EQ("__asm {\n"
2425             "}\n"
2426             "int i;",
2427             format("__asm   {\n"
2428                    "}\n"
2429                    "int   i;"));
2430 }
2431 
2432 TEST_F(FormatTest, FormatTryCatch) {
2433   verifyFormat("try {\n"
2434                "  throw a * b;\n"
2435                "} catch (int a) {\n"
2436                "  // Do nothing.\n"
2437                "} catch (...) {\n"
2438                "  exit(42);\n"
2439                "}");
2440 
2441   // Function-level try statements.
2442   verifyFormat("int f() try { return 4; } catch (...) {\n"
2443                "  return 5;\n"
2444                "}");
2445   verifyFormat("class A {\n"
2446                "  int a;\n"
2447                "  A() try : a(0) {\n"
2448                "  } catch (...) {\n"
2449                "    throw;\n"
2450                "  }\n"
2451                "};\n");
2452 
2453   // Incomplete try-catch blocks.
2454   verifyIncompleteFormat("try {} catch (");
2455 }
2456 
2457 TEST_F(FormatTest, FormatSEHTryCatch) {
2458   verifyFormat("__try {\n"
2459                "  int a = b * c;\n"
2460                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2461                "  // Do nothing.\n"
2462                "}");
2463 
2464   verifyFormat("__try {\n"
2465                "  int a = b * c;\n"
2466                "} __finally {\n"
2467                "  // Do nothing.\n"
2468                "}");
2469 
2470   verifyFormat("DEBUG({\n"
2471                "  __try {\n"
2472                "  } __finally {\n"
2473                "  }\n"
2474                "});\n");
2475 }
2476 
2477 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2478   verifyFormat("try {\n"
2479                "  f();\n"
2480                "} catch {\n"
2481                "  g();\n"
2482                "}");
2483   verifyFormat("try {\n"
2484                "  f();\n"
2485                "} catch (A a) MACRO(x) {\n"
2486                "  g();\n"
2487                "} catch (B b) MACRO(x) {\n"
2488                "  g();\n"
2489                "}");
2490 }
2491 
2492 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2493   FormatStyle Style = getLLVMStyle();
2494   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2495                           FormatStyle::BS_WebKit}) {
2496     Style.BreakBeforeBraces = BraceStyle;
2497     verifyFormat("try {\n"
2498                  "  // something\n"
2499                  "} catch (...) {\n"
2500                  "  // something\n"
2501                  "}",
2502                  Style);
2503   }
2504   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2505   verifyFormat("try {\n"
2506                "  // something\n"
2507                "}\n"
2508                "catch (...) {\n"
2509                "  // something\n"
2510                "}",
2511                Style);
2512   verifyFormat("__try {\n"
2513                "  // something\n"
2514                "}\n"
2515                "__finally {\n"
2516                "  // something\n"
2517                "}",
2518                Style);
2519   verifyFormat("@try {\n"
2520                "  // something\n"
2521                "}\n"
2522                "@finally {\n"
2523                "  // something\n"
2524                "}",
2525                Style);
2526   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2527   verifyFormat("try\n"
2528                "{\n"
2529                "  // something\n"
2530                "}\n"
2531                "catch (...)\n"
2532                "{\n"
2533                "  // something\n"
2534                "}",
2535                Style);
2536   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2537   verifyFormat("try\n"
2538                "  {\n"
2539                "  // something white\n"
2540                "  }\n"
2541                "catch (...)\n"
2542                "  {\n"
2543                "  // something white\n"
2544                "  }",
2545                Style);
2546   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2547   verifyFormat("try\n"
2548                "  {\n"
2549                "    // something\n"
2550                "  }\n"
2551                "catch (...)\n"
2552                "  {\n"
2553                "    // something\n"
2554                "  }",
2555                Style);
2556   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2557   Style.BraceWrapping.BeforeCatch = true;
2558   verifyFormat("try {\n"
2559                "  // something\n"
2560                "}\n"
2561                "catch (...) {\n"
2562                "  // something\n"
2563                "}",
2564                Style);
2565 }
2566 
2567 TEST_F(FormatTest, StaticInitializers) {
2568   verifyFormat("static SomeClass SC = {1, 'a'};");
2569 
2570   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2571                "    100000000, "
2572                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2573 
2574   // Here, everything other than the "}" would fit on a line.
2575   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2576                "    10000000000000000000000000};");
2577   EXPECT_EQ("S s = {a,\n"
2578             "\n"
2579             "       b};",
2580             format("S s = {\n"
2581                    "  a,\n"
2582                    "\n"
2583                    "  b\n"
2584                    "};"));
2585 
2586   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2587   // line. However, the formatting looks a bit off and this probably doesn't
2588   // happen often in practice.
2589   verifyFormat("static int Variable[1] = {\n"
2590                "    {1000000000000000000000000000000000000}};",
2591                getLLVMStyleWithColumns(40));
2592 }
2593 
2594 TEST_F(FormatTest, DesignatedInitializers) {
2595   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2596   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2597                "                    .bbbbbbbbbb = 2,\n"
2598                "                    .cccccccccc = 3,\n"
2599                "                    .dddddddddd = 4,\n"
2600                "                    .eeeeeeeeee = 5};");
2601   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2602                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2603                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2604                "    .ccccccccccccccccccccccccccc = 3,\n"
2605                "    .ddddddddddddddddddddddddddd = 4,\n"
2606                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2607 
2608   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2609 
2610   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2611   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2612                "                    [2] = bbbbbbbbbb,\n"
2613                "                    [3] = cccccccccc,\n"
2614                "                    [4] = dddddddddd,\n"
2615                "                    [5] = eeeeeeeeee};");
2616   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2617                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2618                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2619                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2620                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2621                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2622 }
2623 
2624 TEST_F(FormatTest, NestedStaticInitializers) {
2625   verifyFormat("static A x = {{{}}};\n");
2626   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2627                "               {init1, init2, init3, init4}}};",
2628                getLLVMStyleWithColumns(50));
2629 
2630   verifyFormat("somes Status::global_reps[3] = {\n"
2631                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2632                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2633                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2634                getLLVMStyleWithColumns(60));
2635   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2636                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2637                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2638                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2639   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2640                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
2641                "rect.fTop}};");
2642 
2643   verifyFormat(
2644       "SomeArrayOfSomeType a = {\n"
2645       "    {{1, 2, 3},\n"
2646       "     {1, 2, 3},\n"
2647       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
2648       "      333333333333333333333333333333},\n"
2649       "     {1, 2, 3},\n"
2650       "     {1, 2, 3}}};");
2651   verifyFormat(
2652       "SomeArrayOfSomeType a = {\n"
2653       "    {{1, 2, 3}},\n"
2654       "    {{1, 2, 3}},\n"
2655       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2656       "      333333333333333333333333333333}},\n"
2657       "    {{1, 2, 3}},\n"
2658       "    {{1, 2, 3}}};");
2659 
2660   verifyFormat("struct {\n"
2661                "  unsigned bit;\n"
2662                "  const char *const name;\n"
2663                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2664                "                 {kOsWin, \"Windows\"},\n"
2665                "                 {kOsLinux, \"Linux\"},\n"
2666                "                 {kOsCrOS, \"Chrome OS\"}};");
2667   verifyFormat("struct {\n"
2668                "  unsigned bit;\n"
2669                "  const char *const name;\n"
2670                "} kBitsToOs[] = {\n"
2671                "    {kOsMac, \"Mac\"},\n"
2672                "    {kOsWin, \"Windows\"},\n"
2673                "    {kOsLinux, \"Linux\"},\n"
2674                "    {kOsCrOS, \"Chrome OS\"},\n"
2675                "};");
2676 }
2677 
2678 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
2679   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
2680                "                      \\\n"
2681                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
2682 }
2683 
2684 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
2685   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
2686                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
2687 
2688   // Do break defaulted and deleted functions.
2689   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2690                "    default;",
2691                getLLVMStyleWithColumns(40));
2692   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
2693                "    delete;",
2694                getLLVMStyleWithColumns(40));
2695 }
2696 
2697 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
2698   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
2699                getLLVMStyleWithColumns(40));
2700   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2701                getLLVMStyleWithColumns(40));
2702   EXPECT_EQ("#define Q                              \\\n"
2703             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
2704             "  \"aaaaaaaa.cpp\"",
2705             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
2706                    getLLVMStyleWithColumns(40)));
2707 }
2708 
2709 TEST_F(FormatTest, UnderstandsLinePPDirective) {
2710   EXPECT_EQ("# 123 \"A string literal\"",
2711             format("   #     123    \"A string literal\""));
2712 }
2713 
2714 TEST_F(FormatTest, LayoutUnknownPPDirective) {
2715   EXPECT_EQ("#;", format("#;"));
2716   verifyFormat("#\n;\n;\n;");
2717 }
2718 
2719 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
2720   EXPECT_EQ("#line 42 \"test\"\n",
2721             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
2722   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
2723                                     getLLVMStyleWithColumns(12)));
2724 }
2725 
2726 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
2727   EXPECT_EQ("#line 42 \"test\"",
2728             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
2729   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
2730 }
2731 
2732 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
2733   verifyFormat("#define A \\x20");
2734   verifyFormat("#define A \\ x20");
2735   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
2736   verifyFormat("#define A ''");
2737   verifyFormat("#define A ''qqq");
2738   verifyFormat("#define A `qqq");
2739   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
2740   EXPECT_EQ("const char *c = STRINGIFY(\n"
2741             "\\na : b);",
2742             format("const char * c = STRINGIFY(\n"
2743                    "\\na : b);"));
2744 
2745   verifyFormat("a\r\\");
2746   verifyFormat("a\v\\");
2747   verifyFormat("a\f\\");
2748 }
2749 
2750 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
2751   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
2752   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
2753   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
2754   // FIXME: We never break before the macro name.
2755   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
2756 
2757   verifyFormat("#define A A\n#define A A");
2758   verifyFormat("#define A(X) A\n#define A A");
2759 
2760   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
2761   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
2762 }
2763 
2764 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
2765   EXPECT_EQ("// somecomment\n"
2766             "#include \"a.h\"\n"
2767             "#define A(  \\\n"
2768             "    A, B)\n"
2769             "#include \"b.h\"\n"
2770             "// somecomment\n",
2771             format("  // somecomment\n"
2772                    "  #include \"a.h\"\n"
2773                    "#define A(A,\\\n"
2774                    "    B)\n"
2775                    "    #include \"b.h\"\n"
2776                    " // somecomment\n",
2777                    getLLVMStyleWithColumns(13)));
2778 }
2779 
2780 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
2781 
2782 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
2783   EXPECT_EQ("#define A    \\\n"
2784             "  c;         \\\n"
2785             "  e;\n"
2786             "f;",
2787             format("#define A c; e;\n"
2788                    "f;",
2789                    getLLVMStyleWithColumns(14)));
2790 }
2791 
2792 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
2793 
2794 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
2795   EXPECT_EQ("int x,\n"
2796             "#define A\n"
2797             "    y;",
2798             format("int x,\n#define A\ny;"));
2799 }
2800 
2801 TEST_F(FormatTest, HashInMacroDefinition) {
2802   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
2803   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
2804   verifyFormat("#define A  \\\n"
2805                "  {        \\\n"
2806                "    f(#c); \\\n"
2807                "  }",
2808                getLLVMStyleWithColumns(11));
2809 
2810   verifyFormat("#define A(X)         \\\n"
2811                "  void function##X()",
2812                getLLVMStyleWithColumns(22));
2813 
2814   verifyFormat("#define A(a, b, c)   \\\n"
2815                "  void a##b##c()",
2816                getLLVMStyleWithColumns(22));
2817 
2818   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
2819 }
2820 
2821 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
2822   EXPECT_EQ("#define A (x)", format("#define A (x)"));
2823   EXPECT_EQ("#define A(x)", format("#define A(x)"));
2824 
2825   FormatStyle Style = getLLVMStyle();
2826   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
2827   verifyFormat("#define true ((foo)1)", Style);
2828   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
2829   verifyFormat("#define false((foo)0)", Style);
2830 }
2831 
2832 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
2833   EXPECT_EQ("#define A b;", format("#define A \\\n"
2834                                    "          \\\n"
2835                                    "  b;",
2836                                    getLLVMStyleWithColumns(25)));
2837   EXPECT_EQ("#define A \\\n"
2838             "          \\\n"
2839             "  a;      \\\n"
2840             "  b;",
2841             format("#define A \\\n"
2842                    "          \\\n"
2843                    "  a;      \\\n"
2844                    "  b;",
2845                    getLLVMStyleWithColumns(11)));
2846   EXPECT_EQ("#define A \\\n"
2847             "  a;      \\\n"
2848             "          \\\n"
2849             "  b;",
2850             format("#define A \\\n"
2851                    "  a;      \\\n"
2852                    "          \\\n"
2853                    "  b;",
2854                    getLLVMStyleWithColumns(11)));
2855 }
2856 
2857 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
2858   verifyIncompleteFormat("#define A :");
2859   verifyFormat("#define SOMECASES  \\\n"
2860                "  case 1:          \\\n"
2861                "  case 2\n",
2862                getLLVMStyleWithColumns(20));
2863   verifyFormat("#define MACRO(a) \\\n"
2864                "  if (a)         \\\n"
2865                "    f();         \\\n"
2866                "  else           \\\n"
2867                "    g()",
2868                getLLVMStyleWithColumns(18));
2869   verifyFormat("#define A template <typename T>");
2870   verifyIncompleteFormat("#define STR(x) #x\n"
2871                          "f(STR(this_is_a_string_literal{));");
2872   verifyFormat("#pragma omp threadprivate( \\\n"
2873                "    y)), // expected-warning",
2874                getLLVMStyleWithColumns(28));
2875   verifyFormat("#d, = };");
2876   verifyFormat("#if \"a");
2877   verifyIncompleteFormat("({\n"
2878                          "#define b     \\\n"
2879                          "  }           \\\n"
2880                          "  a\n"
2881                          "a",
2882                          getLLVMStyleWithColumns(15));
2883   verifyFormat("#define A     \\\n"
2884                "  {           \\\n"
2885                "    {\n"
2886                "#define B     \\\n"
2887                "  }           \\\n"
2888                "  }",
2889                getLLVMStyleWithColumns(15));
2890   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
2891   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
2892   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
2893   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
2894 }
2895 
2896 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
2897   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
2898   EXPECT_EQ("class A : public QObject {\n"
2899             "  Q_OBJECT\n"
2900             "\n"
2901             "  A() {}\n"
2902             "};",
2903             format("class A  :  public QObject {\n"
2904                    "     Q_OBJECT\n"
2905                    "\n"
2906                    "  A() {\n}\n"
2907                    "}  ;"));
2908   EXPECT_EQ("MACRO\n"
2909             "/*static*/ int i;",
2910             format("MACRO\n"
2911                    " /*static*/ int   i;"));
2912   EXPECT_EQ("SOME_MACRO\n"
2913             "namespace {\n"
2914             "void f();\n"
2915             "} // namespace",
2916             format("SOME_MACRO\n"
2917                    "  namespace    {\n"
2918                    "void   f(  );\n"
2919                    "} // namespace"));
2920   // Only if the identifier contains at least 5 characters.
2921   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
2922   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
2923   // Only if everything is upper case.
2924   EXPECT_EQ("class A : public QObject {\n"
2925             "  Q_Object A() {}\n"
2926             "};",
2927             format("class A  :  public QObject {\n"
2928                    "     Q_Object\n"
2929                    "  A() {\n}\n"
2930                    "}  ;"));
2931 
2932   // Only if the next line can actually start an unwrapped line.
2933   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
2934             format("SOME_WEIRD_LOG_MACRO\n"
2935                    "<< SomeThing;"));
2936 
2937   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
2938                "(n, buffers))\n",
2939                getChromiumStyle(FormatStyle::LK_Cpp));
2940 
2941   // See PR41483
2942   EXPECT_EQ("/**/ FOO(a)\n"
2943             "FOO(b)",
2944             format("/**/ FOO(a)\n"
2945                    "FOO(b)"));
2946 }
2947 
2948 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
2949   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2950             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2951             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
2952             "class X {};\n"
2953             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2954             "int *createScopDetectionPass() { return 0; }",
2955             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
2956                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
2957                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
2958                    "  class X {};\n"
2959                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
2960                    "  int *createScopDetectionPass() { return 0; }"));
2961   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
2962   // braces, so that inner block is indented one level more.
2963   EXPECT_EQ("int q() {\n"
2964             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2965             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2966             "  IPC_END_MESSAGE_MAP()\n"
2967             "}",
2968             format("int q() {\n"
2969                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
2970                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
2971                    "  IPC_END_MESSAGE_MAP()\n"
2972                    "}"));
2973 
2974   // Same inside macros.
2975   EXPECT_EQ("#define LIST(L) \\\n"
2976             "  L(A)          \\\n"
2977             "  L(B)          \\\n"
2978             "  L(C)",
2979             format("#define LIST(L) \\\n"
2980                    "  L(A) \\\n"
2981                    "  L(B) \\\n"
2982                    "  L(C)",
2983                    getGoogleStyle()));
2984 
2985   // These must not be recognized as macros.
2986   EXPECT_EQ("int q() {\n"
2987             "  f(x);\n"
2988             "  f(x) {}\n"
2989             "  f(x)->g();\n"
2990             "  f(x)->*g();\n"
2991             "  f(x).g();\n"
2992             "  f(x) = x;\n"
2993             "  f(x) += x;\n"
2994             "  f(x) -= x;\n"
2995             "  f(x) *= x;\n"
2996             "  f(x) /= x;\n"
2997             "  f(x) %= x;\n"
2998             "  f(x) &= x;\n"
2999             "  f(x) |= x;\n"
3000             "  f(x) ^= x;\n"
3001             "  f(x) >>= x;\n"
3002             "  f(x) <<= x;\n"
3003             "  f(x)[y].z();\n"
3004             "  LOG(INFO) << x;\n"
3005             "  ifstream(x) >> x;\n"
3006             "}\n",
3007             format("int q() {\n"
3008                    "  f(x)\n;\n"
3009                    "  f(x)\n {}\n"
3010                    "  f(x)\n->g();\n"
3011                    "  f(x)\n->*g();\n"
3012                    "  f(x)\n.g();\n"
3013                    "  f(x)\n = x;\n"
3014                    "  f(x)\n += x;\n"
3015                    "  f(x)\n -= x;\n"
3016                    "  f(x)\n *= x;\n"
3017                    "  f(x)\n /= x;\n"
3018                    "  f(x)\n %= x;\n"
3019                    "  f(x)\n &= x;\n"
3020                    "  f(x)\n |= x;\n"
3021                    "  f(x)\n ^= x;\n"
3022                    "  f(x)\n >>= x;\n"
3023                    "  f(x)\n <<= x;\n"
3024                    "  f(x)\n[y].z();\n"
3025                    "  LOG(INFO)\n << x;\n"
3026                    "  ifstream(x)\n >> x;\n"
3027                    "}\n"));
3028   EXPECT_EQ("int q() {\n"
3029             "  F(x)\n"
3030             "  if (1) {\n"
3031             "  }\n"
3032             "  F(x)\n"
3033             "  while (1) {\n"
3034             "  }\n"
3035             "  F(x)\n"
3036             "  G(x);\n"
3037             "  F(x)\n"
3038             "  try {\n"
3039             "    Q();\n"
3040             "  } catch (...) {\n"
3041             "  }\n"
3042             "}\n",
3043             format("int q() {\n"
3044                    "F(x)\n"
3045                    "if (1) {}\n"
3046                    "F(x)\n"
3047                    "while (1) {}\n"
3048                    "F(x)\n"
3049                    "G(x);\n"
3050                    "F(x)\n"
3051                    "try { Q(); } catch (...) {}\n"
3052                    "}\n"));
3053   EXPECT_EQ("class A {\n"
3054             "  A() : t(0) {}\n"
3055             "  A(int i) noexcept() : {}\n"
3056             "  A(X x)\n" // FIXME: function-level try blocks are broken.
3057             "  try : t(0) {\n"
3058             "  } catch (...) {\n"
3059             "  }\n"
3060             "};",
3061             format("class A {\n"
3062                    "  A()\n : t(0) {}\n"
3063                    "  A(int i)\n noexcept() : {}\n"
3064                    "  A(X x)\n"
3065                    "  try : t(0) {} catch (...) {}\n"
3066                    "};"));
3067   FormatStyle Style = getLLVMStyle();
3068   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3069   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3070   Style.BraceWrapping.AfterFunction = true;
3071   EXPECT_EQ("void f()\n"
3072             "try\n"
3073             "{\n"
3074             "}",
3075             format("void f() try {\n"
3076                    "}",
3077                    Style));
3078   EXPECT_EQ("class SomeClass {\n"
3079             "public:\n"
3080             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3081             "};",
3082             format("class SomeClass {\n"
3083                    "public:\n"
3084                    "  SomeClass()\n"
3085                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3086                    "};"));
3087   EXPECT_EQ("class SomeClass {\n"
3088             "public:\n"
3089             "  SomeClass()\n"
3090             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3091             "};",
3092             format("class SomeClass {\n"
3093                    "public:\n"
3094                    "  SomeClass()\n"
3095                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3096                    "};",
3097                    getLLVMStyleWithColumns(40)));
3098 
3099   verifyFormat("MACRO(>)");
3100 
3101   // Some macros contain an implicit semicolon.
3102   Style = getLLVMStyle();
3103   Style.StatementMacros.push_back("FOO");
3104   verifyFormat("FOO(a) int b = 0;");
3105   verifyFormat("FOO(a)\n"
3106                "int b = 0;",
3107                Style);
3108   verifyFormat("FOO(a);\n"
3109                "int b = 0;",
3110                Style);
3111   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3112                "int b = 0;",
3113                Style);
3114   verifyFormat("FOO()\n"
3115                "int b = 0;",
3116                Style);
3117   verifyFormat("FOO\n"
3118                "int b = 0;",
3119                Style);
3120   verifyFormat("void f() {\n"
3121                "  FOO(a)\n"
3122                "  return a;\n"
3123                "}",
3124                Style);
3125   verifyFormat("FOO(a)\n"
3126                "FOO(b)",
3127                Style);
3128   verifyFormat("int a = 0;\n"
3129                "FOO(b)\n"
3130                "int c = 0;",
3131                Style);
3132   verifyFormat("int a = 0;\n"
3133                "int x = FOO(a)\n"
3134                "int b = 0;",
3135                Style);
3136   verifyFormat("void foo(int a) { FOO(a) }\n"
3137                "uint32_t bar() {}",
3138                Style);
3139 }
3140 
3141 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3142   verifyFormat("#define A \\\n"
3143                "  f({     \\\n"
3144                "    g();  \\\n"
3145                "  });",
3146                getLLVMStyleWithColumns(11));
3147 }
3148 
3149 TEST_F(FormatTest, IndentPreprocessorDirectives) {
3150   FormatStyle Style = getLLVMStyle();
3151   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3152   Style.ColumnLimit = 40;
3153   verifyFormat("#ifdef _WIN32\n"
3154                "#define A 0\n"
3155                "#ifdef VAR2\n"
3156                "#define B 1\n"
3157                "#include <someheader.h>\n"
3158                "#define MACRO                          \\\n"
3159                "  some_very_long_func_aaaaaaaaaa();\n"
3160                "#endif\n"
3161                "#else\n"
3162                "#define A 1\n"
3163                "#endif",
3164                Style);
3165   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3166   verifyFormat("#ifdef _WIN32\n"
3167                "#  define A 0\n"
3168                "#  ifdef VAR2\n"
3169                "#    define B 1\n"
3170                "#    include <someheader.h>\n"
3171                "#    define MACRO                      \\\n"
3172                "      some_very_long_func_aaaaaaaaaa();\n"
3173                "#  endif\n"
3174                "#else\n"
3175                "#  define A 1\n"
3176                "#endif",
3177                Style);
3178   verifyFormat("#if A\n"
3179                "#  define MACRO                        \\\n"
3180                "    void a(int x) {                    \\\n"
3181                "      b();                             \\\n"
3182                "      c();                             \\\n"
3183                "      d();                             \\\n"
3184                "      e();                             \\\n"
3185                "      f();                             \\\n"
3186                "    }\n"
3187                "#endif",
3188                Style);
3189   // Comments before include guard.
3190   verifyFormat("// file comment\n"
3191                "// file comment\n"
3192                "#ifndef HEADER_H\n"
3193                "#define HEADER_H\n"
3194                "code();\n"
3195                "#endif",
3196                Style);
3197   // Test with include guards.
3198   verifyFormat("#ifndef HEADER_H\n"
3199                "#define HEADER_H\n"
3200                "code();\n"
3201                "#endif",
3202                Style);
3203   // Include guards must have a #define with the same variable immediately
3204   // after #ifndef.
3205   verifyFormat("#ifndef NOT_GUARD\n"
3206                "#  define FOO\n"
3207                "code();\n"
3208                "#endif",
3209                Style);
3210 
3211   // Include guards must cover the entire file.
3212   verifyFormat("code();\n"
3213                "code();\n"
3214                "#ifndef NOT_GUARD\n"
3215                "#  define NOT_GUARD\n"
3216                "code();\n"
3217                "#endif",
3218                Style);
3219   verifyFormat("#ifndef NOT_GUARD\n"
3220                "#  define NOT_GUARD\n"
3221                "code();\n"
3222                "#endif\n"
3223                "code();",
3224                Style);
3225   // Test with trailing blank lines.
3226   verifyFormat("#ifndef HEADER_H\n"
3227                "#define HEADER_H\n"
3228                "code();\n"
3229                "#endif\n",
3230                Style);
3231   // Include guards don't have #else.
3232   verifyFormat("#ifndef NOT_GUARD\n"
3233                "#  define NOT_GUARD\n"
3234                "code();\n"
3235                "#else\n"
3236                "#endif",
3237                Style);
3238   verifyFormat("#ifndef NOT_GUARD\n"
3239                "#  define NOT_GUARD\n"
3240                "code();\n"
3241                "#elif FOO\n"
3242                "#endif",
3243                Style);
3244   // Non-identifier #define after potential include guard.
3245   verifyFormat("#ifndef FOO\n"
3246                "#  define 1\n"
3247                "#endif\n",
3248                Style);
3249   // #if closes past last non-preprocessor line.
3250   verifyFormat("#ifndef FOO\n"
3251                "#define FOO\n"
3252                "#if 1\n"
3253                "int i;\n"
3254                "#  define A 0\n"
3255                "#endif\n"
3256                "#endif\n",
3257                Style);
3258   // Don't crash if there is an #elif directive without a condition.
3259   verifyFormat("#if 1\n"
3260                "int x;\n"
3261                "#elif\n"
3262                "int y;\n"
3263                "#else\n"
3264                "int z;\n"
3265                "#endif",
3266                Style);
3267   // FIXME: This doesn't handle the case where there's code between the
3268   // #ifndef and #define but all other conditions hold. This is because when
3269   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3270   // previous code line yet, so we can't detect it.
3271   EXPECT_EQ("#ifndef NOT_GUARD\n"
3272             "code();\n"
3273             "#define NOT_GUARD\n"
3274             "code();\n"
3275             "#endif",
3276             format("#ifndef NOT_GUARD\n"
3277                    "code();\n"
3278                    "#  define NOT_GUARD\n"
3279                    "code();\n"
3280                    "#endif",
3281                    Style));
3282   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3283   // be outside an include guard. Examples are #pragma once and
3284   // #pragma GCC diagnostic, or anything else that does not change the meaning
3285   // of the file if it's included multiple times.
3286   EXPECT_EQ("#ifdef WIN32\n"
3287             "#  pragma once\n"
3288             "#endif\n"
3289             "#ifndef HEADER_H\n"
3290             "#  define HEADER_H\n"
3291             "code();\n"
3292             "#endif",
3293             format("#ifdef WIN32\n"
3294                    "#  pragma once\n"
3295                    "#endif\n"
3296                    "#ifndef HEADER_H\n"
3297                    "#define HEADER_H\n"
3298                    "code();\n"
3299                    "#endif",
3300                    Style));
3301   // FIXME: This does not detect when there is a single non-preprocessor line
3302   // in front of an include-guard-like structure where other conditions hold
3303   // because ScopedLineState hides the line.
3304   EXPECT_EQ("code();\n"
3305             "#ifndef HEADER_H\n"
3306             "#define HEADER_H\n"
3307             "code();\n"
3308             "#endif",
3309             format("code();\n"
3310                    "#ifndef HEADER_H\n"
3311                    "#  define HEADER_H\n"
3312                    "code();\n"
3313                    "#endif",
3314                    Style));
3315   // Keep comments aligned with #, otherwise indent comments normally. These
3316   // tests cannot use verifyFormat because messUp manipulates leading
3317   // whitespace.
3318   {
3319     const char *Expected = ""
3320                            "void f() {\n"
3321                            "#if 1\n"
3322                            "// Preprocessor aligned.\n"
3323                            "#  define A 0\n"
3324                            "  // Code. Separated by blank line.\n"
3325                            "\n"
3326                            "#  define B 0\n"
3327                            "  // Code. Not aligned with #\n"
3328                            "#  define C 0\n"
3329                            "#endif";
3330     const char *ToFormat = ""
3331                            "void f() {\n"
3332                            "#if 1\n"
3333                            "// Preprocessor aligned.\n"
3334                            "#  define A 0\n"
3335                            "// Code. Separated by blank line.\n"
3336                            "\n"
3337                            "#  define B 0\n"
3338                            "   // Code. Not aligned with #\n"
3339                            "#  define C 0\n"
3340                            "#endif";
3341     EXPECT_EQ(Expected, format(ToFormat, Style));
3342     EXPECT_EQ(Expected, format(Expected, Style));
3343   }
3344   // Keep block quotes aligned.
3345   {
3346     const char *Expected = ""
3347                            "void f() {\n"
3348                            "#if 1\n"
3349                            "/* Preprocessor aligned. */\n"
3350                            "#  define A 0\n"
3351                            "  /* Code. Separated by blank line. */\n"
3352                            "\n"
3353                            "#  define B 0\n"
3354                            "  /* Code. Not aligned with # */\n"
3355                            "#  define C 0\n"
3356                            "#endif";
3357     const char *ToFormat = ""
3358                            "void f() {\n"
3359                            "#if 1\n"
3360                            "/* Preprocessor aligned. */\n"
3361                            "#  define A 0\n"
3362                            "/* Code. Separated by blank line. */\n"
3363                            "\n"
3364                            "#  define B 0\n"
3365                            "   /* Code. Not aligned with # */\n"
3366                            "#  define C 0\n"
3367                            "#endif";
3368     EXPECT_EQ(Expected, format(ToFormat, Style));
3369     EXPECT_EQ(Expected, format(Expected, Style));
3370   }
3371   // Keep comments aligned with un-indented directives.
3372   {
3373     const char *Expected = ""
3374                            "void f() {\n"
3375                            "// Preprocessor aligned.\n"
3376                            "#define A 0\n"
3377                            "  // Code. Separated by blank line.\n"
3378                            "\n"
3379                            "#define B 0\n"
3380                            "  // Code. Not aligned with #\n"
3381                            "#define C 0\n";
3382     const char *ToFormat = ""
3383                            "void f() {\n"
3384                            "// Preprocessor aligned.\n"
3385                            "#define A 0\n"
3386                            "// Code. Separated by blank line.\n"
3387                            "\n"
3388                            "#define B 0\n"
3389                            "   // Code. Not aligned with #\n"
3390                            "#define C 0\n";
3391     EXPECT_EQ(Expected, format(ToFormat, Style));
3392     EXPECT_EQ(Expected, format(Expected, Style));
3393   }
3394   // Test AfterHash with tabs.
3395   {
3396     FormatStyle Tabbed = Style;
3397     Tabbed.UseTab = FormatStyle::UT_Always;
3398     Tabbed.IndentWidth = 8;
3399     Tabbed.TabWidth = 8;
3400     verifyFormat("#ifdef _WIN32\n"
3401                  "#\tdefine A 0\n"
3402                  "#\tifdef VAR2\n"
3403                  "#\t\tdefine B 1\n"
3404                  "#\t\tinclude <someheader.h>\n"
3405                  "#\t\tdefine MACRO          \\\n"
3406                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3407                  "#\tendif\n"
3408                  "#else\n"
3409                  "#\tdefine A 1\n"
3410                  "#endif",
3411                  Tabbed);
3412   }
3413 
3414   // Regression test: Multiline-macro inside include guards.
3415   verifyFormat("#ifndef HEADER_H\n"
3416                "#define HEADER_H\n"
3417                "#define A()        \\\n"
3418                "  int i;           \\\n"
3419                "  int j;\n"
3420                "#endif // HEADER_H",
3421                getLLVMStyleWithColumns(20));
3422 
3423   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3424   // Basic before hash indent tests
3425   verifyFormat("#ifdef _WIN32\n"
3426                "  #define A 0\n"
3427                "  #ifdef VAR2\n"
3428                "    #define B 1\n"
3429                "    #include <someheader.h>\n"
3430                "    #define MACRO                      \\\n"
3431                "      some_very_long_func_aaaaaaaaaa();\n"
3432                "  #endif\n"
3433                "#else\n"
3434                "  #define A 1\n"
3435                "#endif",
3436                Style);
3437   verifyFormat("#if A\n"
3438                "  #define MACRO                        \\\n"
3439                "    void a(int x) {                    \\\n"
3440                "      b();                             \\\n"
3441                "      c();                             \\\n"
3442                "      d();                             \\\n"
3443                "      e();                             \\\n"
3444                "      f();                             \\\n"
3445                "    }\n"
3446                "#endif",
3447                Style);
3448   // Keep comments aligned with indented directives. These
3449   // tests cannot use verifyFormat because messUp manipulates leading
3450   // whitespace.
3451   {
3452     const char *Expected = "void f() {\n"
3453                            "// Aligned to preprocessor.\n"
3454                            "#if 1\n"
3455                            "  // Aligned to code.\n"
3456                            "  int a;\n"
3457                            "  #if 1\n"
3458                            "    // Aligned to preprocessor.\n"
3459                            "    #define A 0\n"
3460                            "  // Aligned to code.\n"
3461                            "  int b;\n"
3462                            "  #endif\n"
3463                            "#endif\n"
3464                            "}";
3465     const char *ToFormat = "void f() {\n"
3466                            "// Aligned to preprocessor.\n"
3467                            "#if 1\n"
3468                            "// Aligned to code.\n"
3469                            "int a;\n"
3470                            "#if 1\n"
3471                            "// Aligned to preprocessor.\n"
3472                            "#define A 0\n"
3473                            "// Aligned to code.\n"
3474                            "int b;\n"
3475                            "#endif\n"
3476                            "#endif\n"
3477                            "}";
3478     EXPECT_EQ(Expected, format(ToFormat, Style));
3479     EXPECT_EQ(Expected, format(Expected, Style));
3480   }
3481   {
3482     const char *Expected = "void f() {\n"
3483                            "/* Aligned to preprocessor. */\n"
3484                            "#if 1\n"
3485                            "  /* Aligned to code. */\n"
3486                            "  int a;\n"
3487                            "  #if 1\n"
3488                            "    /* Aligned to preprocessor. */\n"
3489                            "    #define A 0\n"
3490                            "  /* Aligned to code. */\n"
3491                            "  int b;\n"
3492                            "  #endif\n"
3493                            "#endif\n"
3494                            "}";
3495     const char *ToFormat = "void f() {\n"
3496                            "/* Aligned to preprocessor. */\n"
3497                            "#if 1\n"
3498                            "/* Aligned to code. */\n"
3499                            "int a;\n"
3500                            "#if 1\n"
3501                            "/* Aligned to preprocessor. */\n"
3502                            "#define A 0\n"
3503                            "/* Aligned to code. */\n"
3504                            "int b;\n"
3505                            "#endif\n"
3506                            "#endif\n"
3507                            "}";
3508     EXPECT_EQ(Expected, format(ToFormat, Style));
3509     EXPECT_EQ(Expected, format(Expected, Style));
3510   }
3511 
3512   // Test single comment before preprocessor
3513   verifyFormat("// Comment\n"
3514                "\n"
3515                "#if 1\n"
3516                "#endif",
3517                Style);
3518 }
3519 
3520 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3521   verifyFormat("{\n  { a #c; }\n}");
3522 }
3523 
3524 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3525   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
3526             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3527   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
3528             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3529 }
3530 
3531 TEST_F(FormatTest, EscapedNewlines) {
3532   FormatStyle Narrow = getLLVMStyleWithColumns(11);
3533   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
3534             format("#define A \\\nint i;\\\n  int j;", Narrow));
3535   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3536   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3537   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
3538   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3539 
3540   FormatStyle AlignLeft = getLLVMStyle();
3541   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3542   EXPECT_EQ("#define MACRO(x) \\\n"
3543             "private:         \\\n"
3544             "  int x(int a);\n",
3545             format("#define MACRO(x) \\\n"
3546                    "private:         \\\n"
3547                    "  int x(int a);\n",
3548                    AlignLeft));
3549 
3550   // CRLF line endings
3551   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
3552             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
3553   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3554   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3555   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
3556   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3557   EXPECT_EQ("#define MACRO(x) \\\r\n"
3558             "private:         \\\r\n"
3559             "  int x(int a);\r\n",
3560             format("#define MACRO(x) \\\r\n"
3561                    "private:         \\\r\n"
3562                    "  int x(int a);\r\n",
3563                    AlignLeft));
3564 
3565   FormatStyle DontAlign = getLLVMStyle();
3566   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3567   DontAlign.MaxEmptyLinesToKeep = 3;
3568   // FIXME: can't use verifyFormat here because the newline before
3569   // "public:" is not inserted the first time it's reformatted
3570   EXPECT_EQ("#define A \\\n"
3571             "  class Foo { \\\n"
3572             "    void bar(); \\\n"
3573             "\\\n"
3574             "\\\n"
3575             "\\\n"
3576             "  public: \\\n"
3577             "    void baz(); \\\n"
3578             "  };",
3579             format("#define A \\\n"
3580                    "  class Foo { \\\n"
3581                    "    void bar(); \\\n"
3582                    "\\\n"
3583                    "\\\n"
3584                    "\\\n"
3585                    "  public: \\\n"
3586                    "    void baz(); \\\n"
3587                    "  };",
3588                    DontAlign));
3589 }
3590 
3591 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3592   verifyFormat("#define A \\\n"
3593                "  int v(  \\\n"
3594                "      a); \\\n"
3595                "  int i;",
3596                getLLVMStyleWithColumns(11));
3597 }
3598 
3599 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3600   EXPECT_EQ(
3601       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3602       "                      \\\n"
3603       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3604       "\n"
3605       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3606       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3607       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
3608              "\\\n"
3609              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3610              "  \n"
3611              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3612              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3613 }
3614 
3615 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3616   EXPECT_EQ("int\n"
3617             "#define A\n"
3618             "    a;",
3619             format("int\n#define A\na;"));
3620   verifyFormat("functionCallTo(\n"
3621                "    someOtherFunction(\n"
3622                "        withSomeParameters, whichInSequence,\n"
3623                "        areLongerThanALine(andAnotherCall,\n"
3624                "#define A B\n"
3625                "                           withMoreParamters,\n"
3626                "                           whichStronglyInfluenceTheLayout),\n"
3627                "        andMoreParameters),\n"
3628                "    trailing);",
3629                getLLVMStyleWithColumns(69));
3630   verifyFormat("Foo::Foo()\n"
3631                "#ifdef BAR\n"
3632                "    : baz(0)\n"
3633                "#endif\n"
3634                "{\n"
3635                "}");
3636   verifyFormat("void f() {\n"
3637                "  if (true)\n"
3638                "#ifdef A\n"
3639                "    f(42);\n"
3640                "  x();\n"
3641                "#else\n"
3642                "    g();\n"
3643                "  x();\n"
3644                "#endif\n"
3645                "}");
3646   verifyFormat("void f(param1, param2,\n"
3647                "       param3,\n"
3648                "#ifdef A\n"
3649                "       param4(param5,\n"
3650                "#ifdef A1\n"
3651                "              param6,\n"
3652                "#ifdef A2\n"
3653                "              param7),\n"
3654                "#else\n"
3655                "              param8),\n"
3656                "       param9,\n"
3657                "#endif\n"
3658                "       param10,\n"
3659                "#endif\n"
3660                "       param11)\n"
3661                "#else\n"
3662                "       param12)\n"
3663                "#endif\n"
3664                "{\n"
3665                "  x();\n"
3666                "}",
3667                getLLVMStyleWithColumns(28));
3668   verifyFormat("#if 1\n"
3669                "int i;");
3670   verifyFormat("#if 1\n"
3671                "#endif\n"
3672                "#if 1\n"
3673                "#else\n"
3674                "#endif\n");
3675   verifyFormat("DEBUG({\n"
3676                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3677                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
3678                "});\n"
3679                "#if a\n"
3680                "#else\n"
3681                "#endif");
3682 
3683   verifyIncompleteFormat("void f(\n"
3684                          "#if A\n"
3685                          ");\n"
3686                          "#else\n"
3687                          "#endif");
3688 }
3689 
3690 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
3691   verifyFormat("#endif\n"
3692                "#if B");
3693 }
3694 
3695 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
3696   FormatStyle SingleLine = getLLVMStyle();
3697   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
3698   verifyFormat("#if 0\n"
3699                "#elif 1\n"
3700                "#endif\n"
3701                "void foo() {\n"
3702                "  if (test) foo2();\n"
3703                "}",
3704                SingleLine);
3705 }
3706 
3707 TEST_F(FormatTest, LayoutBlockInsideParens) {
3708   verifyFormat("functionCall({ int i; });");
3709   verifyFormat("functionCall({\n"
3710                "  int i;\n"
3711                "  int j;\n"
3712                "});");
3713   verifyFormat("functionCall(\n"
3714                "    {\n"
3715                "      int i;\n"
3716                "      int j;\n"
3717                "    },\n"
3718                "    aaaa, bbbb, cccc);");
3719   verifyFormat("functionA(functionB({\n"
3720                "            int i;\n"
3721                "            int j;\n"
3722                "          }),\n"
3723                "          aaaa, bbbb, cccc);");
3724   verifyFormat("functionCall(\n"
3725                "    {\n"
3726                "      int i;\n"
3727                "      int j;\n"
3728                "    },\n"
3729                "    aaaa, bbbb, // comment\n"
3730                "    cccc);");
3731   verifyFormat("functionA(functionB({\n"
3732                "            int i;\n"
3733                "            int j;\n"
3734                "          }),\n"
3735                "          aaaa, bbbb, // comment\n"
3736                "          cccc);");
3737   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
3738   verifyFormat("functionCall(aaaa, bbbb, {\n"
3739                "  int i;\n"
3740                "  int j;\n"
3741                "});");
3742   verifyFormat(
3743       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
3744       "    {\n"
3745       "      int i; // break\n"
3746       "    },\n"
3747       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
3748       "                                     ccccccccccccccccc));");
3749   verifyFormat("DEBUG({\n"
3750                "  if (a)\n"
3751                "    f();\n"
3752                "});");
3753 }
3754 
3755 TEST_F(FormatTest, LayoutBlockInsideStatement) {
3756   EXPECT_EQ("SOME_MACRO { int i; }\n"
3757             "int i;",
3758             format("  SOME_MACRO  {int i;}  int i;"));
3759 }
3760 
3761 TEST_F(FormatTest, LayoutNestedBlocks) {
3762   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
3763                "  struct s {\n"
3764                "    int i;\n"
3765                "  };\n"
3766                "  s kBitsToOs[] = {{10}};\n"
3767                "  for (int i = 0; i < 10; ++i)\n"
3768                "    return;\n"
3769                "}");
3770   verifyFormat("call(parameter, {\n"
3771                "  something();\n"
3772                "  // Comment using all columns.\n"
3773                "  somethingelse();\n"
3774                "});",
3775                getLLVMStyleWithColumns(40));
3776   verifyFormat("DEBUG( //\n"
3777                "    { f(); }, a);");
3778   verifyFormat("DEBUG( //\n"
3779                "    {\n"
3780                "      f(); //\n"
3781                "    },\n"
3782                "    a);");
3783 
3784   EXPECT_EQ("call(parameter, {\n"
3785             "  something();\n"
3786             "  // Comment too\n"
3787             "  // looooooooooong.\n"
3788             "  somethingElse();\n"
3789             "});",
3790             format("call(parameter, {\n"
3791                    "  something();\n"
3792                    "  // Comment too looooooooooong.\n"
3793                    "  somethingElse();\n"
3794                    "});",
3795                    getLLVMStyleWithColumns(29)));
3796   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
3797   EXPECT_EQ("DEBUG({ // comment\n"
3798             "  int i;\n"
3799             "});",
3800             format("DEBUG({ // comment\n"
3801                    "int  i;\n"
3802                    "});"));
3803   EXPECT_EQ("DEBUG({\n"
3804             "  int i;\n"
3805             "\n"
3806             "  // comment\n"
3807             "  int j;\n"
3808             "});",
3809             format("DEBUG({\n"
3810                    "  int  i;\n"
3811                    "\n"
3812                    "  // comment\n"
3813                    "  int  j;\n"
3814                    "});"));
3815 
3816   verifyFormat("DEBUG({\n"
3817                "  if (a)\n"
3818                "    return;\n"
3819                "});");
3820   verifyGoogleFormat("DEBUG({\n"
3821                      "  if (a) return;\n"
3822                      "});");
3823   FormatStyle Style = getGoogleStyle();
3824   Style.ColumnLimit = 45;
3825   verifyFormat("Debug(\n"
3826                "    aaaaa,\n"
3827                "    {\n"
3828                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
3829                "    },\n"
3830                "    a);",
3831                Style);
3832 
3833   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
3834 
3835   verifyNoCrash("^{v^{a}}");
3836 }
3837 
3838 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
3839   EXPECT_EQ("#define MACRO()                     \\\n"
3840             "  Debug(aaa, /* force line break */ \\\n"
3841             "        {                           \\\n"
3842             "          int i;                    \\\n"
3843             "          int j;                    \\\n"
3844             "        })",
3845             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
3846                    "          {  int   i;  int  j;   })",
3847                    getGoogleStyle()));
3848 
3849   EXPECT_EQ("#define A                                       \\\n"
3850             "  [] {                                          \\\n"
3851             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
3852             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
3853             "  }",
3854             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
3855                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
3856                    getGoogleStyle()));
3857 }
3858 
3859 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
3860   EXPECT_EQ("{}", format("{}"));
3861   verifyFormat("enum E {};");
3862   verifyFormat("enum E {}");
3863   FormatStyle Style = getLLVMStyle();
3864   Style.SpaceInEmptyBlock = true;
3865   EXPECT_EQ("void f() { }", format("void f() {}", Style));
3866   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
3867   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
3868 }
3869 
3870 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
3871   FormatStyle Style = getLLVMStyle();
3872   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
3873   Style.MacroBlockEnd = "^[A-Z_]+_END$";
3874   verifyFormat("FOO_BEGIN\n"
3875                "  FOO_ENTRY\n"
3876                "FOO_END",
3877                Style);
3878   verifyFormat("FOO_BEGIN\n"
3879                "  NESTED_FOO_BEGIN\n"
3880                "    NESTED_FOO_ENTRY\n"
3881                "  NESTED_FOO_END\n"
3882                "FOO_END",
3883                Style);
3884   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
3885                "  int x;\n"
3886                "  x = 1;\n"
3887                "FOO_END(Baz)",
3888                Style);
3889 }
3890 
3891 //===----------------------------------------------------------------------===//
3892 // Line break tests.
3893 //===----------------------------------------------------------------------===//
3894 
3895 TEST_F(FormatTest, PreventConfusingIndents) {
3896   verifyFormat(
3897       "void f() {\n"
3898       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
3899       "                         parameter, parameter, parameter)),\n"
3900       "                     SecondLongCall(parameter));\n"
3901       "}");
3902   verifyFormat(
3903       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3904       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
3905       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
3906       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
3907   verifyFormat(
3908       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
3909       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
3910       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
3911       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
3912   verifyFormat(
3913       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
3914       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
3915       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
3916       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
3917   verifyFormat("int a = bbbb && ccc &&\n"
3918                "        fffff(\n"
3919                "#define A Just forcing a new line\n"
3920                "            ddd);");
3921 }
3922 
3923 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
3924   verifyFormat(
3925       "bool aaaaaaa =\n"
3926       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
3927       "    bbbbbbbb();");
3928   verifyFormat(
3929       "bool aaaaaaa =\n"
3930       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
3931       "    bbbbbbbb();");
3932 
3933   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
3934                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
3935                "    ccccccccc == ddddddddddd;");
3936   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
3937                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
3938                "    ccccccccc == ddddddddddd;");
3939   verifyFormat(
3940       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
3941       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
3942       "    ccccccccc == ddddddddddd;");
3943 
3944   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3945                "                 aaaaaa) &&\n"
3946                "         bbbbbb && cccccc;");
3947   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
3948                "                 aaaaaa) >>\n"
3949                "         bbbbbb;");
3950   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
3951                "    SourceMgr.getSpellingColumnNumber(\n"
3952                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
3953                "    1);");
3954 
3955   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3956                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
3957                "    cccccc) {\n}");
3958   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3959                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
3960                "              cccccc) {\n}");
3961   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
3962                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
3963                "              cccccc) {\n}");
3964   verifyFormat("b = a &&\n"
3965                "    // Comment\n"
3966                "    b.c && d;");
3967 
3968   // If the LHS of a comparison is not a binary expression itself, the
3969   // additional linebreak confuses many people.
3970   verifyFormat(
3971       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3972       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
3973       "}");
3974   verifyFormat(
3975       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3976       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3977       "}");
3978   verifyFormat(
3979       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
3980       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3981       "}");
3982   verifyFormat(
3983       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3984       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
3985       "}");
3986   // Even explicit parentheses stress the precedence enough to make the
3987   // additional break unnecessary.
3988   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3989                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
3990                "}");
3991   // This cases is borderline, but with the indentation it is still readable.
3992   verifyFormat(
3993       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
3994       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
3995       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
3996       "}",
3997       getLLVMStyleWithColumns(75));
3998 
3999   // If the LHS is a binary expression, we should still use the additional break
4000   // as otherwise the formatting hides the operator precedence.
4001   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4002                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4003                "    5) {\n"
4004                "}");
4005   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4006                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4007                "    5) {\n"
4008                "}");
4009 
4010   FormatStyle OnePerLine = getLLVMStyle();
4011   OnePerLine.BinPackParameters = false;
4012   verifyFormat(
4013       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4014       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4015       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4016       OnePerLine);
4017 
4018   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4019                "                .aaa(aaaaaaaaaaaaa) *\n"
4020                "            aaaaaaa +\n"
4021                "        aaaaaaa;",
4022                getLLVMStyleWithColumns(40));
4023 }
4024 
4025 TEST_F(FormatTest, ExpressionIndentation) {
4026   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4027                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4028                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4029                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4030                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4031                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4032                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4033                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4034                "                 ccccccccccccccccccccccccccccccccccccccccc;");
4035   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4036                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4037                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4038                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4039   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4040                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4041                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4042                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4043   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4044                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4045                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4046                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4047   verifyFormat("if () {\n"
4048                "} else if (aaaaa && bbbbb > // break\n"
4049                "                        ccccc) {\n"
4050                "}");
4051   verifyFormat("if () {\n"
4052                "} else if constexpr (aaaaa && bbbbb > // break\n"
4053                "                                  ccccc) {\n"
4054                "}");
4055   verifyFormat("if () {\n"
4056                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4057                "                                  ccccc) {\n"
4058                "}");
4059   verifyFormat("if () {\n"
4060                "} else if (aaaaa &&\n"
4061                "           bbbbb > // break\n"
4062                "               ccccc &&\n"
4063                "           ddddd) {\n"
4064                "}");
4065 
4066   // Presence of a trailing comment used to change indentation of b.
4067   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4068                "       b;\n"
4069                "return aaaaaaaaaaaaaaaaaaa +\n"
4070                "       b; //",
4071                getLLVMStyleWithColumns(30));
4072 }
4073 
4074 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4075   // Not sure what the best system is here. Like this, the LHS can be found
4076   // immediately above an operator (everything with the same or a higher
4077   // indent). The RHS is aligned right of the operator and so compasses
4078   // everything until something with the same indent as the operator is found.
4079   // FIXME: Is this a good system?
4080   FormatStyle Style = getLLVMStyle();
4081   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4082   verifyFormat(
4083       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4084       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4085       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4086       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4087       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4088       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4089       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4090       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4091       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
4092       Style);
4093   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4094                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4095                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4096                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4097                Style);
4098   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4099                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4100                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4101                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4102                Style);
4103   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4104                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4105                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4106                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4107                Style);
4108   verifyFormat("if () {\n"
4109                "} else if (aaaaa\n"
4110                "           && bbbbb // break\n"
4111                "                  > ccccc) {\n"
4112                "}",
4113                Style);
4114   verifyFormat("return (a)\n"
4115                "       // comment\n"
4116                "       + b;",
4117                Style);
4118   verifyFormat(
4119       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4120       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4121       "             + cc;",
4122       Style);
4123 
4124   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4125                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4126                Style);
4127 
4128   // Forced by comments.
4129   verifyFormat(
4130       "unsigned ContentSize =\n"
4131       "    sizeof(int16_t)   // DWARF ARange version number\n"
4132       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4133       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4134       "    + sizeof(int8_t); // Segment Size (in bytes)");
4135 
4136   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4137                "       == boost::fusion::at_c<1>(iiii).second;",
4138                Style);
4139 
4140   Style.ColumnLimit = 60;
4141   verifyFormat("zzzzzzzzzz\n"
4142                "    = bbbbbbbbbbbbbbbbb\n"
4143                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4144                Style);
4145 
4146   Style.ColumnLimit = 80;
4147   Style.IndentWidth = 4;
4148   Style.TabWidth = 4;
4149   Style.UseTab = FormatStyle::UT_Always;
4150   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4151   Style.AlignOperands = false;
4152   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4153             "\t&& (someOtherLongishConditionPart1\n"
4154             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4155             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4156                    "(someOtherLongishConditionPart1 || "
4157                    "someOtherEvenLongerNestedConditionPart2);",
4158                    Style));
4159 }
4160 
4161 TEST_F(FormatTest, EnforcedOperatorWraps) {
4162   // Here we'd like to wrap after the || operators, but a comment is forcing an
4163   // earlier wrap.
4164   verifyFormat("bool x = aaaaa //\n"
4165                "         || bbbbb\n"
4166                "         //\n"
4167                "         || cccc;");
4168 }
4169 
4170 TEST_F(FormatTest, NoOperandAlignment) {
4171   FormatStyle Style = getLLVMStyle();
4172   Style.AlignOperands = false;
4173   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4174                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4175                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4176                Style);
4177   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4178   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4179                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4180                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4181                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4182                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4183                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4184                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4185                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4186                "        > ccccccccccccccccccccccccccccccccccccccccc;",
4187                Style);
4188 
4189   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4190                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4191                "    + cc;",
4192                Style);
4193   verifyFormat("int a = aa\n"
4194                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4195                "        * cccccccccccccccccccccccccccccccccccc;\n",
4196                Style);
4197 
4198   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4199   verifyFormat("return (a > b\n"
4200                "    // comment1\n"
4201                "    // comment2\n"
4202                "    || c);",
4203                Style);
4204 }
4205 
4206 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4207   FormatStyle Style = getLLVMStyle();
4208   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4209   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4210                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4211                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4212                Style);
4213 }
4214 
4215 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4216   FormatStyle Style = getLLVMStyle();
4217   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4218   Style.BinPackArguments = false;
4219   Style.ColumnLimit = 40;
4220   verifyFormat("void test() {\n"
4221                "  someFunction(\n"
4222                "      this + argument + is + quite\n"
4223                "      + long + so + it + gets + wrapped\n"
4224                "      + but + remains + bin - packed);\n"
4225                "}",
4226                Style);
4227   verifyFormat("void test() {\n"
4228                "  someFunction(arg1,\n"
4229                "               this + argument + is\n"
4230                "                   + quite + long + so\n"
4231                "                   + it + gets + wrapped\n"
4232                "                   + but + remains + bin\n"
4233                "                   - packed,\n"
4234                "               arg3);\n"
4235                "}",
4236                Style);
4237   verifyFormat("void test() {\n"
4238                "  someFunction(\n"
4239                "      arg1,\n"
4240                "      this + argument + has\n"
4241                "          + anotherFunc(nested,\n"
4242                "                        calls + whose\n"
4243                "                            + arguments\n"
4244                "                            + are + also\n"
4245                "                            + wrapped,\n"
4246                "                        in + addition)\n"
4247                "          + to + being + bin - packed,\n"
4248                "      arg3);\n"
4249                "}",
4250                Style);
4251 
4252   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4253   verifyFormat("void test() {\n"
4254                "  someFunction(\n"
4255                "      arg1,\n"
4256                "      this + argument + has +\n"
4257                "          anotherFunc(nested,\n"
4258                "                      calls + whose +\n"
4259                "                          arguments +\n"
4260                "                          are + also +\n"
4261                "                          wrapped,\n"
4262                "                      in + addition) +\n"
4263                "          to + being + bin - packed,\n"
4264                "      arg3);\n"
4265                "}",
4266                Style);
4267 }
4268 
4269 TEST_F(FormatTest, ConstructorInitializers) {
4270   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4271   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4272                getLLVMStyleWithColumns(45));
4273   verifyFormat("Constructor()\n"
4274                "    : Inttializer(FitsOnTheLine) {}",
4275                getLLVMStyleWithColumns(44));
4276   verifyFormat("Constructor()\n"
4277                "    : Inttializer(FitsOnTheLine) {}",
4278                getLLVMStyleWithColumns(43));
4279 
4280   verifyFormat("template <typename T>\n"
4281                "Constructor() : Initializer(FitsOnTheLine) {}",
4282                getLLVMStyleWithColumns(45));
4283 
4284   verifyFormat(
4285       "SomeClass::Constructor()\n"
4286       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4287 
4288   verifyFormat(
4289       "SomeClass::Constructor()\n"
4290       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4291       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4292   verifyFormat(
4293       "SomeClass::Constructor()\n"
4294       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4295       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4296   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4297                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4298                "    : aaaaaaaaaa(aaaaaa) {}");
4299 
4300   verifyFormat("Constructor()\n"
4301                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4302                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4303                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4304                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
4305 
4306   verifyFormat("Constructor()\n"
4307                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4308                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4309 
4310   verifyFormat("Constructor(int Parameter = 0)\n"
4311                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4312                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4313   verifyFormat("Constructor()\n"
4314                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4315                "}",
4316                getLLVMStyleWithColumns(60));
4317   verifyFormat("Constructor()\n"
4318                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4319                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4320 
4321   // Here a line could be saved by splitting the second initializer onto two
4322   // lines, but that is not desirable.
4323   verifyFormat("Constructor()\n"
4324                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4325                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
4326                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4327 
4328   FormatStyle OnePerLine = getLLVMStyle();
4329   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4330   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4331   verifyFormat("SomeClass::Constructor()\n"
4332                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4333                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4334                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4335                OnePerLine);
4336   verifyFormat("SomeClass::Constructor()\n"
4337                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4338                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4339                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4340                OnePerLine);
4341   verifyFormat("MyClass::MyClass(int var)\n"
4342                "    : some_var_(var),            // 4 space indent\n"
4343                "      some_other_var_(var + 1) { // lined up\n"
4344                "}",
4345                OnePerLine);
4346   verifyFormat("Constructor()\n"
4347                "    : aaaaa(aaaaaa),\n"
4348                "      aaaaa(aaaaaa),\n"
4349                "      aaaaa(aaaaaa),\n"
4350                "      aaaaa(aaaaaa),\n"
4351                "      aaaaa(aaaaaa) {}",
4352                OnePerLine);
4353   verifyFormat("Constructor()\n"
4354                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4355                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
4356                OnePerLine);
4357   OnePerLine.BinPackParameters = false;
4358   verifyFormat(
4359       "Constructor()\n"
4360       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4361       "          aaaaaaaaaaa().aaa(),\n"
4362       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4363       OnePerLine);
4364   OnePerLine.ColumnLimit = 60;
4365   verifyFormat("Constructor()\n"
4366                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4367                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4368                OnePerLine);
4369 
4370   EXPECT_EQ("Constructor()\n"
4371             "    : // Comment forcing unwanted break.\n"
4372             "      aaaa(aaaa) {}",
4373             format("Constructor() :\n"
4374                    "    // Comment forcing unwanted break.\n"
4375                    "    aaaa(aaaa) {}"));
4376 }
4377 
4378 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4379   FormatStyle Style = getLLVMStyle();
4380   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4381   Style.ColumnLimit = 60;
4382   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4383   Style.AllowAllConstructorInitializersOnNextLine = true;
4384   Style.BinPackParameters = false;
4385 
4386   for (int i = 0; i < 4; ++i) {
4387     // Test all combinations of parameters that should not have an effect.
4388     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4389     Style.AllowAllArgumentsOnNextLine = i & 2;
4390 
4391     Style.AllowAllConstructorInitializersOnNextLine = true;
4392     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4393     verifyFormat("Constructor()\n"
4394                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4395                  Style);
4396     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4397 
4398     Style.AllowAllConstructorInitializersOnNextLine = false;
4399     verifyFormat("Constructor()\n"
4400                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4401                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4402                  Style);
4403     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4404 
4405     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4406     Style.AllowAllConstructorInitializersOnNextLine = true;
4407     verifyFormat("Constructor()\n"
4408                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4409                  Style);
4410 
4411     Style.AllowAllConstructorInitializersOnNextLine = false;
4412     verifyFormat("Constructor()\n"
4413                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4414                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4415                  Style);
4416 
4417     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4418     Style.AllowAllConstructorInitializersOnNextLine = true;
4419     verifyFormat("Constructor() :\n"
4420                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4421                  Style);
4422 
4423     Style.AllowAllConstructorInitializersOnNextLine = false;
4424     verifyFormat("Constructor() :\n"
4425                  "    aaaaaaaaaaaaaaaaaa(a),\n"
4426                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4427                  Style);
4428   }
4429 
4430   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4431   // AllowAllConstructorInitializersOnNextLine in all
4432   // BreakConstructorInitializers modes
4433   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4434   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4435   Style.AllowAllConstructorInitializersOnNextLine = false;
4436   verifyFormat("SomeClassWithALongName::Constructor(\n"
4437                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4438                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4439                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4440                Style);
4441 
4442   Style.AllowAllConstructorInitializersOnNextLine = true;
4443   verifyFormat("SomeClassWithALongName::Constructor(\n"
4444                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4445                "    int bbbbbbbbbbbbb,\n"
4446                "    int cccccccccccccccc)\n"
4447                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4448                Style);
4449 
4450   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4451   Style.AllowAllConstructorInitializersOnNextLine = false;
4452   verifyFormat("SomeClassWithALongName::Constructor(\n"
4453                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4454                "    int bbbbbbbbbbbbb)\n"
4455                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4456                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4457                Style);
4458 
4459   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4460 
4461   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4462   verifyFormat("SomeClassWithALongName::Constructor(\n"
4463                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4464                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4465                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4466                Style);
4467 
4468   Style.AllowAllConstructorInitializersOnNextLine = true;
4469   verifyFormat("SomeClassWithALongName::Constructor(\n"
4470                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4471                "    int bbbbbbbbbbbbb,\n"
4472                "    int cccccccccccccccc)\n"
4473                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4474                Style);
4475 
4476   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4477   Style.AllowAllConstructorInitializersOnNextLine = false;
4478   verifyFormat("SomeClassWithALongName::Constructor(\n"
4479                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4480                "    int bbbbbbbbbbbbb)\n"
4481                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4482                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4483                Style);
4484 
4485   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4486   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4487   verifyFormat("SomeClassWithALongName::Constructor(\n"
4488                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4489                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4490                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4491                Style);
4492 
4493   Style.AllowAllConstructorInitializersOnNextLine = true;
4494   verifyFormat("SomeClassWithALongName::Constructor(\n"
4495                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4496                "    int bbbbbbbbbbbbb,\n"
4497                "    int cccccccccccccccc) :\n"
4498                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4499                Style);
4500 
4501   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4502   Style.AllowAllConstructorInitializersOnNextLine = false;
4503   verifyFormat("SomeClassWithALongName::Constructor(\n"
4504                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4505                "    int bbbbbbbbbbbbb) :\n"
4506                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4507                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4508                Style);
4509 }
4510 
4511 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4512   FormatStyle Style = getLLVMStyle();
4513   Style.ColumnLimit = 60;
4514   Style.BinPackArguments = false;
4515   for (int i = 0; i < 4; ++i) {
4516     // Test all combinations of parameters that should not have an effect.
4517     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4518     Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4519 
4520     Style.AllowAllArgumentsOnNextLine = true;
4521     verifyFormat("void foo() {\n"
4522                  "  FunctionCallWithReallyLongName(\n"
4523                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4524                  "}",
4525                  Style);
4526     Style.AllowAllArgumentsOnNextLine = false;
4527     verifyFormat("void foo() {\n"
4528                  "  FunctionCallWithReallyLongName(\n"
4529                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4530                  "      bbbbbbbbbbbb);\n"
4531                  "}",
4532                  Style);
4533 
4534     Style.AllowAllArgumentsOnNextLine = true;
4535     verifyFormat("void foo() {\n"
4536                  "  auto VariableWithReallyLongName = {\n"
4537                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4538                  "}",
4539                  Style);
4540     Style.AllowAllArgumentsOnNextLine = false;
4541     verifyFormat("void foo() {\n"
4542                  "  auto VariableWithReallyLongName = {\n"
4543                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4544                  "      bbbbbbbbbbbb};\n"
4545                  "}",
4546                  Style);
4547   }
4548 
4549   // This parameter should not affect declarations.
4550   Style.BinPackParameters = false;
4551   Style.AllowAllArgumentsOnNextLine = false;
4552   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4553   verifyFormat("void FunctionCallWithReallyLongName(\n"
4554                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
4555                Style);
4556   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4557   verifyFormat("void FunctionCallWithReallyLongName(\n"
4558                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
4559                "    int bbbbbbbbbbbb);",
4560                Style);
4561 }
4562 
4563 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
4564   FormatStyle Style = getLLVMStyle();
4565   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4566 
4567   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4568   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
4569                getStyleWithColumns(Style, 45));
4570   verifyFormat("Constructor() :\n"
4571                "    Initializer(FitsOnTheLine) {}",
4572                getStyleWithColumns(Style, 44));
4573   verifyFormat("Constructor() :\n"
4574                "    Initializer(FitsOnTheLine) {}",
4575                getStyleWithColumns(Style, 43));
4576 
4577   verifyFormat("template <typename T>\n"
4578                "Constructor() : Initializer(FitsOnTheLine) {}",
4579                getStyleWithColumns(Style, 50));
4580   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4581   verifyFormat(
4582       "SomeClass::Constructor() :\n"
4583       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4584       Style);
4585 
4586   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
4587   verifyFormat(
4588       "SomeClass::Constructor() :\n"
4589       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4590       Style);
4591 
4592   verifyFormat(
4593       "SomeClass::Constructor() :\n"
4594       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4595       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4596       Style);
4597   verifyFormat(
4598       "SomeClass::Constructor() :\n"
4599       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4600       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
4601       Style);
4602   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4603                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
4604                "    aaaaaaaaaa(aaaaaa) {}",
4605                Style);
4606 
4607   verifyFormat("Constructor() :\n"
4608                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4609                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4610                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4611                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
4612                Style);
4613 
4614   verifyFormat("Constructor() :\n"
4615                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4616                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4617                Style);
4618 
4619   verifyFormat("Constructor(int Parameter = 0) :\n"
4620                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4621                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
4622                Style);
4623   verifyFormat("Constructor() :\n"
4624                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4625                "}",
4626                getStyleWithColumns(Style, 60));
4627   verifyFormat("Constructor() :\n"
4628                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4629                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
4630                Style);
4631 
4632   // Here a line could be saved by splitting the second initializer onto two
4633   // lines, but that is not desirable.
4634   verifyFormat("Constructor() :\n"
4635                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4636                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
4637                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4638                Style);
4639 
4640   FormatStyle OnePerLine = Style;
4641   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4642   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
4643   verifyFormat("SomeClass::Constructor() :\n"
4644                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4645                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4646                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4647                OnePerLine);
4648   verifyFormat("SomeClass::Constructor() :\n"
4649                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4650                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4651                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4652                OnePerLine);
4653   verifyFormat("MyClass::MyClass(int var) :\n"
4654                "    some_var_(var),            // 4 space indent\n"
4655                "    some_other_var_(var + 1) { // lined up\n"
4656                "}",
4657                OnePerLine);
4658   verifyFormat("Constructor() :\n"
4659                "    aaaaa(aaaaaa),\n"
4660                "    aaaaa(aaaaaa),\n"
4661                "    aaaaa(aaaaaa),\n"
4662                "    aaaaa(aaaaaa),\n"
4663                "    aaaaa(aaaaaa) {}",
4664                OnePerLine);
4665   verifyFormat("Constructor() :\n"
4666                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4667                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
4668                OnePerLine);
4669   OnePerLine.BinPackParameters = false;
4670   verifyFormat("Constructor() :\n"
4671                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4672                "        aaaaaaaaaaa().aaa(),\n"
4673                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4674                OnePerLine);
4675   OnePerLine.ColumnLimit = 60;
4676   verifyFormat("Constructor() :\n"
4677                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4678                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4679                OnePerLine);
4680 
4681   EXPECT_EQ("Constructor() :\n"
4682             "    // Comment forcing unwanted break.\n"
4683             "    aaaa(aaaa) {}",
4684             format("Constructor() :\n"
4685                    "    // Comment forcing unwanted break.\n"
4686                    "    aaaa(aaaa) {}",
4687                    Style));
4688 
4689   Style.ColumnLimit = 0;
4690   verifyFormat("SomeClass::Constructor() :\n"
4691                "    a(a) {}",
4692                Style);
4693   verifyFormat("SomeClass::Constructor() noexcept :\n"
4694                "    a(a) {}",
4695                Style);
4696   verifyFormat("SomeClass::Constructor() :\n"
4697                "    a(a), b(b), c(c) {}",
4698                Style);
4699   verifyFormat("SomeClass::Constructor() :\n"
4700                "    a(a) {\n"
4701                "  foo();\n"
4702                "  bar();\n"
4703                "}",
4704                Style);
4705 
4706   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
4707   verifyFormat("SomeClass::Constructor() :\n"
4708                "    a(a), b(b), c(c) {\n"
4709                "}",
4710                Style);
4711   verifyFormat("SomeClass::Constructor() :\n"
4712                "    a(a) {\n"
4713                "}",
4714                Style);
4715 
4716   Style.ColumnLimit = 80;
4717   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
4718   Style.ConstructorInitializerIndentWidth = 2;
4719   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
4720   verifyFormat("SomeClass::Constructor() :\n"
4721                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4722                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
4723                Style);
4724 
4725   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
4726   // well
4727   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
4728   verifyFormat(
4729       "class SomeClass\n"
4730       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4731       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
4732       Style);
4733   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
4734   verifyFormat(
4735       "class SomeClass\n"
4736       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4737       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
4738       Style);
4739   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
4740   verifyFormat(
4741       "class SomeClass :\n"
4742       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4743       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
4744       Style);
4745 }
4746 
4747 #ifndef EXPENSIVE_CHECKS
4748 // Expensive checks enables libstdc++ checking which includes validating the
4749 // state of ranges used in std::priority_queue - this blows out the
4750 // runtime/scalability of the function and makes this test unacceptably slow.
4751 TEST_F(FormatTest, MemoizationTests) {
4752   // This breaks if the memoization lookup does not take \c Indent and
4753   // \c LastSpace into account.
4754   verifyFormat(
4755       "extern CFRunLoopTimerRef\n"
4756       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
4757       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
4758       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
4759       "                     CFRunLoopTimerContext *context) {}");
4760 
4761   // Deep nesting somewhat works around our memoization.
4762   verifyFormat(
4763       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
4764       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
4765       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
4766       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
4767       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
4768       getLLVMStyleWithColumns(65));
4769   verifyFormat(
4770       "aaaaa(\n"
4771       "    aaaaa,\n"
4772       "    aaaaa(\n"
4773       "        aaaaa,\n"
4774       "        aaaaa(\n"
4775       "            aaaaa,\n"
4776       "            aaaaa(\n"
4777       "                aaaaa,\n"
4778       "                aaaaa(\n"
4779       "                    aaaaa,\n"
4780       "                    aaaaa(\n"
4781       "                        aaaaa,\n"
4782       "                        aaaaa(\n"
4783       "                            aaaaa,\n"
4784       "                            aaaaa(\n"
4785       "                                aaaaa,\n"
4786       "                                aaaaa(\n"
4787       "                                    aaaaa,\n"
4788       "                                    aaaaa(\n"
4789       "                                        aaaaa,\n"
4790       "                                        aaaaa(\n"
4791       "                                            aaaaa,\n"
4792       "                                            aaaaa(\n"
4793       "                                                aaaaa,\n"
4794       "                                                aaaaa))))))))))));",
4795       getLLVMStyleWithColumns(65));
4796   verifyFormat(
4797       "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"
4798       "                                  a),\n"
4799       "                                a),\n"
4800       "                              a),\n"
4801       "                            a),\n"
4802       "                          a),\n"
4803       "                        a),\n"
4804       "                      a),\n"
4805       "                    a),\n"
4806       "                  a),\n"
4807       "                a),\n"
4808       "              a),\n"
4809       "            a),\n"
4810       "          a),\n"
4811       "        a),\n"
4812       "      a),\n"
4813       "    a),\n"
4814       "  a)",
4815       getLLVMStyleWithColumns(65));
4816 
4817   // This test takes VERY long when memoization is broken.
4818   FormatStyle OnePerLine = getLLVMStyle();
4819   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4820   OnePerLine.BinPackParameters = false;
4821   std::string input = "Constructor()\n"
4822                       "    : aaaa(a,\n";
4823   for (unsigned i = 0, e = 80; i != e; ++i) {
4824     input += "           a,\n";
4825   }
4826   input += "           a) {}";
4827   verifyFormat(input, OnePerLine);
4828 }
4829 #endif
4830 
4831 TEST_F(FormatTest, BreaksAsHighAsPossible) {
4832   verifyFormat(
4833       "void f() {\n"
4834       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
4835       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
4836       "    f();\n"
4837       "}");
4838   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
4839                "    Intervals[i - 1].getRange().getLast()) {\n}");
4840 }
4841 
4842 TEST_F(FormatTest, BreaksFunctionDeclarations) {
4843   // Principially, we break function declarations in a certain order:
4844   // 1) break amongst arguments.
4845   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
4846                "                              Cccccccccccccc cccccccccccccc);");
4847   verifyFormat("template <class TemplateIt>\n"
4848                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
4849                "                            TemplateIt *stop) {}");
4850 
4851   // 2) break after return type.
4852   verifyFormat(
4853       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4854       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
4855       getGoogleStyle());
4856 
4857   // 3) break after (.
4858   verifyFormat(
4859       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
4860       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
4861       getGoogleStyle());
4862 
4863   // 4) break before after nested name specifiers.
4864   verifyFormat(
4865       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4866       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
4867       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
4868       getGoogleStyle());
4869 
4870   // However, there are exceptions, if a sufficient amount of lines can be
4871   // saved.
4872   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
4873   // more adjusting.
4874   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
4875                "                                  Cccccccccccccc cccccccccc,\n"
4876                "                                  Cccccccccccccc cccccccccc,\n"
4877                "                                  Cccccccccccccc cccccccccc,\n"
4878                "                                  Cccccccccccccc cccccccccc);");
4879   verifyFormat(
4880       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4881       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
4882       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
4883       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
4884       getGoogleStyle());
4885   verifyFormat(
4886       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
4887       "                                          Cccccccccccccc cccccccccc,\n"
4888       "                                          Cccccccccccccc cccccccccc,\n"
4889       "                                          Cccccccccccccc cccccccccc,\n"
4890       "                                          Cccccccccccccc cccccccccc,\n"
4891       "                                          Cccccccccccccc cccccccccc,\n"
4892       "                                          Cccccccccccccc cccccccccc);");
4893   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
4894                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
4895                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
4896                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
4897                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
4898 
4899   // Break after multi-line parameters.
4900   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4901                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4902                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4903                "    bbbb bbbb);");
4904   verifyFormat("void SomeLoooooooooooongFunction(\n"
4905                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
4906                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4907                "    int bbbbbbbbbbbbb);");
4908 
4909   // Treat overloaded operators like other functions.
4910   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
4911                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
4912   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
4913                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
4914   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
4915                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
4916   verifyGoogleFormat(
4917       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
4918       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
4919   verifyGoogleFormat(
4920       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
4921       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
4922   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4923                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
4924   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
4925                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
4926   verifyGoogleFormat(
4927       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
4928       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4929       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
4930   verifyGoogleFormat("template <typename T>\n"
4931                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4932                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
4933                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
4934 
4935   FormatStyle Style = getLLVMStyle();
4936   Style.PointerAlignment = FormatStyle::PAS_Left;
4937   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4938                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
4939                Style);
4940   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
4941                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4942                Style);
4943 }
4944 
4945 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
4946   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
4947   // Prefer keeping `::` followed by `operator` together.
4948   EXPECT_EQ("const aaaa::bbbbbbb &\n"
4949             "ccccccccc::operator++() {\n"
4950             "  stuff();\n"
4951             "}",
4952             format("const aaaa::bbbbbbb\n"
4953                    "&ccccccccc::operator++() { stuff(); }",
4954                    getLLVMStyleWithColumns(40)));
4955 }
4956 
4957 TEST_F(FormatTest, TrailingReturnType) {
4958   verifyFormat("auto foo() -> int;\n");
4959   // correct trailing return type spacing
4960   verifyFormat("auto operator->() -> int;\n");
4961   verifyFormat("auto operator++(int) -> int;\n");
4962 
4963   verifyFormat("struct S {\n"
4964                "  auto bar() const -> int;\n"
4965                "};");
4966   verifyFormat("template <size_t Order, typename T>\n"
4967                "auto load_img(const std::string &filename)\n"
4968                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
4969   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
4970                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
4971   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
4972   verifyFormat("template <typename T>\n"
4973                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
4974                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
4975 
4976   // Not trailing return types.
4977   verifyFormat("void f() { auto a = b->c(); }");
4978 }
4979 
4980 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
4981   // Avoid breaking before trailing 'const' or other trailing annotations, if
4982   // they are not function-like.
4983   FormatStyle Style = getGoogleStyle();
4984   Style.ColumnLimit = 47;
4985   verifyFormat("void someLongFunction(\n"
4986                "    int someLoooooooooooooongParameter) const {\n}",
4987                getLLVMStyleWithColumns(47));
4988   verifyFormat("LoooooongReturnType\n"
4989                "someLoooooooongFunction() const {}",
4990                getLLVMStyleWithColumns(47));
4991   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
4992                "    const {}",
4993                Style);
4994   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
4995                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
4996   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
4997                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
4998   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
4999                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5000   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5001                "                   aaaaaaaaaaa aaaaa) const override;");
5002   verifyGoogleFormat(
5003       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5004       "    const override;");
5005 
5006   // Even if the first parameter has to be wrapped.
5007   verifyFormat("void someLongFunction(\n"
5008                "    int someLongParameter) const {}",
5009                getLLVMStyleWithColumns(46));
5010   verifyFormat("void someLongFunction(\n"
5011                "    int someLongParameter) const {}",
5012                Style);
5013   verifyFormat("void someLongFunction(\n"
5014                "    int someLongParameter) override {}",
5015                Style);
5016   verifyFormat("void someLongFunction(\n"
5017                "    int someLongParameter) OVERRIDE {}",
5018                Style);
5019   verifyFormat("void someLongFunction(\n"
5020                "    int someLongParameter) final {}",
5021                Style);
5022   verifyFormat("void someLongFunction(\n"
5023                "    int someLongParameter) FINAL {}",
5024                Style);
5025   verifyFormat("void someLongFunction(\n"
5026                "    int parameter) const override {}",
5027                Style);
5028 
5029   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5030   verifyFormat("void someLongFunction(\n"
5031                "    int someLongParameter) const\n"
5032                "{\n"
5033                "}",
5034                Style);
5035 
5036   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5037   verifyFormat("void someLongFunction(\n"
5038                "    int someLongParameter) const\n"
5039                "  {\n"
5040                "  }",
5041                Style);
5042 
5043   // Unless these are unknown annotations.
5044   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5045                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5046                "    LONG_AND_UGLY_ANNOTATION;");
5047 
5048   // Breaking before function-like trailing annotations is fine to keep them
5049   // close to their arguments.
5050   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5051                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5052   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5053                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5054   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5055                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5056   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5057                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5058   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5059 
5060   verifyFormat(
5061       "void aaaaaaaaaaaaaaaaaa()\n"
5062       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5063       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5064   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5065                "    __attribute__((unused));");
5066   verifyGoogleFormat(
5067       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5068       "    GUARDED_BY(aaaaaaaaaaaa);");
5069   verifyGoogleFormat(
5070       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5071       "    GUARDED_BY(aaaaaaaaaaaa);");
5072   verifyGoogleFormat(
5073       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5074       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5075   verifyGoogleFormat(
5076       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5077       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5078 }
5079 
5080 TEST_F(FormatTest, FunctionAnnotations) {
5081   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5082                "int OldFunction(const string &parameter) {}");
5083   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5084                "string OldFunction(const string &parameter) {}");
5085   verifyFormat("template <typename T>\n"
5086                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5087                "string OldFunction(const string &parameter) {}");
5088 
5089   // Not function annotations.
5090   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5091                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5092   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5093                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5094   verifyFormat("MACRO(abc).function() // wrap\n"
5095                "    << abc;");
5096   verifyFormat("MACRO(abc)->function() // wrap\n"
5097                "    << abc;");
5098   verifyFormat("MACRO(abc)::function() // wrap\n"
5099                "    << abc;");
5100 }
5101 
5102 TEST_F(FormatTest, BreaksDesireably) {
5103   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5104                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5105                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5106   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5107                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5108                "}");
5109 
5110   verifyFormat(
5111       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5112       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5113 
5114   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5115                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5116                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5117 
5118   verifyFormat(
5119       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5120       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5121       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5122       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5123       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5124 
5125   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5126                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5127 
5128   verifyFormat(
5129       "void f() {\n"
5130       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5131       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5132       "}");
5133   verifyFormat(
5134       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5135       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5136   verifyFormat(
5137       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5138       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5139   verifyFormat(
5140       "aaaaaa(aaa,\n"
5141       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5142       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5143       "       aaaa);");
5144   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5145                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5146                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5147 
5148   // Indent consistently independent of call expression and unary operator.
5149   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5150                "    dddddddddddddddddddddddddddddd));");
5151   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5152                "    dddddddddddddddddddddddddddddd));");
5153   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5154                "    dddddddddddddddddddddddddddddd));");
5155 
5156   // This test case breaks on an incorrect memoization, i.e. an optimization not
5157   // taking into account the StopAt value.
5158   verifyFormat(
5159       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5160       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5161       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5162       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5163 
5164   verifyFormat("{\n  {\n    {\n"
5165                "      Annotation.SpaceRequiredBefore =\n"
5166                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5167                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5168                "    }\n  }\n}");
5169 
5170   // Break on an outer level if there was a break on an inner level.
5171   EXPECT_EQ("f(g(h(a, // comment\n"
5172             "      b, c),\n"
5173             "    d, e),\n"
5174             "  x, y);",
5175             format("f(g(h(a, // comment\n"
5176                    "    b, c), d, e), x, y);"));
5177 
5178   // Prefer breaking similar line breaks.
5179   verifyFormat(
5180       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5181       "                             NSTrackingMouseEnteredAndExited |\n"
5182       "                             NSTrackingActiveAlways;");
5183 }
5184 
5185 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5186   FormatStyle NoBinPacking = getGoogleStyle();
5187   NoBinPacking.BinPackParameters = false;
5188   NoBinPacking.BinPackArguments = true;
5189   verifyFormat("void f() {\n"
5190                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5191                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5192                "}",
5193                NoBinPacking);
5194   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5195                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5196                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5197                NoBinPacking);
5198 
5199   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5200   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5201                "                        vector<int> bbbbbbbbbbbbbbb);",
5202                NoBinPacking);
5203   // FIXME: This behavior difference is probably not wanted. However, currently
5204   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5205   // template arguments from BreakBeforeParameter being set because of the
5206   // one-per-line formatting.
5207   verifyFormat(
5208       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5209       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5210       NoBinPacking);
5211   verifyFormat(
5212       "void fffffffffff(\n"
5213       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5214       "        aaaaaaaaaa);");
5215 }
5216 
5217 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5218   FormatStyle NoBinPacking = getGoogleStyle();
5219   NoBinPacking.BinPackParameters = false;
5220   NoBinPacking.BinPackArguments = false;
5221   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5222                "  aaaaaaaaaaaaaaaaaaaa,\n"
5223                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5224                NoBinPacking);
5225   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5226                "        aaaaaaaaaaaaa,\n"
5227                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5228                NoBinPacking);
5229   verifyFormat(
5230       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5231       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5232       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5233       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5234       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5235       NoBinPacking);
5236   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5237                "    .aaaaaaaaaaaaaaaaaa();",
5238                NoBinPacking);
5239   verifyFormat("void f() {\n"
5240                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5241                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5242                "}",
5243                NoBinPacking);
5244 
5245   verifyFormat(
5246       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5247       "             aaaaaaaaaaaa,\n"
5248       "             aaaaaaaaaaaa);",
5249       NoBinPacking);
5250   verifyFormat(
5251       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5252       "                               ddddddddddddddddddddddddddddd),\n"
5253       "             test);",
5254       NoBinPacking);
5255 
5256   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5257                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5258                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5259                "    aaaaaaaaaaaaaaaaaa;",
5260                NoBinPacking);
5261   verifyFormat("a(\"a\"\n"
5262                "  \"a\",\n"
5263                "  a);");
5264 
5265   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5266   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5267                "                aaaaaaaaa,\n"
5268                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5269                NoBinPacking);
5270   verifyFormat(
5271       "void f() {\n"
5272       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5273       "      .aaaaaaa();\n"
5274       "}",
5275       NoBinPacking);
5276   verifyFormat(
5277       "template <class SomeType, class SomeOtherType>\n"
5278       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5279       NoBinPacking);
5280 }
5281 
5282 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5283   FormatStyle Style = getLLVMStyleWithColumns(15);
5284   Style.ExperimentalAutoDetectBinPacking = true;
5285   EXPECT_EQ("aaa(aaaa,\n"
5286             "    aaaa,\n"
5287             "    aaaa);\n"
5288             "aaa(aaaa,\n"
5289             "    aaaa,\n"
5290             "    aaaa);",
5291             format("aaa(aaaa,\n" // one-per-line
5292                    "  aaaa,\n"
5293                    "    aaaa  );\n"
5294                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5295                    Style));
5296   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5297             "    aaaa);\n"
5298             "aaa(aaaa, aaaa,\n"
5299             "    aaaa);",
5300             format("aaa(aaaa,  aaaa,\n" // bin-packed
5301                    "    aaaa  );\n"
5302                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5303                    Style));
5304 }
5305 
5306 TEST_F(FormatTest, FormatsBuilderPattern) {
5307   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5308                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5309                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5310                "    .StartsWith(\".init\", ORDER_INIT)\n"
5311                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5312                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5313                "    .Default(ORDER_TEXT);\n");
5314 
5315   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5316                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5317   verifyFormat("aaaaaaa->aaaaaaa\n"
5318                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5319                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5320                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5321   verifyFormat(
5322       "aaaaaaa->aaaaaaa\n"
5323       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5324       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5325   verifyFormat(
5326       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5327       "    aaaaaaaaaaaaaa);");
5328   verifyFormat(
5329       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5330       "    aaaaaa->aaaaaaaaaaaa()\n"
5331       "        ->aaaaaaaaaaaaaaaa(\n"
5332       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5333       "        ->aaaaaaaaaaaaaaaaa();");
5334   verifyGoogleFormat(
5335       "void f() {\n"
5336       "  someo->Add((new util::filetools::Handler(dir))\n"
5337       "                 ->OnEvent1(NewPermanentCallback(\n"
5338       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5339       "                 ->OnEvent2(NewPermanentCallback(\n"
5340       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5341       "                 ->OnEvent3(NewPermanentCallback(\n"
5342       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5343       "                 ->OnEvent5(NewPermanentCallback(\n"
5344       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5345       "                 ->OnEvent6(NewPermanentCallback(\n"
5346       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5347       "}");
5348 
5349   verifyFormat(
5350       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5351   verifyFormat("aaaaaaaaaaaaaaa()\n"
5352                "    .aaaaaaaaaaaaaaa()\n"
5353                "    .aaaaaaaaaaaaaaa()\n"
5354                "    .aaaaaaaaaaaaaaa()\n"
5355                "    .aaaaaaaaaaaaaaa();");
5356   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5357                "    .aaaaaaaaaaaaaaa()\n"
5358                "    .aaaaaaaaaaaaaaa()\n"
5359                "    .aaaaaaaaaaaaaaa();");
5360   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5361                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5362                "    .aaaaaaaaaaaaaaa();");
5363   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5364                "    ->aaaaaaaaaaaaaae(0)\n"
5365                "    ->aaaaaaaaaaaaaaa();");
5366 
5367   // Don't linewrap after very short segments.
5368   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5369                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5370                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5371   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5372                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5373                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5374   verifyFormat("aaa()\n"
5375                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5376                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5377                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5378 
5379   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5380                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5381                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5382   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5383                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5384                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5385 
5386   // Prefer not to break after empty parentheses.
5387   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5388                "    First->LastNewlineOffset);");
5389 
5390   // Prefer not to create "hanging" indents.
5391   verifyFormat(
5392       "return !soooooooooooooome_map\n"
5393       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5394       "            .second;");
5395   verifyFormat(
5396       "return aaaaaaaaaaaaaaaa\n"
5397       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5398       "    .aaaa(aaaaaaaaaaaaaa);");
5399   // No hanging indent here.
5400   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5401                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5402   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5403                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5404   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5405                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5406                getLLVMStyleWithColumns(60));
5407   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5408                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5409                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5410                getLLVMStyleWithColumns(59));
5411   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5412                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5413                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5414 
5415   // Dont break if only closing statements before member call
5416   verifyFormat("test() {\n"
5417                "  ([]() -> {\n"
5418                "    int b = 32;\n"
5419                "    return 3;\n"
5420                "  }).foo();\n"
5421                "}");
5422   verifyFormat("test() {\n"
5423                "  (\n"
5424                "      []() -> {\n"
5425                "        int b = 32;\n"
5426                "        return 3;\n"
5427                "      },\n"
5428                "      foo, bar)\n"
5429                "      .foo();\n"
5430                "}");
5431   verifyFormat("test() {\n"
5432                "  ([]() -> {\n"
5433                "    int b = 32;\n"
5434                "    return 3;\n"
5435                "  })\n"
5436                "      .foo()\n"
5437                "      .bar();\n"
5438                "}");
5439   verifyFormat("test() {\n"
5440                "  ([]() -> {\n"
5441                "    int b = 32;\n"
5442                "    return 3;\n"
5443                "  })\n"
5444                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5445                "           \"bbbb\");\n"
5446                "}",
5447                getLLVMStyleWithColumns(30));
5448 }
5449 
5450 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5451   verifyFormat(
5452       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5453       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5454   verifyFormat(
5455       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5456       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5457 
5458   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5459                "    ccccccccccccccccccccccccc) {\n}");
5460   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5461                "    ccccccccccccccccccccccccc) {\n}");
5462 
5463   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5464                "    ccccccccccccccccccccccccc) {\n}");
5465   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5466                "    ccccccccccccccccccccccccc) {\n}");
5467 
5468   verifyFormat(
5469       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
5470       "    ccccccccccccccccccccccccc) {\n}");
5471   verifyFormat(
5472       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
5473       "    ccccccccccccccccccccccccc) {\n}");
5474 
5475   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5476                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
5477                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
5478                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5479   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5480                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
5481                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
5482                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5483 
5484   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5485                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
5486                "    aaaaaaaaaaaaaaa != aa) {\n}");
5487   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5488                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
5489                "    aaaaaaaaaaaaaaa != aa) {\n}");
5490 }
5491 
5492 TEST_F(FormatTest, BreaksAfterAssignments) {
5493   verifyFormat(
5494       "unsigned Cost =\n"
5495       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
5496       "                        SI->getPointerAddressSpaceee());\n");
5497   verifyFormat(
5498       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
5499       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
5500 
5501   verifyFormat(
5502       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
5503       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
5504   verifyFormat("unsigned OriginalStartColumn =\n"
5505                "    SourceMgr.getSpellingColumnNumber(\n"
5506                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
5507                "    1;");
5508 }
5509 
5510 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
5511   FormatStyle Style = getLLVMStyle();
5512   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5513                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
5514                Style);
5515 
5516   Style.PenaltyBreakAssignment = 20;
5517   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5518                "                                 cccccccccccccccccccccccccc;",
5519                Style);
5520 }
5521 
5522 TEST_F(FormatTest, AlignsAfterAssignments) {
5523   verifyFormat(
5524       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5525       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
5526   verifyFormat(
5527       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5528       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
5529   verifyFormat(
5530       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5531       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
5532   verifyFormat(
5533       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5534       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
5535   verifyFormat(
5536       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5537       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5538       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
5539 }
5540 
5541 TEST_F(FormatTest, AlignsAfterReturn) {
5542   verifyFormat(
5543       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5544       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
5545   verifyFormat(
5546       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5547       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
5548   verifyFormat(
5549       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5550       "       aaaaaaaaaaaaaaaaaaaaaa();");
5551   verifyFormat(
5552       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
5553       "        aaaaaaaaaaaaaaaaaaaaaa());");
5554   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5555                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5556   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5557                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
5558                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5559   verifyFormat("return\n"
5560                "    // true if code is one of a or b.\n"
5561                "    code == a || code == b;");
5562 }
5563 
5564 TEST_F(FormatTest, AlignsAfterOpenBracket) {
5565   verifyFormat(
5566       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5567       "                                                aaaaaaaaa aaaaaaa) {}");
5568   verifyFormat(
5569       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5570       "                                               aaaaaaaaaaa aaaaaaaaa);");
5571   verifyFormat(
5572       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5573       "                                             aaaaaaaaaaaaaaaaaaaaa));");
5574   FormatStyle Style = getLLVMStyle();
5575   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5576   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5577                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
5578                Style);
5579   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5580                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
5581                Style);
5582   verifyFormat("SomeLongVariableName->someFunction(\n"
5583                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
5584                Style);
5585   verifyFormat(
5586       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
5587       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5588       Style);
5589   verifyFormat(
5590       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
5591       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5592       Style);
5593   verifyFormat(
5594       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
5595       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
5596       Style);
5597 
5598   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
5599                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
5600                "        b));",
5601                Style);
5602 
5603   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5604   Style.BinPackArguments = false;
5605   Style.BinPackParameters = false;
5606   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5607                "    aaaaaaaaaaa aaaaaaaa,\n"
5608                "    aaaaaaaaa aaaaaaa,\n"
5609                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5610                Style);
5611   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
5612                "    aaaaaaaaaaa aaaaaaaaa,\n"
5613                "    aaaaaaaaaaa aaaaaaaaa,\n"
5614                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5615                Style);
5616   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
5617                "    aaaaaaaaaaaaaaa,\n"
5618                "    aaaaaaaaaaaaaaaaaaaaa,\n"
5619                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
5620                Style);
5621   verifyFormat(
5622       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
5623       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
5624       Style);
5625   verifyFormat(
5626       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
5627       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
5628       Style);
5629   verifyFormat(
5630       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5631       "    aaaaaaaaaaaaaaaaaaaaa(\n"
5632       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
5633       "    aaaaaaaaaaaaaaaa);",
5634       Style);
5635   verifyFormat(
5636       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5637       "    aaaaaaaaaaaaaaaaaaaaa(\n"
5638       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
5639       "    aaaaaaaaaaaaaaaa);",
5640       Style);
5641 }
5642 
5643 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
5644   FormatStyle Style = getLLVMStyleWithColumns(40);
5645   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5646                "          bbbbbbbbbbbbbbbbbbbbbb);",
5647                Style);
5648   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
5649   Style.AlignOperands = false;
5650   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5651                "          bbbbbbbbbbbbbbbbbbbbbb);",
5652                Style);
5653   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5654   Style.AlignOperands = true;
5655   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5656                "          bbbbbbbbbbbbbbbbbbbbbb);",
5657                Style);
5658   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5659   Style.AlignOperands = false;
5660   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
5661                "    bbbbbbbbbbbbbbbbbbbbbb);",
5662                Style);
5663 }
5664 
5665 TEST_F(FormatTest, BreaksConditionalExpressions) {
5666   verifyFormat(
5667       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5668       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5669       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5670   verifyFormat(
5671       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
5672       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5673       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5674   verifyFormat(
5675       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5676       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5677   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
5678                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5679                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5680   verifyFormat(
5681       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
5682       "                                                    : aaaaaaaaaaaaa);");
5683   verifyFormat(
5684       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5685       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5686       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5687       "                   aaaaaaaaaaaaa);");
5688   verifyFormat(
5689       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5690       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5691       "                   aaaaaaaaaaaaa);");
5692   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5693                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5694                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5695                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5696                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5697   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5698                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5699                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5700                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5701                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5702                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5703                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5704   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5705                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5706                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5707                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5708                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5709   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5710                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5711                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5712   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
5713                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5714                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5715                "        : aaaaaaaaaaaaaaaa;");
5716   verifyFormat(
5717       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5718       "    ? aaaaaaaaaaaaaaa\n"
5719       "    : aaaaaaaaaaaaaaa;");
5720   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
5721                "          aaaaaaaaa\n"
5722                "      ? b\n"
5723                "      : c);");
5724   verifyFormat("return aaaa == bbbb\n"
5725                "           // comment\n"
5726                "           ? aaaa\n"
5727                "           : bbbb;");
5728   verifyFormat("unsigned Indent =\n"
5729                "    format(TheLine.First,\n"
5730                "           IndentForLevel[TheLine.Level] >= 0\n"
5731                "               ? IndentForLevel[TheLine.Level]\n"
5732                "               : TheLine * 2,\n"
5733                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
5734                getLLVMStyleWithColumns(60));
5735   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
5736                "                  ? aaaaaaaaaaaaaaa\n"
5737                "                  : bbbbbbbbbbbbbbb //\n"
5738                "                        ? ccccccccccccccc\n"
5739                "                        : ddddddddddddddd;");
5740   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
5741                "                  ? aaaaaaaaaaaaaaa\n"
5742                "                  : (bbbbbbbbbbbbbbb //\n"
5743                "                         ? ccccccccccccccc\n"
5744                "                         : ddddddddddddddd);");
5745   verifyFormat(
5746       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5747       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5748       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
5749       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
5750       "                                      : aaaaaaaaaa;");
5751   verifyFormat(
5752       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5753       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
5754       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5755 
5756   FormatStyle NoBinPacking = getLLVMStyle();
5757   NoBinPacking.BinPackArguments = false;
5758   verifyFormat(
5759       "void f() {\n"
5760       "  g(aaa,\n"
5761       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
5762       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5763       "        ? aaaaaaaaaaaaaaa\n"
5764       "        : aaaaaaaaaaaaaaa);\n"
5765       "}",
5766       NoBinPacking);
5767   verifyFormat(
5768       "void f() {\n"
5769       "  g(aaa,\n"
5770       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
5771       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5772       "        ?: aaaaaaaaaaaaaaa);\n"
5773       "}",
5774       NoBinPacking);
5775 
5776   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
5777                "             // comment.\n"
5778                "             ccccccccccccccccccccccccccccccccccccccc\n"
5779                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5780                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
5781 
5782   // Assignments in conditional expressions. Apparently not uncommon :-(.
5783   verifyFormat("return a != b\n"
5784                "           // comment\n"
5785                "           ? a = b\n"
5786                "           : a = b;");
5787   verifyFormat("return a != b\n"
5788                "           // comment\n"
5789                "           ? a = a != b\n"
5790                "                     // comment\n"
5791                "                     ? a = b\n"
5792                "                     : a\n"
5793                "           : a;\n");
5794   verifyFormat("return a != b\n"
5795                "           // comment\n"
5796                "           ? a\n"
5797                "           : a = a != b\n"
5798                "                     // comment\n"
5799                "                     ? a = b\n"
5800                "                     : a;");
5801 }
5802 
5803 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
5804   FormatStyle Style = getLLVMStyle();
5805   Style.BreakBeforeTernaryOperators = false;
5806   Style.ColumnLimit = 70;
5807   verifyFormat(
5808       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5809       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
5810       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5811       Style);
5812   verifyFormat(
5813       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
5814       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
5815       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5816       Style);
5817   verifyFormat(
5818       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
5819       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5820       Style);
5821   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
5822                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
5823                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5824                Style);
5825   verifyFormat(
5826       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
5827       "                                                      aaaaaaaaaaaaa);",
5828       Style);
5829   verifyFormat(
5830       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5831       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
5832       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5833       "                   aaaaaaaaaaaaa);",
5834       Style);
5835   verifyFormat(
5836       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5837       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5838       "                   aaaaaaaaaaaaa);",
5839       Style);
5840   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5841                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5842                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
5843                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5844                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5845                Style);
5846   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5847                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5848                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5849                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
5850                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5851                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5852                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5853                Style);
5854   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5855                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
5856                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5857                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5858                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5859                Style);
5860   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5861                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
5862                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
5863                Style);
5864   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
5865                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5866                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
5867                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
5868                Style);
5869   verifyFormat(
5870       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5871       "    aaaaaaaaaaaaaaa :\n"
5872       "    aaaaaaaaaaaaaaa;",
5873       Style);
5874   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
5875                "          aaaaaaaaa ?\n"
5876                "      b :\n"
5877                "      c);",
5878                Style);
5879   verifyFormat("unsigned Indent =\n"
5880                "    format(TheLine.First,\n"
5881                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
5882                "               IndentForLevel[TheLine.Level] :\n"
5883                "               TheLine * 2,\n"
5884                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
5885                Style);
5886   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
5887                "                  aaaaaaaaaaaaaaa :\n"
5888                "                  bbbbbbbbbbbbbbb ? //\n"
5889                "                      ccccccccccccccc :\n"
5890                "                      ddddddddddddddd;",
5891                Style);
5892   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
5893                "                  aaaaaaaaaaaaaaa :\n"
5894                "                  (bbbbbbbbbbbbbbb ? //\n"
5895                "                       ccccccccccccccc :\n"
5896                "                       ddddddddddddddd);",
5897                Style);
5898   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5899                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
5900                "            ccccccccccccccccccccccccccc;",
5901                Style);
5902   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
5903                "           aaaaa :\n"
5904                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
5905                Style);
5906 }
5907 
5908 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
5909   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
5910                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
5911   verifyFormat("bool a = true, b = false;");
5912 
5913   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5914                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
5915                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
5916                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
5917   verifyFormat(
5918       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
5919       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
5920       "     d = e && f;");
5921   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
5922                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
5923   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
5924                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
5925   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
5926                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
5927 
5928   FormatStyle Style = getGoogleStyle();
5929   Style.PointerAlignment = FormatStyle::PAS_Left;
5930   Style.DerivePointerAlignment = false;
5931   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5932                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
5933                "    *b = bbbbbbbbbbbbbbbbbbb;",
5934                Style);
5935   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
5936                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
5937                Style);
5938   verifyFormat("vector<int*> a, b;", Style);
5939   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
5940 }
5941 
5942 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
5943   verifyFormat("arr[foo ? bar : baz];");
5944   verifyFormat("f()[foo ? bar : baz];");
5945   verifyFormat("(a + b)[foo ? bar : baz];");
5946   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
5947 }
5948 
5949 TEST_F(FormatTest, AlignsStringLiterals) {
5950   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
5951                "                                      \"short literal\");");
5952   verifyFormat(
5953       "looooooooooooooooooooooooongFunction(\n"
5954       "    \"short literal\"\n"
5955       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
5956   verifyFormat("someFunction(\"Always break between multi-line\"\n"
5957                "             \" string literals\",\n"
5958                "             and, other, parameters);");
5959   EXPECT_EQ("fun + \"1243\" /* comment */\n"
5960             "      \"5678\";",
5961             format("fun + \"1243\" /* comment */\n"
5962                    "    \"5678\";",
5963                    getLLVMStyleWithColumns(28)));
5964   EXPECT_EQ(
5965       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
5966       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
5967       "         \"aaaaaaaaaaaaaaaa\";",
5968       format("aaaaaa ="
5969              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
5970              "aaaaaaaaaaaaaaaaaaaaa\" "
5971              "\"aaaaaaaaaaaaaaaa\";"));
5972   verifyFormat("a = a + \"a\"\n"
5973                "        \"a\"\n"
5974                "        \"a\";");
5975   verifyFormat("f(\"a\", \"b\"\n"
5976                "       \"c\");");
5977 
5978   verifyFormat(
5979       "#define LL_FORMAT \"ll\"\n"
5980       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
5981       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
5982 
5983   verifyFormat("#define A(X)          \\\n"
5984                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
5985                "  \"ccccc\"",
5986                getLLVMStyleWithColumns(23));
5987   verifyFormat("#define A \"def\"\n"
5988                "f(\"abc\" A \"ghi\"\n"
5989                "  \"jkl\");");
5990 
5991   verifyFormat("f(L\"a\"\n"
5992                "  L\"b\");");
5993   verifyFormat("#define A(X)            \\\n"
5994                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
5995                "  L\"ccccc\"",
5996                getLLVMStyleWithColumns(25));
5997 
5998   verifyFormat("f(@\"a\"\n"
5999                "  @\"b\");");
6000   verifyFormat("NSString s = @\"a\"\n"
6001                "             @\"b\"\n"
6002                "             @\"c\";");
6003   verifyFormat("NSString s = @\"a\"\n"
6004                "              \"b\"\n"
6005                "              \"c\";");
6006 }
6007 
6008 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6009   FormatStyle Style = getLLVMStyle();
6010   // No declarations or definitions should be moved to own line.
6011   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6012   verifyFormat("class A {\n"
6013                "  int f() { return 1; }\n"
6014                "  int g();\n"
6015                "};\n"
6016                "int f() { return 1; }\n"
6017                "int g();\n",
6018                Style);
6019 
6020   // All declarations and definitions should have the return type moved to its
6021   // own
6022   // line.
6023   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6024   verifyFormat("class E {\n"
6025                "  int\n"
6026                "  f() {\n"
6027                "    return 1;\n"
6028                "  }\n"
6029                "  int\n"
6030                "  g();\n"
6031                "};\n"
6032                "int\n"
6033                "f() {\n"
6034                "  return 1;\n"
6035                "}\n"
6036                "int\n"
6037                "g();\n",
6038                Style);
6039 
6040   // Top-level definitions, and no kinds of declarations should have the
6041   // return type moved to its own line.
6042   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6043   verifyFormat("class B {\n"
6044                "  int f() { return 1; }\n"
6045                "  int g();\n"
6046                "};\n"
6047                "int\n"
6048                "f() {\n"
6049                "  return 1;\n"
6050                "}\n"
6051                "int g();\n",
6052                Style);
6053 
6054   // Top-level definitions and declarations should have the return type moved
6055   // to its own line.
6056   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6057   verifyFormat("class C {\n"
6058                "  int f() { return 1; }\n"
6059                "  int g();\n"
6060                "};\n"
6061                "int\n"
6062                "f() {\n"
6063                "  return 1;\n"
6064                "}\n"
6065                "int\n"
6066                "g();\n",
6067                Style);
6068 
6069   // All definitions should have the return type moved to its own line, but no
6070   // kinds of declarations.
6071   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6072   verifyFormat("class D {\n"
6073                "  int\n"
6074                "  f() {\n"
6075                "    return 1;\n"
6076                "  }\n"
6077                "  int g();\n"
6078                "};\n"
6079                "int\n"
6080                "f() {\n"
6081                "  return 1;\n"
6082                "}\n"
6083                "int g();\n",
6084                Style);
6085   verifyFormat("const char *\n"
6086                "f(void) {\n" // Break here.
6087                "  return \"\";\n"
6088                "}\n"
6089                "const char *bar(void);\n", // No break here.
6090                Style);
6091   verifyFormat("template <class T>\n"
6092                "T *\n"
6093                "f(T &c) {\n" // Break here.
6094                "  return NULL;\n"
6095                "}\n"
6096                "template <class T> T *f(T &c);\n", // No break here.
6097                Style);
6098   verifyFormat("class C {\n"
6099                "  int\n"
6100                "  operator+() {\n"
6101                "    return 1;\n"
6102                "  }\n"
6103                "  int\n"
6104                "  operator()() {\n"
6105                "    return 1;\n"
6106                "  }\n"
6107                "};\n",
6108                Style);
6109   verifyFormat("void\n"
6110                "A::operator()() {}\n"
6111                "void\n"
6112                "A::operator>>() {}\n"
6113                "void\n"
6114                "A::operator+() {}\n",
6115                Style);
6116   verifyFormat("void *operator new(std::size_t s);", // No break here.
6117                Style);
6118   verifyFormat("void *\n"
6119                "operator new(std::size_t s) {}",
6120                Style);
6121   verifyFormat("void *\n"
6122                "operator delete[](void *ptr) {}",
6123                Style);
6124   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6125   verifyFormat("const char *\n"
6126                "f(void)\n" // Break here.
6127                "{\n"
6128                "  return \"\";\n"
6129                "}\n"
6130                "const char *bar(void);\n", // No break here.
6131                Style);
6132   verifyFormat("template <class T>\n"
6133                "T *\n"     // Problem here: no line break
6134                "f(T &c)\n" // Break here.
6135                "{\n"
6136                "  return NULL;\n"
6137                "}\n"
6138                "template <class T> T *f(T &c);\n", // No break here.
6139                Style);
6140   verifyFormat("int\n"
6141                "foo(A<bool> a)\n"
6142                "{\n"
6143                "  return a;\n"
6144                "}\n",
6145                Style);
6146   verifyFormat("int\n"
6147                "foo(A<8> a)\n"
6148                "{\n"
6149                "  return a;\n"
6150                "}\n",
6151                Style);
6152   verifyFormat("int\n"
6153                "foo(A<B<bool>, 8> a)\n"
6154                "{\n"
6155                "  return a;\n"
6156                "}\n",
6157                Style);
6158   verifyFormat("int\n"
6159                "foo(A<B<8>, bool> a)\n"
6160                "{\n"
6161                "  return a;\n"
6162                "}\n",
6163                Style);
6164   verifyFormat("int\n"
6165                "foo(A<B<bool>, bool> a)\n"
6166                "{\n"
6167                "  return a;\n"
6168                "}\n",
6169                Style);
6170   verifyFormat("int\n"
6171                "foo(A<B<8>, 8> a)\n"
6172                "{\n"
6173                "  return a;\n"
6174                "}\n",
6175                Style);
6176 
6177   Style = getGNUStyle();
6178 
6179   // Test for comments at the end of function declarations.
6180   verifyFormat("void\n"
6181                "foo (int a, /*abc*/ int b) // def\n"
6182                "{\n"
6183                "}\n",
6184                Style);
6185 
6186   verifyFormat("void\n"
6187                "foo (int a, /* abc */ int b) /* def */\n"
6188                "{\n"
6189                "}\n",
6190                Style);
6191 
6192   // Definitions that should not break after return type
6193   verifyFormat("void foo (int a, int b); // def\n", Style);
6194   verifyFormat("void foo (int a, int b); /* def */\n", Style);
6195   verifyFormat("void foo (int a, int b);\n", Style);
6196 }
6197 
6198 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
6199   FormatStyle NoBreak = getLLVMStyle();
6200   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
6201   FormatStyle Break = getLLVMStyle();
6202   Break.AlwaysBreakBeforeMultilineStrings = true;
6203   verifyFormat("aaaa = \"bbbb\"\n"
6204                "       \"cccc\";",
6205                NoBreak);
6206   verifyFormat("aaaa =\n"
6207                "    \"bbbb\"\n"
6208                "    \"cccc\";",
6209                Break);
6210   verifyFormat("aaaa(\"bbbb\"\n"
6211                "     \"cccc\");",
6212                NoBreak);
6213   verifyFormat("aaaa(\n"
6214                "    \"bbbb\"\n"
6215                "    \"cccc\");",
6216                Break);
6217   verifyFormat("aaaa(qqq, \"bbbb\"\n"
6218                "          \"cccc\");",
6219                NoBreak);
6220   verifyFormat("aaaa(qqq,\n"
6221                "     \"bbbb\"\n"
6222                "     \"cccc\");",
6223                Break);
6224   verifyFormat("aaaa(qqq,\n"
6225                "     L\"bbbb\"\n"
6226                "     L\"cccc\");",
6227                Break);
6228   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
6229                "                      \"bbbb\"));",
6230                Break);
6231   verifyFormat("string s = someFunction(\n"
6232                "    \"abc\"\n"
6233                "    \"abc\");",
6234                Break);
6235 
6236   // As we break before unary operators, breaking right after them is bad.
6237   verifyFormat("string foo = abc ? \"x\"\n"
6238                "                   \"blah blah blah blah blah blah\"\n"
6239                "                 : \"y\";",
6240                Break);
6241 
6242   // Don't break if there is no column gain.
6243   verifyFormat("f(\"aaaa\"\n"
6244                "  \"bbbb\");",
6245                Break);
6246 
6247   // Treat literals with escaped newlines like multi-line string literals.
6248   EXPECT_EQ("x = \"a\\\n"
6249             "b\\\n"
6250             "c\";",
6251             format("x = \"a\\\n"
6252                    "b\\\n"
6253                    "c\";",
6254                    NoBreak));
6255   EXPECT_EQ("xxxx =\n"
6256             "    \"a\\\n"
6257             "b\\\n"
6258             "c\";",
6259             format("xxxx = \"a\\\n"
6260                    "b\\\n"
6261                    "c\";",
6262                    Break));
6263 
6264   EXPECT_EQ("NSString *const kString =\n"
6265             "    @\"aaaa\"\n"
6266             "    @\"bbbb\";",
6267             format("NSString *const kString = @\"aaaa\"\n"
6268                    "@\"bbbb\";",
6269                    Break));
6270 
6271   Break.ColumnLimit = 0;
6272   verifyFormat("const char *hello = \"hello llvm\";", Break);
6273 }
6274 
6275 TEST_F(FormatTest, AlignsPipes) {
6276   verifyFormat(
6277       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6278       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6279       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6280   verifyFormat(
6281       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
6282       "                     << aaaaaaaaaaaaaaaaaaaa;");
6283   verifyFormat(
6284       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6285       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6286   verifyFormat(
6287       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
6288       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6289   verifyFormat(
6290       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
6291       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
6292       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
6293   verifyFormat(
6294       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6295       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6296       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6297   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6298                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6299                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6300                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
6301   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
6302                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
6303   verifyFormat(
6304       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6305       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6306   verifyFormat(
6307       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
6308       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
6309 
6310   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
6311                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
6312   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6313                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6314                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
6315                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
6316   verifyFormat("LOG_IF(aaa == //\n"
6317                "       bbb)\n"
6318                "    << a << b;");
6319 
6320   // But sometimes, breaking before the first "<<" is desirable.
6321   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6322                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
6323   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
6324                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6325                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6326   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
6327                "    << BEF << IsTemplate << Description << E->getType();");
6328   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6329                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6330                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6331   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
6332                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6333                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6334                "    << aaa;");
6335 
6336   verifyFormat(
6337       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6338       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
6339 
6340   // Incomplete string literal.
6341   EXPECT_EQ("llvm::errs() << \"\n"
6342             "             << a;",
6343             format("llvm::errs() << \"\n<<a;"));
6344 
6345   verifyFormat("void f() {\n"
6346                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
6347                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
6348                "}");
6349 
6350   // Handle 'endl'.
6351   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
6352                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
6353   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
6354 
6355   // Handle '\n'.
6356   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
6357                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
6358   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
6359                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
6360   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
6361                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
6362   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
6363 }
6364 
6365 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
6366   verifyFormat("return out << \"somepacket = {\\n\"\n"
6367                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
6368                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
6369                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
6370                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
6371                "           << \"}\";");
6372 
6373   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
6374                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
6375                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
6376   verifyFormat(
6377       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
6378       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
6379       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
6380       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
6381       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
6382   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
6383                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
6384   verifyFormat(
6385       "void f() {\n"
6386       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
6387       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
6388       "}");
6389 
6390   // Breaking before the first "<<" is generally not desirable.
6391   verifyFormat(
6392       "llvm::errs()\n"
6393       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6394       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6395       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6396       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6397       getLLVMStyleWithColumns(70));
6398   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
6399                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6400                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
6401                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6402                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
6403                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6404                getLLVMStyleWithColumns(70));
6405 
6406   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
6407                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
6408                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
6409   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
6410                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
6411                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
6412   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
6413                "           (aaaa + aaaa);",
6414                getLLVMStyleWithColumns(40));
6415   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
6416                "                  (aaaaaaa + aaaaa));",
6417                getLLVMStyleWithColumns(40));
6418   verifyFormat(
6419       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
6420       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
6421       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
6422 }
6423 
6424 TEST_F(FormatTest, UnderstandsEquals) {
6425   verifyFormat(
6426       "aaaaaaaaaaaaaaaaa =\n"
6427       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6428   verifyFormat(
6429       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6430       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
6431   verifyFormat(
6432       "if (a) {\n"
6433       "  f();\n"
6434       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6435       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
6436       "}");
6437 
6438   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6439                "        100000000 + 10000000) {\n}");
6440 }
6441 
6442 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
6443   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
6444                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
6445 
6446   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
6447                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
6448 
6449   verifyFormat(
6450       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
6451       "                                                          Parameter2);");
6452 
6453   verifyFormat(
6454       "ShortObject->shortFunction(\n"
6455       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
6456       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
6457 
6458   verifyFormat("loooooooooooooongFunction(\n"
6459                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
6460 
6461   verifyFormat(
6462       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
6463       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
6464 
6465   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
6466                "    .WillRepeatedly(Return(SomeValue));");
6467   verifyFormat("void f() {\n"
6468                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
6469                "      .Times(2)\n"
6470                "      .WillRepeatedly(Return(SomeValue));\n"
6471                "}");
6472   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
6473                "    ccccccccccccccccccccccc);");
6474   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6475                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6476                "          .aaaaa(aaaaa),\n"
6477                "      aaaaaaaaaaaaaaaaaaaaa);");
6478   verifyFormat("void f() {\n"
6479                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6480                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
6481                "}");
6482   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6483                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6484                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6485                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6486                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
6487   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6488                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6489                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6490                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
6491                "}");
6492 
6493   // Here, it is not necessary to wrap at "." or "->".
6494   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
6495                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
6496   verifyFormat(
6497       "aaaaaaaaaaa->aaaaaaaaa(\n"
6498       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6499       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
6500 
6501   verifyFormat(
6502       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6503       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
6504   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
6505                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
6506   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
6507                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
6508 
6509   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6510                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6511                "    .a();");
6512 
6513   FormatStyle NoBinPacking = getLLVMStyle();
6514   NoBinPacking.BinPackParameters = false;
6515   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
6516                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
6517                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
6518                "                         aaaaaaaaaaaaaaaaaaa,\n"
6519                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6520                NoBinPacking);
6521 
6522   // If there is a subsequent call, change to hanging indentation.
6523   verifyFormat(
6524       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6525       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
6526       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
6527   verifyFormat(
6528       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6529       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
6530   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6531                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6532                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
6533   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6534                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6535                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
6536 }
6537 
6538 TEST_F(FormatTest, WrapsTemplateDeclarations) {
6539   verifyFormat("template <typename T>\n"
6540                "virtual void loooooooooooongFunction(int Param1, int Param2);");
6541   verifyFormat("template <typename T>\n"
6542                "// T should be one of {A, B}.\n"
6543                "virtual void loooooooooooongFunction(int Param1, int Param2);");
6544   verifyFormat(
6545       "template <typename T>\n"
6546       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
6547   verifyFormat("template <typename T>\n"
6548                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
6549                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
6550   verifyFormat(
6551       "template <typename T>\n"
6552       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
6553       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
6554   verifyFormat(
6555       "template <typename T>\n"
6556       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
6557       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
6558       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6559   verifyFormat("template <typename T>\n"
6560                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6561                "    int aaaaaaaaaaaaaaaaaaaaaa);");
6562   verifyFormat(
6563       "template <typename T1, typename T2 = char, typename T3 = char,\n"
6564       "          typename T4 = char>\n"
6565       "void f();");
6566   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
6567                "          template <typename> class cccccccccccccccccccccc,\n"
6568                "          typename ddddddddddddd>\n"
6569                "class C {};");
6570   verifyFormat(
6571       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
6572       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6573 
6574   verifyFormat("void f() {\n"
6575                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
6576                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
6577                "}");
6578 
6579   verifyFormat("template <typename T> class C {};");
6580   verifyFormat("template <typename T> void f();");
6581   verifyFormat("template <typename T> void f() {}");
6582   verifyFormat(
6583       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
6584       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6585       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
6586       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
6587       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6588       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
6589       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
6590       getLLVMStyleWithColumns(72));
6591   EXPECT_EQ("static_cast<A< //\n"
6592             "    B> *>(\n"
6593             "\n"
6594             ");",
6595             format("static_cast<A<//\n"
6596                    "    B>*>(\n"
6597                    "\n"
6598                    "    );"));
6599   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6600                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
6601 
6602   FormatStyle AlwaysBreak = getLLVMStyle();
6603   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
6604   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
6605   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
6606   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
6607   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6608                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
6609                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
6610   verifyFormat("template <template <typename> class Fooooooo,\n"
6611                "          template <typename> class Baaaaaaar>\n"
6612                "struct C {};",
6613                AlwaysBreak);
6614   verifyFormat("template <typename T> // T can be A, B or C.\n"
6615                "struct C {};",
6616                AlwaysBreak);
6617   verifyFormat("template <enum E> class A {\n"
6618                "public:\n"
6619                "  E *f();\n"
6620                "};");
6621 
6622   FormatStyle NeverBreak = getLLVMStyle();
6623   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
6624   verifyFormat("template <typename T> class C {};", NeverBreak);
6625   verifyFormat("template <typename T> void f();", NeverBreak);
6626   verifyFormat("template <typename T> void f() {}", NeverBreak);
6627   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
6628                "bbbbbbbbbbbbbbbbbbbb) {}",
6629                NeverBreak);
6630   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6631                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
6632                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
6633                NeverBreak);
6634   verifyFormat("template <template <typename> class Fooooooo,\n"
6635                "          template <typename> class Baaaaaaar>\n"
6636                "struct C {};",
6637                NeverBreak);
6638   verifyFormat("template <typename T> // T can be A, B or C.\n"
6639                "struct C {};",
6640                NeverBreak);
6641   verifyFormat("template <enum E> class A {\n"
6642                "public:\n"
6643                "  E *f();\n"
6644                "};",
6645                NeverBreak);
6646   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
6647   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
6648                "bbbbbbbbbbbbbbbbbbbb) {}",
6649                NeverBreak);
6650 }
6651 
6652 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
6653   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
6654   Style.ColumnLimit = 60;
6655   EXPECT_EQ("// Baseline - no comments.\n"
6656             "template <\n"
6657             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
6658             "void f() {}",
6659             format("// Baseline - no comments.\n"
6660                    "template <\n"
6661                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
6662                    "void f() {}",
6663                    Style));
6664 
6665   EXPECT_EQ("template <\n"
6666             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
6667             "void f() {}",
6668             format("template <\n"
6669                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
6670                    "void f() {}",
6671                    Style));
6672 
6673   EXPECT_EQ(
6674       "template <\n"
6675       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
6676       "void f() {}",
6677       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
6678              "void f() {}",
6679              Style));
6680 
6681   EXPECT_EQ(
6682       "template <\n"
6683       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
6684       "                                               // multiline\n"
6685       "void f() {}",
6686       format("template <\n"
6687              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
6688              "                                              // multiline\n"
6689              "void f() {}",
6690              Style));
6691 
6692   EXPECT_EQ(
6693       "template <typename aaaaaaaaaa<\n"
6694       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
6695       "void f() {}",
6696       format(
6697           "template <\n"
6698           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
6699           "void f() {}",
6700           Style));
6701 }
6702 
6703 TEST_F(FormatTest, WrapsTemplateParameters) {
6704   FormatStyle Style = getLLVMStyle();
6705   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6706   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
6707   verifyFormat(
6708       "template <typename... a> struct q {};\n"
6709       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
6710       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
6711       "    y;",
6712       Style);
6713   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6714   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
6715   verifyFormat(
6716       "template <typename... a> struct r {};\n"
6717       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
6718       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
6719       "    y;",
6720       Style);
6721   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6722   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
6723   verifyFormat("template <typename... a> struct s {};\n"
6724                "extern s<\n"
6725                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
6726                "aaaaaaaaaaaaaaaaaaaaaa,\n"
6727                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
6728                "aaaaaaaaaaaaaaaaaaaaaa>\n"
6729                "    y;",
6730                Style);
6731   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6732   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
6733   verifyFormat("template <typename... a> struct t {};\n"
6734                "extern t<\n"
6735                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
6736                "aaaaaaaaaaaaaaaaaaaaaa,\n"
6737                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
6738                "aaaaaaaaaaaaaaaaaaaaaa>\n"
6739                "    y;",
6740                Style);
6741 }
6742 
6743 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
6744   verifyFormat(
6745       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
6746       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
6747   verifyFormat(
6748       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
6749       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6750       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
6751 
6752   // FIXME: Should we have the extra indent after the second break?
6753   verifyFormat(
6754       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
6755       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
6756       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
6757 
6758   verifyFormat(
6759       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
6760       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
6761 
6762   // Breaking at nested name specifiers is generally not desirable.
6763   verifyFormat(
6764       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6765       "    aaaaaaaaaaaaaaaaaaaaaaa);");
6766 
6767   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
6768                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
6769                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6770                "                   aaaaaaaaaaaaaaaaaaaaa);",
6771                getLLVMStyleWithColumns(74));
6772 
6773   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
6774                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6775                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
6776 }
6777 
6778 TEST_F(FormatTest, UnderstandsTemplateParameters) {
6779   verifyFormat("A<int> a;");
6780   verifyFormat("A<A<A<int>>> a;");
6781   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
6782   verifyFormat("bool x = a < 1 || 2 > a;");
6783   verifyFormat("bool x = 5 < f<int>();");
6784   verifyFormat("bool x = f<int>() > 5;");
6785   verifyFormat("bool x = 5 < a<int>::x;");
6786   verifyFormat("bool x = a < 4 ? a > 2 : false;");
6787   verifyFormat("bool x = f() ? a < 2 : a > 2;");
6788 
6789   verifyGoogleFormat("A<A<int>> a;");
6790   verifyGoogleFormat("A<A<A<int>>> a;");
6791   verifyGoogleFormat("A<A<A<A<int>>>> a;");
6792   verifyGoogleFormat("A<A<int> > a;");
6793   verifyGoogleFormat("A<A<A<int> > > a;");
6794   verifyGoogleFormat("A<A<A<A<int> > > > a;");
6795   verifyGoogleFormat("A<::A<int>> a;");
6796   verifyGoogleFormat("A<::A> a;");
6797   verifyGoogleFormat("A< ::A> a;");
6798   verifyGoogleFormat("A< ::A<int> > a;");
6799   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
6800   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
6801   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
6802   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
6803   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
6804             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
6805 
6806   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
6807 
6808   // template closer followed by a token that starts with > or =
6809   verifyFormat("bool b = a<1> > 1;");
6810   verifyFormat("bool b = a<1> >= 1;");
6811   verifyFormat("int i = a<1> >> 1;");
6812   FormatStyle Style = getLLVMStyle();
6813   Style.SpaceBeforeAssignmentOperators = false;
6814   verifyFormat("bool b= a<1> == 1;", Style);
6815   verifyFormat("a<int> = 1;", Style);
6816   verifyFormat("a<int> >>= 1;", Style);
6817 
6818   verifyFormat("test >> a >> b;");
6819   verifyFormat("test << a >> b;");
6820 
6821   verifyFormat("f<int>();");
6822   verifyFormat("template <typename T> void f() {}");
6823   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
6824   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
6825                "sizeof(char)>::type>;");
6826   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
6827   verifyFormat("f(a.operator()<A>());");
6828   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6829                "      .template operator()<A>());",
6830                getLLVMStyleWithColumns(35));
6831 
6832   // Not template parameters.
6833   verifyFormat("return a < b && c > d;");
6834   verifyFormat("void f() {\n"
6835                "  while (a < b && c > d) {\n"
6836                "  }\n"
6837                "}");
6838   verifyFormat("template <typename... Types>\n"
6839                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
6840 
6841   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6842                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
6843                getLLVMStyleWithColumns(60));
6844   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
6845   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
6846   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
6847 }
6848 
6849 TEST_F(FormatTest, BitshiftOperatorWidth) {
6850   EXPECT_EQ("int a = 1 << 2; /* foo\n"
6851             "                   bar */",
6852             format("int    a=1<<2;  /* foo\n"
6853                    "                   bar */"));
6854 
6855   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
6856             "                     bar */",
6857             format("int  b  =256>>1 ;  /* foo\n"
6858                    "                      bar */"));
6859 }
6860 
6861 TEST_F(FormatTest, UnderstandsBinaryOperators) {
6862   verifyFormat("COMPARE(a, ==, b);");
6863   verifyFormat("auto s = sizeof...(Ts) - 1;");
6864 }
6865 
6866 TEST_F(FormatTest, UnderstandsPointersToMembers) {
6867   verifyFormat("int A::*x;");
6868   verifyFormat("int (S::*func)(void *);");
6869   verifyFormat("void f() { int (S::*func)(void *); }");
6870   verifyFormat("typedef bool *(Class::*Member)() const;");
6871   verifyFormat("void f() {\n"
6872                "  (a->*f)();\n"
6873                "  a->*x;\n"
6874                "  (a.*f)();\n"
6875                "  ((*a).*f)();\n"
6876                "  a.*x;\n"
6877                "}");
6878   verifyFormat("void f() {\n"
6879                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
6880                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
6881                "}");
6882   verifyFormat(
6883       "(aaaaaaaaaa->*bbbbbbb)(\n"
6884       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
6885   FormatStyle Style = getLLVMStyle();
6886   Style.PointerAlignment = FormatStyle::PAS_Left;
6887   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
6888 }
6889 
6890 TEST_F(FormatTest, UnderstandsUnaryOperators) {
6891   verifyFormat("int a = -2;");
6892   verifyFormat("f(-1, -2, -3);");
6893   verifyFormat("a[-1] = 5;");
6894   verifyFormat("int a = 5 + -2;");
6895   verifyFormat("if (i == -1) {\n}");
6896   verifyFormat("if (i != -1) {\n}");
6897   verifyFormat("if (i > -1) {\n}");
6898   verifyFormat("if (i < -1) {\n}");
6899   verifyFormat("++(a->f());");
6900   verifyFormat("--(a->f());");
6901   verifyFormat("(a->f())++;");
6902   verifyFormat("a[42]++;");
6903   verifyFormat("if (!(a->f())) {\n}");
6904   verifyFormat("if (!+i) {\n}");
6905   verifyFormat("~&a;");
6906 
6907   verifyFormat("a-- > b;");
6908   verifyFormat("b ? -a : c;");
6909   verifyFormat("n * sizeof char16;");
6910   verifyFormat("n * alignof char16;", getGoogleStyle());
6911   verifyFormat("sizeof(char);");
6912   verifyFormat("alignof(char);", getGoogleStyle());
6913 
6914   verifyFormat("return -1;");
6915   verifyFormat("switch (a) {\n"
6916                "case -1:\n"
6917                "  break;\n"
6918                "}");
6919   verifyFormat("#define X -1");
6920   verifyFormat("#define X -kConstant");
6921 
6922   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
6923   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
6924 
6925   verifyFormat("int a = /* confusing comment */ -1;");
6926   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
6927   verifyFormat("int a = i /* confusing comment */++;");
6928 }
6929 
6930 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
6931   verifyFormat("if (!aaaaaaaaaa( // break\n"
6932                "        aaaaa)) {\n"
6933                "}");
6934   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
6935                "    aaaaa));");
6936   verifyFormat("*aaa = aaaaaaa( // break\n"
6937                "    bbbbbb);");
6938 }
6939 
6940 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
6941   verifyFormat("bool operator<();");
6942   verifyFormat("bool operator>();");
6943   verifyFormat("bool operator=();");
6944   verifyFormat("bool operator==();");
6945   verifyFormat("bool operator!=();");
6946   verifyFormat("int operator+();");
6947   verifyFormat("int operator++();");
6948   verifyFormat("int operator++(int) volatile noexcept;");
6949   verifyFormat("bool operator,();");
6950   verifyFormat("bool operator();");
6951   verifyFormat("bool operator()();");
6952   verifyFormat("bool operator[]();");
6953   verifyFormat("operator bool();");
6954   verifyFormat("operator int();");
6955   verifyFormat("operator void *();");
6956   verifyFormat("operator SomeType<int>();");
6957   verifyFormat("operator SomeType<int, int>();");
6958   verifyFormat("operator SomeType<SomeType<int>>();");
6959   verifyFormat("void *operator new(std::size_t size);");
6960   verifyFormat("void *operator new[](std::size_t size);");
6961   verifyFormat("void operator delete(void *ptr);");
6962   verifyFormat("void operator delete[](void *ptr);");
6963   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
6964                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
6965   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
6966                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
6967 
6968   verifyFormat(
6969       "ostream &operator<<(ostream &OutputStream,\n"
6970       "                    SomeReallyLongType WithSomeReallyLongValue);");
6971   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
6972                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
6973                "  return left.group < right.group;\n"
6974                "}");
6975   verifyFormat("SomeType &operator=(const SomeType &S);");
6976   verifyFormat("f.template operator()<int>();");
6977 
6978   verifyGoogleFormat("operator void*();");
6979   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
6980   verifyGoogleFormat("operator ::A();");
6981 
6982   verifyFormat("using A::operator+;");
6983   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
6984                "int i;");
6985 }
6986 
6987 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
6988   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
6989   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
6990   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
6991   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
6992   verifyFormat("Deleted &operator=(const Deleted &) &;");
6993   verifyFormat("Deleted &operator=(const Deleted &) &&;");
6994   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
6995   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
6996   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
6997   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
6998   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
6999   verifyFormat("void Fn(T const &) const &;");
7000   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7001   verifyFormat("template <typename T>\n"
7002                "void F(T) && = delete;",
7003                getGoogleStyle());
7004 
7005   FormatStyle AlignLeft = getLLVMStyle();
7006   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7007   verifyFormat("void A::b() && {}", AlignLeft);
7008   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7009   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7010                AlignLeft);
7011   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7012   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7013   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7014   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7015   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7016   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7017   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7018   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7019 
7020   FormatStyle Spaces = getLLVMStyle();
7021   Spaces.SpacesInCStyleCastParentheses = true;
7022   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7023   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7024   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7025   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7026 
7027   Spaces.SpacesInCStyleCastParentheses = false;
7028   Spaces.SpacesInParentheses = true;
7029   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7030   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7031                Spaces);
7032   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7033   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7034 
7035   FormatStyle BreakTemplate = getLLVMStyle();
7036   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7037 
7038   verifyFormat("struct f {\n"
7039                "  template <class T>\n"
7040                "  int &foo(const std::string &str) & noexcept {}\n"
7041                "};",
7042                BreakTemplate);
7043 
7044   verifyFormat("struct f {\n"
7045                "  template <class T>\n"
7046                "  int &foo(const std::string &str) && noexcept {}\n"
7047                "};",
7048                BreakTemplate);
7049 
7050   verifyFormat("struct f {\n"
7051                "  template <class T>\n"
7052                "  int &foo(const std::string &str) const & noexcept {}\n"
7053                "};",
7054                BreakTemplate);
7055 
7056   verifyFormat("struct f {\n"
7057                "  template <class T>\n"
7058                "  int &foo(const std::string &str) const & noexcept {}\n"
7059                "};",
7060                BreakTemplate);
7061 
7062   verifyFormat("struct f {\n"
7063                "  template <class T>\n"
7064                "  auto foo(const std::string &str) && noexcept -> int & {}\n"
7065                "};",
7066                BreakTemplate);
7067 
7068   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7069   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7070       FormatStyle::BTDS_Yes;
7071   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7072 
7073   verifyFormat("struct f {\n"
7074                "  template <class T>\n"
7075                "  int& foo(const std::string& str) & noexcept {}\n"
7076                "};",
7077                AlignLeftBreakTemplate);
7078 
7079   verifyFormat("struct f {\n"
7080                "  template <class T>\n"
7081                "  int& foo(const std::string& str) && noexcept {}\n"
7082                "};",
7083                AlignLeftBreakTemplate);
7084 
7085   verifyFormat("struct f {\n"
7086                "  template <class T>\n"
7087                "  int& foo(const std::string& str) const & noexcept {}\n"
7088                "};",
7089                AlignLeftBreakTemplate);
7090 
7091   verifyFormat("struct f {\n"
7092                "  template <class T>\n"
7093                "  int& foo(const std::string& str) const & noexcept {}\n"
7094                "};",
7095                AlignLeftBreakTemplate);
7096 
7097   verifyFormat("struct f {\n"
7098                "  template <class T>\n"
7099                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7100                "};",
7101                AlignLeftBreakTemplate);
7102 }
7103 
7104 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7105   verifyFormat("void f() {\n"
7106                "  A *a = new A;\n"
7107                "  A *a = new (placement) A;\n"
7108                "  delete a;\n"
7109                "  delete (A *)a;\n"
7110                "}");
7111   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7112                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7113   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7114                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7115                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7116   verifyFormat("delete[] h->p;");
7117 }
7118 
7119 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
7120   verifyFormat("int *f(int *a) {}");
7121   verifyFormat("int main(int argc, char **argv) {}");
7122   verifyFormat("Test::Test(int b) : a(b * b) {}");
7123   verifyIndependentOfContext("f(a, *a);");
7124   verifyFormat("void g() { f(*a); }");
7125   verifyIndependentOfContext("int a = b * 10;");
7126   verifyIndependentOfContext("int a = 10 * b;");
7127   verifyIndependentOfContext("int a = b * c;");
7128   verifyIndependentOfContext("int a += b * c;");
7129   verifyIndependentOfContext("int a -= b * c;");
7130   verifyIndependentOfContext("int a *= b * c;");
7131   verifyIndependentOfContext("int a /= b * c;");
7132   verifyIndependentOfContext("int a = *b;");
7133   verifyIndependentOfContext("int a = *b * c;");
7134   verifyIndependentOfContext("int a = b * *c;");
7135   verifyIndependentOfContext("int a = b * (10);");
7136   verifyIndependentOfContext("S << b * (10);");
7137   verifyIndependentOfContext("return 10 * b;");
7138   verifyIndependentOfContext("return *b * *c;");
7139   verifyIndependentOfContext("return a & ~b;");
7140   verifyIndependentOfContext("f(b ? *c : *d);");
7141   verifyIndependentOfContext("int a = b ? *c : *d;");
7142   verifyIndependentOfContext("*b = a;");
7143   verifyIndependentOfContext("a * ~b;");
7144   verifyIndependentOfContext("a * !b;");
7145   verifyIndependentOfContext("a * +b;");
7146   verifyIndependentOfContext("a * -b;");
7147   verifyIndependentOfContext("a * ++b;");
7148   verifyIndependentOfContext("a * --b;");
7149   verifyIndependentOfContext("a[4] * b;");
7150   verifyIndependentOfContext("a[a * a] = 1;");
7151   verifyIndependentOfContext("f() * b;");
7152   verifyIndependentOfContext("a * [self dostuff];");
7153   verifyIndependentOfContext("int x = a * (a + b);");
7154   verifyIndependentOfContext("(a *)(a + b);");
7155   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
7156   verifyIndependentOfContext("int *pa = (int *)&a;");
7157   verifyIndependentOfContext("return sizeof(int **);");
7158   verifyIndependentOfContext("return sizeof(int ******);");
7159   verifyIndependentOfContext("return (int **&)a;");
7160   verifyIndependentOfContext("f((*PointerToArray)[10]);");
7161   verifyFormat("void f(Type (*parameter)[10]) {}");
7162   verifyFormat("void f(Type (&parameter)[10]) {}");
7163   verifyGoogleFormat("return sizeof(int**);");
7164   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
7165   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
7166   verifyFormat("auto a = [](int **&, int ***) {};");
7167   verifyFormat("auto PointerBinding = [](const char *S) {};");
7168   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
7169   verifyFormat("[](const decltype(*a) &value) {}");
7170   verifyFormat("decltype(a * b) F();");
7171   verifyFormat("#define MACRO() [](A *a) { return 1; }");
7172   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
7173   verifyIndependentOfContext("typedef void (*f)(int *a);");
7174   verifyIndependentOfContext("int i{a * b};");
7175   verifyIndependentOfContext("aaa && aaa->f();");
7176   verifyIndependentOfContext("int x = ~*p;");
7177   verifyFormat("Constructor() : a(a), area(width * height) {}");
7178   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
7179   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
7180   verifyFormat("void f() { f(a, c * d); }");
7181   verifyFormat("void f() { f(new a(), c * d); }");
7182   verifyFormat("void f(const MyOverride &override);");
7183   verifyFormat("void f(const MyFinal &final);");
7184   verifyIndependentOfContext("bool a = f() && override.f();");
7185   verifyIndependentOfContext("bool a = f() && final.f();");
7186 
7187   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
7188 
7189   verifyIndependentOfContext("A<int *> a;");
7190   verifyIndependentOfContext("A<int **> a;");
7191   verifyIndependentOfContext("A<int *, int *> a;");
7192   verifyIndependentOfContext("A<int *[]> a;");
7193   verifyIndependentOfContext(
7194       "const char *const p = reinterpret_cast<const char *const>(q);");
7195   verifyIndependentOfContext("A<int **, int **> a;");
7196   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
7197   verifyFormat("for (char **a = b; *a; ++a) {\n}");
7198   verifyFormat("for (; a && b;) {\n}");
7199   verifyFormat("bool foo = true && [] { return false; }();");
7200 
7201   verifyFormat(
7202       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7203       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7204 
7205   verifyGoogleFormat("int const* a = &b;");
7206   verifyGoogleFormat("**outparam = 1;");
7207   verifyGoogleFormat("*outparam = a * b;");
7208   verifyGoogleFormat("int main(int argc, char** argv) {}");
7209   verifyGoogleFormat("A<int*> a;");
7210   verifyGoogleFormat("A<int**> a;");
7211   verifyGoogleFormat("A<int*, int*> a;");
7212   verifyGoogleFormat("A<int**, int**> a;");
7213   verifyGoogleFormat("f(b ? *c : *d);");
7214   verifyGoogleFormat("int a = b ? *c : *d;");
7215   verifyGoogleFormat("Type* t = **x;");
7216   verifyGoogleFormat("Type* t = *++*x;");
7217   verifyGoogleFormat("*++*x;");
7218   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
7219   verifyGoogleFormat("Type* t = x++ * y;");
7220   verifyGoogleFormat(
7221       "const char* const p = reinterpret_cast<const char* const>(q);");
7222   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
7223   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
7224   verifyGoogleFormat("template <typename T>\n"
7225                      "void f(int i = 0, SomeType** temps = NULL);");
7226 
7227   FormatStyle Left = getLLVMStyle();
7228   Left.PointerAlignment = FormatStyle::PAS_Left;
7229   verifyFormat("x = *a(x) = *a(y);", Left);
7230   verifyFormat("for (;; *a = b) {\n}", Left);
7231   verifyFormat("return *this += 1;", Left);
7232   verifyFormat("throw *x;", Left);
7233   verifyFormat("delete *x;", Left);
7234   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
7235   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
7236   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
7237 
7238   verifyIndependentOfContext("a = *(x + y);");
7239   verifyIndependentOfContext("a = &(x + y);");
7240   verifyIndependentOfContext("*(x + y).call();");
7241   verifyIndependentOfContext("&(x + y)->call();");
7242   verifyFormat("void f() { &(*I).first; }");
7243 
7244   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
7245   verifyFormat(
7246       "int *MyValues = {\n"
7247       "    *A, // Operator detection might be confused by the '{'\n"
7248       "    *BB // Operator detection might be confused by previous comment\n"
7249       "};");
7250 
7251   verifyIndependentOfContext("if (int *a = &b)");
7252   verifyIndependentOfContext("if (int &a = *b)");
7253   verifyIndependentOfContext("if (a & b[i])");
7254   verifyIndependentOfContext("if constexpr (a & b[i])");
7255   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
7256   verifyIndependentOfContext("if (a * (b * c))");
7257   verifyIndependentOfContext("if constexpr (a * (b * c))");
7258   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
7259   verifyIndependentOfContext("if (a::b::c::d & b[i])");
7260   verifyIndependentOfContext("if (*b[i])");
7261   verifyIndependentOfContext("if (int *a = (&b))");
7262   verifyIndependentOfContext("while (int *a = &b)");
7263   verifyIndependentOfContext("while (a * (b * c))");
7264   verifyIndependentOfContext("size = sizeof *a;");
7265   verifyIndependentOfContext("if (a && (b = c))");
7266   verifyFormat("void f() {\n"
7267                "  for (const int &v : Values) {\n"
7268                "  }\n"
7269                "}");
7270   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
7271   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
7272   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
7273 
7274   verifyFormat("#define A (!a * b)");
7275   verifyFormat("#define MACRO     \\\n"
7276                "  int *i = a * b; \\\n"
7277                "  void f(a *b);",
7278                getLLVMStyleWithColumns(19));
7279 
7280   verifyIndependentOfContext("A = new SomeType *[Length];");
7281   verifyIndependentOfContext("A = new SomeType *[Length]();");
7282   verifyIndependentOfContext("T **t = new T *;");
7283   verifyIndependentOfContext("T **t = new T *();");
7284   verifyGoogleFormat("A = new SomeType*[Length]();");
7285   verifyGoogleFormat("A = new SomeType*[Length];");
7286   verifyGoogleFormat("T** t = new T*;");
7287   verifyGoogleFormat("T** t = new T*();");
7288 
7289   verifyFormat("STATIC_ASSERT((a & b) == 0);");
7290   verifyFormat("STATIC_ASSERT(0 == (a & b));");
7291   verifyFormat("template <bool a, bool b> "
7292                "typename t::if<x && y>::type f() {}");
7293   verifyFormat("template <int *y> f() {}");
7294   verifyFormat("vector<int *> v;");
7295   verifyFormat("vector<int *const> v;");
7296   verifyFormat("vector<int *const **const *> v;");
7297   verifyFormat("vector<int *volatile> v;");
7298   verifyFormat("vector<a * b> v;");
7299   verifyFormat("foo<b && false>();");
7300   verifyFormat("foo<b & 1>();");
7301   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
7302   verifyFormat(
7303       "template <class T, class = typename std::enable_if<\n"
7304       "                       std::is_integral<T>::value &&\n"
7305       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
7306       "void F();",
7307       getLLVMStyleWithColumns(70));
7308   verifyFormat("template <class T,\n"
7309                "          class = typename std::enable_if<\n"
7310                "              std::is_integral<T>::value &&\n"
7311                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
7312                "          class U>\n"
7313                "void F();",
7314                getLLVMStyleWithColumns(70));
7315   verifyFormat(
7316       "template <class T,\n"
7317       "          class = typename ::std::enable_if<\n"
7318       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
7319       "void F();",
7320       getGoogleStyleWithColumns(68));
7321 
7322   verifyIndependentOfContext("MACRO(int *i);");
7323   verifyIndependentOfContext("MACRO(auto *a);");
7324   verifyIndependentOfContext("MACRO(const A *a);");
7325   verifyIndependentOfContext("MACRO(A *const a);");
7326   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
7327   verifyFormat("void f() { f(float{1}, a * a); }");
7328   // FIXME: Is there a way to make this work?
7329   // verifyIndependentOfContext("MACRO(A *a);");
7330 
7331   verifyFormat("DatumHandle const *operator->() const { return input_; }");
7332   verifyFormat("return options != nullptr && operator==(*options);");
7333 
7334   EXPECT_EQ("#define OP(x)                                    \\\n"
7335             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
7336             "    return s << a.DebugString();                 \\\n"
7337             "  }",
7338             format("#define OP(x) \\\n"
7339                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
7340                    "    return s << a.DebugString(); \\\n"
7341                    "  }",
7342                    getLLVMStyleWithColumns(50)));
7343 
7344   // FIXME: We cannot handle this case yet; we might be able to figure out that
7345   // foo<x> d > v; doesn't make sense.
7346   verifyFormat("foo<a<b && c> d> v;");
7347 
7348   FormatStyle PointerMiddle = getLLVMStyle();
7349   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
7350   verifyFormat("delete *x;", PointerMiddle);
7351   verifyFormat("int * x;", PointerMiddle);
7352   verifyFormat("int *[] x;", PointerMiddle);
7353   verifyFormat("template <int * y> f() {}", PointerMiddle);
7354   verifyFormat("int * f(int * a) {}", PointerMiddle);
7355   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
7356   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
7357   verifyFormat("A<int *> a;", PointerMiddle);
7358   verifyFormat("A<int **> a;", PointerMiddle);
7359   verifyFormat("A<int *, int *> a;", PointerMiddle);
7360   verifyFormat("A<int *[]> a;", PointerMiddle);
7361   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
7362   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
7363   verifyFormat("T ** t = new T *;", PointerMiddle);
7364 
7365   // Member function reference qualifiers aren't binary operators.
7366   verifyFormat("string // break\n"
7367                "operator()() & {}");
7368   verifyFormat("string // break\n"
7369                "operator()() && {}");
7370   verifyGoogleFormat("template <typename T>\n"
7371                      "auto x() & -> int {}");
7372 }
7373 
7374 TEST_F(FormatTest, UnderstandsAttributes) {
7375   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
7376   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
7377                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
7378   FormatStyle AfterType = getLLVMStyle();
7379   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
7380   verifyFormat("__attribute__((nodebug)) void\n"
7381                "foo() {}\n",
7382                AfterType);
7383 }
7384 
7385 TEST_F(FormatTest, UnderstandsSquareAttributes) {
7386   verifyFormat("SomeType s [[unused]] (InitValue);");
7387   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
7388   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
7389   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
7390   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
7391   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7392                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
7393 
7394   // Make sure we do not mistake attributes for array subscripts.
7395   verifyFormat("int a() {}\n"
7396                "[[unused]] int b() {}\n");
7397   verifyFormat("NSArray *arr;\n"
7398                "arr[[Foo() bar]];");
7399 
7400   // On the other hand, we still need to correctly find array subscripts.
7401   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
7402 
7403   // Make sure that we do not mistake Objective-C method inside array literals
7404   // as attributes, even if those method names are also keywords.
7405   verifyFormat("@[ [foo bar] ];");
7406   verifyFormat("@[ [NSArray class] ];");
7407   verifyFormat("@[ [foo enum] ];");
7408 
7409   // Make sure we do not parse attributes as lambda introducers.
7410   FormatStyle MultiLineFunctions = getLLVMStyle();
7411   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
7412   verifyFormat("[[unused]] int b() {\n"
7413                "  return 42;\n"
7414                "}\n",
7415                MultiLineFunctions);
7416 }
7417 
7418 TEST_F(FormatTest, UnderstandsEllipsis) {
7419   verifyFormat("int printf(const char *fmt, ...);");
7420   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
7421   verifyFormat("template <class... Ts> void Foo(Ts *... ts) {}");
7422 
7423   FormatStyle PointersLeft = getLLVMStyle();
7424   PointersLeft.PointerAlignment = FormatStyle::PAS_Left;
7425   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", PointersLeft);
7426 }
7427 
7428 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
7429   EXPECT_EQ("int *a;\n"
7430             "int *a;\n"
7431             "int *a;",
7432             format("int *a;\n"
7433                    "int* a;\n"
7434                    "int *a;",
7435                    getGoogleStyle()));
7436   EXPECT_EQ("int* a;\n"
7437             "int* a;\n"
7438             "int* a;",
7439             format("int* a;\n"
7440                    "int* a;\n"
7441                    "int *a;",
7442                    getGoogleStyle()));
7443   EXPECT_EQ("int *a;\n"
7444             "int *a;\n"
7445             "int *a;",
7446             format("int *a;\n"
7447                    "int * a;\n"
7448                    "int *  a;",
7449                    getGoogleStyle()));
7450   EXPECT_EQ("auto x = [] {\n"
7451             "  int *a;\n"
7452             "  int *a;\n"
7453             "  int *a;\n"
7454             "};",
7455             format("auto x=[]{int *a;\n"
7456                    "int * a;\n"
7457                    "int *  a;};",
7458                    getGoogleStyle()));
7459 }
7460 
7461 TEST_F(FormatTest, UnderstandsRvalueReferences) {
7462   verifyFormat("int f(int &&a) {}");
7463   verifyFormat("int f(int a, char &&b) {}");
7464   verifyFormat("void f() { int &&a = b; }");
7465   verifyGoogleFormat("int f(int a, char&& b) {}");
7466   verifyGoogleFormat("void f() { int&& a = b; }");
7467 
7468   verifyIndependentOfContext("A<int &&> a;");
7469   verifyIndependentOfContext("A<int &&, int &&> a;");
7470   verifyGoogleFormat("A<int&&> a;");
7471   verifyGoogleFormat("A<int&&, int&&> a;");
7472 
7473   // Not rvalue references:
7474   verifyFormat("template <bool B, bool C> class A {\n"
7475                "  static_assert(B && C, \"Something is wrong\");\n"
7476                "};");
7477   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
7478   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
7479   verifyFormat("#define A(a, b) (a && b)");
7480 }
7481 
7482 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
7483   verifyFormat("void f() {\n"
7484                "  x[aaaaaaaaa -\n"
7485                "    b] = 23;\n"
7486                "}",
7487                getLLVMStyleWithColumns(15));
7488 }
7489 
7490 TEST_F(FormatTest, FormatsCasts) {
7491   verifyFormat("Type *A = static_cast<Type *>(P);");
7492   verifyFormat("Type *A = (Type *)P;");
7493   verifyFormat("Type *A = (vector<Type *, int *>)P;");
7494   verifyFormat("int a = (int)(2.0f);");
7495   verifyFormat("int a = (int)2.0f;");
7496   verifyFormat("x[(int32)y];");
7497   verifyFormat("x = (int32)y;");
7498   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
7499   verifyFormat("int a = (int)*b;");
7500   verifyFormat("int a = (int)2.0f;");
7501   verifyFormat("int a = (int)~0;");
7502   verifyFormat("int a = (int)++a;");
7503   verifyFormat("int a = (int)sizeof(int);");
7504   verifyFormat("int a = (int)+2;");
7505   verifyFormat("my_int a = (my_int)2.0f;");
7506   verifyFormat("my_int a = (my_int)sizeof(int);");
7507   verifyFormat("return (my_int)aaa;");
7508   verifyFormat("#define x ((int)-1)");
7509   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
7510   verifyFormat("#define p(q) ((int *)&q)");
7511   verifyFormat("fn(a)(b) + 1;");
7512 
7513   verifyFormat("void f() { my_int a = (my_int)*b; }");
7514   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
7515   verifyFormat("my_int a = (my_int)~0;");
7516   verifyFormat("my_int a = (my_int)++a;");
7517   verifyFormat("my_int a = (my_int)-2;");
7518   verifyFormat("my_int a = (my_int)1;");
7519   verifyFormat("my_int a = (my_int *)1;");
7520   verifyFormat("my_int a = (const my_int)-1;");
7521   verifyFormat("my_int a = (const my_int *)-1;");
7522   verifyFormat("my_int a = (my_int)(my_int)-1;");
7523   verifyFormat("my_int a = (ns::my_int)-2;");
7524   verifyFormat("case (my_int)ONE:");
7525   verifyFormat("auto x = (X)this;");
7526 
7527   // FIXME: single value wrapped with paren will be treated as cast.
7528   verifyFormat("void f(int i = (kValue)*kMask) {}");
7529 
7530   verifyFormat("{ (void)F; }");
7531 
7532   // Don't break after a cast's
7533   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7534                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
7535                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
7536 
7537   // These are not casts.
7538   verifyFormat("void f(int *) {}");
7539   verifyFormat("f(foo)->b;");
7540   verifyFormat("f(foo).b;");
7541   verifyFormat("f(foo)(b);");
7542   verifyFormat("f(foo)[b];");
7543   verifyFormat("[](foo) { return 4; }(bar);");
7544   verifyFormat("(*funptr)(foo)[4];");
7545   verifyFormat("funptrs[4](foo)[4];");
7546   verifyFormat("void f(int *);");
7547   verifyFormat("void f(int *) = 0;");
7548   verifyFormat("void f(SmallVector<int>) {}");
7549   verifyFormat("void f(SmallVector<int>);");
7550   verifyFormat("void f(SmallVector<int>) = 0;");
7551   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
7552   verifyFormat("int a = sizeof(int) * b;");
7553   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
7554   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
7555   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
7556   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
7557 
7558   // These are not casts, but at some point were confused with casts.
7559   verifyFormat("virtual void foo(int *) override;");
7560   verifyFormat("virtual void foo(char &) const;");
7561   verifyFormat("virtual void foo(int *a, char *) const;");
7562   verifyFormat("int a = sizeof(int *) + b;");
7563   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
7564   verifyFormat("bool b = f(g<int>) && c;");
7565   verifyFormat("typedef void (*f)(int i) func;");
7566 
7567   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
7568                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7569   // FIXME: The indentation here is not ideal.
7570   verifyFormat(
7571       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7572       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
7573       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
7574 }
7575 
7576 TEST_F(FormatTest, FormatsFunctionTypes) {
7577   verifyFormat("A<bool()> a;");
7578   verifyFormat("A<SomeType()> a;");
7579   verifyFormat("A<void (*)(int, std::string)> a;");
7580   verifyFormat("A<void *(int)>;");
7581   verifyFormat("void *(*a)(int *, SomeType *);");
7582   verifyFormat("int (*func)(void *);");
7583   verifyFormat("void f() { int (*func)(void *); }");
7584   verifyFormat("template <class CallbackClass>\n"
7585                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
7586 
7587   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
7588   verifyGoogleFormat("void* (*a)(int);");
7589   verifyGoogleFormat(
7590       "template <class CallbackClass>\n"
7591       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
7592 
7593   // Other constructs can look somewhat like function types:
7594   verifyFormat("A<sizeof(*x)> a;");
7595   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
7596   verifyFormat("some_var = function(*some_pointer_var)[0];");
7597   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
7598   verifyFormat("int x = f(&h)();");
7599   verifyFormat("returnsFunction(&param1, &param2)(param);");
7600   verifyFormat("std::function<\n"
7601                "    LooooooooooongTemplatedType<\n"
7602                "        SomeType>*(\n"
7603                "        LooooooooooooooooongType type)>\n"
7604                "    function;",
7605                getGoogleStyleWithColumns(40));
7606 }
7607 
7608 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
7609   verifyFormat("A (*foo_)[6];");
7610   verifyFormat("vector<int> (*foo_)[6];");
7611 }
7612 
7613 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
7614   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7615                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
7616   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
7617                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
7618   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7619                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
7620 
7621   // Different ways of ()-initializiation.
7622   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7623                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
7624   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7625                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
7626   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7627                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
7628   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
7629                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
7630 
7631   // Lambdas should not confuse the variable declaration heuristic.
7632   verifyFormat("LooooooooooooooooongType\n"
7633                "    variable(nullptr, [](A *a) {});",
7634                getLLVMStyleWithColumns(40));
7635 }
7636 
7637 TEST_F(FormatTest, BreaksLongDeclarations) {
7638   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
7639                "    AnotherNameForTheLongType;");
7640   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
7641                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7642   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
7643                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
7644   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
7645                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
7646   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
7647                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
7648   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
7649                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
7650   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
7651                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
7652   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
7653                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
7654   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
7655                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
7656   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
7657                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
7658   FormatStyle Indented = getLLVMStyle();
7659   Indented.IndentWrappedFunctionNames = true;
7660   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
7661                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
7662                Indented);
7663   verifyFormat(
7664       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
7665       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
7666       Indented);
7667   verifyFormat(
7668       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
7669       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
7670       Indented);
7671   verifyFormat(
7672       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
7673       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
7674       Indented);
7675 
7676   // FIXME: Without the comment, this breaks after "(".
7677   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
7678                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
7679                getGoogleStyle());
7680 
7681   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
7682                "                  int LoooooooooooooooooooongParam2) {}");
7683   verifyFormat(
7684       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
7685       "                                   SourceLocation L, IdentifierIn *II,\n"
7686       "                                   Type *T) {}");
7687   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
7688                "ReallyReaaallyLongFunctionName(\n"
7689                "    const std::string &SomeParameter,\n"
7690                "    const SomeType<string, SomeOtherTemplateParameter>\n"
7691                "        &ReallyReallyLongParameterName,\n"
7692                "    const SomeType<string, SomeOtherTemplateParameter>\n"
7693                "        &AnotherLongParameterName) {}");
7694   verifyFormat("template <typename A>\n"
7695                "SomeLoooooooooooooooooooooongType<\n"
7696                "    typename some_namespace::SomeOtherType<A>::Type>\n"
7697                "Function() {}");
7698 
7699   verifyGoogleFormat(
7700       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
7701       "    aaaaaaaaaaaaaaaaaaaaaaa;");
7702   verifyGoogleFormat(
7703       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
7704       "                                   SourceLocation L) {}");
7705   verifyGoogleFormat(
7706       "some_namespace::LongReturnType\n"
7707       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
7708       "    int first_long_parameter, int second_parameter) {}");
7709 
7710   verifyGoogleFormat("template <typename T>\n"
7711                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
7712                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
7713   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7714                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
7715 
7716   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7717                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7718                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7719   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7720                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
7721                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
7722   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7723                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
7724                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
7725                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7726 
7727   verifyFormat("template <typename T> // Templates on own line.\n"
7728                "static int            // Some comment.\n"
7729                "MyFunction(int a);",
7730                getLLVMStyle());
7731 }
7732 
7733 TEST_F(FormatTest, FormatsArrays) {
7734   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
7735                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
7736   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
7737                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
7738   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
7739                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
7740   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7741                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
7742   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7743                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
7744   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7745                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
7746                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
7747   verifyFormat(
7748       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
7749       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
7750       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
7751   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
7752                "    .aaaaaaaaaaaaaaaaaaaaaa();");
7753 
7754   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
7755                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
7756   verifyFormat(
7757       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
7758       "                                  .aaaaaaa[0]\n"
7759       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
7760   verifyFormat("a[::b::c];");
7761 
7762   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
7763 
7764   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
7765   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
7766 }
7767 
7768 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
7769   verifyFormat("(a)->b();");
7770   verifyFormat("--a;");
7771 }
7772 
7773 TEST_F(FormatTest, HandlesIncludeDirectives) {
7774   verifyFormat("#include <string>\n"
7775                "#include <a/b/c.h>\n"
7776                "#include \"a/b/string\"\n"
7777                "#include \"string.h\"\n"
7778                "#include \"string.h\"\n"
7779                "#include <a-a>\n"
7780                "#include < path with space >\n"
7781                "#include_next <test.h>"
7782                "#include \"abc.h\" // this is included for ABC\n"
7783                "#include \"some long include\" // with a comment\n"
7784                "#include \"some very long include path\"\n"
7785                "#include <some/very/long/include/path>\n",
7786                getLLVMStyleWithColumns(35));
7787   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
7788   EXPECT_EQ("#include <a>", format("#include<a>"));
7789 
7790   verifyFormat("#import <string>");
7791   verifyFormat("#import <a/b/c.h>");
7792   verifyFormat("#import \"a/b/string\"");
7793   verifyFormat("#import \"string.h\"");
7794   verifyFormat("#import \"string.h\"");
7795   verifyFormat("#if __has_include(<strstream>)\n"
7796                "#include <strstream>\n"
7797                "#endif");
7798 
7799   verifyFormat("#define MY_IMPORT <a/b>");
7800 
7801   verifyFormat("#if __has_include(<a/b>)");
7802   verifyFormat("#if __has_include_next(<a/b>)");
7803   verifyFormat("#define F __has_include(<a/b>)");
7804   verifyFormat("#define F __has_include_next(<a/b>)");
7805 
7806   // Protocol buffer definition or missing "#".
7807   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
7808                getLLVMStyleWithColumns(30));
7809 
7810   FormatStyle Style = getLLVMStyle();
7811   Style.AlwaysBreakBeforeMultilineStrings = true;
7812   Style.ColumnLimit = 0;
7813   verifyFormat("#import \"abc.h\"", Style);
7814 
7815   // But 'import' might also be a regular C++ namespace.
7816   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7817                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7818 }
7819 
7820 //===----------------------------------------------------------------------===//
7821 // Error recovery tests.
7822 //===----------------------------------------------------------------------===//
7823 
7824 TEST_F(FormatTest, IncompleteParameterLists) {
7825   FormatStyle NoBinPacking = getLLVMStyle();
7826   NoBinPacking.BinPackParameters = false;
7827   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
7828                "                        double *min_x,\n"
7829                "                        double *max_x,\n"
7830                "                        double *min_y,\n"
7831                "                        double *max_y,\n"
7832                "                        double *min_z,\n"
7833                "                        double *max_z, ) {}",
7834                NoBinPacking);
7835 }
7836 
7837 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
7838   verifyFormat("void f() { return; }\n42");
7839   verifyFormat("void f() {\n"
7840                "  if (0)\n"
7841                "    return;\n"
7842                "}\n"
7843                "42");
7844   verifyFormat("void f() { return }\n42");
7845   verifyFormat("void f() {\n"
7846                "  if (0)\n"
7847                "    return\n"
7848                "}\n"
7849                "42");
7850 }
7851 
7852 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
7853   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
7854   EXPECT_EQ("void f() {\n"
7855             "  if (a)\n"
7856             "    return\n"
7857             "}",
7858             format("void  f  (  )  {  if  ( a )  return  }"));
7859   EXPECT_EQ("namespace N {\n"
7860             "void f()\n"
7861             "}",
7862             format("namespace  N  {  void f()  }"));
7863   EXPECT_EQ("namespace N {\n"
7864             "void f() {}\n"
7865             "void g()\n"
7866             "} // namespace N",
7867             format("namespace N  { void f( ) { } void g( ) }"));
7868 }
7869 
7870 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
7871   verifyFormat("int aaaaaaaa =\n"
7872                "    // Overlylongcomment\n"
7873                "    b;",
7874                getLLVMStyleWithColumns(20));
7875   verifyFormat("function(\n"
7876                "    ShortArgument,\n"
7877                "    LoooooooooooongArgument);\n",
7878                getLLVMStyleWithColumns(20));
7879 }
7880 
7881 TEST_F(FormatTest, IncorrectAccessSpecifier) {
7882   verifyFormat("public:");
7883   verifyFormat("class A {\n"
7884                "public\n"
7885                "  void f() {}\n"
7886                "};");
7887   verifyFormat("public\n"
7888                "int qwerty;");
7889   verifyFormat("public\n"
7890                "B {}");
7891   verifyFormat("public\n"
7892                "{}");
7893   verifyFormat("public\n"
7894                "B { int x; }");
7895 }
7896 
7897 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
7898   verifyFormat("{");
7899   verifyFormat("#})");
7900   verifyNoCrash("(/**/[:!] ?[).");
7901 }
7902 
7903 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
7904   // Found by oss-fuzz:
7905   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
7906   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7907   Style.ColumnLimit = 60;
7908   verifyNoCrash(
7909       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
7910       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
7911       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
7912       Style);
7913 }
7914 
7915 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
7916   verifyFormat("do {\n}");
7917   verifyFormat("do {\n}\n"
7918                "f();");
7919   verifyFormat("do {\n}\n"
7920                "wheeee(fun);");
7921   verifyFormat("do {\n"
7922                "  f();\n"
7923                "}");
7924 }
7925 
7926 TEST_F(FormatTest, IncorrectCodeMissingParens) {
7927   verifyFormat("if {\n  foo;\n  foo();\n}");
7928   verifyFormat("switch {\n  foo;\n  foo();\n}");
7929   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
7930   verifyFormat("while {\n  foo;\n  foo();\n}");
7931   verifyFormat("do {\n  foo;\n  foo();\n} while;");
7932 }
7933 
7934 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
7935   verifyIncompleteFormat("namespace {\n"
7936                          "class Foo { Foo (\n"
7937                          "};\n"
7938                          "} // namespace");
7939 }
7940 
7941 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
7942   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
7943   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
7944   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
7945   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
7946 
7947   EXPECT_EQ("{\n"
7948             "  {\n"
7949             "    breakme(\n"
7950             "        qwe);\n"
7951             "  }\n",
7952             format("{\n"
7953                    "    {\n"
7954                    " breakme(qwe);\n"
7955                    "}\n",
7956                    getLLVMStyleWithColumns(10)));
7957 }
7958 
7959 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
7960   verifyFormat("int x = {\n"
7961                "    avariable,\n"
7962                "    b(alongervariable)};",
7963                getLLVMStyleWithColumns(25));
7964 }
7965 
7966 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
7967   verifyFormat("return (a)(b){1, 2, 3};");
7968 }
7969 
7970 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
7971   verifyFormat("vector<int> x{1, 2, 3, 4};");
7972   verifyFormat("vector<int> x{\n"
7973                "    1,\n"
7974                "    2,\n"
7975                "    3,\n"
7976                "    4,\n"
7977                "};");
7978   verifyFormat("vector<T> x{{}, {}, {}, {}};");
7979   verifyFormat("f({1, 2});");
7980   verifyFormat("auto v = Foo{-1};");
7981   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
7982   verifyFormat("Class::Class : member{1, 2, 3} {}");
7983   verifyFormat("new vector<int>{1, 2, 3};");
7984   verifyFormat("new int[3]{1, 2, 3};");
7985   verifyFormat("new int{1};");
7986   verifyFormat("return {arg1, arg2};");
7987   verifyFormat("return {arg1, SomeType{parameter}};");
7988   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
7989   verifyFormat("new T{arg1, arg2};");
7990   verifyFormat("f(MyMap[{composite, key}]);");
7991   verifyFormat("class Class {\n"
7992                "  T member = {arg1, arg2};\n"
7993                "};");
7994   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
7995   verifyFormat("const struct A a = {.a = 1, .b = 2};");
7996   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
7997   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
7998   verifyFormat("int a = std::is_integral<int>{} + 0;");
7999 
8000   verifyFormat("int foo(int i) { return fo1{}(i); }");
8001   verifyFormat("int foo(int i) { return fo1{}(i); }");
8002   verifyFormat("auto i = decltype(x){};");
8003   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
8004   verifyFormat("Node n{1, Node{1000}, //\n"
8005                "       2};");
8006   verifyFormat("Aaaa aaaaaaa{\n"
8007                "    {\n"
8008                "        aaaa,\n"
8009                "    },\n"
8010                "};");
8011   verifyFormat("class C : public D {\n"
8012                "  SomeClass SC{2};\n"
8013                "};");
8014   verifyFormat("class C : public A {\n"
8015                "  class D : public B {\n"
8016                "    void f() { int i{2}; }\n"
8017                "  };\n"
8018                "};");
8019   verifyFormat("#define A {a, a},");
8020 
8021   // Avoid breaking between equal sign and opening brace
8022   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
8023   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
8024   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
8025                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
8026                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
8027                "     {\"ccccccccccccccccccccc\", 2}};",
8028                AvoidBreakingFirstArgument);
8029 
8030   // Binpacking only if there is no trailing comma
8031   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
8032                "                      cccccccccc, dddddddddd};",
8033                getLLVMStyleWithColumns(50));
8034   verifyFormat("const Aaaaaa aaaaa = {\n"
8035                "    aaaaaaaaaaa,\n"
8036                "    bbbbbbbbbbb,\n"
8037                "    ccccccccccc,\n"
8038                "    ddddddddddd,\n"
8039                "};",
8040                getLLVMStyleWithColumns(50));
8041 
8042   // Cases where distinguising braced lists and blocks is hard.
8043   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
8044   verifyFormat("void f() {\n"
8045                "  return; // comment\n"
8046                "}\n"
8047                "SomeType t;");
8048   verifyFormat("void f() {\n"
8049                "  if (a) {\n"
8050                "    f();\n"
8051                "  }\n"
8052                "}\n"
8053                "SomeType t;");
8054 
8055   // In combination with BinPackArguments = false.
8056   FormatStyle NoBinPacking = getLLVMStyle();
8057   NoBinPacking.BinPackArguments = false;
8058   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
8059                "                      bbbbb,\n"
8060                "                      ccccc,\n"
8061                "                      ddddd,\n"
8062                "                      eeeee,\n"
8063                "                      ffffff,\n"
8064                "                      ggggg,\n"
8065                "                      hhhhhh,\n"
8066                "                      iiiiii,\n"
8067                "                      jjjjjj,\n"
8068                "                      kkkkkk};",
8069                NoBinPacking);
8070   verifyFormat("const Aaaaaa aaaaa = {\n"
8071                "    aaaaa,\n"
8072                "    bbbbb,\n"
8073                "    ccccc,\n"
8074                "    ddddd,\n"
8075                "    eeeee,\n"
8076                "    ffffff,\n"
8077                "    ggggg,\n"
8078                "    hhhhhh,\n"
8079                "    iiiiii,\n"
8080                "    jjjjjj,\n"
8081                "    kkkkkk,\n"
8082                "};",
8083                NoBinPacking);
8084   verifyFormat(
8085       "const Aaaaaa aaaaa = {\n"
8086       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
8087       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
8088       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
8089       "};",
8090       NoBinPacking);
8091 
8092   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
8093   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
8094             "    CDDDP83848_BMCR_REGISTER,\n"
8095             "    CDDDP83848_BMSR_REGISTER,\n"
8096             "    CDDDP83848_RBR_REGISTER};",
8097             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
8098                    "                                CDDDP83848_BMSR_REGISTER,\n"
8099                    "                                CDDDP83848_RBR_REGISTER};",
8100                    NoBinPacking));
8101 
8102   // FIXME: The alignment of these trailing comments might be bad. Then again,
8103   // this might be utterly useless in real code.
8104   verifyFormat("Constructor::Constructor()\n"
8105                "    : some_value{         //\n"
8106                "                 aaaaaaa, //\n"
8107                "                 bbbbbbb} {}");
8108 
8109   // In braced lists, the first comment is always assumed to belong to the
8110   // first element. Thus, it can be moved to the next or previous line as
8111   // appropriate.
8112   EXPECT_EQ("function({// First element:\n"
8113             "          1,\n"
8114             "          // Second element:\n"
8115             "          2});",
8116             format("function({\n"
8117                    "    // First element:\n"
8118                    "    1,\n"
8119                    "    // Second element:\n"
8120                    "    2});"));
8121   EXPECT_EQ("std::vector<int> MyNumbers{\n"
8122             "    // First element:\n"
8123             "    1,\n"
8124             "    // Second element:\n"
8125             "    2};",
8126             format("std::vector<int> MyNumbers{// First element:\n"
8127                    "                           1,\n"
8128                    "                           // Second element:\n"
8129                    "                           2};",
8130                    getLLVMStyleWithColumns(30)));
8131   // A trailing comma should still lead to an enforced line break and no
8132   // binpacking.
8133   EXPECT_EQ("vector<int> SomeVector = {\n"
8134             "    // aaa\n"
8135             "    1,\n"
8136             "    2,\n"
8137             "};",
8138             format("vector<int> SomeVector = { // aaa\n"
8139                    "    1, 2, };"));
8140 
8141   FormatStyle ExtraSpaces = getLLVMStyle();
8142   ExtraSpaces.Cpp11BracedListStyle = false;
8143   ExtraSpaces.ColumnLimit = 75;
8144   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
8145   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
8146   verifyFormat("f({ 1, 2 });", ExtraSpaces);
8147   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
8148   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
8149   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
8150   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
8151   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
8152   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
8153   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
8154   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
8155   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
8156   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
8157   verifyFormat("class Class {\n"
8158                "  T member = { arg1, arg2 };\n"
8159                "};",
8160                ExtraSpaces);
8161   verifyFormat(
8162       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8163       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
8164       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
8165       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
8166       ExtraSpaces);
8167   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
8168   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
8169                ExtraSpaces);
8170   verifyFormat(
8171       "someFunction(OtherParam,\n"
8172       "             BracedList{ // comment 1 (Forcing interesting break)\n"
8173       "                         param1, param2,\n"
8174       "                         // comment 2\n"
8175       "                         param3, param4 });",
8176       ExtraSpaces);
8177   verifyFormat(
8178       "std::this_thread::sleep_for(\n"
8179       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
8180       ExtraSpaces);
8181   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
8182                "    aaaaaaa,\n"
8183                "    aaaaaaaaaa,\n"
8184                "    aaaaa,\n"
8185                "    aaaaaaaaaaaaaaa,\n"
8186                "    aaa,\n"
8187                "    aaaaaaaaaa,\n"
8188                "    a,\n"
8189                "    aaaaaaaaaaaaaaaaaaaaa,\n"
8190                "    aaaaaaaaaaaa,\n"
8191                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
8192                "    aaaaaaa,\n"
8193                "    a};");
8194   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
8195   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
8196   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
8197 
8198   // Avoid breaking between initializer/equal sign and opening brace
8199   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
8200   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
8201                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
8202                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
8203                "  { \"ccccccccccccccccccccc\", 2 }\n"
8204                "};",
8205                ExtraSpaces);
8206   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
8207                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
8208                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
8209                "  { \"ccccccccccccccccccccc\", 2 }\n"
8210                "};",
8211                ExtraSpaces);
8212 
8213   FormatStyle SpaceBeforeBrace = getLLVMStyle();
8214   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
8215   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
8216   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
8217 
8218   FormatStyle SpaceBetweenBraces = getLLVMStyle();
8219   SpaceBetweenBraces.SpacesInAngles = true;
8220   SpaceBetweenBraces.SpacesInParentheses = true;
8221   SpaceBetweenBraces.SpacesInSquareBrackets = true;
8222   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
8223   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
8224   verifyFormat("vector< int > x{ // comment 1\n"
8225                "                 1, 2, 3, 4 };",
8226                SpaceBetweenBraces);
8227   SpaceBetweenBraces.ColumnLimit = 20;
8228   EXPECT_EQ("vector< int > x{\n"
8229             "    1, 2, 3, 4 };",
8230             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
8231   SpaceBetweenBraces.ColumnLimit = 24;
8232   EXPECT_EQ("vector< int > x{ 1, 2,\n"
8233             "                 3, 4 };",
8234             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
8235   EXPECT_EQ("vector< int > x{\n"
8236             "    1,\n"
8237             "    2,\n"
8238             "    3,\n"
8239             "    4,\n"
8240             "};",
8241             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
8242   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
8243   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
8244   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
8245 }
8246 
8247 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
8248   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8249                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8250                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8251                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8252                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8253                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
8254   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
8255                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8256                "                 1, 22, 333, 4444, 55555, //\n"
8257                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8258                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
8259   verifyFormat(
8260       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
8261       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
8262       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
8263       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
8264       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
8265       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
8266       "                 7777777};");
8267   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
8268                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
8269                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
8270   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
8271                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
8272                "    // Separating comment.\n"
8273                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
8274   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
8275                "    // Leading comment\n"
8276                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
8277                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
8278   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
8279                "                 1, 1, 1, 1};",
8280                getLLVMStyleWithColumns(39));
8281   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
8282                "                 1, 1, 1, 1};",
8283                getLLVMStyleWithColumns(38));
8284   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
8285                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
8286                getLLVMStyleWithColumns(43));
8287   verifyFormat(
8288       "static unsigned SomeValues[10][3] = {\n"
8289       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
8290       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
8291   verifyFormat("static auto fields = new vector<string>{\n"
8292                "    \"aaaaaaaaaaaaa\",\n"
8293                "    \"aaaaaaaaaaaaa\",\n"
8294                "    \"aaaaaaaaaaaa\",\n"
8295                "    \"aaaaaaaaaaaaaa\",\n"
8296                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
8297                "    \"aaaaaaaaaaaa\",\n"
8298                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
8299                "};");
8300   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
8301   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
8302                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
8303                "                 3, cccccccccccccccccccccc};",
8304                getLLVMStyleWithColumns(60));
8305 
8306   // Trailing commas.
8307   verifyFormat("vector<int> x = {\n"
8308                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
8309                "};",
8310                getLLVMStyleWithColumns(39));
8311   verifyFormat("vector<int> x = {\n"
8312                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
8313                "};",
8314                getLLVMStyleWithColumns(39));
8315   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
8316                "                 1, 1, 1, 1,\n"
8317                "                 /**/ /**/};",
8318                getLLVMStyleWithColumns(39));
8319 
8320   // Trailing comment in the first line.
8321   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
8322                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
8323                "    111111111,  222222222,  3333333333,  444444444,  //\n"
8324                "    11111111,   22222222,   333333333,   44444444};");
8325   // Trailing comment in the last line.
8326   verifyFormat("int aaaaa[] = {\n"
8327                "    1, 2, 3, // comment\n"
8328                "    4, 5, 6  // comment\n"
8329                "};");
8330 
8331   // With nested lists, we should either format one item per line or all nested
8332   // lists one on line.
8333   // FIXME: For some nested lists, we can do better.
8334   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
8335                "        {aaaaaaaaaaaaaaaaaaa},\n"
8336                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
8337                "        {aaaaaaaaaaaaaaaaa}};",
8338                getLLVMStyleWithColumns(60));
8339   verifyFormat(
8340       "SomeStruct my_struct_array = {\n"
8341       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
8342       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
8343       "    {aaa, aaa},\n"
8344       "    {aaa, aaa},\n"
8345       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
8346       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
8347       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
8348 
8349   // No column layout should be used here.
8350   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
8351                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
8352 
8353   verifyNoCrash("a<,");
8354 
8355   // No braced initializer here.
8356   verifyFormat("void f() {\n"
8357                "  struct Dummy {};\n"
8358                "  f(v);\n"
8359                "}");
8360 
8361   // Long lists should be formatted in columns even if they are nested.
8362   verifyFormat(
8363       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8364       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8365       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8366       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8367       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
8368       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
8369 
8370   // Allow "single-column" layout even if that violates the column limit. There
8371   // isn't going to be a better way.
8372   verifyFormat("std::vector<int> a = {\n"
8373                "    aaaaaaaa,\n"
8374                "    aaaaaaaa,\n"
8375                "    aaaaaaaa,\n"
8376                "    aaaaaaaa,\n"
8377                "    aaaaaaaaaa,\n"
8378                "    aaaaaaaa,\n"
8379                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
8380                getLLVMStyleWithColumns(30));
8381   verifyFormat("vector<int> aaaa = {\n"
8382                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8383                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8384                "    aaaaaa.aaaaaaa,\n"
8385                "    aaaaaa.aaaaaaa,\n"
8386                "    aaaaaa.aaaaaaa,\n"
8387                "    aaaaaa.aaaaaaa,\n"
8388                "};");
8389 
8390   // Don't create hanging lists.
8391   verifyFormat("someFunction(Param, {List1, List2,\n"
8392                "                     List3});",
8393                getLLVMStyleWithColumns(35));
8394   verifyFormat("someFunction(Param, Param,\n"
8395                "             {List1, List2,\n"
8396                "              List3});",
8397                getLLVMStyleWithColumns(35));
8398   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
8399                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
8400 }
8401 
8402 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
8403   FormatStyle DoNotMerge = getLLVMStyle();
8404   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8405 
8406   verifyFormat("void f() { return 42; }");
8407   verifyFormat("void f() {\n"
8408                "  return 42;\n"
8409                "}",
8410                DoNotMerge);
8411   verifyFormat("void f() {\n"
8412                "  // Comment\n"
8413                "}");
8414   verifyFormat("{\n"
8415                "#error {\n"
8416                "  int a;\n"
8417                "}");
8418   verifyFormat("{\n"
8419                "  int a;\n"
8420                "#error {\n"
8421                "}");
8422   verifyFormat("void f() {} // comment");
8423   verifyFormat("void f() { int a; } // comment");
8424   verifyFormat("void f() {\n"
8425                "} // comment",
8426                DoNotMerge);
8427   verifyFormat("void f() {\n"
8428                "  int a;\n"
8429                "} // comment",
8430                DoNotMerge);
8431   verifyFormat("void f() {\n"
8432                "} // comment",
8433                getLLVMStyleWithColumns(15));
8434 
8435   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
8436   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
8437 
8438   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
8439   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
8440   verifyFormat("class C {\n"
8441                "  C()\n"
8442                "      : iiiiiiii(nullptr),\n"
8443                "        kkkkkkk(nullptr),\n"
8444                "        mmmmmmm(nullptr),\n"
8445                "        nnnnnnn(nullptr) {}\n"
8446                "};",
8447                getGoogleStyle());
8448 
8449   FormatStyle NoColumnLimit = getLLVMStyle();
8450   NoColumnLimit.ColumnLimit = 0;
8451   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
8452   EXPECT_EQ("class C {\n"
8453             "  A() : b(0) {}\n"
8454             "};",
8455             format("class C{A():b(0){}};", NoColumnLimit));
8456   EXPECT_EQ("A()\n"
8457             "    : b(0) {\n"
8458             "}",
8459             format("A()\n:b(0)\n{\n}", NoColumnLimit));
8460 
8461   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
8462   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
8463       FormatStyle::SFS_None;
8464   EXPECT_EQ("A()\n"
8465             "    : b(0) {\n"
8466             "}",
8467             format("A():b(0){}", DoNotMergeNoColumnLimit));
8468   EXPECT_EQ("A()\n"
8469             "    : b(0) {\n"
8470             "}",
8471             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
8472 
8473   verifyFormat("#define A          \\\n"
8474                "  void f() {       \\\n"
8475                "    int i;         \\\n"
8476                "  }",
8477                getLLVMStyleWithColumns(20));
8478   verifyFormat("#define A           \\\n"
8479                "  void f() { int i; }",
8480                getLLVMStyleWithColumns(21));
8481   verifyFormat("#define A            \\\n"
8482                "  void f() {         \\\n"
8483                "    int i;           \\\n"
8484                "  }                  \\\n"
8485                "  int j;",
8486                getLLVMStyleWithColumns(22));
8487   verifyFormat("#define A             \\\n"
8488                "  void f() { int i; } \\\n"
8489                "  int j;",
8490                getLLVMStyleWithColumns(23));
8491 }
8492 
8493 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
8494   FormatStyle MergeEmptyOnly = getLLVMStyle();
8495   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
8496   verifyFormat("class C {\n"
8497                "  int f() {}\n"
8498                "};",
8499                MergeEmptyOnly);
8500   verifyFormat("class C {\n"
8501                "  int f() {\n"
8502                "    return 42;\n"
8503                "  }\n"
8504                "};",
8505                MergeEmptyOnly);
8506   verifyFormat("int f() {}", MergeEmptyOnly);
8507   verifyFormat("int f() {\n"
8508                "  return 42;\n"
8509                "}",
8510                MergeEmptyOnly);
8511 
8512   // Also verify behavior when BraceWrapping.AfterFunction = true
8513   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
8514   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
8515   verifyFormat("int f() {}", MergeEmptyOnly);
8516   verifyFormat("class C {\n"
8517                "  int f() {}\n"
8518                "};",
8519                MergeEmptyOnly);
8520 }
8521 
8522 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
8523   FormatStyle MergeInlineOnly = getLLVMStyle();
8524   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
8525   verifyFormat("class C {\n"
8526                "  int f() { return 42; }\n"
8527                "};",
8528                MergeInlineOnly);
8529   verifyFormat("int f() {\n"
8530                "  return 42;\n"
8531                "}",
8532                MergeInlineOnly);
8533 
8534   // SFS_Inline implies SFS_Empty
8535   verifyFormat("class C {\n"
8536                "  int f() {}\n"
8537                "};",
8538                MergeInlineOnly);
8539   verifyFormat("int f() {}", MergeInlineOnly);
8540 
8541   // Also verify behavior when BraceWrapping.AfterFunction = true
8542   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
8543   MergeInlineOnly.BraceWrapping.AfterFunction = true;
8544   verifyFormat("class C {\n"
8545                "  int f() { return 42; }\n"
8546                "};",
8547                MergeInlineOnly);
8548   verifyFormat("int f()\n"
8549                "{\n"
8550                "  return 42;\n"
8551                "}",
8552                MergeInlineOnly);
8553 
8554   // SFS_Inline implies SFS_Empty
8555   verifyFormat("int f() {}", MergeInlineOnly);
8556   verifyFormat("class C {\n"
8557                "  int f() {}\n"
8558                "};",
8559                MergeInlineOnly);
8560 }
8561 
8562 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
8563   FormatStyle MergeInlineOnly = getLLVMStyle();
8564   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
8565       FormatStyle::SFS_InlineOnly;
8566   verifyFormat("class C {\n"
8567                "  int f() { return 42; }\n"
8568                "};",
8569                MergeInlineOnly);
8570   verifyFormat("int f() {\n"
8571                "  return 42;\n"
8572                "}",
8573                MergeInlineOnly);
8574 
8575   // SFS_InlineOnly does not imply SFS_Empty
8576   verifyFormat("class C {\n"
8577                "  int f() {}\n"
8578                "};",
8579                MergeInlineOnly);
8580   verifyFormat("int f() {\n"
8581                "}",
8582                MergeInlineOnly);
8583 
8584   // Also verify behavior when BraceWrapping.AfterFunction = true
8585   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
8586   MergeInlineOnly.BraceWrapping.AfterFunction = true;
8587   verifyFormat("class C {\n"
8588                "  int f() { return 42; }\n"
8589                "};",
8590                MergeInlineOnly);
8591   verifyFormat("int f()\n"
8592                "{\n"
8593                "  return 42;\n"
8594                "}",
8595                MergeInlineOnly);
8596 
8597   // SFS_InlineOnly does not imply SFS_Empty
8598   verifyFormat("int f()\n"
8599                "{\n"
8600                "}",
8601                MergeInlineOnly);
8602   verifyFormat("class C {\n"
8603                "  int f() {}\n"
8604                "};",
8605                MergeInlineOnly);
8606 }
8607 
8608 TEST_F(FormatTest, SplitEmptyFunction) {
8609   FormatStyle Style = getLLVMStyle();
8610   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8611   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
8612   Style.BraceWrapping.AfterFunction = true;
8613   Style.BraceWrapping.SplitEmptyFunction = false;
8614   Style.ColumnLimit = 40;
8615 
8616   verifyFormat("int f()\n"
8617                "{}",
8618                Style);
8619   verifyFormat("int f()\n"
8620                "{\n"
8621                "  return 42;\n"
8622                "}",
8623                Style);
8624   verifyFormat("int f()\n"
8625                "{\n"
8626                "  // some comment\n"
8627                "}",
8628                Style);
8629 
8630   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
8631   verifyFormat("int f() {}", Style);
8632   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
8633                "{}",
8634                Style);
8635   verifyFormat("int f()\n"
8636                "{\n"
8637                "  return 0;\n"
8638                "}",
8639                Style);
8640 
8641   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
8642   verifyFormat("class Foo {\n"
8643                "  int f() {}\n"
8644                "};\n",
8645                Style);
8646   verifyFormat("class Foo {\n"
8647                "  int f() { return 0; }\n"
8648                "};\n",
8649                Style);
8650   verifyFormat("class Foo {\n"
8651                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
8652                "  {}\n"
8653                "};\n",
8654                Style);
8655   verifyFormat("class Foo {\n"
8656                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
8657                "  {\n"
8658                "    return 0;\n"
8659                "  }\n"
8660                "};\n",
8661                Style);
8662 
8663   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
8664   verifyFormat("int f() {}", Style);
8665   verifyFormat("int f() { return 0; }", Style);
8666   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
8667                "{}",
8668                Style);
8669   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
8670                "{\n"
8671                "  return 0;\n"
8672                "}",
8673                Style);
8674 }
8675 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
8676   FormatStyle Style = getLLVMStyle();
8677   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
8678   verifyFormat("#ifdef A\n"
8679                "int f() {}\n"
8680                "#else\n"
8681                "int g() {}\n"
8682                "#endif",
8683                Style);
8684 }
8685 
8686 TEST_F(FormatTest, SplitEmptyClass) {
8687   FormatStyle Style = getLLVMStyle();
8688   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
8689   Style.BraceWrapping.AfterClass = true;
8690   Style.BraceWrapping.SplitEmptyRecord = false;
8691 
8692   verifyFormat("class Foo\n"
8693                "{};",
8694                Style);
8695   verifyFormat("/* something */ class Foo\n"
8696                "{};",
8697                Style);
8698   verifyFormat("template <typename X> class Foo\n"
8699                "{};",
8700                Style);
8701   verifyFormat("class Foo\n"
8702                "{\n"
8703                "  Foo();\n"
8704                "};",
8705                Style);
8706   verifyFormat("typedef class Foo\n"
8707                "{\n"
8708                "} Foo_t;",
8709                Style);
8710 }
8711 
8712 TEST_F(FormatTest, SplitEmptyStruct) {
8713   FormatStyle Style = getLLVMStyle();
8714   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
8715   Style.BraceWrapping.AfterStruct = true;
8716   Style.BraceWrapping.SplitEmptyRecord = false;
8717 
8718   verifyFormat("struct Foo\n"
8719                "{};",
8720                Style);
8721   verifyFormat("/* something */ struct Foo\n"
8722                "{};",
8723                Style);
8724   verifyFormat("template <typename X> struct Foo\n"
8725                "{};",
8726                Style);
8727   verifyFormat("struct Foo\n"
8728                "{\n"
8729                "  Foo();\n"
8730                "};",
8731                Style);
8732   verifyFormat("typedef struct Foo\n"
8733                "{\n"
8734                "} Foo_t;",
8735                Style);
8736   // typedef struct Bar {} Bar_t;
8737 }
8738 
8739 TEST_F(FormatTest, SplitEmptyUnion) {
8740   FormatStyle Style = getLLVMStyle();
8741   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
8742   Style.BraceWrapping.AfterUnion = true;
8743   Style.BraceWrapping.SplitEmptyRecord = false;
8744 
8745   verifyFormat("union Foo\n"
8746                "{};",
8747                Style);
8748   verifyFormat("/* something */ union Foo\n"
8749                "{};",
8750                Style);
8751   verifyFormat("union Foo\n"
8752                "{\n"
8753                "  A,\n"
8754                "};",
8755                Style);
8756   verifyFormat("typedef union Foo\n"
8757                "{\n"
8758                "} Foo_t;",
8759                Style);
8760 }
8761 
8762 TEST_F(FormatTest, SplitEmptyNamespace) {
8763   FormatStyle Style = getLLVMStyle();
8764   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
8765   Style.BraceWrapping.AfterNamespace = true;
8766   Style.BraceWrapping.SplitEmptyNamespace = false;
8767 
8768   verifyFormat("namespace Foo\n"
8769                "{};",
8770                Style);
8771   verifyFormat("/* something */ namespace Foo\n"
8772                "{};",
8773                Style);
8774   verifyFormat("inline namespace Foo\n"
8775                "{};",
8776                Style);
8777   verifyFormat("/* something */ inline namespace Foo\n"
8778                "{};",
8779                Style);
8780   verifyFormat("export namespace Foo\n"
8781                "{};",
8782                Style);
8783   verifyFormat("namespace Foo\n"
8784                "{\n"
8785                "void Bar();\n"
8786                "};",
8787                Style);
8788 }
8789 
8790 TEST_F(FormatTest, NeverMergeShortRecords) {
8791   FormatStyle Style = getLLVMStyle();
8792 
8793   verifyFormat("class Foo {\n"
8794                "  Foo();\n"
8795                "};",
8796                Style);
8797   verifyFormat("typedef class Foo {\n"
8798                "  Foo();\n"
8799                "} Foo_t;",
8800                Style);
8801   verifyFormat("struct Foo {\n"
8802                "  Foo();\n"
8803                "};",
8804                Style);
8805   verifyFormat("typedef struct Foo {\n"
8806                "  Foo();\n"
8807                "} Foo_t;",
8808                Style);
8809   verifyFormat("union Foo {\n"
8810                "  A,\n"
8811                "};",
8812                Style);
8813   verifyFormat("typedef union Foo {\n"
8814                "  A,\n"
8815                "} Foo_t;",
8816                Style);
8817   verifyFormat("namespace Foo {\n"
8818                "void Bar();\n"
8819                "};",
8820                Style);
8821 
8822   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
8823   Style.BraceWrapping.AfterClass = true;
8824   Style.BraceWrapping.AfterStruct = true;
8825   Style.BraceWrapping.AfterUnion = true;
8826   Style.BraceWrapping.AfterNamespace = true;
8827   verifyFormat("class Foo\n"
8828                "{\n"
8829                "  Foo();\n"
8830                "};",
8831                Style);
8832   verifyFormat("typedef class Foo\n"
8833                "{\n"
8834                "  Foo();\n"
8835                "} Foo_t;",
8836                Style);
8837   verifyFormat("struct Foo\n"
8838                "{\n"
8839                "  Foo();\n"
8840                "};",
8841                Style);
8842   verifyFormat("typedef struct Foo\n"
8843                "{\n"
8844                "  Foo();\n"
8845                "} Foo_t;",
8846                Style);
8847   verifyFormat("union Foo\n"
8848                "{\n"
8849                "  A,\n"
8850                "};",
8851                Style);
8852   verifyFormat("typedef union Foo\n"
8853                "{\n"
8854                "  A,\n"
8855                "} Foo_t;",
8856                Style);
8857   verifyFormat("namespace Foo\n"
8858                "{\n"
8859                "void Bar();\n"
8860                "};",
8861                Style);
8862 }
8863 
8864 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
8865   // Elaborate type variable declarations.
8866   verifyFormat("struct foo a = {bar};\nint n;");
8867   verifyFormat("class foo a = {bar};\nint n;");
8868   verifyFormat("union foo a = {bar};\nint n;");
8869 
8870   // Elaborate types inside function definitions.
8871   verifyFormat("struct foo f() {}\nint n;");
8872   verifyFormat("class foo f() {}\nint n;");
8873   verifyFormat("union foo f() {}\nint n;");
8874 
8875   // Templates.
8876   verifyFormat("template <class X> void f() {}\nint n;");
8877   verifyFormat("template <struct X> void f() {}\nint n;");
8878   verifyFormat("template <union X> void f() {}\nint n;");
8879 
8880   // Actual definitions...
8881   verifyFormat("struct {\n} n;");
8882   verifyFormat(
8883       "template <template <class T, class Y>, class Z> class X {\n} n;");
8884   verifyFormat("union Z {\n  int n;\n} x;");
8885   verifyFormat("class MACRO Z {\n} n;");
8886   verifyFormat("class MACRO(X) Z {\n} n;");
8887   verifyFormat("class __attribute__(X) Z {\n} n;");
8888   verifyFormat("class __declspec(X) Z {\n} n;");
8889   verifyFormat("class A##B##C {\n} n;");
8890   verifyFormat("class alignas(16) Z {\n} n;");
8891   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
8892   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
8893 
8894   // Redefinition from nested context:
8895   verifyFormat("class A::B::C {\n} n;");
8896 
8897   // Template definitions.
8898   verifyFormat(
8899       "template <typename F>\n"
8900       "Matcher(const Matcher<F> &Other,\n"
8901       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
8902       "                             !is_same<F, T>::value>::type * = 0)\n"
8903       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
8904 
8905   // FIXME: This is still incorrectly handled at the formatter side.
8906   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
8907   verifyFormat("int i = SomeFunction(a<b, a> b);");
8908 
8909   // FIXME:
8910   // This now gets parsed incorrectly as class definition.
8911   // verifyFormat("class A<int> f() {\n}\nint n;");
8912 
8913   // Elaborate types where incorrectly parsing the structural element would
8914   // break the indent.
8915   verifyFormat("if (true)\n"
8916                "  class X x;\n"
8917                "else\n"
8918                "  f();\n");
8919 
8920   // This is simply incomplete. Formatting is not important, but must not crash.
8921   verifyFormat("class A:");
8922 }
8923 
8924 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
8925   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
8926             format("#error Leave     all         white!!!!! space* alone!\n"));
8927   EXPECT_EQ(
8928       "#warning Leave     all         white!!!!! space* alone!\n",
8929       format("#warning Leave     all         white!!!!! space* alone!\n"));
8930   EXPECT_EQ("#error 1", format("  #  error   1"));
8931   EXPECT_EQ("#warning 1", format("  #  warning 1"));
8932 }
8933 
8934 TEST_F(FormatTest, FormatHashIfExpressions) {
8935   verifyFormat("#if AAAA && BBBB");
8936   verifyFormat("#if (AAAA && BBBB)");
8937   verifyFormat("#elif (AAAA && BBBB)");
8938   // FIXME: Come up with a better indentation for #elif.
8939   verifyFormat(
8940       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
8941       "    defined(BBBBBBBB)\n"
8942       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
8943       "    defined(BBBBBBBB)\n"
8944       "#endif",
8945       getLLVMStyleWithColumns(65));
8946 }
8947 
8948 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
8949   FormatStyle AllowsMergedIf = getGoogleStyle();
8950   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
8951       FormatStyle::SIS_WithoutElse;
8952   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
8953   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
8954   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
8955   EXPECT_EQ("if (true) return 42;",
8956             format("if (true)\nreturn 42;", AllowsMergedIf));
8957   FormatStyle ShortMergedIf = AllowsMergedIf;
8958   ShortMergedIf.ColumnLimit = 25;
8959   verifyFormat("#define A \\\n"
8960                "  if (true) return 42;",
8961                ShortMergedIf);
8962   verifyFormat("#define A \\\n"
8963                "  f();    \\\n"
8964                "  if (true)\n"
8965                "#define B",
8966                ShortMergedIf);
8967   verifyFormat("#define A \\\n"
8968                "  f();    \\\n"
8969                "  if (true)\n"
8970                "g();",
8971                ShortMergedIf);
8972   verifyFormat("{\n"
8973                "#ifdef A\n"
8974                "  // Comment\n"
8975                "  if (true) continue;\n"
8976                "#endif\n"
8977                "  // Comment\n"
8978                "  if (true) continue;\n"
8979                "}",
8980                ShortMergedIf);
8981   ShortMergedIf.ColumnLimit = 33;
8982   verifyFormat("#define A \\\n"
8983                "  if constexpr (true) return 42;",
8984                ShortMergedIf);
8985   verifyFormat("#define A \\\n"
8986                "  if CONSTEXPR (true) return 42;",
8987                ShortMergedIf);
8988   ShortMergedIf.ColumnLimit = 29;
8989   verifyFormat("#define A                   \\\n"
8990                "  if (aaaaaaaaaa) return 1; \\\n"
8991                "  return 2;",
8992                ShortMergedIf);
8993   ShortMergedIf.ColumnLimit = 28;
8994   verifyFormat("#define A         \\\n"
8995                "  if (aaaaaaaaaa) \\\n"
8996                "    return 1;     \\\n"
8997                "  return 2;",
8998                ShortMergedIf);
8999   verifyFormat("#define A                \\\n"
9000                "  if constexpr (aaaaaaa) \\\n"
9001                "    return 1;            \\\n"
9002                "  return 2;",
9003                ShortMergedIf);
9004   verifyFormat("#define A                \\\n"
9005                "  if CONSTEXPR (aaaaaaa) \\\n"
9006                "    return 1;            \\\n"
9007                "  return 2;",
9008                ShortMergedIf);
9009 }
9010 
9011 TEST_F(FormatTest, FormatStarDependingOnContext) {
9012   verifyFormat("void f(int *a);");
9013   verifyFormat("void f() { f(fint * b); }");
9014   verifyFormat("class A {\n  void f(int *a);\n};");
9015   verifyFormat("class A {\n  int *a;\n};");
9016   verifyFormat("namespace a {\n"
9017                "namespace b {\n"
9018                "class A {\n"
9019                "  void f() {}\n"
9020                "  int *a;\n"
9021                "};\n"
9022                "} // namespace b\n"
9023                "} // namespace a");
9024 }
9025 
9026 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
9027   verifyFormat("while");
9028   verifyFormat("operator");
9029 }
9030 
9031 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
9032   // This code would be painfully slow to format if we didn't skip it.
9033   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
9034                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9035                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9036                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9037                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
9038                    "A(1, 1)\n"
9039                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
9040                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9041                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9042                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9043                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9044                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9045                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9046                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9047                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
9048                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
9049   // Deeply nested part is untouched, rest is formatted.
9050   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
9051             format(std::string("int    i;\n") + Code + "int    j;\n",
9052                    getLLVMStyle(), SC_ExpectIncomplete));
9053 }
9054 
9055 //===----------------------------------------------------------------------===//
9056 // Objective-C tests.
9057 //===----------------------------------------------------------------------===//
9058 
9059 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
9060   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
9061   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
9062             format("-(NSUInteger)indexOfObject:(id)anObject;"));
9063   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
9064   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
9065   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
9066             format("-(NSInteger)Method3:(id)anObject;"));
9067   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
9068             format("-(NSInteger)Method4:(id)anObject;"));
9069   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
9070             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
9071   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
9072             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
9073   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9074             "forAllCells:(BOOL)flag;",
9075             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
9076                    "forAllCells:(BOOL)flag;"));
9077 
9078   // Very long objectiveC method declaration.
9079   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
9080                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
9081   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
9082                "                    inRange:(NSRange)range\n"
9083                "                   outRange:(NSRange)out_range\n"
9084                "                  outRange1:(NSRange)out_range1\n"
9085                "                  outRange2:(NSRange)out_range2\n"
9086                "                  outRange3:(NSRange)out_range3\n"
9087                "                  outRange4:(NSRange)out_range4\n"
9088                "                  outRange5:(NSRange)out_range5\n"
9089                "                  outRange6:(NSRange)out_range6\n"
9090                "                  outRange7:(NSRange)out_range7\n"
9091                "                  outRange8:(NSRange)out_range8\n"
9092                "                  outRange9:(NSRange)out_range9;");
9093 
9094   // When the function name has to be wrapped.
9095   FormatStyle Style = getLLVMStyle();
9096   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
9097   // and always indents instead.
9098   Style.IndentWrappedFunctionNames = false;
9099   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9100                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
9101                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
9102                "}",
9103                Style);
9104   Style.IndentWrappedFunctionNames = true;
9105   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
9106                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
9107                "               anotherName:(NSString)dddddddddddddd {\n"
9108                "}",
9109                Style);
9110 
9111   verifyFormat("- (int)sum:(vector<int>)numbers;");
9112   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
9113   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
9114   // protocol lists (but not for template classes):
9115   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
9116 
9117   verifyFormat("- (int (*)())foo:(int (*)())f;");
9118   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
9119 
9120   // If there's no return type (very rare in practice!), LLVM and Google style
9121   // agree.
9122   verifyFormat("- foo;");
9123   verifyFormat("- foo:(int)f;");
9124   verifyGoogleFormat("- foo:(int)foo;");
9125 }
9126 
9127 TEST_F(FormatTest, BreaksStringLiterals) {
9128   EXPECT_EQ("\"some text \"\n"
9129             "\"other\";",
9130             format("\"some text other\";", getLLVMStyleWithColumns(12)));
9131   EXPECT_EQ("\"some text \"\n"
9132             "\"other\";",
9133             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
9134   EXPECT_EQ(
9135       "#define A  \\\n"
9136       "  \"some \"  \\\n"
9137       "  \"text \"  \\\n"
9138       "  \"other\";",
9139       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
9140   EXPECT_EQ(
9141       "#define A  \\\n"
9142       "  \"so \"    \\\n"
9143       "  \"text \"  \\\n"
9144       "  \"other\";",
9145       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
9146 
9147   EXPECT_EQ("\"some text\"",
9148             format("\"some text\"", getLLVMStyleWithColumns(1)));
9149   EXPECT_EQ("\"some text\"",
9150             format("\"some text\"", getLLVMStyleWithColumns(11)));
9151   EXPECT_EQ("\"some \"\n"
9152             "\"text\"",
9153             format("\"some text\"", getLLVMStyleWithColumns(10)));
9154   EXPECT_EQ("\"some \"\n"
9155             "\"text\"",
9156             format("\"some text\"", getLLVMStyleWithColumns(7)));
9157   EXPECT_EQ("\"some\"\n"
9158             "\" tex\"\n"
9159             "\"t\"",
9160             format("\"some text\"", getLLVMStyleWithColumns(6)));
9161   EXPECT_EQ("\"some\"\n"
9162             "\" tex\"\n"
9163             "\" and\"",
9164             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
9165   EXPECT_EQ("\"some\"\n"
9166             "\"/tex\"\n"
9167             "\"/and\"",
9168             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
9169 
9170   EXPECT_EQ("variable =\n"
9171             "    \"long string \"\n"
9172             "    \"literal\";",
9173             format("variable = \"long string literal\";",
9174                    getLLVMStyleWithColumns(20)));
9175 
9176   EXPECT_EQ("variable = f(\n"
9177             "    \"long string \"\n"
9178             "    \"literal\",\n"
9179             "    short,\n"
9180             "    loooooooooooooooooooong);",
9181             format("variable = f(\"long string literal\", short, "
9182                    "loooooooooooooooooooong);",
9183                    getLLVMStyleWithColumns(20)));
9184 
9185   EXPECT_EQ(
9186       "f(g(\"long string \"\n"
9187       "    \"literal\"),\n"
9188       "  b);",
9189       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
9190   EXPECT_EQ("f(g(\"long string \"\n"
9191             "    \"literal\",\n"
9192             "    a),\n"
9193             "  b);",
9194             format("f(g(\"long string literal\", a), b);",
9195                    getLLVMStyleWithColumns(20)));
9196   EXPECT_EQ(
9197       "f(\"one two\".split(\n"
9198       "    variable));",
9199       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
9200   EXPECT_EQ("f(\"one two three four five six \"\n"
9201             "  \"seven\".split(\n"
9202             "      really_looooong_variable));",
9203             format("f(\"one two three four five six seven\"."
9204                    "split(really_looooong_variable));",
9205                    getLLVMStyleWithColumns(33)));
9206 
9207   EXPECT_EQ("f(\"some \"\n"
9208             "  \"text\",\n"
9209             "  other);",
9210             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
9211 
9212   // Only break as a last resort.
9213   verifyFormat(
9214       "aaaaaaaaaaaaaaaaaaaa(\n"
9215       "    aaaaaaaaaaaaaaaaaaaa,\n"
9216       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
9217 
9218   EXPECT_EQ("\"splitmea\"\n"
9219             "\"trandomp\"\n"
9220             "\"oint\"",
9221             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
9222 
9223   EXPECT_EQ("\"split/\"\n"
9224             "\"pathat/\"\n"
9225             "\"slashes\"",
9226             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
9227 
9228   EXPECT_EQ("\"split/\"\n"
9229             "\"pathat/\"\n"
9230             "\"slashes\"",
9231             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
9232   EXPECT_EQ("\"split at \"\n"
9233             "\"spaces/at/\"\n"
9234             "\"slashes.at.any$\"\n"
9235             "\"non-alphanumeric%\"\n"
9236             "\"1111111111characte\"\n"
9237             "\"rs\"",
9238             format("\"split at "
9239                    "spaces/at/"
9240                    "slashes.at."
9241                    "any$non-"
9242                    "alphanumeric%"
9243                    "1111111111characte"
9244                    "rs\"",
9245                    getLLVMStyleWithColumns(20)));
9246 
9247   // Verify that splitting the strings understands
9248   // Style::AlwaysBreakBeforeMultilineStrings.
9249   EXPECT_EQ("aaaaaaaaaaaa(\n"
9250             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
9251             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
9252             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
9253                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
9254                    "aaaaaaaaaaaaaaaaaaaaaa\");",
9255                    getGoogleStyle()));
9256   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
9257             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
9258             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
9259                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
9260                    "aaaaaaaaaaaaaaaaaaaaaa\";",
9261                    getGoogleStyle()));
9262   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
9263             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
9264             format("llvm::outs() << "
9265                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
9266                    "aaaaaaaaaaaaaaaaaaa\";"));
9267   EXPECT_EQ("ffff(\n"
9268             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
9269             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
9270             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
9271                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
9272                    getGoogleStyle()));
9273 
9274   FormatStyle Style = getLLVMStyleWithColumns(12);
9275   Style.BreakStringLiterals = false;
9276   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
9277 
9278   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
9279   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
9280   EXPECT_EQ("#define A \\\n"
9281             "  \"some \" \\\n"
9282             "  \"text \" \\\n"
9283             "  \"other\";",
9284             format("#define A \"some text other\";", AlignLeft));
9285 }
9286 
9287 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
9288   EXPECT_EQ("C a = \"some more \"\n"
9289             "      \"text\";",
9290             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
9291 }
9292 
9293 TEST_F(FormatTest, FullyRemoveEmptyLines) {
9294   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
9295   NoEmptyLines.MaxEmptyLinesToKeep = 0;
9296   EXPECT_EQ("int i = a(b());",
9297             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
9298 }
9299 
9300 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
9301   EXPECT_EQ(
9302       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
9303       "(\n"
9304       "    \"x\t\");",
9305       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
9306              "aaaaaaa("
9307              "\"x\t\");"));
9308 }
9309 
9310 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
9311   EXPECT_EQ(
9312       "u8\"utf8 string \"\n"
9313       "u8\"literal\";",
9314       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
9315   EXPECT_EQ(
9316       "u\"utf16 string \"\n"
9317       "u\"literal\";",
9318       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
9319   EXPECT_EQ(
9320       "U\"utf32 string \"\n"
9321       "U\"literal\";",
9322       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
9323   EXPECT_EQ("L\"wide string \"\n"
9324             "L\"literal\";",
9325             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
9326   EXPECT_EQ("@\"NSString \"\n"
9327             "@\"literal\";",
9328             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
9329   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
9330 
9331   // This input makes clang-format try to split the incomplete unicode escape
9332   // sequence, which used to lead to a crasher.
9333   verifyNoCrash(
9334       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
9335       getLLVMStyleWithColumns(60));
9336 }
9337 
9338 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
9339   FormatStyle Style = getGoogleStyleWithColumns(15);
9340   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
9341   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
9342   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
9343   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
9344   EXPECT_EQ("u8R\"x(raw literal)x\";",
9345             format("u8R\"x(raw literal)x\";", Style));
9346 }
9347 
9348 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
9349   FormatStyle Style = getLLVMStyleWithColumns(20);
9350   EXPECT_EQ(
9351       "_T(\"aaaaaaaaaaaaaa\")\n"
9352       "_T(\"aaaaaaaaaaaaaa\")\n"
9353       "_T(\"aaaaaaaaaaaa\")",
9354       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
9355   EXPECT_EQ("f(x,\n"
9356             "  _T(\"aaaaaaaaaaaa\")\n"
9357             "  _T(\"aaa\"),\n"
9358             "  z);",
9359             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
9360 
9361   // FIXME: Handle embedded spaces in one iteration.
9362   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
9363   //            "_T(\"aaaaaaaaaaaaa\")\n"
9364   //            "_T(\"aaaaaaaaaaaaa\")\n"
9365   //            "_T(\"a\")",
9366   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
9367   //                   getLLVMStyleWithColumns(20)));
9368   EXPECT_EQ(
9369       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
9370       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
9371   EXPECT_EQ("f(\n"
9372             "#if !TEST\n"
9373             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
9374             "#endif\n"
9375             ");",
9376             format("f(\n"
9377                    "#if !TEST\n"
9378                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
9379                    "#endif\n"
9380                    ");"));
9381   EXPECT_EQ("f(\n"
9382             "\n"
9383             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
9384             format("f(\n"
9385                    "\n"
9386                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
9387 }
9388 
9389 TEST_F(FormatTest, BreaksStringLiteralOperands) {
9390   // In a function call with two operands, the second can be broken with no line
9391   // break before it.
9392   EXPECT_EQ(
9393       "func(a, \"long long \"\n"
9394       "        \"long long\");",
9395       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
9396   // In a function call with three operands, the second must be broken with a
9397   // line break before it.
9398   EXPECT_EQ("func(a,\n"
9399             "     \"long long long \"\n"
9400             "     \"long\",\n"
9401             "     c);",
9402             format("func(a, \"long long long long\", c);",
9403                    getLLVMStyleWithColumns(24)));
9404   // In a function call with three operands, the third must be broken with a
9405   // line break before it.
9406   EXPECT_EQ("func(a, b,\n"
9407             "     \"long long long \"\n"
9408             "     \"long\");",
9409             format("func(a, b, \"long long long long\");",
9410                    getLLVMStyleWithColumns(24)));
9411   // In a function call with three operands, both the second and the third must
9412   // be broken with a line break before them.
9413   EXPECT_EQ("func(a,\n"
9414             "     \"long long long \"\n"
9415             "     \"long\",\n"
9416             "     \"long long long \"\n"
9417             "     \"long\");",
9418             format("func(a, \"long long long long\", \"long long long long\");",
9419                    getLLVMStyleWithColumns(24)));
9420   // In a chain of << with two operands, the second can be broken with no line
9421   // break before it.
9422   EXPECT_EQ("a << \"line line \"\n"
9423             "     \"line\";",
9424             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
9425   // In a chain of << with three operands, the second can be broken with no line
9426   // break before it.
9427   EXPECT_EQ(
9428       "abcde << \"line \"\n"
9429       "         \"line line\"\n"
9430       "      << c;",
9431       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
9432   // In a chain of << with three operands, the third must be broken with a line
9433   // break before it.
9434   EXPECT_EQ(
9435       "a << b\n"
9436       "  << \"line line \"\n"
9437       "     \"line\";",
9438       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
9439   // In a chain of << with three operands, the second can be broken with no line
9440   // break before it and the third must be broken with a line break before it.
9441   EXPECT_EQ("abcd << \"line line \"\n"
9442             "        \"line\"\n"
9443             "     << \"line line \"\n"
9444             "        \"line\";",
9445             format("abcd << \"line line line\" << \"line line line\";",
9446                    getLLVMStyleWithColumns(20)));
9447   // In a chain of binary operators with two operands, the second can be broken
9448   // with no line break before it.
9449   EXPECT_EQ(
9450       "abcd + \"line line \"\n"
9451       "       \"line line\";",
9452       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
9453   // In a chain of binary operators with three operands, the second must be
9454   // broken with a line break before it.
9455   EXPECT_EQ("abcd +\n"
9456             "    \"line line \"\n"
9457             "    \"line line\" +\n"
9458             "    e;",
9459             format("abcd + \"line line line line\" + e;",
9460                    getLLVMStyleWithColumns(20)));
9461   // In a function call with two operands, with AlignAfterOpenBracket enabled,
9462   // the first must be broken with a line break before it.
9463   FormatStyle Style = getLLVMStyleWithColumns(25);
9464   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
9465   EXPECT_EQ("someFunction(\n"
9466             "    \"long long long \"\n"
9467             "    \"long\",\n"
9468             "    a);",
9469             format("someFunction(\"long long long long\", a);", Style));
9470 }
9471 
9472 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
9473   EXPECT_EQ(
9474       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
9475       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
9476       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
9477       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
9478              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
9479              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
9480 }
9481 
9482 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
9483   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
9484             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
9485   EXPECT_EQ("fffffffffff(g(R\"x(\n"
9486             "multiline raw string literal xxxxxxxxxxxxxx\n"
9487             ")x\",\n"
9488             "              a),\n"
9489             "            b);",
9490             format("fffffffffff(g(R\"x(\n"
9491                    "multiline raw string literal xxxxxxxxxxxxxx\n"
9492                    ")x\", a), b);",
9493                    getGoogleStyleWithColumns(20)));
9494   EXPECT_EQ("fffffffffff(\n"
9495             "    g(R\"x(qqq\n"
9496             "multiline raw string literal xxxxxxxxxxxxxx\n"
9497             ")x\",\n"
9498             "      a),\n"
9499             "    b);",
9500             format("fffffffffff(g(R\"x(qqq\n"
9501                    "multiline raw string literal xxxxxxxxxxxxxx\n"
9502                    ")x\", a), b);",
9503                    getGoogleStyleWithColumns(20)));
9504 
9505   EXPECT_EQ("fffffffffff(R\"x(\n"
9506             "multiline raw string literal xxxxxxxxxxxxxx\n"
9507             ")x\");",
9508             format("fffffffffff(R\"x(\n"
9509                    "multiline raw string literal xxxxxxxxxxxxxx\n"
9510                    ")x\");",
9511                    getGoogleStyleWithColumns(20)));
9512   EXPECT_EQ("fffffffffff(R\"x(\n"
9513             "multiline raw string literal xxxxxxxxxxxxxx\n"
9514             ")x\" + bbbbbb);",
9515             format("fffffffffff(R\"x(\n"
9516                    "multiline raw string literal xxxxxxxxxxxxxx\n"
9517                    ")x\" +   bbbbbb);",
9518                    getGoogleStyleWithColumns(20)));
9519   EXPECT_EQ("fffffffffff(\n"
9520             "    R\"x(\n"
9521             "multiline raw string literal xxxxxxxxxxxxxx\n"
9522             ")x\" +\n"
9523             "    bbbbbb);",
9524             format("fffffffffff(\n"
9525                    " R\"x(\n"
9526                    "multiline raw string literal xxxxxxxxxxxxxx\n"
9527                    ")x\" + bbbbbb);",
9528                    getGoogleStyleWithColumns(20)));
9529   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
9530             format("fffffffffff(\n"
9531                    " R\"(single line raw string)\" + bbbbbb);"));
9532 }
9533 
9534 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
9535   verifyFormat("string a = \"unterminated;");
9536   EXPECT_EQ("function(\"unterminated,\n"
9537             "         OtherParameter);",
9538             format("function(  \"unterminated,\n"
9539                    "    OtherParameter);"));
9540 }
9541 
9542 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
9543   FormatStyle Style = getLLVMStyle();
9544   Style.Standard = FormatStyle::LS_Cpp03;
9545   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
9546             format("#define x(_a) printf(\"foo\"_a);", Style));
9547 }
9548 
9549 TEST_F(FormatTest, CppLexVersion) {
9550   FormatStyle Style = getLLVMStyle();
9551   // Formatting of x * y differs if x is a type.
9552   verifyFormat("void foo() { MACRO(a * b); }", Style);
9553   verifyFormat("void foo() { MACRO(int *b); }", Style);
9554 
9555   // LLVM style uses latest lexer.
9556   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
9557   Style.Standard = FormatStyle::LS_Cpp17;
9558   // But in c++17, char8_t isn't a keyword.
9559   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
9560 }
9561 
9562 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
9563 
9564 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
9565   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
9566             "             \"ddeeefff\");",
9567             format("someFunction(\"aaabbbcccdddeeefff\");",
9568                    getLLVMStyleWithColumns(25)));
9569   EXPECT_EQ("someFunction1234567890(\n"
9570             "    \"aaabbbcccdddeeefff\");",
9571             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
9572                    getLLVMStyleWithColumns(26)));
9573   EXPECT_EQ("someFunction1234567890(\n"
9574             "    \"aaabbbcccdddeeeff\"\n"
9575             "    \"f\");",
9576             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
9577                    getLLVMStyleWithColumns(25)));
9578   EXPECT_EQ("someFunction1234567890(\n"
9579             "    \"aaabbbcccdddeeeff\"\n"
9580             "    \"f\");",
9581             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
9582                    getLLVMStyleWithColumns(24)));
9583   EXPECT_EQ("someFunction(\n"
9584             "    \"aaabbbcc ddde \"\n"
9585             "    \"efff\");",
9586             format("someFunction(\"aaabbbcc ddde efff\");",
9587                    getLLVMStyleWithColumns(25)));
9588   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
9589             "             \"ddeeefff\");",
9590             format("someFunction(\"aaabbbccc ddeeefff\");",
9591                    getLLVMStyleWithColumns(25)));
9592   EXPECT_EQ("someFunction1234567890(\n"
9593             "    \"aaabb \"\n"
9594             "    \"cccdddeeefff\");",
9595             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
9596                    getLLVMStyleWithColumns(25)));
9597   EXPECT_EQ("#define A          \\\n"
9598             "  string s =       \\\n"
9599             "      \"123456789\"  \\\n"
9600             "      \"0\";         \\\n"
9601             "  int i;",
9602             format("#define A string s = \"1234567890\"; int i;",
9603                    getLLVMStyleWithColumns(20)));
9604   EXPECT_EQ("someFunction(\n"
9605             "    \"aaabbbcc \"\n"
9606             "    \"dddeeefff\");",
9607             format("someFunction(\"aaabbbcc dddeeefff\");",
9608                    getLLVMStyleWithColumns(25)));
9609 }
9610 
9611 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
9612   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
9613   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
9614   EXPECT_EQ("\"test\"\n"
9615             "\"\\n\"",
9616             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
9617   EXPECT_EQ("\"tes\\\\\"\n"
9618             "\"n\"",
9619             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
9620   EXPECT_EQ("\"\\\\\\\\\"\n"
9621             "\"\\n\"",
9622             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
9623   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
9624   EXPECT_EQ("\"\\uff01\"\n"
9625             "\"test\"",
9626             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
9627   EXPECT_EQ("\"\\Uff01ff02\"",
9628             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
9629   EXPECT_EQ("\"\\x000000000001\"\n"
9630             "\"next\"",
9631             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
9632   EXPECT_EQ("\"\\x000000000001next\"",
9633             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
9634   EXPECT_EQ("\"\\x000000000001\"",
9635             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
9636   EXPECT_EQ("\"test\"\n"
9637             "\"\\000000\"\n"
9638             "\"000001\"",
9639             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
9640   EXPECT_EQ("\"test\\000\"\n"
9641             "\"00000000\"\n"
9642             "\"1\"",
9643             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
9644 }
9645 
9646 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
9647   verifyFormat("void f() {\n"
9648                "  return g() {}\n"
9649                "  void h() {}");
9650   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
9651                "g();\n"
9652                "}");
9653 }
9654 
9655 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
9656   verifyFormat(
9657       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
9658 }
9659 
9660 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
9661   verifyFormat("class X {\n"
9662                "  void f() {\n"
9663                "  }\n"
9664                "};",
9665                getLLVMStyleWithColumns(12));
9666 }
9667 
9668 TEST_F(FormatTest, ConfigurableIndentWidth) {
9669   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
9670   EightIndent.IndentWidth = 8;
9671   EightIndent.ContinuationIndentWidth = 8;
9672   verifyFormat("void f() {\n"
9673                "        someFunction();\n"
9674                "        if (true) {\n"
9675                "                f();\n"
9676                "        }\n"
9677                "}",
9678                EightIndent);
9679   verifyFormat("class X {\n"
9680                "        void f() {\n"
9681                "        }\n"
9682                "};",
9683                EightIndent);
9684   verifyFormat("int x[] = {\n"
9685                "        call(),\n"
9686                "        call()};",
9687                EightIndent);
9688 }
9689 
9690 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
9691   verifyFormat("double\n"
9692                "f();",
9693                getLLVMStyleWithColumns(8));
9694 }
9695 
9696 TEST_F(FormatTest, ConfigurableUseOfTab) {
9697   FormatStyle Tab = getLLVMStyleWithColumns(42);
9698   Tab.IndentWidth = 8;
9699   Tab.UseTab = FormatStyle::UT_Always;
9700   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
9701 
9702   EXPECT_EQ("if (aaaaaaaa && // q\n"
9703             "    bb)\t\t// w\n"
9704             "\t;",
9705             format("if (aaaaaaaa &&// q\n"
9706                    "bb)// w\n"
9707                    ";",
9708                    Tab));
9709   EXPECT_EQ("if (aaa && bbb) // w\n"
9710             "\t;",
9711             format("if(aaa&&bbb)// w\n"
9712                    ";",
9713                    Tab));
9714 
9715   verifyFormat("class X {\n"
9716                "\tvoid f() {\n"
9717                "\t\tsomeFunction(parameter1,\n"
9718                "\t\t\t     parameter2);\n"
9719                "\t}\n"
9720                "};",
9721                Tab);
9722   verifyFormat("#define A                        \\\n"
9723                "\tvoid f() {               \\\n"
9724                "\t\tsomeFunction(    \\\n"
9725                "\t\t    parameter1,  \\\n"
9726                "\t\t    parameter2); \\\n"
9727                "\t}",
9728                Tab);
9729   verifyFormat("int a;\t      // x\n"
9730                "int bbbbbbbb; // x\n",
9731                Tab);
9732 
9733   Tab.TabWidth = 4;
9734   Tab.IndentWidth = 8;
9735   verifyFormat("class TabWidth4Indent8 {\n"
9736                "\t\tvoid f() {\n"
9737                "\t\t\t\tsomeFunction(parameter1,\n"
9738                "\t\t\t\t\t\t\t parameter2);\n"
9739                "\t\t}\n"
9740                "};",
9741                Tab);
9742 
9743   Tab.TabWidth = 4;
9744   Tab.IndentWidth = 4;
9745   verifyFormat("class TabWidth4Indent4 {\n"
9746                "\tvoid f() {\n"
9747                "\t\tsomeFunction(parameter1,\n"
9748                "\t\t\t\t\t parameter2);\n"
9749                "\t}\n"
9750                "};",
9751                Tab);
9752 
9753   Tab.TabWidth = 8;
9754   Tab.IndentWidth = 4;
9755   verifyFormat("class TabWidth8Indent4 {\n"
9756                "    void f() {\n"
9757                "\tsomeFunction(parameter1,\n"
9758                "\t\t     parameter2);\n"
9759                "    }\n"
9760                "};",
9761                Tab);
9762 
9763   Tab.TabWidth = 8;
9764   Tab.IndentWidth = 8;
9765   EXPECT_EQ("/*\n"
9766             "\t      a\t\tcomment\n"
9767             "\t      in multiple lines\n"
9768             "       */",
9769             format("   /*\t \t \n"
9770                    " \t \t a\t\tcomment\t \t\n"
9771                    " \t \t in multiple lines\t\n"
9772                    " \t  */",
9773                    Tab));
9774 
9775   Tab.UseTab = FormatStyle::UT_ForIndentation;
9776   verifyFormat("{\n"
9777                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9778                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9779                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9780                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9781                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9782                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9783                "};",
9784                Tab);
9785   verifyFormat("enum AA {\n"
9786                "\ta1, // Force multiple lines\n"
9787                "\ta2,\n"
9788                "\ta3\n"
9789                "};",
9790                Tab);
9791   EXPECT_EQ("if (aaaaaaaa && // q\n"
9792             "    bb)         // w\n"
9793             "\t;",
9794             format("if (aaaaaaaa &&// q\n"
9795                    "bb)// w\n"
9796                    ";",
9797                    Tab));
9798   verifyFormat("class X {\n"
9799                "\tvoid f() {\n"
9800                "\t\tsomeFunction(parameter1,\n"
9801                "\t\t             parameter2);\n"
9802                "\t}\n"
9803                "};",
9804                Tab);
9805   verifyFormat("{\n"
9806                "\tQ(\n"
9807                "\t    {\n"
9808                "\t\t    int a;\n"
9809                "\t\t    someFunction(aaaaaaaa,\n"
9810                "\t\t                 bbbbbbb);\n"
9811                "\t    },\n"
9812                "\t    p);\n"
9813                "}",
9814                Tab);
9815   EXPECT_EQ("{\n"
9816             "\t/* aaaa\n"
9817             "\t   bbbb */\n"
9818             "}",
9819             format("{\n"
9820                    "/* aaaa\n"
9821                    "   bbbb */\n"
9822                    "}",
9823                    Tab));
9824   EXPECT_EQ("{\n"
9825             "\t/*\n"
9826             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9827             "\t  bbbbbbbbbbbbb\n"
9828             "\t*/\n"
9829             "}",
9830             format("{\n"
9831                    "/*\n"
9832                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
9833                    "*/\n"
9834                    "}",
9835                    Tab));
9836   EXPECT_EQ("{\n"
9837             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9838             "\t// bbbbbbbbbbbbb\n"
9839             "}",
9840             format("{\n"
9841                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
9842                    "}",
9843                    Tab));
9844   EXPECT_EQ("{\n"
9845             "\t/*\n"
9846             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9847             "\t  bbbbbbbbbbbbb\n"
9848             "\t*/\n"
9849             "}",
9850             format("{\n"
9851                    "\t/*\n"
9852                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
9853                    "\t*/\n"
9854                    "}",
9855                    Tab));
9856   EXPECT_EQ("{\n"
9857             "\t/*\n"
9858             "\n"
9859             "\t*/\n"
9860             "}",
9861             format("{\n"
9862                    "\t/*\n"
9863                    "\n"
9864                    "\t*/\n"
9865                    "}",
9866                    Tab));
9867   EXPECT_EQ("{\n"
9868             "\t/*\n"
9869             " asdf\n"
9870             "\t*/\n"
9871             "}",
9872             format("{\n"
9873                    "\t/*\n"
9874                    " asdf\n"
9875                    "\t*/\n"
9876                    "}",
9877                    Tab));
9878 
9879   Tab.UseTab = FormatStyle::UT_Never;
9880   EXPECT_EQ("/*\n"
9881             "              a\t\tcomment\n"
9882             "              in multiple lines\n"
9883             "       */",
9884             format("   /*\t \t \n"
9885                    " \t \t a\t\tcomment\t \t\n"
9886                    " \t \t in multiple lines\t\n"
9887                    " \t  */",
9888                    Tab));
9889   EXPECT_EQ("/* some\n"
9890             "   comment */",
9891             format(" \t \t /* some\n"
9892                    " \t \t    comment */",
9893                    Tab));
9894   EXPECT_EQ("int a; /* some\n"
9895             "   comment */",
9896             format(" \t \t int a; /* some\n"
9897                    " \t \t    comment */",
9898                    Tab));
9899 
9900   EXPECT_EQ("int a; /* some\n"
9901             "comment */",
9902             format(" \t \t int\ta; /* some\n"
9903                    " \t \t    comment */",
9904                    Tab));
9905   EXPECT_EQ("f(\"\t\t\"); /* some\n"
9906             "    comment */",
9907             format(" \t \t f(\"\t\t\"); /* some\n"
9908                    " \t \t    comment */",
9909                    Tab));
9910   EXPECT_EQ("{\n"
9911             "  /*\n"
9912             "   * Comment\n"
9913             "   */\n"
9914             "  int i;\n"
9915             "}",
9916             format("{\n"
9917                    "\t/*\n"
9918                    "\t * Comment\n"
9919                    "\t */\n"
9920                    "\t int i;\n"
9921                    "}"));
9922 
9923   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
9924   Tab.TabWidth = 8;
9925   Tab.IndentWidth = 8;
9926   EXPECT_EQ("if (aaaaaaaa && // q\n"
9927             "    bb)         // w\n"
9928             "\t;",
9929             format("if (aaaaaaaa &&// q\n"
9930                    "bb)// w\n"
9931                    ";",
9932                    Tab));
9933   EXPECT_EQ("if (aaa && bbb) // w\n"
9934             "\t;",
9935             format("if(aaa&&bbb)// w\n"
9936                    ";",
9937                    Tab));
9938   verifyFormat("class X {\n"
9939                "\tvoid f() {\n"
9940                "\t\tsomeFunction(parameter1,\n"
9941                "\t\t\t     parameter2);\n"
9942                "\t}\n"
9943                "};",
9944                Tab);
9945   verifyFormat("#define A                        \\\n"
9946                "\tvoid f() {               \\\n"
9947                "\t\tsomeFunction(    \\\n"
9948                "\t\t    parameter1,  \\\n"
9949                "\t\t    parameter2); \\\n"
9950                "\t}",
9951                Tab);
9952   Tab.TabWidth = 4;
9953   Tab.IndentWidth = 8;
9954   verifyFormat("class TabWidth4Indent8 {\n"
9955                "\t\tvoid f() {\n"
9956                "\t\t\t\tsomeFunction(parameter1,\n"
9957                "\t\t\t\t\t\t\t parameter2);\n"
9958                "\t\t}\n"
9959                "};",
9960                Tab);
9961   Tab.TabWidth = 4;
9962   Tab.IndentWidth = 4;
9963   verifyFormat("class TabWidth4Indent4 {\n"
9964                "\tvoid f() {\n"
9965                "\t\tsomeFunction(parameter1,\n"
9966                "\t\t\t\t\t parameter2);\n"
9967                "\t}\n"
9968                "};",
9969                Tab);
9970   Tab.TabWidth = 8;
9971   Tab.IndentWidth = 4;
9972   verifyFormat("class TabWidth8Indent4 {\n"
9973                "    void f() {\n"
9974                "\tsomeFunction(parameter1,\n"
9975                "\t\t     parameter2);\n"
9976                "    }\n"
9977                "};",
9978                Tab);
9979   Tab.TabWidth = 8;
9980   Tab.IndentWidth = 8;
9981   EXPECT_EQ("/*\n"
9982             "\t      a\t\tcomment\n"
9983             "\t      in multiple lines\n"
9984             "       */",
9985             format("   /*\t \t \n"
9986                    " \t \t a\t\tcomment\t \t\n"
9987                    " \t \t in multiple lines\t\n"
9988                    " \t  */",
9989                    Tab));
9990   verifyFormat("{\n"
9991                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9992                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9993                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9994                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9995                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9996                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
9997                "};",
9998                Tab);
9999   verifyFormat("enum AA {\n"
10000                "\ta1, // Force multiple lines\n"
10001                "\ta2,\n"
10002                "\ta3\n"
10003                "};",
10004                Tab);
10005   EXPECT_EQ("if (aaaaaaaa && // q\n"
10006             "    bb)         // w\n"
10007             "\t;",
10008             format("if (aaaaaaaa &&// q\n"
10009                    "bb)// w\n"
10010                    ";",
10011                    Tab));
10012   verifyFormat("class X {\n"
10013                "\tvoid f() {\n"
10014                "\t\tsomeFunction(parameter1,\n"
10015                "\t\t\t     parameter2);\n"
10016                "\t}\n"
10017                "};",
10018                Tab);
10019   verifyFormat("{\n"
10020                "\tQ(\n"
10021                "\t    {\n"
10022                "\t\t    int a;\n"
10023                "\t\t    someFunction(aaaaaaaa,\n"
10024                "\t\t\t\t bbbbbbb);\n"
10025                "\t    },\n"
10026                "\t    p);\n"
10027                "}",
10028                Tab);
10029   EXPECT_EQ("{\n"
10030             "\t/* aaaa\n"
10031             "\t   bbbb */\n"
10032             "}",
10033             format("{\n"
10034                    "/* aaaa\n"
10035                    "   bbbb */\n"
10036                    "}",
10037                    Tab));
10038   EXPECT_EQ("{\n"
10039             "\t/*\n"
10040             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10041             "\t  bbbbbbbbbbbbb\n"
10042             "\t*/\n"
10043             "}",
10044             format("{\n"
10045                    "/*\n"
10046                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10047                    "*/\n"
10048                    "}",
10049                    Tab));
10050   EXPECT_EQ("{\n"
10051             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10052             "\t// bbbbbbbbbbbbb\n"
10053             "}",
10054             format("{\n"
10055                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10056                    "}",
10057                    Tab));
10058   EXPECT_EQ("{\n"
10059             "\t/*\n"
10060             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10061             "\t  bbbbbbbbbbbbb\n"
10062             "\t*/\n"
10063             "}",
10064             format("{\n"
10065                    "\t/*\n"
10066                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10067                    "\t*/\n"
10068                    "}",
10069                    Tab));
10070   EXPECT_EQ("{\n"
10071             "\t/*\n"
10072             "\n"
10073             "\t*/\n"
10074             "}",
10075             format("{\n"
10076                    "\t/*\n"
10077                    "\n"
10078                    "\t*/\n"
10079                    "}",
10080                    Tab));
10081   EXPECT_EQ("{\n"
10082             "\t/*\n"
10083             " asdf\n"
10084             "\t*/\n"
10085             "}",
10086             format("{\n"
10087                    "\t/*\n"
10088                    " asdf\n"
10089                    "\t*/\n"
10090                    "}",
10091                    Tab));
10092   EXPECT_EQ("/*\n"
10093             "\t      a\t\tcomment\n"
10094             "\t      in multiple lines\n"
10095             "       */",
10096             format("   /*\t \t \n"
10097                    " \t \t a\t\tcomment\t \t\n"
10098                    " \t \t in multiple lines\t\n"
10099                    " \t  */",
10100                    Tab));
10101   EXPECT_EQ("/* some\n"
10102             "   comment */",
10103             format(" \t \t /* some\n"
10104                    " \t \t    comment */",
10105                    Tab));
10106   EXPECT_EQ("int a; /* some\n"
10107             "   comment */",
10108             format(" \t \t int a; /* some\n"
10109                    " \t \t    comment */",
10110                    Tab));
10111   EXPECT_EQ("int a; /* some\n"
10112             "comment */",
10113             format(" \t \t int\ta; /* some\n"
10114                    " \t \t    comment */",
10115                    Tab));
10116   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10117             "    comment */",
10118             format(" \t \t f(\"\t\t\"); /* some\n"
10119                    " \t \t    comment */",
10120                    Tab));
10121   EXPECT_EQ("{\n"
10122             "  /*\n"
10123             "   * Comment\n"
10124             "   */\n"
10125             "  int i;\n"
10126             "}",
10127             format("{\n"
10128                    "\t/*\n"
10129                    "\t * Comment\n"
10130                    "\t */\n"
10131                    "\t int i;\n"
10132                    "}"));
10133   Tab.AlignConsecutiveAssignments = true;
10134   Tab.AlignConsecutiveDeclarations = true;
10135   Tab.TabWidth = 4;
10136   Tab.IndentWidth = 4;
10137   verifyFormat("class Assign {\n"
10138                "\tvoid f() {\n"
10139                "\t\tint         x      = 123;\n"
10140                "\t\tint         random = 4;\n"
10141                "\t\tstd::string alphabet =\n"
10142                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
10143                "\t}\n"
10144                "};",
10145                Tab);
10146 }
10147 
10148 TEST_F(FormatTest, ZeroTabWidth) {
10149   FormatStyle Tab = getLLVMStyleWithColumns(42);
10150   Tab.IndentWidth = 8;
10151   Tab.UseTab = FormatStyle::UT_Never;
10152   Tab.TabWidth = 0;
10153   EXPECT_EQ("void a(){\n"
10154             "    // line starts with '\t'\n"
10155             "};",
10156             format("void a(){\n"
10157                    "\t// line starts with '\t'\n"
10158                    "};",
10159                    Tab));
10160 
10161   EXPECT_EQ("void a(){\n"
10162             "    // line starts with '\t'\n"
10163             "};",
10164             format("void a(){\n"
10165                    "\t\t// line starts with '\t'\n"
10166                    "};",
10167                    Tab));
10168 
10169   Tab.UseTab = FormatStyle::UT_ForIndentation;
10170   EXPECT_EQ("void a(){\n"
10171             "    // line starts with '\t'\n"
10172             "};",
10173             format("void a(){\n"
10174                    "\t// line starts with '\t'\n"
10175                    "};",
10176                    Tab));
10177 
10178   EXPECT_EQ("void a(){\n"
10179             "    // line starts with '\t'\n"
10180             "};",
10181             format("void a(){\n"
10182                    "\t\t// line starts with '\t'\n"
10183                    "};",
10184                    Tab));
10185 
10186   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
10187   EXPECT_EQ("void a(){\n"
10188             "    // line starts with '\t'\n"
10189             "};",
10190             format("void a(){\n"
10191                    "\t// line starts with '\t'\n"
10192                    "};",
10193                    Tab));
10194 
10195   EXPECT_EQ("void a(){\n"
10196             "    // line starts with '\t'\n"
10197             "};",
10198             format("void a(){\n"
10199                    "\t\t// line starts with '\t'\n"
10200                    "};",
10201                    Tab));
10202 
10203   Tab.UseTab = FormatStyle::UT_Always;
10204   EXPECT_EQ("void a(){\n"
10205             "// line starts with '\t'\n"
10206             "};",
10207             format("void a(){\n"
10208                    "\t// line starts with '\t'\n"
10209                    "};",
10210                    Tab));
10211 
10212   EXPECT_EQ("void a(){\n"
10213             "// line starts with '\t'\n"
10214             "};",
10215             format("void a(){\n"
10216                    "\t\t// line starts with '\t'\n"
10217                    "};",
10218                    Tab));
10219 }
10220 
10221 TEST_F(FormatTest, CalculatesOriginalColumn) {
10222   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
10223             "q\"; /* some\n"
10224             "       comment */",
10225             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
10226                    "q\"; /* some\n"
10227                    "       comment */",
10228                    getLLVMStyle()));
10229   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
10230             "/* some\n"
10231             "   comment */",
10232             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
10233                    " /* some\n"
10234                    "    comment */",
10235                    getLLVMStyle()));
10236   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
10237             "qqq\n"
10238             "/* some\n"
10239             "   comment */",
10240             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
10241                    "qqq\n"
10242                    " /* some\n"
10243                    "    comment */",
10244                    getLLVMStyle()));
10245   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
10246             "wwww; /* some\n"
10247             "         comment */",
10248             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
10249                    "wwww; /* some\n"
10250                    "         comment */",
10251                    getLLVMStyle()));
10252 }
10253 
10254 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
10255   FormatStyle NoSpace = getLLVMStyle();
10256   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
10257 
10258   verifyFormat("while(true)\n"
10259                "  continue;",
10260                NoSpace);
10261   verifyFormat("for(;;)\n"
10262                "  continue;",
10263                NoSpace);
10264   verifyFormat("if(true)\n"
10265                "  f();\n"
10266                "else if(true)\n"
10267                "  f();",
10268                NoSpace);
10269   verifyFormat("do {\n"
10270                "  do_something();\n"
10271                "} while(something());",
10272                NoSpace);
10273   verifyFormat("switch(x) {\n"
10274                "default:\n"
10275                "  break;\n"
10276                "}",
10277                NoSpace);
10278   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
10279   verifyFormat("size_t x = sizeof(x);", NoSpace);
10280   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
10281   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
10282   verifyFormat("alignas(128) char a[128];", NoSpace);
10283   verifyFormat("size_t x = alignof(MyType);", NoSpace);
10284   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
10285   verifyFormat("int f() throw(Deprecated);", NoSpace);
10286   verifyFormat("typedef void (*cb)(int);", NoSpace);
10287   verifyFormat("T A::operator()();", NoSpace);
10288   verifyFormat("X A::operator++(T);", NoSpace);
10289   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
10290 
10291   FormatStyle Space = getLLVMStyle();
10292   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
10293 
10294   verifyFormat("int f ();", Space);
10295   verifyFormat("void f (int a, T b) {\n"
10296                "  while (true)\n"
10297                "    continue;\n"
10298                "}",
10299                Space);
10300   verifyFormat("if (true)\n"
10301                "  f ();\n"
10302                "else if (true)\n"
10303                "  f ();",
10304                Space);
10305   verifyFormat("do {\n"
10306                "  do_something ();\n"
10307                "} while (something ());",
10308                Space);
10309   verifyFormat("switch (x) {\n"
10310                "default:\n"
10311                "  break;\n"
10312                "}",
10313                Space);
10314   verifyFormat("A::A () : a (1) {}", Space);
10315   verifyFormat("void f () __attribute__ ((asdf));", Space);
10316   verifyFormat("*(&a + 1);\n"
10317                "&((&a)[1]);\n"
10318                "a[(b + c) * d];\n"
10319                "(((a + 1) * 2) + 3) * 4;",
10320                Space);
10321   verifyFormat("#define A(x) x", Space);
10322   verifyFormat("#define A (x) x", Space);
10323   verifyFormat("#if defined(x)\n"
10324                "#endif",
10325                Space);
10326   verifyFormat("auto i = std::make_unique<int> (5);", Space);
10327   verifyFormat("size_t x = sizeof (x);", Space);
10328   verifyFormat("auto f (int x) -> decltype (x);", Space);
10329   verifyFormat("int f (T x) noexcept (x.create ());", Space);
10330   verifyFormat("alignas (128) char a[128];", Space);
10331   verifyFormat("size_t x = alignof (MyType);", Space);
10332   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
10333   verifyFormat("int f () throw (Deprecated);", Space);
10334   verifyFormat("typedef void (*cb) (int);", Space);
10335   verifyFormat("T A::operator() ();", Space);
10336   verifyFormat("X A::operator++ (T);", Space);
10337   verifyFormat("auto lambda = [] () { return 0; };", Space);
10338   verifyFormat("int x = int (y);", Space);
10339 
10340   FormatStyle SomeSpace = getLLVMStyle();
10341   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
10342 
10343   verifyFormat("[]() -> float {}", SomeSpace);
10344   verifyFormat("[] (auto foo) {}", SomeSpace);
10345   verifyFormat("[foo]() -> int {}", SomeSpace);
10346   verifyFormat("int f();", SomeSpace);
10347   verifyFormat("void f (int a, T b) {\n"
10348                "  while (true)\n"
10349                "    continue;\n"
10350                "}",
10351                SomeSpace);
10352   verifyFormat("if (true)\n"
10353                "  f();\n"
10354                "else if (true)\n"
10355                "  f();",
10356                SomeSpace);
10357   verifyFormat("do {\n"
10358                "  do_something();\n"
10359                "} while (something());",
10360                SomeSpace);
10361   verifyFormat("switch (x) {\n"
10362                "default:\n"
10363                "  break;\n"
10364                "}",
10365                SomeSpace);
10366   verifyFormat("A::A() : a (1) {}", SomeSpace);
10367   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
10368   verifyFormat("*(&a + 1);\n"
10369                "&((&a)[1]);\n"
10370                "a[(b + c) * d];\n"
10371                "(((a + 1) * 2) + 3) * 4;",
10372                SomeSpace);
10373   verifyFormat("#define A(x) x", SomeSpace);
10374   verifyFormat("#define A (x) x", SomeSpace);
10375   verifyFormat("#if defined(x)\n"
10376                "#endif",
10377                SomeSpace);
10378   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
10379   verifyFormat("size_t x = sizeof (x);", SomeSpace);
10380   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
10381   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
10382   verifyFormat("alignas (128) char a[128];", SomeSpace);
10383   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
10384   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
10385                SomeSpace);
10386   verifyFormat("int f() throw (Deprecated);", SomeSpace);
10387   verifyFormat("typedef void (*cb) (int);", SomeSpace);
10388   verifyFormat("T A::operator()();", SomeSpace);
10389   verifyFormat("X A::operator++ (T);", SomeSpace);
10390   verifyFormat("int x = int (y);", SomeSpace);
10391   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
10392 }
10393 
10394 TEST_F(FormatTest, SpaceAfterLogicalNot) {
10395   FormatStyle Spaces = getLLVMStyle();
10396   Spaces.SpaceAfterLogicalNot = true;
10397 
10398   verifyFormat("bool x = ! y", Spaces);
10399   verifyFormat("if (! isFailure())", Spaces);
10400   verifyFormat("if (! (a && b))", Spaces);
10401   verifyFormat("\"Error!\"", Spaces);
10402   verifyFormat("! ! x", Spaces);
10403 }
10404 
10405 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
10406   FormatStyle Spaces = getLLVMStyle();
10407 
10408   Spaces.SpacesInParentheses = true;
10409   verifyFormat("do_something( ::globalVar );", Spaces);
10410   verifyFormat("call( x, y, z );", Spaces);
10411   verifyFormat("call();", Spaces);
10412   verifyFormat("std::function<void( int, int )> callback;", Spaces);
10413   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
10414                Spaces);
10415   verifyFormat("while ( (bool)1 )\n"
10416                "  continue;",
10417                Spaces);
10418   verifyFormat("for ( ;; )\n"
10419                "  continue;",
10420                Spaces);
10421   verifyFormat("if ( true )\n"
10422                "  f();\n"
10423                "else if ( true )\n"
10424                "  f();",
10425                Spaces);
10426   verifyFormat("do {\n"
10427                "  do_something( (int)i );\n"
10428                "} while ( something() );",
10429                Spaces);
10430   verifyFormat("switch ( x ) {\n"
10431                "default:\n"
10432                "  break;\n"
10433                "}",
10434                Spaces);
10435 
10436   Spaces.SpacesInParentheses = false;
10437   Spaces.SpacesInCStyleCastParentheses = true;
10438   verifyFormat("Type *A = ( Type * )P;", Spaces);
10439   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
10440   verifyFormat("x = ( int32 )y;", Spaces);
10441   verifyFormat("int a = ( int )(2.0f);", Spaces);
10442   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
10443   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
10444   verifyFormat("#define x (( int )-1)", Spaces);
10445 
10446   // Run the first set of tests again with:
10447   Spaces.SpacesInParentheses = false;
10448   Spaces.SpaceInEmptyParentheses = true;
10449   Spaces.SpacesInCStyleCastParentheses = true;
10450   verifyFormat("call(x, y, z);", Spaces);
10451   verifyFormat("call( );", Spaces);
10452   verifyFormat("std::function<void(int, int)> callback;", Spaces);
10453   verifyFormat("while (( bool )1)\n"
10454                "  continue;",
10455                Spaces);
10456   verifyFormat("for (;;)\n"
10457                "  continue;",
10458                Spaces);
10459   verifyFormat("if (true)\n"
10460                "  f( );\n"
10461                "else if (true)\n"
10462                "  f( );",
10463                Spaces);
10464   verifyFormat("do {\n"
10465                "  do_something(( int )i);\n"
10466                "} while (something( ));",
10467                Spaces);
10468   verifyFormat("switch (x) {\n"
10469                "default:\n"
10470                "  break;\n"
10471                "}",
10472                Spaces);
10473 
10474   // Run the first set of tests again with:
10475   Spaces.SpaceAfterCStyleCast = true;
10476   verifyFormat("call(x, y, z);", Spaces);
10477   verifyFormat("call( );", Spaces);
10478   verifyFormat("std::function<void(int, int)> callback;", Spaces);
10479   verifyFormat("while (( bool ) 1)\n"
10480                "  continue;",
10481                Spaces);
10482   verifyFormat("for (;;)\n"
10483                "  continue;",
10484                Spaces);
10485   verifyFormat("if (true)\n"
10486                "  f( );\n"
10487                "else if (true)\n"
10488                "  f( );",
10489                Spaces);
10490   verifyFormat("do {\n"
10491                "  do_something(( int ) i);\n"
10492                "} while (something( ));",
10493                Spaces);
10494   verifyFormat("switch (x) {\n"
10495                "default:\n"
10496                "  break;\n"
10497                "}",
10498                Spaces);
10499 
10500   // Run subset of tests again with:
10501   Spaces.SpacesInCStyleCastParentheses = false;
10502   Spaces.SpaceAfterCStyleCast = true;
10503   verifyFormat("while ((bool) 1)\n"
10504                "  continue;",
10505                Spaces);
10506   verifyFormat("do {\n"
10507                "  do_something((int) i);\n"
10508                "} while (something( ));",
10509                Spaces);
10510 }
10511 
10512 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
10513   verifyFormat("int a[5];");
10514   verifyFormat("a[3] += 42;");
10515 
10516   FormatStyle Spaces = getLLVMStyle();
10517   Spaces.SpacesInSquareBrackets = true;
10518   // Lambdas unchanged.
10519   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
10520   verifyFormat("return [i, args...] {};", Spaces);
10521 
10522   // Not lambdas.
10523   verifyFormat("int a[ 5 ];", Spaces);
10524   verifyFormat("a[ 3 ] += 42;", Spaces);
10525   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
10526   verifyFormat("double &operator[](int i) { return 0; }\n"
10527                "int i;",
10528                Spaces);
10529   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
10530   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
10531   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
10532 }
10533 
10534 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
10535   verifyFormat("int a = 5;");
10536   verifyFormat("a += 42;");
10537   verifyFormat("a or_eq 8;");
10538 
10539   FormatStyle Spaces = getLLVMStyle();
10540   Spaces.SpaceBeforeAssignmentOperators = false;
10541   verifyFormat("int a= 5;", Spaces);
10542   verifyFormat("a+= 42;", Spaces);
10543   verifyFormat("a or_eq 8;", Spaces);
10544 }
10545 
10546 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
10547   verifyFormat("class Foo : public Bar {};");
10548   verifyFormat("Foo::Foo() : foo(1) {}");
10549   verifyFormat("for (auto a : b) {\n}");
10550   verifyFormat("int x = a ? b : c;");
10551   verifyFormat("{\n"
10552                "label0:\n"
10553                "  int x = 0;\n"
10554                "}");
10555   verifyFormat("switch (x) {\n"
10556                "case 1:\n"
10557                "default:\n"
10558                "}");
10559 
10560   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
10561   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
10562   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
10563   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
10564   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
10565   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
10566   verifyFormat("{\n"
10567                "label1:\n"
10568                "  int x = 0;\n"
10569                "}",
10570                CtorInitializerStyle);
10571   verifyFormat("switch (x) {\n"
10572                "case 1:\n"
10573                "default:\n"
10574                "}",
10575                CtorInitializerStyle);
10576   CtorInitializerStyle.BreakConstructorInitializers =
10577       FormatStyle::BCIS_AfterColon;
10578   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
10579                "    aaaaaaaaaaaaaaaa(1),\n"
10580                "    bbbbbbbbbbbbbbbb(2) {}",
10581                CtorInitializerStyle);
10582   CtorInitializerStyle.BreakConstructorInitializers =
10583       FormatStyle::BCIS_BeforeComma;
10584   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
10585                "    : aaaaaaaaaaaaaaaa(1)\n"
10586                "    , bbbbbbbbbbbbbbbb(2) {}",
10587                CtorInitializerStyle);
10588   CtorInitializerStyle.BreakConstructorInitializers =
10589       FormatStyle::BCIS_BeforeColon;
10590   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
10591                "    : aaaaaaaaaaaaaaaa(1),\n"
10592                "      bbbbbbbbbbbbbbbb(2) {}",
10593                CtorInitializerStyle);
10594   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
10595   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
10596                ": aaaaaaaaaaaaaaaa(1),\n"
10597                "  bbbbbbbbbbbbbbbb(2) {}",
10598                CtorInitializerStyle);
10599 
10600   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
10601   InheritanceStyle.SpaceBeforeInheritanceColon = false;
10602   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
10603   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
10604   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
10605   verifyFormat("int x = a ? b : c;", InheritanceStyle);
10606   verifyFormat("{\n"
10607                "label2:\n"
10608                "  int x = 0;\n"
10609                "}",
10610                InheritanceStyle);
10611   verifyFormat("switch (x) {\n"
10612                "case 1:\n"
10613                "default:\n"
10614                "}",
10615                InheritanceStyle);
10616   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
10617   verifyFormat("class Foooooooooooooooooooooo:\n"
10618                "    public aaaaaaaaaaaaaaaaaa,\n"
10619                "    public bbbbbbbbbbbbbbbbbb {\n"
10620                "}",
10621                InheritanceStyle);
10622   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
10623   verifyFormat("class Foooooooooooooooooooooo\n"
10624                "    : public aaaaaaaaaaaaaaaaaa\n"
10625                "    , public bbbbbbbbbbbbbbbbbb {\n"
10626                "}",
10627                InheritanceStyle);
10628   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
10629   verifyFormat("class Foooooooooooooooooooooo\n"
10630                "    : public aaaaaaaaaaaaaaaaaa,\n"
10631                "      public bbbbbbbbbbbbbbbbbb {\n"
10632                "}",
10633                InheritanceStyle);
10634   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
10635   verifyFormat("class Foooooooooooooooooooooo\n"
10636                ": public aaaaaaaaaaaaaaaaaa,\n"
10637                "  public bbbbbbbbbbbbbbbbbb {}",
10638                InheritanceStyle);
10639 
10640   FormatStyle ForLoopStyle = getLLVMStyle();
10641   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
10642   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
10643   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
10644   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
10645   verifyFormat("int x = a ? b : c;", ForLoopStyle);
10646   verifyFormat("{\n"
10647                "label2:\n"
10648                "  int x = 0;\n"
10649                "}",
10650                ForLoopStyle);
10651   verifyFormat("switch (x) {\n"
10652                "case 1:\n"
10653                "default:\n"
10654                "}",
10655                ForLoopStyle);
10656 
10657   FormatStyle NoSpaceStyle = getLLVMStyle();
10658   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
10659   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
10660   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
10661   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
10662   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
10663   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
10664   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
10665   verifyFormat("{\n"
10666                "label3:\n"
10667                "  int x = 0;\n"
10668                "}",
10669                NoSpaceStyle);
10670   verifyFormat("switch (x) {\n"
10671                "case 1:\n"
10672                "default:\n"
10673                "}",
10674                NoSpaceStyle);
10675 }
10676 
10677 TEST_F(FormatTest, AlignConsecutiveMacros) {
10678   FormatStyle Style = getLLVMStyle();
10679   Style.AlignConsecutiveAssignments = true;
10680   Style.AlignConsecutiveDeclarations = true;
10681   Style.AlignConsecutiveMacros = false;
10682 
10683   verifyFormat("#define a 3\n"
10684                "#define bbbb 4\n"
10685                "#define ccc (5)",
10686                Style);
10687 
10688   verifyFormat("#define f(x) (x * x)\n"
10689                "#define fff(x, y, z) (x * y + z)\n"
10690                "#define ffff(x, y) (x - y)",
10691                Style);
10692 
10693   verifyFormat("#define foo(x, y) (x + y)\n"
10694                "#define bar (5, 6)(2 + 2)",
10695                Style);
10696 
10697   verifyFormat("#define a 3\n"
10698                "#define bbbb 4\n"
10699                "#define ccc (5)\n"
10700                "#define f(x) (x * x)\n"
10701                "#define fff(x, y, z) (x * y + z)\n"
10702                "#define ffff(x, y) (x - y)",
10703                Style);
10704 
10705   Style.AlignConsecutiveMacros = true;
10706   verifyFormat("#define a    3\n"
10707                "#define bbbb 4\n"
10708                "#define ccc  (5)",
10709                Style);
10710 
10711   verifyFormat("#define f(x)         (x * x)\n"
10712                "#define fff(x, y, z) (x * y + z)\n"
10713                "#define ffff(x, y)   (x - y)",
10714                Style);
10715 
10716   verifyFormat("#define foo(x, y) (x + y)\n"
10717                "#define bar       (5, 6)(2 + 2)",
10718                Style);
10719 
10720   verifyFormat("#define a            3\n"
10721                "#define bbbb         4\n"
10722                "#define ccc          (5)\n"
10723                "#define f(x)         (x * x)\n"
10724                "#define fff(x, y, z) (x * y + z)\n"
10725                "#define ffff(x, y)   (x - y)",
10726                Style);
10727 
10728   verifyFormat("#define a         5\n"
10729                "#define foo(x, y) (x + y)\n"
10730                "#define CCC       (6)\n"
10731                "auto lambda = []() {\n"
10732                "  auto  ii = 0;\n"
10733                "  float j  = 0;\n"
10734                "  return 0;\n"
10735                "};\n"
10736                "int   i  = 0;\n"
10737                "float i2 = 0;\n"
10738                "auto  v  = type{\n"
10739                "    i = 1,   //\n"
10740                "    (i = 2), //\n"
10741                "    i = 3    //\n"
10742                "};",
10743                Style);
10744 
10745   Style.AlignConsecutiveMacros = false;
10746   Style.ColumnLimit = 20;
10747 
10748   verifyFormat("#define a          \\\n"
10749                "  \"aabbbbbbbbbbbb\"\n"
10750                "#define D          \\\n"
10751                "  \"aabbbbbbbbbbbb\" \\\n"
10752                "  \"ccddeeeeeeeee\"\n"
10753                "#define B          \\\n"
10754                "  \"QQQQQQQQQQQQQ\"  \\\n"
10755                "  \"FFFFFFFFFFFFF\"  \\\n"
10756                "  \"LLLLLLLL\"\n",
10757                Style);
10758 
10759   Style.AlignConsecutiveMacros = true;
10760   verifyFormat("#define a          \\\n"
10761                "  \"aabbbbbbbbbbbb\"\n"
10762                "#define D          \\\n"
10763                "  \"aabbbbbbbbbbbb\" \\\n"
10764                "  \"ccddeeeeeeeee\"\n"
10765                "#define B          \\\n"
10766                "  \"QQQQQQQQQQQQQ\"  \\\n"
10767                "  \"FFFFFFFFFFFFF\"  \\\n"
10768                "  \"LLLLLLLL\"\n",
10769                Style);
10770 }
10771 
10772 TEST_F(FormatTest, AlignConsecutiveAssignments) {
10773   FormatStyle Alignment = getLLVMStyle();
10774   Alignment.AlignConsecutiveMacros = true;
10775   Alignment.AlignConsecutiveAssignments = false;
10776   verifyFormat("int a = 5;\n"
10777                "int oneTwoThree = 123;",
10778                Alignment);
10779   verifyFormat("int a = 5;\n"
10780                "int oneTwoThree = 123;",
10781                Alignment);
10782 
10783   Alignment.AlignConsecutiveAssignments = true;
10784   verifyFormat("int a           = 5;\n"
10785                "int oneTwoThree = 123;",
10786                Alignment);
10787   verifyFormat("int a           = method();\n"
10788                "int oneTwoThree = 133;",
10789                Alignment);
10790   verifyFormat("a &= 5;\n"
10791                "bcd *= 5;\n"
10792                "ghtyf += 5;\n"
10793                "dvfvdb -= 5;\n"
10794                "a /= 5;\n"
10795                "vdsvsv %= 5;\n"
10796                "sfdbddfbdfbb ^= 5;\n"
10797                "dvsdsv |= 5;\n"
10798                "int dsvvdvsdvvv = 123;",
10799                Alignment);
10800   verifyFormat("int i = 1, j = 10;\n"
10801                "something = 2000;",
10802                Alignment);
10803   verifyFormat("something = 2000;\n"
10804                "int i = 1, j = 10;\n",
10805                Alignment);
10806   verifyFormat("something = 2000;\n"
10807                "another   = 911;\n"
10808                "int i = 1, j = 10;\n"
10809                "oneMore = 1;\n"
10810                "i       = 2;",
10811                Alignment);
10812   verifyFormat("int a   = 5;\n"
10813                "int one = 1;\n"
10814                "method();\n"
10815                "int oneTwoThree = 123;\n"
10816                "int oneTwo      = 12;",
10817                Alignment);
10818   verifyFormat("int oneTwoThree = 123;\n"
10819                "int oneTwo      = 12;\n"
10820                "method();\n",
10821                Alignment);
10822   verifyFormat("int oneTwoThree = 123; // comment\n"
10823                "int oneTwo      = 12;  // comment",
10824                Alignment);
10825   EXPECT_EQ("int a = 5;\n"
10826             "\n"
10827             "int oneTwoThree = 123;",
10828             format("int a       = 5;\n"
10829                    "\n"
10830                    "int oneTwoThree= 123;",
10831                    Alignment));
10832   EXPECT_EQ("int a   = 5;\n"
10833             "int one = 1;\n"
10834             "\n"
10835             "int oneTwoThree = 123;",
10836             format("int a = 5;\n"
10837                    "int one = 1;\n"
10838                    "\n"
10839                    "int oneTwoThree = 123;",
10840                    Alignment));
10841   EXPECT_EQ("int a   = 5;\n"
10842             "int one = 1;\n"
10843             "\n"
10844             "int oneTwoThree = 123;\n"
10845             "int oneTwo      = 12;",
10846             format("int a = 5;\n"
10847                    "int one = 1;\n"
10848                    "\n"
10849                    "int oneTwoThree = 123;\n"
10850                    "int oneTwo = 12;",
10851                    Alignment));
10852   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
10853   verifyFormat("#define A \\\n"
10854                "  int aaaa       = 12; \\\n"
10855                "  int b          = 23; \\\n"
10856                "  int ccc        = 234; \\\n"
10857                "  int dddddddddd = 2345;",
10858                Alignment);
10859   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10860   verifyFormat("#define A               \\\n"
10861                "  int aaaa       = 12;  \\\n"
10862                "  int b          = 23;  \\\n"
10863                "  int ccc        = 234; \\\n"
10864                "  int dddddddddd = 2345;",
10865                Alignment);
10866   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
10867   verifyFormat("#define A                                                      "
10868                "                \\\n"
10869                "  int aaaa       = 12;                                         "
10870                "                \\\n"
10871                "  int b          = 23;                                         "
10872                "                \\\n"
10873                "  int ccc        = 234;                                        "
10874                "                \\\n"
10875                "  int dddddddddd = 2345;",
10876                Alignment);
10877   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
10878                "k = 4, int l = 5,\n"
10879                "                  int m = 6) {\n"
10880                "  int j      = 10;\n"
10881                "  otherThing = 1;\n"
10882                "}",
10883                Alignment);
10884   verifyFormat("void SomeFunction(int parameter = 0) {\n"
10885                "  int i   = 1;\n"
10886                "  int j   = 2;\n"
10887                "  int big = 10000;\n"
10888                "}",
10889                Alignment);
10890   verifyFormat("class C {\n"
10891                "public:\n"
10892                "  int i            = 1;\n"
10893                "  virtual void f() = 0;\n"
10894                "};",
10895                Alignment);
10896   verifyFormat("int i = 1;\n"
10897                "if (SomeType t = getSomething()) {\n"
10898                "}\n"
10899                "int j   = 2;\n"
10900                "int big = 10000;",
10901                Alignment);
10902   verifyFormat("int j = 7;\n"
10903                "for (int k = 0; k < N; ++k) {\n"
10904                "}\n"
10905                "int j   = 2;\n"
10906                "int big = 10000;\n"
10907                "}",
10908                Alignment);
10909   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
10910   verifyFormat("int i = 1;\n"
10911                "LooooooooooongType loooooooooooooooooooooongVariable\n"
10912                "    = someLooooooooooooooooongFunction();\n"
10913                "int j = 2;",
10914                Alignment);
10915   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
10916   verifyFormat("int i = 1;\n"
10917                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
10918                "    someLooooooooooooooooongFunction();\n"
10919                "int j = 2;",
10920                Alignment);
10921 
10922   verifyFormat("auto lambda = []() {\n"
10923                "  auto i = 0;\n"
10924                "  return 0;\n"
10925                "};\n"
10926                "int i  = 0;\n"
10927                "auto v = type{\n"
10928                "    i = 1,   //\n"
10929                "    (i = 2), //\n"
10930                "    i = 3    //\n"
10931                "};",
10932                Alignment);
10933 
10934   verifyFormat(
10935       "int i      = 1;\n"
10936       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
10937       "                          loooooooooooooooooooooongParameterB);\n"
10938       "int j      = 2;",
10939       Alignment);
10940 
10941   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
10942                "          typename B   = very_long_type_name_1,\n"
10943                "          typename T_2 = very_long_type_name_2>\n"
10944                "auto foo() {}\n",
10945                Alignment);
10946   verifyFormat("int a, b = 1;\n"
10947                "int c  = 2;\n"
10948                "int dd = 3;\n",
10949                Alignment);
10950   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
10951                "float b[1][] = {{3.f}};\n",
10952                Alignment);
10953   verifyFormat("for (int i = 0; i < 1; i++)\n"
10954                "  int x = 1;\n",
10955                Alignment);
10956   verifyFormat("for (i = 0; i < 1; i++)\n"
10957                "  x = 1;\n"
10958                "y = 1;\n",
10959                Alignment);
10960 }
10961 
10962 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
10963   FormatStyle Alignment = getLLVMStyle();
10964   Alignment.AlignConsecutiveMacros = true;
10965   Alignment.AlignConsecutiveDeclarations = false;
10966   verifyFormat("float const a = 5;\n"
10967                "int oneTwoThree = 123;",
10968                Alignment);
10969   verifyFormat("int a = 5;\n"
10970                "float const oneTwoThree = 123;",
10971                Alignment);
10972 
10973   Alignment.AlignConsecutiveDeclarations = true;
10974   verifyFormat("float const a = 5;\n"
10975                "int         oneTwoThree = 123;",
10976                Alignment);
10977   verifyFormat("int         a = method();\n"
10978                "float const oneTwoThree = 133;",
10979                Alignment);
10980   verifyFormat("int i = 1, j = 10;\n"
10981                "something = 2000;",
10982                Alignment);
10983   verifyFormat("something = 2000;\n"
10984                "int i = 1, j = 10;\n",
10985                Alignment);
10986   verifyFormat("float      something = 2000;\n"
10987                "double     another = 911;\n"
10988                "int        i = 1, j = 10;\n"
10989                "const int *oneMore = 1;\n"
10990                "unsigned   i = 2;",
10991                Alignment);
10992   verifyFormat("float a = 5;\n"
10993                "int   one = 1;\n"
10994                "method();\n"
10995                "const double       oneTwoThree = 123;\n"
10996                "const unsigned int oneTwo = 12;",
10997                Alignment);
10998   verifyFormat("int      oneTwoThree{0}; // comment\n"
10999                "unsigned oneTwo;         // comment",
11000                Alignment);
11001   EXPECT_EQ("float const a = 5;\n"
11002             "\n"
11003             "int oneTwoThree = 123;",
11004             format("float const   a = 5;\n"
11005                    "\n"
11006                    "int           oneTwoThree= 123;",
11007                    Alignment));
11008   EXPECT_EQ("float a = 5;\n"
11009             "int   one = 1;\n"
11010             "\n"
11011             "unsigned oneTwoThree = 123;",
11012             format("float    a = 5;\n"
11013                    "int      one = 1;\n"
11014                    "\n"
11015                    "unsigned oneTwoThree = 123;",
11016                    Alignment));
11017   EXPECT_EQ("float a = 5;\n"
11018             "int   one = 1;\n"
11019             "\n"
11020             "unsigned oneTwoThree = 123;\n"
11021             "int      oneTwo = 12;",
11022             format("float    a = 5;\n"
11023                    "int one = 1;\n"
11024                    "\n"
11025                    "unsigned oneTwoThree = 123;\n"
11026                    "int oneTwo = 12;",
11027                    Alignment));
11028   // Function prototype alignment
11029   verifyFormat("int    a();\n"
11030                "double b();",
11031                Alignment);
11032   verifyFormat("int    a(int x);\n"
11033                "double b();",
11034                Alignment);
11035   unsigned OldColumnLimit = Alignment.ColumnLimit;
11036   // We need to set ColumnLimit to zero, in order to stress nested alignments,
11037   // otherwise the function parameters will be re-flowed onto a single line.
11038   Alignment.ColumnLimit = 0;
11039   EXPECT_EQ("int    a(int   x,\n"
11040             "         float y);\n"
11041             "double b(int    x,\n"
11042             "         double y);",
11043             format("int a(int x,\n"
11044                    " float y);\n"
11045                    "double b(int x,\n"
11046                    " double y);",
11047                    Alignment));
11048   // This ensures that function parameters of function declarations are
11049   // correctly indented when their owning functions are indented.
11050   // The failure case here is for 'double y' to not be indented enough.
11051   EXPECT_EQ("double a(int x);\n"
11052             "int    b(int    y,\n"
11053             "         double z);",
11054             format("double a(int x);\n"
11055                    "int b(int y,\n"
11056                    " double z);",
11057                    Alignment));
11058   // Set ColumnLimit low so that we induce wrapping immediately after
11059   // the function name and opening paren.
11060   Alignment.ColumnLimit = 13;
11061   verifyFormat("int function(\n"
11062                "    int  x,\n"
11063                "    bool y);",
11064                Alignment);
11065   Alignment.ColumnLimit = OldColumnLimit;
11066   // Ensure function pointers don't screw up recursive alignment
11067   verifyFormat("int    a(int x, void (*fp)(int y));\n"
11068                "double b();",
11069                Alignment);
11070   Alignment.AlignConsecutiveAssignments = true;
11071   // Ensure recursive alignment is broken by function braces, so that the
11072   // "a = 1" does not align with subsequent assignments inside the function
11073   // body.
11074   verifyFormat("int func(int a = 1) {\n"
11075                "  int b  = 2;\n"
11076                "  int cc = 3;\n"
11077                "}",
11078                Alignment);
11079   verifyFormat("float      something = 2000;\n"
11080                "double     another   = 911;\n"
11081                "int        i = 1, j = 10;\n"
11082                "const int *oneMore = 1;\n"
11083                "unsigned   i       = 2;",
11084                Alignment);
11085   verifyFormat("int      oneTwoThree = {0}; // comment\n"
11086                "unsigned oneTwo      = 0;   // comment",
11087                Alignment);
11088   // Make sure that scope is correctly tracked, in the absence of braces
11089   verifyFormat("for (int i = 0; i < n; i++)\n"
11090                "  j = i;\n"
11091                "double x = 1;\n",
11092                Alignment);
11093   verifyFormat("if (int i = 0)\n"
11094                "  j = i;\n"
11095                "double x = 1;\n",
11096                Alignment);
11097   // Ensure operator[] and operator() are comprehended
11098   verifyFormat("struct test {\n"
11099                "  long long int foo();\n"
11100                "  int           operator[](int a);\n"
11101                "  double        bar();\n"
11102                "};\n",
11103                Alignment);
11104   verifyFormat("struct test {\n"
11105                "  long long int foo();\n"
11106                "  int           operator()(int a);\n"
11107                "  double        bar();\n"
11108                "};\n",
11109                Alignment);
11110   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
11111             "  int const i   = 1;\n"
11112             "  int *     j   = 2;\n"
11113             "  int       big = 10000;\n"
11114             "\n"
11115             "  unsigned oneTwoThree = 123;\n"
11116             "  int      oneTwo      = 12;\n"
11117             "  method();\n"
11118             "  float k  = 2;\n"
11119             "  int   ll = 10000;\n"
11120             "}",
11121             format("void SomeFunction(int parameter= 0) {\n"
11122                    " int const  i= 1;\n"
11123                    "  int *j=2;\n"
11124                    " int big  =  10000;\n"
11125                    "\n"
11126                    "unsigned oneTwoThree  =123;\n"
11127                    "int oneTwo = 12;\n"
11128                    "  method();\n"
11129                    "float k= 2;\n"
11130                    "int ll=10000;\n"
11131                    "}",
11132                    Alignment));
11133   Alignment.AlignConsecutiveAssignments = false;
11134   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
11135   verifyFormat("#define A \\\n"
11136                "  int       aaaa = 12; \\\n"
11137                "  float     b = 23; \\\n"
11138                "  const int ccc = 234; \\\n"
11139                "  unsigned  dddddddddd = 2345;",
11140                Alignment);
11141   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
11142   verifyFormat("#define A              \\\n"
11143                "  int       aaaa = 12; \\\n"
11144                "  float     b = 23;    \\\n"
11145                "  const int ccc = 234; \\\n"
11146                "  unsigned  dddddddddd = 2345;",
11147                Alignment);
11148   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
11149   Alignment.ColumnLimit = 30;
11150   verifyFormat("#define A                    \\\n"
11151                "  int       aaaa = 12;       \\\n"
11152                "  float     b = 23;          \\\n"
11153                "  const int ccc = 234;       \\\n"
11154                "  int       dddddddddd = 2345;",
11155                Alignment);
11156   Alignment.ColumnLimit = 80;
11157   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
11158                "k = 4, int l = 5,\n"
11159                "                  int m = 6) {\n"
11160                "  const int j = 10;\n"
11161                "  otherThing = 1;\n"
11162                "}",
11163                Alignment);
11164   verifyFormat("void SomeFunction(int parameter = 0) {\n"
11165                "  int const i = 1;\n"
11166                "  int *     j = 2;\n"
11167                "  int       big = 10000;\n"
11168                "}",
11169                Alignment);
11170   verifyFormat("class C {\n"
11171                "public:\n"
11172                "  int          i = 1;\n"
11173                "  virtual void f() = 0;\n"
11174                "};",
11175                Alignment);
11176   verifyFormat("float i = 1;\n"
11177                "if (SomeType t = getSomething()) {\n"
11178                "}\n"
11179                "const unsigned j = 2;\n"
11180                "int            big = 10000;",
11181                Alignment);
11182   verifyFormat("float j = 7;\n"
11183                "for (int k = 0; k < N; ++k) {\n"
11184                "}\n"
11185                "unsigned j = 2;\n"
11186                "int      big = 10000;\n"
11187                "}",
11188                Alignment);
11189   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
11190   verifyFormat("float              i = 1;\n"
11191                "LooooooooooongType loooooooooooooooooooooongVariable\n"
11192                "    = someLooooooooooooooooongFunction();\n"
11193                "int j = 2;",
11194                Alignment);
11195   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
11196   verifyFormat("int                i = 1;\n"
11197                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
11198                "    someLooooooooooooooooongFunction();\n"
11199                "int j = 2;",
11200                Alignment);
11201 
11202   Alignment.AlignConsecutiveAssignments = true;
11203   verifyFormat("auto lambda = []() {\n"
11204                "  auto  ii = 0;\n"
11205                "  float j  = 0;\n"
11206                "  return 0;\n"
11207                "};\n"
11208                "int   i  = 0;\n"
11209                "float i2 = 0;\n"
11210                "auto  v  = type{\n"
11211                "    i = 1,   //\n"
11212                "    (i = 2), //\n"
11213                "    i = 3    //\n"
11214                "};",
11215                Alignment);
11216   Alignment.AlignConsecutiveAssignments = false;
11217 
11218   verifyFormat(
11219       "int      i = 1;\n"
11220       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
11221       "                          loooooooooooooooooooooongParameterB);\n"
11222       "int      j = 2;",
11223       Alignment);
11224 
11225   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
11226   // We expect declarations and assignments to align, as long as it doesn't
11227   // exceed the column limit, starting a new alignment sequence whenever it
11228   // happens.
11229   Alignment.AlignConsecutiveAssignments = true;
11230   Alignment.ColumnLimit = 30;
11231   verifyFormat("float    ii              = 1;\n"
11232                "unsigned j               = 2;\n"
11233                "int someVerylongVariable = 1;\n"
11234                "AnotherLongType  ll = 123456;\n"
11235                "VeryVeryLongType k  = 2;\n"
11236                "int              myvar = 1;",
11237                Alignment);
11238   Alignment.ColumnLimit = 80;
11239   Alignment.AlignConsecutiveAssignments = false;
11240 
11241   verifyFormat(
11242       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
11243       "          typename LongType, typename B>\n"
11244       "auto foo() {}\n",
11245       Alignment);
11246   verifyFormat("float a, b = 1;\n"
11247                "int   c = 2;\n"
11248                "int   dd = 3;\n",
11249                Alignment);
11250   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
11251                "float b[1][] = {{3.f}};\n",
11252                Alignment);
11253   Alignment.AlignConsecutiveAssignments = true;
11254   verifyFormat("float a, b = 1;\n"
11255                "int   c  = 2;\n"
11256                "int   dd = 3;\n",
11257                Alignment);
11258   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
11259                "float b[1][] = {{3.f}};\n",
11260                Alignment);
11261   Alignment.AlignConsecutiveAssignments = false;
11262 
11263   Alignment.ColumnLimit = 30;
11264   Alignment.BinPackParameters = false;
11265   verifyFormat("void foo(float     a,\n"
11266                "         float     b,\n"
11267                "         int       c,\n"
11268                "         uint32_t *d) {\n"
11269                "  int *  e = 0;\n"
11270                "  float  f = 0;\n"
11271                "  double g = 0;\n"
11272                "}\n"
11273                "void bar(ino_t     a,\n"
11274                "         int       b,\n"
11275                "         uint32_t *c,\n"
11276                "         bool      d) {}\n",
11277                Alignment);
11278   Alignment.BinPackParameters = true;
11279   Alignment.ColumnLimit = 80;
11280 
11281   // Bug 33507
11282   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
11283   verifyFormat(
11284       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
11285       "  static const Version verVs2017;\n"
11286       "  return true;\n"
11287       "});\n",
11288       Alignment);
11289   Alignment.PointerAlignment = FormatStyle::PAS_Right;
11290 
11291   // See llvm.org/PR35641
11292   Alignment.AlignConsecutiveDeclarations = true;
11293   verifyFormat("int func() { //\n"
11294                "  int      b;\n"
11295                "  unsigned c;\n"
11296                "}",
11297                Alignment);
11298 
11299   // See PR37175
11300   FormatStyle Style = getMozillaStyle();
11301   Style.AlignConsecutiveDeclarations = true;
11302   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
11303             "foo(int a);",
11304             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
11305 }
11306 
11307 TEST_F(FormatTest, LinuxBraceBreaking) {
11308   FormatStyle LinuxBraceStyle = getLLVMStyle();
11309   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
11310   verifyFormat("namespace a\n"
11311                "{\n"
11312                "class A\n"
11313                "{\n"
11314                "  void f()\n"
11315                "  {\n"
11316                "    if (true) {\n"
11317                "      a();\n"
11318                "      b();\n"
11319                "    } else {\n"
11320                "      a();\n"
11321                "    }\n"
11322                "  }\n"
11323                "  void g() { return; }\n"
11324                "};\n"
11325                "struct B {\n"
11326                "  int x;\n"
11327                "};\n"
11328                "} // namespace a\n",
11329                LinuxBraceStyle);
11330   verifyFormat("enum X {\n"
11331                "  Y = 0,\n"
11332                "}\n",
11333                LinuxBraceStyle);
11334   verifyFormat("struct S {\n"
11335                "  int Type;\n"
11336                "  union {\n"
11337                "    int x;\n"
11338                "    double y;\n"
11339                "  } Value;\n"
11340                "  class C\n"
11341                "  {\n"
11342                "    MyFavoriteType Value;\n"
11343                "  } Class;\n"
11344                "}\n",
11345                LinuxBraceStyle);
11346 }
11347 
11348 TEST_F(FormatTest, MozillaBraceBreaking) {
11349   FormatStyle MozillaBraceStyle = getLLVMStyle();
11350   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
11351   MozillaBraceStyle.FixNamespaceComments = false;
11352   verifyFormat("namespace a {\n"
11353                "class A\n"
11354                "{\n"
11355                "  void f()\n"
11356                "  {\n"
11357                "    if (true) {\n"
11358                "      a();\n"
11359                "      b();\n"
11360                "    }\n"
11361                "  }\n"
11362                "  void g() { return; }\n"
11363                "};\n"
11364                "enum E\n"
11365                "{\n"
11366                "  A,\n"
11367                "  // foo\n"
11368                "  B,\n"
11369                "  C\n"
11370                "};\n"
11371                "struct B\n"
11372                "{\n"
11373                "  int x;\n"
11374                "};\n"
11375                "}\n",
11376                MozillaBraceStyle);
11377   verifyFormat("struct S\n"
11378                "{\n"
11379                "  int Type;\n"
11380                "  union\n"
11381                "  {\n"
11382                "    int x;\n"
11383                "    double y;\n"
11384                "  } Value;\n"
11385                "  class C\n"
11386                "  {\n"
11387                "    MyFavoriteType Value;\n"
11388                "  } Class;\n"
11389                "}\n",
11390                MozillaBraceStyle);
11391 }
11392 
11393 TEST_F(FormatTest, StroustrupBraceBreaking) {
11394   FormatStyle StroustrupBraceStyle = getLLVMStyle();
11395   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
11396   verifyFormat("namespace a {\n"
11397                "class A {\n"
11398                "  void f()\n"
11399                "  {\n"
11400                "    if (true) {\n"
11401                "      a();\n"
11402                "      b();\n"
11403                "    }\n"
11404                "  }\n"
11405                "  void g() { return; }\n"
11406                "};\n"
11407                "struct B {\n"
11408                "  int x;\n"
11409                "};\n"
11410                "} // namespace a\n",
11411                StroustrupBraceStyle);
11412 
11413   verifyFormat("void foo()\n"
11414                "{\n"
11415                "  if (a) {\n"
11416                "    a();\n"
11417                "  }\n"
11418                "  else {\n"
11419                "    b();\n"
11420                "  }\n"
11421                "}\n",
11422                StroustrupBraceStyle);
11423 
11424   verifyFormat("#ifdef _DEBUG\n"
11425                "int foo(int i = 0)\n"
11426                "#else\n"
11427                "int foo(int i = 5)\n"
11428                "#endif\n"
11429                "{\n"
11430                "  return i;\n"
11431                "}",
11432                StroustrupBraceStyle);
11433 
11434   verifyFormat("void foo() {}\n"
11435                "void bar()\n"
11436                "#ifdef _DEBUG\n"
11437                "{\n"
11438                "  foo();\n"
11439                "}\n"
11440                "#else\n"
11441                "{\n"
11442                "}\n"
11443                "#endif",
11444                StroustrupBraceStyle);
11445 
11446   verifyFormat("void foobar() { int i = 5; }\n"
11447                "#ifdef _DEBUG\n"
11448                "void bar() {}\n"
11449                "#else\n"
11450                "void bar() { foobar(); }\n"
11451                "#endif",
11452                StroustrupBraceStyle);
11453 }
11454 
11455 TEST_F(FormatTest, AllmanBraceBreaking) {
11456   FormatStyle AllmanBraceStyle = getLLVMStyle();
11457   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
11458 
11459   EXPECT_EQ("namespace a\n"
11460             "{\n"
11461             "void f();\n"
11462             "void g();\n"
11463             "} // namespace a\n",
11464             format("namespace a\n"
11465                    "{\n"
11466                    "void f();\n"
11467                    "void g();\n"
11468                    "}\n",
11469                    AllmanBraceStyle));
11470 
11471   verifyFormat("namespace a\n"
11472                "{\n"
11473                "class A\n"
11474                "{\n"
11475                "  void f()\n"
11476                "  {\n"
11477                "    if (true)\n"
11478                "    {\n"
11479                "      a();\n"
11480                "      b();\n"
11481                "    }\n"
11482                "  }\n"
11483                "  void g() { return; }\n"
11484                "};\n"
11485                "struct B\n"
11486                "{\n"
11487                "  int x;\n"
11488                "};\n"
11489                "union C\n"
11490                "{\n"
11491                "};\n"
11492                "} // namespace a",
11493                AllmanBraceStyle);
11494 
11495   verifyFormat("void f()\n"
11496                "{\n"
11497                "  if (true)\n"
11498                "  {\n"
11499                "    a();\n"
11500                "  }\n"
11501                "  else if (false)\n"
11502                "  {\n"
11503                "    b();\n"
11504                "  }\n"
11505                "  else\n"
11506                "  {\n"
11507                "    c();\n"
11508                "  }\n"
11509                "}\n",
11510                AllmanBraceStyle);
11511 
11512   verifyFormat("void f()\n"
11513                "{\n"
11514                "  for (int i = 0; i < 10; ++i)\n"
11515                "  {\n"
11516                "    a();\n"
11517                "  }\n"
11518                "  while (false)\n"
11519                "  {\n"
11520                "    b();\n"
11521                "  }\n"
11522                "  do\n"
11523                "  {\n"
11524                "    c();\n"
11525                "  } while (false)\n"
11526                "}\n",
11527                AllmanBraceStyle);
11528 
11529   verifyFormat("void f(int a)\n"
11530                "{\n"
11531                "  switch (a)\n"
11532                "  {\n"
11533                "  case 0:\n"
11534                "    break;\n"
11535                "  case 1:\n"
11536                "  {\n"
11537                "    break;\n"
11538                "  }\n"
11539                "  case 2:\n"
11540                "  {\n"
11541                "  }\n"
11542                "  break;\n"
11543                "  default:\n"
11544                "    break;\n"
11545                "  }\n"
11546                "}\n",
11547                AllmanBraceStyle);
11548 
11549   verifyFormat("enum X\n"
11550                "{\n"
11551                "  Y = 0,\n"
11552                "}\n",
11553                AllmanBraceStyle);
11554   verifyFormat("enum X\n"
11555                "{\n"
11556                "  Y = 0\n"
11557                "}\n",
11558                AllmanBraceStyle);
11559 
11560   verifyFormat("@interface BSApplicationController ()\n"
11561                "{\n"
11562                "@private\n"
11563                "  id _extraIvar;\n"
11564                "}\n"
11565                "@end\n",
11566                AllmanBraceStyle);
11567 
11568   verifyFormat("#ifdef _DEBUG\n"
11569                "int foo(int i = 0)\n"
11570                "#else\n"
11571                "int foo(int i = 5)\n"
11572                "#endif\n"
11573                "{\n"
11574                "  return i;\n"
11575                "}",
11576                AllmanBraceStyle);
11577 
11578   verifyFormat("void foo() {}\n"
11579                "void bar()\n"
11580                "#ifdef _DEBUG\n"
11581                "{\n"
11582                "  foo();\n"
11583                "}\n"
11584                "#else\n"
11585                "{\n"
11586                "}\n"
11587                "#endif",
11588                AllmanBraceStyle);
11589 
11590   verifyFormat("void foobar() { int i = 5; }\n"
11591                "#ifdef _DEBUG\n"
11592                "void bar() {}\n"
11593                "#else\n"
11594                "void bar() { foobar(); }\n"
11595                "#endif",
11596                AllmanBraceStyle);
11597 
11598   // This shouldn't affect ObjC blocks..
11599   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
11600                "  // ...\n"
11601                "  int i;\n"
11602                "}];",
11603                AllmanBraceStyle);
11604   verifyFormat("void (^block)(void) = ^{\n"
11605                "  // ...\n"
11606                "  int i;\n"
11607                "};",
11608                AllmanBraceStyle);
11609   // .. or dict literals.
11610   verifyFormat("void f()\n"
11611                "{\n"
11612                "  // ...\n"
11613                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
11614                "}",
11615                AllmanBraceStyle);
11616   verifyFormat("void f()\n"
11617                "{\n"
11618                "  // ...\n"
11619                "  [object someMethod:@{a : @\"b\"}];\n"
11620                "}",
11621                AllmanBraceStyle);
11622   verifyFormat("int f()\n"
11623                "{ // comment\n"
11624                "  return 42;\n"
11625                "}",
11626                AllmanBraceStyle);
11627 
11628   AllmanBraceStyle.ColumnLimit = 19;
11629   verifyFormat("void f() { int i; }", AllmanBraceStyle);
11630   AllmanBraceStyle.ColumnLimit = 18;
11631   verifyFormat("void f()\n"
11632                "{\n"
11633                "  int i;\n"
11634                "}",
11635                AllmanBraceStyle);
11636   AllmanBraceStyle.ColumnLimit = 80;
11637 
11638   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
11639   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
11640       FormatStyle::SIS_WithoutElse;
11641   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
11642   verifyFormat("void f(bool b)\n"
11643                "{\n"
11644                "  if (b)\n"
11645                "  {\n"
11646                "    return;\n"
11647                "  }\n"
11648                "}\n",
11649                BreakBeforeBraceShortIfs);
11650   verifyFormat("void f(bool b)\n"
11651                "{\n"
11652                "  if constexpr (b)\n"
11653                "  {\n"
11654                "    return;\n"
11655                "  }\n"
11656                "}\n",
11657                BreakBeforeBraceShortIfs);
11658   verifyFormat("void f(bool b)\n"
11659                "{\n"
11660                "  if CONSTEXPR (b)\n"
11661                "  {\n"
11662                "    return;\n"
11663                "  }\n"
11664                "}\n",
11665                BreakBeforeBraceShortIfs);
11666   verifyFormat("void f(bool b)\n"
11667                "{\n"
11668                "  if (b) return;\n"
11669                "}\n",
11670                BreakBeforeBraceShortIfs);
11671   verifyFormat("void f(bool b)\n"
11672                "{\n"
11673                "  if constexpr (b) return;\n"
11674                "}\n",
11675                BreakBeforeBraceShortIfs);
11676   verifyFormat("void f(bool b)\n"
11677                "{\n"
11678                "  if CONSTEXPR (b) return;\n"
11679                "}\n",
11680                BreakBeforeBraceShortIfs);
11681   verifyFormat("void f(bool b)\n"
11682                "{\n"
11683                "  while (b)\n"
11684                "  {\n"
11685                "    return;\n"
11686                "  }\n"
11687                "}\n",
11688                BreakBeforeBraceShortIfs);
11689 }
11690 
11691 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
11692   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
11693   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
11694 
11695   // Make a few changes to the style for testing purposes
11696   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
11697       FormatStyle::SFS_Empty;
11698   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
11699   WhitesmithsBraceStyle.ColumnLimit = 0;
11700 
11701   // FIXME: this test case can't decide whether there should be a blank line
11702   // after the ~D() line or not. It adds one if one doesn't exist in the test
11703   // and it removes the line if one exists.
11704   /*
11705   verifyFormat("class A;\n"
11706                "namespace B\n"
11707                "  {\n"
11708                "class C;\n"
11709                "// Comment\n"
11710                "class D\n"
11711                "  {\n"
11712                "public:\n"
11713                "  D();\n"
11714                "  ~D() {}\n"
11715                "private:\n"
11716                "  enum E\n"
11717                "    {\n"
11718                "    F\n"
11719                "    }\n"
11720                "  };\n"
11721                "  } // namespace B\n",
11722                WhitesmithsBraceStyle);
11723   */
11724 
11725   verifyFormat("namespace a\n"
11726                "  {\n"
11727                "class A\n"
11728                "  {\n"
11729                "  void f()\n"
11730                "    {\n"
11731                "    if (true)\n"
11732                "      {\n"
11733                "      a();\n"
11734                "      b();\n"
11735                "      }\n"
11736                "    }\n"
11737                "  void g()\n"
11738                "    {\n"
11739                "    return;\n"
11740                "    }\n"
11741                "  };\n"
11742                "struct B\n"
11743                "  {\n"
11744                "  int x;\n"
11745                "  };\n"
11746                "  } // namespace a",
11747                WhitesmithsBraceStyle);
11748 
11749   verifyFormat("void f()\n"
11750                "  {\n"
11751                "  if (true)\n"
11752                "    {\n"
11753                "    a();\n"
11754                "    }\n"
11755                "  else if (false)\n"
11756                "    {\n"
11757                "    b();\n"
11758                "    }\n"
11759                "  else\n"
11760                "    {\n"
11761                "    c();\n"
11762                "    }\n"
11763                "  }\n",
11764                WhitesmithsBraceStyle);
11765 
11766   verifyFormat("void f()\n"
11767                "  {\n"
11768                "  for (int i = 0; i < 10; ++i)\n"
11769                "    {\n"
11770                "    a();\n"
11771                "    }\n"
11772                "  while (false)\n"
11773                "    {\n"
11774                "    b();\n"
11775                "    }\n"
11776                "  do\n"
11777                "    {\n"
11778                "    c();\n"
11779                "    } while (false)\n"
11780                "  }\n",
11781                WhitesmithsBraceStyle);
11782 
11783   // FIXME: the block and the break under case 2 in this test don't get indented
11784   // correctly
11785   /*
11786   verifyFormat("void switchTest1(int a)\n"
11787                "  {\n"
11788                "  switch (a)\n"
11789                "    {\n"
11790                "    case 2:\n"
11791                "      {\n"
11792                "      }\n"
11793                "      break;\n"
11794                "    }\n"
11795                "  }\n",
11796                WhitesmithsBraceStyle);
11797   */
11798 
11799   // FIXME: the block and the break under case 2 in this test don't get indented
11800   // correctly
11801   /*
11802   verifyFormat("void switchTest2(int a)\n"
11803                "  {\n"
11804                "  switch (a)\n"
11805                "    {\n"
11806                "  case 0:\n"
11807                "    break;\n"
11808                "  case 1:\n"
11809                "    {\n"
11810                "    break;\n"
11811                "    }\n"
11812                "  case 2:\n"
11813                "    {\n"
11814                "    }\n"
11815                "    break;\n"
11816                "  default:\n"
11817                "    break;\n"
11818                "    }\n"
11819                "  }\n",
11820                WhitesmithsBraceStyle);
11821   */
11822 
11823   verifyFormat("enum X\n"
11824                "  {\n"
11825                "  Y = 0, // testing\n"
11826                "  }\n",
11827                WhitesmithsBraceStyle);
11828 
11829   verifyFormat("enum X\n"
11830                "  {\n"
11831                "  Y = 0\n"
11832                "  }\n",
11833                WhitesmithsBraceStyle);
11834   verifyFormat("enum X\n"
11835                "  {\n"
11836                "  Y = 0,\n"
11837                "  Z = 1\n"
11838                "  };\n",
11839                WhitesmithsBraceStyle);
11840 
11841   verifyFormat("@interface BSApplicationController ()\n"
11842                "  {\n"
11843                "@private\n"
11844                "  id _extraIvar;\n"
11845                "  }\n"
11846                "@end\n",
11847                WhitesmithsBraceStyle);
11848 
11849   verifyFormat("#ifdef _DEBUG\n"
11850                "int foo(int i = 0)\n"
11851                "#else\n"
11852                "int foo(int i = 5)\n"
11853                "#endif\n"
11854                "  {\n"
11855                "  return i;\n"
11856                "  }",
11857                WhitesmithsBraceStyle);
11858 
11859   verifyFormat("void foo() {}\n"
11860                "void bar()\n"
11861                "#ifdef _DEBUG\n"
11862                "  {\n"
11863                "  foo();\n"
11864                "  }\n"
11865                "#else\n"
11866                "  {\n"
11867                "  }\n"
11868                "#endif",
11869                WhitesmithsBraceStyle);
11870 
11871   verifyFormat("void foobar()\n"
11872                "  {\n"
11873                "  int i = 5;\n"
11874                "  }\n"
11875                "#ifdef _DEBUG\n"
11876                "void bar()\n"
11877                "  {\n"
11878                "  }\n"
11879                "#else\n"
11880                "void bar()\n"
11881                "  {\n"
11882                "  foobar();\n"
11883                "  }\n"
11884                "#endif",
11885                WhitesmithsBraceStyle);
11886 
11887   // This shouldn't affect ObjC blocks..
11888   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
11889                "  // ...\n"
11890                "  int i;\n"
11891                "}];",
11892                WhitesmithsBraceStyle);
11893   verifyFormat("void (^block)(void) = ^{\n"
11894                "  // ...\n"
11895                "  int i;\n"
11896                "};",
11897                WhitesmithsBraceStyle);
11898   // .. or dict literals.
11899   verifyFormat("void f()\n"
11900                "  {\n"
11901                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
11902                "  }",
11903                WhitesmithsBraceStyle);
11904 
11905   verifyFormat("int f()\n"
11906                "  { // comment\n"
11907                "  return 42;\n"
11908                "  }",
11909                WhitesmithsBraceStyle);
11910 
11911   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
11912   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
11913       FormatStyle::SIS_Always;
11914   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
11915   verifyFormat("void f(bool b)\n"
11916                "  {\n"
11917                "  if (b)\n"
11918                "    {\n"
11919                "    return;\n"
11920                "    }\n"
11921                "  }\n",
11922                BreakBeforeBraceShortIfs);
11923   verifyFormat("void f(bool b)\n"
11924                "  {\n"
11925                "  if (b) return;\n"
11926                "  }\n",
11927                BreakBeforeBraceShortIfs);
11928   verifyFormat("void f(bool b)\n"
11929                "  {\n"
11930                "  while (b)\n"
11931                "    {\n"
11932                "    return;\n"
11933                "    }\n"
11934                "  }\n",
11935                BreakBeforeBraceShortIfs);
11936 }
11937 
11938 TEST_F(FormatTest, GNUBraceBreaking) {
11939   FormatStyle GNUBraceStyle = getLLVMStyle();
11940   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
11941   verifyFormat("namespace a\n"
11942                "{\n"
11943                "class A\n"
11944                "{\n"
11945                "  void f()\n"
11946                "  {\n"
11947                "    int a;\n"
11948                "    {\n"
11949                "      int b;\n"
11950                "    }\n"
11951                "    if (true)\n"
11952                "      {\n"
11953                "        a();\n"
11954                "        b();\n"
11955                "      }\n"
11956                "  }\n"
11957                "  void g() { return; }\n"
11958                "}\n"
11959                "} // namespace a",
11960                GNUBraceStyle);
11961 
11962   verifyFormat("void f()\n"
11963                "{\n"
11964                "  if (true)\n"
11965                "    {\n"
11966                "      a();\n"
11967                "    }\n"
11968                "  else if (false)\n"
11969                "    {\n"
11970                "      b();\n"
11971                "    }\n"
11972                "  else\n"
11973                "    {\n"
11974                "      c();\n"
11975                "    }\n"
11976                "}\n",
11977                GNUBraceStyle);
11978 
11979   verifyFormat("void f()\n"
11980                "{\n"
11981                "  for (int i = 0; i < 10; ++i)\n"
11982                "    {\n"
11983                "      a();\n"
11984                "    }\n"
11985                "  while (false)\n"
11986                "    {\n"
11987                "      b();\n"
11988                "    }\n"
11989                "  do\n"
11990                "    {\n"
11991                "      c();\n"
11992                "    }\n"
11993                "  while (false);\n"
11994                "}\n",
11995                GNUBraceStyle);
11996 
11997   verifyFormat("void f(int a)\n"
11998                "{\n"
11999                "  switch (a)\n"
12000                "    {\n"
12001                "    case 0:\n"
12002                "      break;\n"
12003                "    case 1:\n"
12004                "      {\n"
12005                "        break;\n"
12006                "      }\n"
12007                "    case 2:\n"
12008                "      {\n"
12009                "      }\n"
12010                "      break;\n"
12011                "    default:\n"
12012                "      break;\n"
12013                "    }\n"
12014                "}\n",
12015                GNUBraceStyle);
12016 
12017   verifyFormat("enum X\n"
12018                "{\n"
12019                "  Y = 0,\n"
12020                "}\n",
12021                GNUBraceStyle);
12022 
12023   verifyFormat("@interface BSApplicationController ()\n"
12024                "{\n"
12025                "@private\n"
12026                "  id _extraIvar;\n"
12027                "}\n"
12028                "@end\n",
12029                GNUBraceStyle);
12030 
12031   verifyFormat("#ifdef _DEBUG\n"
12032                "int foo(int i = 0)\n"
12033                "#else\n"
12034                "int foo(int i = 5)\n"
12035                "#endif\n"
12036                "{\n"
12037                "  return i;\n"
12038                "}",
12039                GNUBraceStyle);
12040 
12041   verifyFormat("void foo() {}\n"
12042                "void bar()\n"
12043                "#ifdef _DEBUG\n"
12044                "{\n"
12045                "  foo();\n"
12046                "}\n"
12047                "#else\n"
12048                "{\n"
12049                "}\n"
12050                "#endif",
12051                GNUBraceStyle);
12052 
12053   verifyFormat("void foobar() { int i = 5; }\n"
12054                "#ifdef _DEBUG\n"
12055                "void bar() {}\n"
12056                "#else\n"
12057                "void bar() { foobar(); }\n"
12058                "#endif",
12059                GNUBraceStyle);
12060 }
12061 
12062 TEST_F(FormatTest, WebKitBraceBreaking) {
12063   FormatStyle WebKitBraceStyle = getLLVMStyle();
12064   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
12065   WebKitBraceStyle.FixNamespaceComments = false;
12066   verifyFormat("namespace a {\n"
12067                "class A {\n"
12068                "  void f()\n"
12069                "  {\n"
12070                "    if (true) {\n"
12071                "      a();\n"
12072                "      b();\n"
12073                "    }\n"
12074                "  }\n"
12075                "  void g() { return; }\n"
12076                "};\n"
12077                "enum E {\n"
12078                "  A,\n"
12079                "  // foo\n"
12080                "  B,\n"
12081                "  C\n"
12082                "};\n"
12083                "struct B {\n"
12084                "  int x;\n"
12085                "};\n"
12086                "}\n",
12087                WebKitBraceStyle);
12088   verifyFormat("struct S {\n"
12089                "  int Type;\n"
12090                "  union {\n"
12091                "    int x;\n"
12092                "    double y;\n"
12093                "  } Value;\n"
12094                "  class C {\n"
12095                "    MyFavoriteType Value;\n"
12096                "  } Class;\n"
12097                "};\n",
12098                WebKitBraceStyle);
12099 }
12100 
12101 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
12102   verifyFormat("void f() {\n"
12103                "  try {\n"
12104                "  } catch (const Exception &e) {\n"
12105                "  }\n"
12106                "}\n",
12107                getLLVMStyle());
12108 }
12109 
12110 TEST_F(FormatTest, UnderstandsPragmas) {
12111   verifyFormat("#pragma omp reduction(| : var)");
12112   verifyFormat("#pragma omp reduction(+ : var)");
12113 
12114   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
12115             "(including parentheses).",
12116             format("#pragma    mark   Any non-hyphenated or hyphenated string "
12117                    "(including parentheses)."));
12118 }
12119 
12120 TEST_F(FormatTest, UnderstandPragmaOption) {
12121   verifyFormat("#pragma option -C -A");
12122 
12123   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
12124 }
12125 
12126 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
12127   FormatStyle Style = getLLVMStyle();
12128   Style.ColumnLimit = 20;
12129 
12130   // See PR41213
12131   EXPECT_EQ("/*\n"
12132             " *\t9012345\n"
12133             " * /8901\n"
12134             " */",
12135             format("/*\n"
12136                    " *\t9012345 /8901\n"
12137                    " */",
12138                    Style));
12139   EXPECT_EQ("/*\n"
12140             " *345678\n"
12141             " *\t/8901\n"
12142             " */",
12143             format("/*\n"
12144                    " *345678\t/8901\n"
12145                    " */",
12146                    Style));
12147 
12148   verifyFormat("int a; // the\n"
12149                "       // comment",
12150                Style);
12151   EXPECT_EQ("int a; /* first line\n"
12152             "        * second\n"
12153             "        * line third\n"
12154             "        * line\n"
12155             "        */",
12156             format("int a; /* first line\n"
12157                    "        * second\n"
12158                    "        * line third\n"
12159                    "        * line\n"
12160                    "        */",
12161                    Style));
12162   EXPECT_EQ("int a; // first line\n"
12163             "       // second\n"
12164             "       // line third\n"
12165             "       // line",
12166             format("int a; // first line\n"
12167                    "       // second line\n"
12168                    "       // third line",
12169                    Style));
12170 
12171   Style.PenaltyExcessCharacter = 90;
12172   verifyFormat("int a; // the comment", Style);
12173   EXPECT_EQ("int a; // the comment\n"
12174             "       // aaa",
12175             format("int a; // the comment aaa", Style));
12176   EXPECT_EQ("int a; /* first line\n"
12177             "        * second line\n"
12178             "        * third line\n"
12179             "        */",
12180             format("int a; /* first line\n"
12181                    "        * second line\n"
12182                    "        * third line\n"
12183                    "        */",
12184                    Style));
12185   EXPECT_EQ("int a; // first line\n"
12186             "       // second line\n"
12187             "       // third line",
12188             format("int a; // first line\n"
12189                    "       // second line\n"
12190                    "       // third line",
12191                    Style));
12192   // FIXME: Investigate why this is not getting the same layout as the test
12193   // above.
12194   EXPECT_EQ("int a; /* first line\n"
12195             "        * second line\n"
12196             "        * third line\n"
12197             "        */",
12198             format("int a; /* first line second line third line"
12199                    "\n*/",
12200                    Style));
12201 
12202   EXPECT_EQ("// foo bar baz bazfoo\n"
12203             "// foo bar foo bar\n",
12204             format("// foo bar baz bazfoo\n"
12205                    "// foo bar foo           bar\n",
12206                    Style));
12207   EXPECT_EQ("// foo bar baz bazfoo\n"
12208             "// foo bar foo bar\n",
12209             format("// foo bar baz      bazfoo\n"
12210                    "// foo            bar foo bar\n",
12211                    Style));
12212 
12213   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
12214   // next one.
12215   EXPECT_EQ("// foo bar baz bazfoo\n"
12216             "// bar foo bar\n",
12217             format("// foo bar baz      bazfoo bar\n"
12218                    "// foo            bar\n",
12219                    Style));
12220 
12221   EXPECT_EQ("// foo bar baz bazfoo\n"
12222             "// foo bar baz bazfoo\n"
12223             "// bar foo bar\n",
12224             format("// foo bar baz      bazfoo\n"
12225                    "// foo bar baz      bazfoo bar\n"
12226                    "// foo bar\n",
12227                    Style));
12228 
12229   EXPECT_EQ("// foo bar baz bazfoo\n"
12230             "// foo bar baz bazfoo\n"
12231             "// bar foo bar\n",
12232             format("// foo bar baz      bazfoo\n"
12233                    "// foo bar baz      bazfoo bar\n"
12234                    "// foo           bar\n",
12235                    Style));
12236 
12237   // Make sure we do not keep protruding characters if strict mode reflow is
12238   // cheaper than keeping protruding characters.
12239   Style.ColumnLimit = 21;
12240   EXPECT_EQ(
12241       "// foo foo foo foo\n"
12242       "// foo foo foo foo\n"
12243       "// foo foo foo foo\n",
12244       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
12245 
12246   EXPECT_EQ("int a = /* long block\n"
12247             "           comment */\n"
12248             "    42;",
12249             format("int a = /* long block comment */ 42;", Style));
12250 }
12251 
12252 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
12253   for (size_t i = 1; i < Styles.size(); ++i)                                   \
12254   EXPECT_EQ(Styles[0], Styles[i])                                              \
12255       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
12256 
12257 TEST_F(FormatTest, GetsPredefinedStyleByName) {
12258   SmallVector<FormatStyle, 3> Styles;
12259   Styles.resize(3);
12260 
12261   Styles[0] = getLLVMStyle();
12262   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
12263   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
12264   EXPECT_ALL_STYLES_EQUAL(Styles);
12265 
12266   Styles[0] = getGoogleStyle();
12267   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
12268   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
12269   EXPECT_ALL_STYLES_EQUAL(Styles);
12270 
12271   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
12272   EXPECT_TRUE(
12273       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
12274   EXPECT_TRUE(
12275       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
12276   EXPECT_ALL_STYLES_EQUAL(Styles);
12277 
12278   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
12279   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
12280   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
12281   EXPECT_ALL_STYLES_EQUAL(Styles);
12282 
12283   Styles[0] = getMozillaStyle();
12284   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
12285   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
12286   EXPECT_ALL_STYLES_EQUAL(Styles);
12287 
12288   Styles[0] = getWebKitStyle();
12289   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
12290   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
12291   EXPECT_ALL_STYLES_EQUAL(Styles);
12292 
12293   Styles[0] = getGNUStyle();
12294   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
12295   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
12296   EXPECT_ALL_STYLES_EQUAL(Styles);
12297 
12298   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
12299 }
12300 
12301 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
12302   SmallVector<FormatStyle, 8> Styles;
12303   Styles.resize(2);
12304 
12305   Styles[0] = getGoogleStyle();
12306   Styles[1] = getLLVMStyle();
12307   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
12308   EXPECT_ALL_STYLES_EQUAL(Styles);
12309 
12310   Styles.resize(5);
12311   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
12312   Styles[1] = getLLVMStyle();
12313   Styles[1].Language = FormatStyle::LK_JavaScript;
12314   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
12315 
12316   Styles[2] = getLLVMStyle();
12317   Styles[2].Language = FormatStyle::LK_JavaScript;
12318   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
12319                                   "BasedOnStyle: Google",
12320                                   &Styles[2])
12321                    .value());
12322 
12323   Styles[3] = getLLVMStyle();
12324   Styles[3].Language = FormatStyle::LK_JavaScript;
12325   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
12326                                   "Language: JavaScript",
12327                                   &Styles[3])
12328                    .value());
12329 
12330   Styles[4] = getLLVMStyle();
12331   Styles[4].Language = FormatStyle::LK_JavaScript;
12332   EXPECT_EQ(0, parseConfiguration("---\n"
12333                                   "BasedOnStyle: LLVM\n"
12334                                   "IndentWidth: 123\n"
12335                                   "---\n"
12336                                   "BasedOnStyle: Google\n"
12337                                   "Language: JavaScript",
12338                                   &Styles[4])
12339                    .value());
12340   EXPECT_ALL_STYLES_EQUAL(Styles);
12341 }
12342 
12343 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
12344   Style.FIELD = false;                                                         \
12345   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
12346   EXPECT_TRUE(Style.FIELD);                                                    \
12347   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
12348   EXPECT_FALSE(Style.FIELD);
12349 
12350 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
12351 
12352 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
12353   Style.STRUCT.FIELD = false;                                                  \
12354   EXPECT_EQ(0,                                                                 \
12355             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
12356                 .value());                                                     \
12357   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
12358   EXPECT_EQ(0,                                                                 \
12359             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
12360                 .value());                                                     \
12361   EXPECT_FALSE(Style.STRUCT.FIELD);
12362 
12363 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
12364   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
12365 
12366 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
12367   EXPECT_NE(VALUE, Style.FIELD);                                               \
12368   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
12369   EXPECT_EQ(VALUE, Style.FIELD)
12370 
12371 TEST_F(FormatTest, ParsesConfigurationBools) {
12372   FormatStyle Style = {};
12373   Style.Language = FormatStyle::LK_Cpp;
12374   CHECK_PARSE_BOOL(AlignOperands);
12375   CHECK_PARSE_BOOL(AlignTrailingComments);
12376   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
12377   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
12378   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
12379   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
12380   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
12381   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
12382   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
12383   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
12384   CHECK_PARSE_BOOL(BinPackArguments);
12385   CHECK_PARSE_BOOL(BinPackParameters);
12386   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
12387   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
12388   CHECK_PARSE_BOOL(BreakStringLiterals);
12389   CHECK_PARSE_BOOL(CompactNamespaces);
12390   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
12391   CHECK_PARSE_BOOL(DerivePointerAlignment);
12392   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
12393   CHECK_PARSE_BOOL(DisableFormat);
12394   CHECK_PARSE_BOOL(IndentCaseLabels);
12395   CHECK_PARSE_BOOL(IndentGotoLabels);
12396   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
12397   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
12398   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
12399   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
12400   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
12401   CHECK_PARSE_BOOL(ReflowComments);
12402   CHECK_PARSE_BOOL(SortIncludes);
12403   CHECK_PARSE_BOOL(SortUsingDeclarations);
12404   CHECK_PARSE_BOOL(SpacesInParentheses);
12405   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
12406   CHECK_PARSE_BOOL(SpacesInAngles);
12407   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
12408   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
12409   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
12410   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
12411   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
12412   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
12413   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
12414   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
12415   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
12416   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
12417   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
12418   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
12419 
12420   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
12421   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
12422   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
12423   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
12424   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
12425   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
12426   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
12427   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
12428   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
12429   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
12430   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
12431   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
12432   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
12433   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
12434   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
12435 }
12436 
12437 #undef CHECK_PARSE_BOOL
12438 
12439 TEST_F(FormatTest, ParsesConfiguration) {
12440   FormatStyle Style = {};
12441   Style.Language = FormatStyle::LK_Cpp;
12442   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
12443   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
12444               ConstructorInitializerIndentWidth, 1234u);
12445   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
12446   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
12447   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
12448   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
12449   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
12450               PenaltyBreakBeforeFirstCallParameter, 1234u);
12451   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
12452               PenaltyBreakTemplateDeclaration, 1234u);
12453   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
12454   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
12455               PenaltyReturnTypeOnItsOwnLine, 1234u);
12456   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
12457               SpacesBeforeTrailingComments, 1234u);
12458   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
12459   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
12460   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
12461 
12462   Style.PointerAlignment = FormatStyle::PAS_Middle;
12463   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
12464               FormatStyle::PAS_Left);
12465   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
12466               FormatStyle::PAS_Right);
12467   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
12468               FormatStyle::PAS_Middle);
12469   // For backward compatibility:
12470   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
12471               FormatStyle::PAS_Left);
12472   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
12473               FormatStyle::PAS_Right);
12474   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
12475               FormatStyle::PAS_Middle);
12476 
12477   Style.Standard = FormatStyle::LS_Auto;
12478   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
12479   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
12480   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
12481   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
12482   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
12483   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
12484   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
12485   // Legacy aliases:
12486   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
12487   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
12488   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
12489   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
12490 
12491   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12492   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
12493               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
12494   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
12495               FormatStyle::BOS_None);
12496   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
12497               FormatStyle::BOS_All);
12498   // For backward compatibility:
12499   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
12500               FormatStyle::BOS_None);
12501   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
12502               FormatStyle::BOS_All);
12503 
12504   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
12505   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
12506               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
12507   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
12508               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
12509   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
12510               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
12511   // For backward compatibility:
12512   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
12513               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
12514 
12515   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
12516   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
12517               FormatStyle::BILS_BeforeComma);
12518   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
12519               FormatStyle::BILS_AfterColon);
12520   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
12521               FormatStyle::BILS_BeforeColon);
12522   // For backward compatibility:
12523   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
12524               FormatStyle::BILS_BeforeComma);
12525 
12526   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
12527   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
12528               FormatStyle::BAS_Align);
12529   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
12530               FormatStyle::BAS_DontAlign);
12531   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
12532               FormatStyle::BAS_AlwaysBreak);
12533   // For backward compatibility:
12534   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
12535               FormatStyle::BAS_DontAlign);
12536   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
12537               FormatStyle::BAS_Align);
12538 
12539   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12540   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
12541               FormatStyle::ENAS_DontAlign);
12542   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
12543               FormatStyle::ENAS_Left);
12544   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
12545               FormatStyle::ENAS_Right);
12546   // For backward compatibility:
12547   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
12548               FormatStyle::ENAS_Left);
12549   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
12550               FormatStyle::ENAS_Right);
12551 
12552   Style.UseTab = FormatStyle::UT_ForIndentation;
12553   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
12554   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
12555   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
12556   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
12557               FormatStyle::UT_ForContinuationAndIndentation);
12558   // For backward compatibility:
12559   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
12560   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
12561 
12562   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
12563   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
12564               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
12565   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
12566               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
12567   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
12568               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
12569   // For backward compatibility:
12570   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
12571               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
12572   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
12573               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
12574 
12575   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
12576   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
12577               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
12578   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
12579               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
12580   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
12581               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
12582   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
12583               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
12584   // For backward compatibility:
12585   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
12586               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
12587   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
12588               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
12589 
12590   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
12591   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
12592               FormatStyle::SBPO_Never);
12593   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
12594               FormatStyle::SBPO_Always);
12595   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
12596               FormatStyle::SBPO_ControlStatements);
12597   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
12598               FormatStyle::SBPO_NonEmptyParentheses);
12599   // For backward compatibility:
12600   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
12601               FormatStyle::SBPO_Never);
12602   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
12603               FormatStyle::SBPO_ControlStatements);
12604 
12605   Style.ColumnLimit = 123;
12606   FormatStyle BaseStyle = getLLVMStyle();
12607   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
12608   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
12609 
12610   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12611   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
12612               FormatStyle::BS_Attach);
12613   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
12614               FormatStyle::BS_Linux);
12615   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
12616               FormatStyle::BS_Mozilla);
12617   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
12618               FormatStyle::BS_Stroustrup);
12619   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
12620               FormatStyle::BS_Allman);
12621   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
12622               FormatStyle::BS_Whitesmiths);
12623   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
12624   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
12625               FormatStyle::BS_WebKit);
12626   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
12627               FormatStyle::BS_Custom);
12628 
12629   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
12630   CHECK_PARSE("BraceWrapping:\n"
12631               "  AfterControlStatement: MultiLine",
12632               BraceWrapping.AfterControlStatement,
12633               FormatStyle::BWACS_MultiLine);
12634   CHECK_PARSE("BraceWrapping:\n"
12635               "  AfterControlStatement: Always",
12636               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
12637   CHECK_PARSE("BraceWrapping:\n"
12638               "  AfterControlStatement: Never",
12639               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
12640   // For backward compatibility:
12641   CHECK_PARSE("BraceWrapping:\n"
12642               "  AfterControlStatement: true",
12643               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
12644   CHECK_PARSE("BraceWrapping:\n"
12645               "  AfterControlStatement: false",
12646               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
12647 
12648   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
12649   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
12650               FormatStyle::RTBS_None);
12651   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
12652               FormatStyle::RTBS_All);
12653   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
12654               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
12655   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
12656               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
12657   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
12658               AlwaysBreakAfterReturnType,
12659               FormatStyle::RTBS_TopLevelDefinitions);
12660 
12661   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
12662   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
12663               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
12664   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
12665               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
12666   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
12667               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
12668   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
12669               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
12670   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
12671               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
12672 
12673   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
12674   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
12675               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
12676   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
12677               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
12678   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
12679               AlwaysBreakAfterDefinitionReturnType,
12680               FormatStyle::DRTBS_TopLevel);
12681 
12682   Style.NamespaceIndentation = FormatStyle::NI_All;
12683   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
12684               FormatStyle::NI_None);
12685   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
12686               FormatStyle::NI_Inner);
12687   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
12688               FormatStyle::NI_All);
12689 
12690   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
12691   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
12692               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
12693   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
12694               AllowShortIfStatementsOnASingleLine,
12695               FormatStyle::SIS_WithoutElse);
12696   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
12697               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
12698   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
12699               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
12700   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
12701               AllowShortIfStatementsOnASingleLine,
12702               FormatStyle::SIS_WithoutElse);
12703 
12704   // FIXME: This is required because parsing a configuration simply overwrites
12705   // the first N elements of the list instead of resetting it.
12706   Style.ForEachMacros.clear();
12707   std::vector<std::string> BoostForeach;
12708   BoostForeach.push_back("BOOST_FOREACH");
12709   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
12710   std::vector<std::string> BoostAndQForeach;
12711   BoostAndQForeach.push_back("BOOST_FOREACH");
12712   BoostAndQForeach.push_back("Q_FOREACH");
12713   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
12714               BoostAndQForeach);
12715 
12716   Style.StatementMacros.clear();
12717   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
12718               std::vector<std::string>{"QUNUSED"});
12719   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
12720               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
12721 
12722   Style.NamespaceMacros.clear();
12723   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
12724               std::vector<std::string>{"TESTSUITE"});
12725   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
12726               std::vector<std::string>({"TESTSUITE", "SUITE"}));
12727 
12728   Style.IncludeStyle.IncludeCategories.clear();
12729   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
12730       {"abc/.*", 2, 0}, {".*", 1, 0}};
12731   CHECK_PARSE("IncludeCategories:\n"
12732               "  - Regex: abc/.*\n"
12733               "    Priority: 2\n"
12734               "  - Regex: .*\n"
12735               "    Priority: 1",
12736               IncludeStyle.IncludeCategories, ExpectedCategories);
12737   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
12738               "abc$");
12739 
12740   Style.RawStringFormats.clear();
12741   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
12742       {
12743           FormatStyle::LK_TextProto,
12744           {"pb", "proto"},
12745           {"PARSE_TEXT_PROTO"},
12746           /*CanonicalDelimiter=*/"",
12747           "llvm",
12748       },
12749       {
12750           FormatStyle::LK_Cpp,
12751           {"cc", "cpp"},
12752           {"C_CODEBLOCK", "CPPEVAL"},
12753           /*CanonicalDelimiter=*/"cc",
12754           /*BasedOnStyle=*/"",
12755       },
12756   };
12757 
12758   CHECK_PARSE("RawStringFormats:\n"
12759               "  - Language: TextProto\n"
12760               "    Delimiters:\n"
12761               "      - 'pb'\n"
12762               "      - 'proto'\n"
12763               "    EnclosingFunctions:\n"
12764               "      - 'PARSE_TEXT_PROTO'\n"
12765               "    BasedOnStyle: llvm\n"
12766               "  - Language: Cpp\n"
12767               "    Delimiters:\n"
12768               "      - 'cc'\n"
12769               "      - 'cpp'\n"
12770               "    EnclosingFunctions:\n"
12771               "      - 'C_CODEBLOCK'\n"
12772               "      - 'CPPEVAL'\n"
12773               "    CanonicalDelimiter: 'cc'",
12774               RawStringFormats, ExpectedRawStringFormats);
12775 }
12776 
12777 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
12778   FormatStyle Style = {};
12779   Style.Language = FormatStyle::LK_Cpp;
12780   CHECK_PARSE("Language: Cpp\n"
12781               "IndentWidth: 12",
12782               IndentWidth, 12u);
12783   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
12784                                "IndentWidth: 34",
12785                                &Style),
12786             ParseError::Unsuitable);
12787   EXPECT_EQ(12u, Style.IndentWidth);
12788   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
12789   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
12790 
12791   Style.Language = FormatStyle::LK_JavaScript;
12792   CHECK_PARSE("Language: JavaScript\n"
12793               "IndentWidth: 12",
12794               IndentWidth, 12u);
12795   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
12796   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
12797                                "IndentWidth: 34",
12798                                &Style),
12799             ParseError::Unsuitable);
12800   EXPECT_EQ(23u, Style.IndentWidth);
12801   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
12802   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
12803 
12804   CHECK_PARSE("BasedOnStyle: LLVM\n"
12805               "IndentWidth: 67",
12806               IndentWidth, 67u);
12807 
12808   CHECK_PARSE("---\n"
12809               "Language: JavaScript\n"
12810               "IndentWidth: 12\n"
12811               "---\n"
12812               "Language: Cpp\n"
12813               "IndentWidth: 34\n"
12814               "...\n",
12815               IndentWidth, 12u);
12816 
12817   Style.Language = FormatStyle::LK_Cpp;
12818   CHECK_PARSE("---\n"
12819               "Language: JavaScript\n"
12820               "IndentWidth: 12\n"
12821               "---\n"
12822               "Language: Cpp\n"
12823               "IndentWidth: 34\n"
12824               "...\n",
12825               IndentWidth, 34u);
12826   CHECK_PARSE("---\n"
12827               "IndentWidth: 78\n"
12828               "---\n"
12829               "Language: JavaScript\n"
12830               "IndentWidth: 56\n"
12831               "...\n",
12832               IndentWidth, 78u);
12833 
12834   Style.ColumnLimit = 123;
12835   Style.IndentWidth = 234;
12836   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
12837   Style.TabWidth = 345;
12838   EXPECT_FALSE(parseConfiguration("---\n"
12839                                   "IndentWidth: 456\n"
12840                                   "BreakBeforeBraces: Allman\n"
12841                                   "---\n"
12842                                   "Language: JavaScript\n"
12843                                   "IndentWidth: 111\n"
12844                                   "TabWidth: 111\n"
12845                                   "---\n"
12846                                   "Language: Cpp\n"
12847                                   "BreakBeforeBraces: Stroustrup\n"
12848                                   "TabWidth: 789\n"
12849                                   "...\n",
12850                                   &Style));
12851   EXPECT_EQ(123u, Style.ColumnLimit);
12852   EXPECT_EQ(456u, Style.IndentWidth);
12853   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
12854   EXPECT_EQ(789u, Style.TabWidth);
12855 
12856   EXPECT_EQ(parseConfiguration("---\n"
12857                                "Language: JavaScript\n"
12858                                "IndentWidth: 56\n"
12859                                "---\n"
12860                                "IndentWidth: 78\n"
12861                                "...\n",
12862                                &Style),
12863             ParseError::Error);
12864   EXPECT_EQ(parseConfiguration("---\n"
12865                                "Language: JavaScript\n"
12866                                "IndentWidth: 56\n"
12867                                "---\n"
12868                                "Language: JavaScript\n"
12869                                "IndentWidth: 78\n"
12870                                "...\n",
12871                                &Style),
12872             ParseError::Error);
12873 
12874   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
12875 }
12876 
12877 #undef CHECK_PARSE
12878 
12879 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
12880   FormatStyle Style = {};
12881   Style.Language = FormatStyle::LK_JavaScript;
12882   Style.BreakBeforeTernaryOperators = true;
12883   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
12884   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
12885 
12886   Style.BreakBeforeTernaryOperators = true;
12887   EXPECT_EQ(0, parseConfiguration("---\n"
12888                                   "BasedOnStyle: Google\n"
12889                                   "---\n"
12890                                   "Language: JavaScript\n"
12891                                   "IndentWidth: 76\n"
12892                                   "...\n",
12893                                   &Style)
12894                    .value());
12895   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
12896   EXPECT_EQ(76u, Style.IndentWidth);
12897   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
12898 }
12899 
12900 TEST_F(FormatTest, ConfigurationRoundTripTest) {
12901   FormatStyle Style = getLLVMStyle();
12902   std::string YAML = configurationAsText(Style);
12903   FormatStyle ParsedStyle = {};
12904   ParsedStyle.Language = FormatStyle::LK_Cpp;
12905   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
12906   EXPECT_EQ(Style, ParsedStyle);
12907 }
12908 
12909 TEST_F(FormatTest, WorksFor8bitEncodings) {
12910   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
12911             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
12912             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
12913             "\"\xef\xee\xf0\xf3...\"",
12914             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
12915                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
12916                    "\xef\xee\xf0\xf3...\"",
12917                    getLLVMStyleWithColumns(12)));
12918 }
12919 
12920 TEST_F(FormatTest, HandlesUTF8BOM) {
12921   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
12922   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
12923             format("\xef\xbb\xbf#include <iostream>"));
12924   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
12925             format("\xef\xbb\xbf\n#include <iostream>"));
12926 }
12927 
12928 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
12929 #if !defined(_MSC_VER)
12930 
12931 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
12932   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
12933                getLLVMStyleWithColumns(35));
12934   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
12935                getLLVMStyleWithColumns(31));
12936   verifyFormat("// Однажды в студёную зимнюю пору...",
12937                getLLVMStyleWithColumns(36));
12938   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
12939   verifyFormat("/* Однажды в студёную зимнюю пору... */",
12940                getLLVMStyleWithColumns(39));
12941   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
12942                getLLVMStyleWithColumns(35));
12943 }
12944 
12945 TEST_F(FormatTest, SplitsUTF8Strings) {
12946   // Non-printable characters' width is currently considered to be the length in
12947   // bytes in UTF8. The characters can be displayed in very different manner
12948   // (zero-width, single width with a substitution glyph, expanded to their code
12949   // (e.g. "<8d>"), so there's no single correct way to handle them.
12950   EXPECT_EQ("\"aaaaÄ\"\n"
12951             "\"\xc2\x8d\";",
12952             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
12953   EXPECT_EQ("\"aaaaaaaÄ\"\n"
12954             "\"\xc2\x8d\";",
12955             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
12956   EXPECT_EQ("\"Однажды, в \"\n"
12957             "\"студёную \"\n"
12958             "\"зимнюю \"\n"
12959             "\"пору,\"",
12960             format("\"Однажды, в студёную зимнюю пору,\"",
12961                    getLLVMStyleWithColumns(13)));
12962   EXPECT_EQ(
12963       "\"一 二 三 \"\n"
12964       "\"四 五六 \"\n"
12965       "\"七 八 九 \"\n"
12966       "\"十\"",
12967       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
12968   EXPECT_EQ("\"一\t\"\n"
12969             "\"二 \t\"\n"
12970             "\"三 四 \"\n"
12971             "\"五\t\"\n"
12972             "\"六 \t\"\n"
12973             "\"七 \"\n"
12974             "\"八九十\tqq\"",
12975             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
12976                    getLLVMStyleWithColumns(11)));
12977 
12978   // UTF8 character in an escape sequence.
12979   EXPECT_EQ("\"aaaaaa\"\n"
12980             "\"\\\xC2\x8D\"",
12981             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
12982 }
12983 
12984 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
12985   EXPECT_EQ("const char *sssss =\n"
12986             "    \"一二三四五六七八\\\n"
12987             " 九 十\";",
12988             format("const char *sssss = \"一二三四五六七八\\\n"
12989                    " 九 十\";",
12990                    getLLVMStyleWithColumns(30)));
12991 }
12992 
12993 TEST_F(FormatTest, SplitsUTF8LineComments) {
12994   EXPECT_EQ("// aaaaÄ\xc2\x8d",
12995             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
12996   EXPECT_EQ("// Я из лесу\n"
12997             "// вышел; был\n"
12998             "// сильный\n"
12999             "// мороз.",
13000             format("// Я из лесу вышел; был сильный мороз.",
13001                    getLLVMStyleWithColumns(13)));
13002   EXPECT_EQ("// 一二三\n"
13003             "// 四五六七\n"
13004             "// 八  九\n"
13005             "// 十",
13006             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
13007 }
13008 
13009 TEST_F(FormatTest, SplitsUTF8BlockComments) {
13010   EXPECT_EQ("/* Гляжу,\n"
13011             " * поднимается\n"
13012             " * медленно в\n"
13013             " * гору\n"
13014             " * Лошадка,\n"
13015             " * везущая\n"
13016             " * хворосту\n"
13017             " * воз. */",
13018             format("/* Гляжу, поднимается медленно в гору\n"
13019                    " * Лошадка, везущая хворосту воз. */",
13020                    getLLVMStyleWithColumns(13)));
13021   EXPECT_EQ(
13022       "/* 一二三\n"
13023       " * 四五六七\n"
13024       " * 八  九\n"
13025       " * 十  */",
13026       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
13027   EXPECT_EQ("/* �������� ��������\n"
13028             " * ��������\n"
13029             " * ������-�� */",
13030             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
13031 }
13032 
13033 #endif // _MSC_VER
13034 
13035 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
13036   FormatStyle Style = getLLVMStyle();
13037 
13038   Style.ConstructorInitializerIndentWidth = 4;
13039   verifyFormat(
13040       "SomeClass::Constructor()\n"
13041       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
13042       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
13043       Style);
13044 
13045   Style.ConstructorInitializerIndentWidth = 2;
13046   verifyFormat(
13047       "SomeClass::Constructor()\n"
13048       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
13049       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
13050       Style);
13051 
13052   Style.ConstructorInitializerIndentWidth = 0;
13053   verifyFormat(
13054       "SomeClass::Constructor()\n"
13055       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
13056       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
13057       Style);
13058   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
13059   verifyFormat(
13060       "SomeLongTemplateVariableName<\n"
13061       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
13062       Style);
13063   verifyFormat("bool smaller = 1 < "
13064                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
13065                "                       "
13066                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
13067                Style);
13068 
13069   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
13070   verifyFormat("SomeClass::Constructor() :\n"
13071                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
13072                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
13073                Style);
13074 }
13075 
13076 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
13077   FormatStyle Style = getLLVMStyle();
13078   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
13079   Style.ConstructorInitializerIndentWidth = 4;
13080   verifyFormat("SomeClass::Constructor()\n"
13081                "    : a(a)\n"
13082                "    , b(b)\n"
13083                "    , c(c) {}",
13084                Style);
13085   verifyFormat("SomeClass::Constructor()\n"
13086                "    : a(a) {}",
13087                Style);
13088 
13089   Style.ColumnLimit = 0;
13090   verifyFormat("SomeClass::Constructor()\n"
13091                "    : a(a) {}",
13092                Style);
13093   verifyFormat("SomeClass::Constructor() noexcept\n"
13094                "    : a(a) {}",
13095                Style);
13096   verifyFormat("SomeClass::Constructor()\n"
13097                "    : a(a)\n"
13098                "    , b(b)\n"
13099                "    , c(c) {}",
13100                Style);
13101   verifyFormat("SomeClass::Constructor()\n"
13102                "    : a(a) {\n"
13103                "  foo();\n"
13104                "  bar();\n"
13105                "}",
13106                Style);
13107 
13108   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
13109   verifyFormat("SomeClass::Constructor()\n"
13110                "    : a(a)\n"
13111                "    , b(b)\n"
13112                "    , c(c) {\n}",
13113                Style);
13114   verifyFormat("SomeClass::Constructor()\n"
13115                "    : a(a) {\n}",
13116                Style);
13117 
13118   Style.ColumnLimit = 80;
13119   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
13120   Style.ConstructorInitializerIndentWidth = 2;
13121   verifyFormat("SomeClass::Constructor()\n"
13122                "  : a(a)\n"
13123                "  , b(b)\n"
13124                "  , c(c) {}",
13125                Style);
13126 
13127   Style.ConstructorInitializerIndentWidth = 0;
13128   verifyFormat("SomeClass::Constructor()\n"
13129                ": a(a)\n"
13130                ", b(b)\n"
13131                ", c(c) {}",
13132                Style);
13133 
13134   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
13135   Style.ConstructorInitializerIndentWidth = 4;
13136   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
13137   verifyFormat(
13138       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
13139       Style);
13140   verifyFormat(
13141       "SomeClass::Constructor()\n"
13142       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
13143       Style);
13144   Style.ConstructorInitializerIndentWidth = 4;
13145   Style.ColumnLimit = 60;
13146   verifyFormat("SomeClass::Constructor()\n"
13147                "    : aaaaaaaa(aaaaaaaa)\n"
13148                "    , aaaaaaaa(aaaaaaaa)\n"
13149                "    , aaaaaaaa(aaaaaaaa) {}",
13150                Style);
13151 }
13152 
13153 TEST_F(FormatTest, Destructors) {
13154   verifyFormat("void F(int &i) { i.~int(); }");
13155   verifyFormat("void F(int &i) { i->~int(); }");
13156 }
13157 
13158 TEST_F(FormatTest, FormatsWithWebKitStyle) {
13159   FormatStyle Style = getWebKitStyle();
13160 
13161   // Don't indent in outer namespaces.
13162   verifyFormat("namespace outer {\n"
13163                "int i;\n"
13164                "namespace inner {\n"
13165                "    int i;\n"
13166                "} // namespace inner\n"
13167                "} // namespace outer\n"
13168                "namespace other_outer {\n"
13169                "int i;\n"
13170                "}",
13171                Style);
13172 
13173   // Don't indent case labels.
13174   verifyFormat("switch (variable) {\n"
13175                "case 1:\n"
13176                "case 2:\n"
13177                "    doSomething();\n"
13178                "    break;\n"
13179                "default:\n"
13180                "    ++variable;\n"
13181                "}",
13182                Style);
13183 
13184   // Wrap before binary operators.
13185   EXPECT_EQ("void f()\n"
13186             "{\n"
13187             "    if (aaaaaaaaaaaaaaaa\n"
13188             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
13189             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
13190             "        return;\n"
13191             "}",
13192             format("void f() {\n"
13193                    "if (aaaaaaaaaaaaaaaa\n"
13194                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
13195                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
13196                    "return;\n"
13197                    "}",
13198                    Style));
13199 
13200   // Allow functions on a single line.
13201   verifyFormat("void f() { return; }", Style);
13202 
13203   // Allow empty blocks on a single line and insert a space in empty blocks.
13204   EXPECT_EQ("void f() { }", format("void f() {}", Style));
13205   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
13206   // However, don't merge non-empty short loops.
13207   EXPECT_EQ("while (true) {\n"
13208             "    continue;\n"
13209             "}",
13210             format("while (true) { continue; }", Style));
13211 
13212   // Constructor initializers are formatted one per line with the "," on the
13213   // new line.
13214   verifyFormat("Constructor()\n"
13215                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
13216                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
13217                "          aaaaaaaaaaaaaa)\n"
13218                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
13219                "{\n"
13220                "}",
13221                Style);
13222   verifyFormat("SomeClass::Constructor()\n"
13223                "    : a(a)\n"
13224                "{\n"
13225                "}",
13226                Style);
13227   EXPECT_EQ("SomeClass::Constructor()\n"
13228             "    : a(a)\n"
13229             "{\n"
13230             "}",
13231             format("SomeClass::Constructor():a(a){}", Style));
13232   verifyFormat("SomeClass::Constructor()\n"
13233                "    : a(a)\n"
13234                "    , b(b)\n"
13235                "    , c(c)\n"
13236                "{\n"
13237                "}",
13238                Style);
13239   verifyFormat("SomeClass::Constructor()\n"
13240                "    : a(a)\n"
13241                "{\n"
13242                "    foo();\n"
13243                "    bar();\n"
13244                "}",
13245                Style);
13246 
13247   // Access specifiers should be aligned left.
13248   verifyFormat("class C {\n"
13249                "public:\n"
13250                "    int i;\n"
13251                "};",
13252                Style);
13253 
13254   // Do not align comments.
13255   verifyFormat("int a; // Do not\n"
13256                "double b; // align comments.",
13257                Style);
13258 
13259   // Do not align operands.
13260   EXPECT_EQ("ASSERT(aaaa\n"
13261             "    || bbbb);",
13262             format("ASSERT ( aaaa\n||bbbb);", Style));
13263 
13264   // Accept input's line breaks.
13265   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
13266             "    || bbbbbbbbbbbbbbb) {\n"
13267             "    i++;\n"
13268             "}",
13269             format("if (aaaaaaaaaaaaaaa\n"
13270                    "|| bbbbbbbbbbbbbbb) { i++; }",
13271                    Style));
13272   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
13273             "    i++;\n"
13274             "}",
13275             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
13276 
13277   // Don't automatically break all macro definitions (llvm.org/PR17842).
13278   verifyFormat("#define aNumber 10", Style);
13279   // However, generally keep the line breaks that the user authored.
13280   EXPECT_EQ("#define aNumber \\\n"
13281             "    10",
13282             format("#define aNumber \\\n"
13283                    " 10",
13284                    Style));
13285 
13286   // Keep empty and one-element array literals on a single line.
13287   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
13288             "                                  copyItems:YES];",
13289             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
13290                    "copyItems:YES];",
13291                    Style));
13292   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
13293             "                                  copyItems:YES];",
13294             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
13295                    "             copyItems:YES];",
13296                    Style));
13297   // FIXME: This does not seem right, there should be more indentation before
13298   // the array literal's entries. Nested blocks have the same problem.
13299   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
13300             "    @\"a\",\n"
13301             "    @\"a\"\n"
13302             "]\n"
13303             "                                  copyItems:YES];",
13304             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
13305                    "     @\"a\",\n"
13306                    "     @\"a\"\n"
13307                    "     ]\n"
13308                    "       copyItems:YES];",
13309                    Style));
13310   EXPECT_EQ(
13311       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
13312       "                                  copyItems:YES];",
13313       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
13314              "   copyItems:YES];",
13315              Style));
13316 
13317   verifyFormat("[self.a b:c c:d];", Style);
13318   EXPECT_EQ("[self.a b:c\n"
13319             "        c:d];",
13320             format("[self.a b:c\n"
13321                    "c:d];",
13322                    Style));
13323 }
13324 
13325 TEST_F(FormatTest, FormatsLambdas) {
13326   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
13327   verifyFormat(
13328       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
13329   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
13330   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
13331   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
13332   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
13333   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
13334   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
13335   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
13336   verifyFormat("int x = f(*+[] {});");
13337   verifyFormat("void f() {\n"
13338                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
13339                "}\n");
13340   verifyFormat("void f() {\n"
13341                "  other(x.begin(), //\n"
13342                "        x.end(),   //\n"
13343                "        [&](int, int) { return 1; });\n"
13344                "}\n");
13345   verifyFormat("void f() {\n"
13346                "  other.other.other.other.other(\n"
13347                "      x.begin(), x.end(),\n"
13348                "      [something, rather](int, int, int, int, int, int, int) { "
13349                "return 1; });\n"
13350                "}\n");
13351   verifyFormat(
13352       "void f() {\n"
13353       "  other.other.other.other.other(\n"
13354       "      x.begin(), x.end(),\n"
13355       "      [something, rather](int, int, int, int, int, int, int) {\n"
13356       "        //\n"
13357       "      });\n"
13358       "}\n");
13359   verifyFormat("SomeFunction([]() { // A cool function...\n"
13360                "  return 43;\n"
13361                "});");
13362   EXPECT_EQ("SomeFunction([]() {\n"
13363             "#define A a\n"
13364             "  return 43;\n"
13365             "});",
13366             format("SomeFunction([](){\n"
13367                    "#define A a\n"
13368                    "return 43;\n"
13369                    "});"));
13370   verifyFormat("void f() {\n"
13371                "  SomeFunction([](decltype(x), A *a) {});\n"
13372                "}");
13373   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
13374                "    [](const aaaaaaaaaa &a) { return a; });");
13375   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
13376                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
13377                "});");
13378   verifyFormat("Constructor()\n"
13379                "    : Field([] { // comment\n"
13380                "        int i;\n"
13381                "      }) {}");
13382   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
13383                "  return some_parameter.size();\n"
13384                "};");
13385   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
13386                "    [](const string &s) { return s; };");
13387   verifyFormat("int i = aaaaaa ? 1 //\n"
13388                "               : [] {\n"
13389                "                   return 2; //\n"
13390                "                 }();");
13391   verifyFormat("llvm::errs() << \"number of twos is \"\n"
13392                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
13393                "                  return x == 2; // force break\n"
13394                "                });");
13395   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
13396                "    [=](int iiiiiiiiiiii) {\n"
13397                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
13398                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
13399                "    });",
13400                getLLVMStyleWithColumns(60));
13401   verifyFormat("SomeFunction({[&] {\n"
13402                "                // comment\n"
13403                "              },\n"
13404                "              [&] {\n"
13405                "                // comment\n"
13406                "              }});");
13407   verifyFormat("SomeFunction({[&] {\n"
13408                "  // comment\n"
13409                "}});");
13410   verifyFormat(
13411       "virtual aaaaaaaaaaaaaaaa(\n"
13412       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
13413       "    aaaaa aaaaaaaaa);");
13414 
13415   // Lambdas with return types.
13416   verifyFormat("int c = []() -> int { return 2; }();\n");
13417   verifyFormat("int c = []() -> int * { return 2; }();\n");
13418   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
13419   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
13420   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
13421   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
13422   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
13423   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
13424   verifyFormat("[a, a]() -> a<1> {};");
13425   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
13426   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
13427   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
13428   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
13429   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
13430   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
13431   verifyFormat("[]() -> foo<!5> { return {}; };");
13432   verifyFormat("[]() -> foo<~5> { return {}; };");
13433   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
13434   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
13435   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
13436   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
13437   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
13438   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
13439   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
13440   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
13441   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
13442   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
13443   verifyFormat("namespace bar {\n"
13444                "// broken:\n"
13445                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
13446                "} // namespace bar");
13447   verifyFormat("namespace bar {\n"
13448                "// broken:\n"
13449                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
13450                "} // namespace bar");
13451   verifyFormat("namespace bar {\n"
13452                "// broken:\n"
13453                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
13454                "} // namespace bar");
13455   verifyFormat("namespace bar {\n"
13456                "// broken:\n"
13457                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
13458                "} // namespace bar");
13459   verifyFormat("namespace bar {\n"
13460                "// broken:\n"
13461                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
13462                "} // namespace bar");
13463   verifyFormat("namespace bar {\n"
13464                "// broken:\n"
13465                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
13466                "} // namespace bar");
13467   verifyFormat("namespace bar {\n"
13468                "// broken:\n"
13469                "auto foo{[]() -> foo<!5> { return {}; }};\n"
13470                "} // namespace bar");
13471   verifyFormat("namespace bar {\n"
13472                "// broken:\n"
13473                "auto foo{[]() -> foo<~5> { return {}; }};\n"
13474                "} // namespace bar");
13475   verifyFormat("namespace bar {\n"
13476                "// broken:\n"
13477                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
13478                "} // namespace bar");
13479   verifyFormat("namespace bar {\n"
13480                "// broken:\n"
13481                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
13482                "} // namespace bar");
13483   verifyFormat("namespace bar {\n"
13484                "// broken:\n"
13485                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
13486                "} // namespace bar");
13487   verifyFormat("namespace bar {\n"
13488                "// broken:\n"
13489                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
13490                "} // namespace bar");
13491   verifyFormat("namespace bar {\n"
13492                "// broken:\n"
13493                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
13494                "} // namespace bar");
13495   verifyFormat("namespace bar {\n"
13496                "// broken:\n"
13497                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
13498                "} // namespace bar");
13499   verifyFormat("namespace bar {\n"
13500                "// broken:\n"
13501                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
13502                "} // namespace bar");
13503   verifyFormat("namespace bar {\n"
13504                "// broken:\n"
13505                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
13506                "} // namespace bar");
13507   verifyFormat("namespace bar {\n"
13508                "// broken:\n"
13509                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
13510                "} // namespace bar");
13511   verifyFormat("namespace bar {\n"
13512                "// broken:\n"
13513                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
13514                "} // namespace bar");
13515   verifyFormat("[]() -> a<1> {};");
13516   verifyFormat("[]() -> a<1> { ; };");
13517   verifyFormat("[]() -> a<1> { ; }();");
13518   verifyFormat("[a, a]() -> a<true> {};");
13519   verifyFormat("[]() -> a<true> {};");
13520   verifyFormat("[]() -> a<true> { ; };");
13521   verifyFormat("[]() -> a<true> { ; }();");
13522   verifyFormat("[a, a]() -> a<false> {};");
13523   verifyFormat("[]() -> a<false> {};");
13524   verifyFormat("[]() -> a<false> { ; };");
13525   verifyFormat("[]() -> a<false> { ; }();");
13526   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
13527   verifyFormat("namespace bar {\n"
13528                "auto foo{[]() -> foo<false> { ; }};\n"
13529                "} // namespace bar");
13530   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
13531                "                   int j) -> int {\n"
13532                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
13533                "};");
13534   verifyFormat(
13535       "aaaaaaaaaaaaaaaaaaaaaa(\n"
13536       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
13537       "      return aaaaaaaaaaaaaaaaa;\n"
13538       "    });",
13539       getLLVMStyleWithColumns(70));
13540   verifyFormat("[]() //\n"
13541                "    -> int {\n"
13542                "  return 1; //\n"
13543                "};");
13544 
13545   // Lambdas with explicit template argument lists.
13546   verifyFormat(
13547       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
13548 
13549   // Multiple lambdas in the same parentheses change indentation rules. These
13550   // lambdas are forced to start on new lines.
13551   verifyFormat("SomeFunction(\n"
13552                "    []() {\n"
13553                "      //\n"
13554                "    },\n"
13555                "    []() {\n"
13556                "      //\n"
13557                "    });");
13558 
13559   // A lambda passed as arg0 is always pushed to the next line.
13560   verifyFormat("SomeFunction(\n"
13561                "    [this] {\n"
13562                "      //\n"
13563                "    },\n"
13564                "    1);\n");
13565 
13566   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
13567   // the arg0 case above.
13568   auto Style = getGoogleStyle();
13569   Style.BinPackArguments = false;
13570   verifyFormat("SomeFunction(\n"
13571                "    a,\n"
13572                "    [this] {\n"
13573                "      //\n"
13574                "    },\n"
13575                "    b);\n",
13576                Style);
13577   verifyFormat("SomeFunction(\n"
13578                "    a,\n"
13579                "    [this] {\n"
13580                "      //\n"
13581                "    },\n"
13582                "    b);\n");
13583 
13584   // A lambda with a very long line forces arg0 to be pushed out irrespective of
13585   // the BinPackArguments value (as long as the code is wide enough).
13586   verifyFormat(
13587       "something->SomeFunction(\n"
13588       "    a,\n"
13589       "    [this] {\n"
13590       "      "
13591       "D0000000000000000000000000000000000000000000000000000000000001();\n"
13592       "    },\n"
13593       "    b);\n");
13594 
13595   // A multi-line lambda is pulled up as long as the introducer fits on the
13596   // previous line and there are no further args.
13597   verifyFormat("function(1, [this, that] {\n"
13598                "  //\n"
13599                "});\n");
13600   verifyFormat("function([this, that] {\n"
13601                "  //\n"
13602                "});\n");
13603   // FIXME: this format is not ideal and we should consider forcing the first
13604   // arg onto its own line.
13605   verifyFormat("function(a, b, c, //\n"
13606                "         d, [this, that] {\n"
13607                "           //\n"
13608                "         });\n");
13609 
13610   // Multiple lambdas are treated correctly even when there is a short arg0.
13611   verifyFormat("SomeFunction(\n"
13612                "    1,\n"
13613                "    [this] {\n"
13614                "      //\n"
13615                "    },\n"
13616                "    [this] {\n"
13617                "      //\n"
13618                "    },\n"
13619                "    1);\n");
13620 
13621   // More complex introducers.
13622   verifyFormat("return [i, args...] {};");
13623 
13624   // Not lambdas.
13625   verifyFormat("constexpr char hello[]{\"hello\"};");
13626   verifyFormat("double &operator[](int i) { return 0; }\n"
13627                "int i;");
13628   verifyFormat("std::unique_ptr<int[]> foo() {}");
13629   verifyFormat("int i = a[a][a]->f();");
13630   verifyFormat("int i = (*b)[a]->f();");
13631 
13632   // Other corner cases.
13633   verifyFormat("void f() {\n"
13634                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
13635                "  );\n"
13636                "}");
13637 
13638   // Lambdas created through weird macros.
13639   verifyFormat("void f() {\n"
13640                "  MACRO((const AA &a) { return 1; });\n"
13641                "  MACRO((AA &a) { return 1; });\n"
13642                "}");
13643 
13644   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
13645                "      doo_dah();\n"
13646                "      doo_dah();\n"
13647                "    })) {\n"
13648                "}");
13649   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
13650                "                doo_dah();\n"
13651                "                doo_dah();\n"
13652                "              })) {\n"
13653                "}");
13654   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
13655                "                doo_dah();\n"
13656                "                doo_dah();\n"
13657                "              })) {\n"
13658                "}");
13659   verifyFormat("auto lambda = []() {\n"
13660                "  int a = 2\n"
13661                "#if A\n"
13662                "          + 2\n"
13663                "#endif\n"
13664                "      ;\n"
13665                "};");
13666 
13667   // Lambdas with complex multiline introducers.
13668   verifyFormat(
13669       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
13670       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
13671       "        -> ::std::unordered_set<\n"
13672       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
13673       "      //\n"
13674       "    });");
13675 
13676   FormatStyle DoNotMerge = getLLVMStyle();
13677   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
13678   verifyFormat("auto c = []() {\n"
13679                "  return b;\n"
13680                "};",
13681                "auto c = []() { return b; };", DoNotMerge);
13682   verifyFormat("auto c = []() {\n"
13683                "};",
13684                " auto c = []() {};", DoNotMerge);
13685 
13686   FormatStyle MergeEmptyOnly = getLLVMStyle();
13687   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
13688   verifyFormat("auto c = []() {\n"
13689                "  return b;\n"
13690                "};",
13691                "auto c = []() {\n"
13692                "  return b;\n"
13693                " };",
13694                MergeEmptyOnly);
13695   verifyFormat("auto c = []() {};",
13696                "auto c = []() {\n"
13697                "};",
13698                MergeEmptyOnly);
13699 
13700   FormatStyle MergeInline = getLLVMStyle();
13701   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
13702   verifyFormat("auto c = []() {\n"
13703                "  return b;\n"
13704                "};",
13705                "auto c = []() { return b; };", MergeInline);
13706   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
13707                MergeInline);
13708   verifyFormat("function([]() { return b; }, a)",
13709                "function([]() { return b; }, a)", MergeInline);
13710   verifyFormat("function(a, []() { return b; })",
13711                "function(a, []() { return b; })", MergeInline);
13712 }
13713 
13714 TEST_F(FormatTest, EmptyLinesInLambdas) {
13715   verifyFormat("auto lambda = []() {\n"
13716                "  x(); //\n"
13717                "};",
13718                "auto lambda = []() {\n"
13719                "\n"
13720                "  x(); //\n"
13721                "\n"
13722                "};");
13723 }
13724 
13725 TEST_F(FormatTest, FormatsBlocks) {
13726   FormatStyle ShortBlocks = getLLVMStyle();
13727   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
13728   verifyFormat("int (^Block)(int, int);", ShortBlocks);
13729   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
13730   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
13731   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
13732   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
13733   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
13734 
13735   verifyFormat("foo(^{ bar(); });", ShortBlocks);
13736   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
13737   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
13738 
13739   verifyFormat("[operation setCompletionBlock:^{\n"
13740                "  [self onOperationDone];\n"
13741                "}];");
13742   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
13743                "  [self onOperationDone];\n"
13744                "}]};");
13745   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
13746                "  f();\n"
13747                "}];");
13748   verifyFormat("int a = [operation block:^int(int *i) {\n"
13749                "  return 1;\n"
13750                "}];");
13751   verifyFormat("[myObject doSomethingWith:arg1\n"
13752                "                      aaa:^int(int *a) {\n"
13753                "                        return 1;\n"
13754                "                      }\n"
13755                "                      bbb:f(a * bbbbbbbb)];");
13756 
13757   verifyFormat("[operation setCompletionBlock:^{\n"
13758                "  [self.delegate newDataAvailable];\n"
13759                "}];",
13760                getLLVMStyleWithColumns(60));
13761   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
13762                "  NSString *path = [self sessionFilePath];\n"
13763                "  if (path) {\n"
13764                "    // ...\n"
13765                "  }\n"
13766                "});");
13767   verifyFormat("[[SessionService sharedService]\n"
13768                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
13769                "      if (window) {\n"
13770                "        [self windowDidLoad:window];\n"
13771                "      } else {\n"
13772                "        [self errorLoadingWindow];\n"
13773                "      }\n"
13774                "    }];");
13775   verifyFormat("void (^largeBlock)(void) = ^{\n"
13776                "  // ...\n"
13777                "};\n",
13778                getLLVMStyleWithColumns(40));
13779   verifyFormat("[[SessionService sharedService]\n"
13780                "    loadWindowWithCompletionBlock: //\n"
13781                "        ^(SessionWindow *window) {\n"
13782                "          if (window) {\n"
13783                "            [self windowDidLoad:window];\n"
13784                "          } else {\n"
13785                "            [self errorLoadingWindow];\n"
13786                "          }\n"
13787                "        }];",
13788                getLLVMStyleWithColumns(60));
13789   verifyFormat("[myObject doSomethingWith:arg1\n"
13790                "    firstBlock:^(Foo *a) {\n"
13791                "      // ...\n"
13792                "      int i;\n"
13793                "    }\n"
13794                "    secondBlock:^(Bar *b) {\n"
13795                "      // ...\n"
13796                "      int i;\n"
13797                "    }\n"
13798                "    thirdBlock:^Foo(Bar *b) {\n"
13799                "      // ...\n"
13800                "      int i;\n"
13801                "    }];");
13802   verifyFormat("[myObject doSomethingWith:arg1\n"
13803                "               firstBlock:-1\n"
13804                "              secondBlock:^(Bar *b) {\n"
13805                "                // ...\n"
13806                "                int i;\n"
13807                "              }];");
13808 
13809   verifyFormat("f(^{\n"
13810                "  @autoreleasepool {\n"
13811                "    if (a) {\n"
13812                "      g();\n"
13813                "    }\n"
13814                "  }\n"
13815                "});");
13816   verifyFormat("Block b = ^int *(A *a, B *b) {}");
13817   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
13818                "};");
13819 
13820   FormatStyle FourIndent = getLLVMStyle();
13821   FourIndent.ObjCBlockIndentWidth = 4;
13822   verifyFormat("[operation setCompletionBlock:^{\n"
13823                "    [self onOperationDone];\n"
13824                "}];",
13825                FourIndent);
13826 }
13827 
13828 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
13829   FormatStyle ZeroColumn = getLLVMStyle();
13830   ZeroColumn.ColumnLimit = 0;
13831 
13832   verifyFormat("[[SessionService sharedService] "
13833                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
13834                "  if (window) {\n"
13835                "    [self windowDidLoad:window];\n"
13836                "  } else {\n"
13837                "    [self errorLoadingWindow];\n"
13838                "  }\n"
13839                "}];",
13840                ZeroColumn);
13841   EXPECT_EQ("[[SessionService sharedService]\n"
13842             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
13843             "      if (window) {\n"
13844             "        [self windowDidLoad:window];\n"
13845             "      } else {\n"
13846             "        [self errorLoadingWindow];\n"
13847             "      }\n"
13848             "    }];",
13849             format("[[SessionService sharedService]\n"
13850                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
13851                    "                if (window) {\n"
13852                    "    [self windowDidLoad:window];\n"
13853                    "  } else {\n"
13854                    "    [self errorLoadingWindow];\n"
13855                    "  }\n"
13856                    "}];",
13857                    ZeroColumn));
13858   verifyFormat("[myObject doSomethingWith:arg1\n"
13859                "    firstBlock:^(Foo *a) {\n"
13860                "      // ...\n"
13861                "      int i;\n"
13862                "    }\n"
13863                "    secondBlock:^(Bar *b) {\n"
13864                "      // ...\n"
13865                "      int i;\n"
13866                "    }\n"
13867                "    thirdBlock:^Foo(Bar *b) {\n"
13868                "      // ...\n"
13869                "      int i;\n"
13870                "    }];",
13871                ZeroColumn);
13872   verifyFormat("f(^{\n"
13873                "  @autoreleasepool {\n"
13874                "    if (a) {\n"
13875                "      g();\n"
13876                "    }\n"
13877                "  }\n"
13878                "});",
13879                ZeroColumn);
13880   verifyFormat("void (^largeBlock)(void) = ^{\n"
13881                "  // ...\n"
13882                "};",
13883                ZeroColumn);
13884 
13885   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
13886   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
13887             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
13888   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
13889   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
13890             "  int i;\n"
13891             "};",
13892             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
13893 }
13894 
13895 TEST_F(FormatTest, SupportsCRLF) {
13896   EXPECT_EQ("int a;\r\n"
13897             "int b;\r\n"
13898             "int c;\r\n",
13899             format("int a;\r\n"
13900                    "  int b;\r\n"
13901                    "    int c;\r\n",
13902                    getLLVMStyle()));
13903   EXPECT_EQ("int a;\r\n"
13904             "int b;\r\n"
13905             "int c;\r\n",
13906             format("int a;\r\n"
13907                    "  int b;\n"
13908                    "    int c;\r\n",
13909                    getLLVMStyle()));
13910   EXPECT_EQ("int a;\n"
13911             "int b;\n"
13912             "int c;\n",
13913             format("int a;\r\n"
13914                    "  int b;\n"
13915                    "    int c;\n",
13916                    getLLVMStyle()));
13917   EXPECT_EQ("\"aaaaaaa \"\r\n"
13918             "\"bbbbbbb\";\r\n",
13919             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
13920   EXPECT_EQ("#define A \\\r\n"
13921             "  b;      \\\r\n"
13922             "  c;      \\\r\n"
13923             "  d;\r\n",
13924             format("#define A \\\r\n"
13925                    "  b; \\\r\n"
13926                    "  c; d; \r\n",
13927                    getGoogleStyle()));
13928 
13929   EXPECT_EQ("/*\r\n"
13930             "multi line block comments\r\n"
13931             "should not introduce\r\n"
13932             "an extra carriage return\r\n"
13933             "*/\r\n",
13934             format("/*\r\n"
13935                    "multi line block comments\r\n"
13936                    "should not introduce\r\n"
13937                    "an extra carriage return\r\n"
13938                    "*/\r\n"));
13939   EXPECT_EQ("/*\r\n"
13940             "\r\n"
13941             "*/",
13942             format("/*\r\n"
13943                    "    \r\r\r\n"
13944                    "*/"));
13945 }
13946 
13947 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
13948   verifyFormat("MY_CLASS(C) {\n"
13949                "  int i;\n"
13950                "  int j;\n"
13951                "};");
13952 }
13953 
13954 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
13955   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
13956   TwoIndent.ContinuationIndentWidth = 2;
13957 
13958   EXPECT_EQ("int i =\n"
13959             "  longFunction(\n"
13960             "    arg);",
13961             format("int i = longFunction(arg);", TwoIndent));
13962 
13963   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
13964   SixIndent.ContinuationIndentWidth = 6;
13965 
13966   EXPECT_EQ("int i =\n"
13967             "      longFunction(\n"
13968             "            arg);",
13969             format("int i = longFunction(arg);", SixIndent));
13970 }
13971 
13972 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
13973   FormatStyle Style = getLLVMStyle();
13974   verifyFormat("int Foo::getter(\n"
13975                "    //\n"
13976                ") const {\n"
13977                "  return foo;\n"
13978                "}",
13979                Style);
13980   verifyFormat("void Foo::setter(\n"
13981                "    //\n"
13982                ") {\n"
13983                "  foo = 1;\n"
13984                "}",
13985                Style);
13986 }
13987 
13988 TEST_F(FormatTest, SpacesInAngles) {
13989   FormatStyle Spaces = getLLVMStyle();
13990   Spaces.SpacesInAngles = true;
13991 
13992   verifyFormat("static_cast< int >(arg);", Spaces);
13993   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
13994   verifyFormat("f< int, float >();", Spaces);
13995   verifyFormat("template <> g() {}", Spaces);
13996   verifyFormat("template < std::vector< int > > f() {}", Spaces);
13997   verifyFormat("std::function< void(int, int) > fct;", Spaces);
13998   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
13999                Spaces);
14000 
14001   Spaces.Standard = FormatStyle::LS_Cpp03;
14002   Spaces.SpacesInAngles = true;
14003   verifyFormat("A< A< int > >();", Spaces);
14004 
14005   Spaces.SpacesInAngles = false;
14006   verifyFormat("A<A<int> >();", Spaces);
14007 
14008   Spaces.Standard = FormatStyle::LS_Cpp11;
14009   Spaces.SpacesInAngles = true;
14010   verifyFormat("A< A< int > >();", Spaces);
14011 
14012   Spaces.SpacesInAngles = false;
14013   verifyFormat("A<A<int>>();", Spaces);
14014 }
14015 
14016 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
14017   FormatStyle Style = getLLVMStyle();
14018   Style.SpaceAfterTemplateKeyword = false;
14019   verifyFormat("template<int> void foo();", Style);
14020 }
14021 
14022 TEST_F(FormatTest, TripleAngleBrackets) {
14023   verifyFormat("f<<<1, 1>>>();");
14024   verifyFormat("f<<<1, 1, 1, s>>>();");
14025   verifyFormat("f<<<a, b, c, d>>>();");
14026   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
14027   verifyFormat("f<param><<<1, 1>>>();");
14028   verifyFormat("f<1><<<1, 1>>>();");
14029   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
14030   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
14031                "aaaaaaaaaaa<<<\n    1, 1>>>();");
14032   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
14033                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
14034 }
14035 
14036 TEST_F(FormatTest, MergeLessLessAtEnd) {
14037   verifyFormat("<<");
14038   EXPECT_EQ("< < <", format("\\\n<<<"));
14039   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
14040                "aaallvm::outs() <<");
14041   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
14042                "aaaallvm::outs()\n    <<");
14043 }
14044 
14045 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
14046   std::string code = "#if A\n"
14047                      "#if B\n"
14048                      "a.\n"
14049                      "#endif\n"
14050                      "    a = 1;\n"
14051                      "#else\n"
14052                      "#endif\n"
14053                      "#if C\n"
14054                      "#else\n"
14055                      "#endif\n";
14056   EXPECT_EQ(code, format(code));
14057 }
14058 
14059 TEST_F(FormatTest, HandleConflictMarkers) {
14060   // Git/SVN conflict markers.
14061   EXPECT_EQ("int a;\n"
14062             "void f() {\n"
14063             "  callme(some(parameter1,\n"
14064             "<<<<<<< text by the vcs\n"
14065             "              parameter2),\n"
14066             "||||||| text by the vcs\n"
14067             "              parameter2),\n"
14068             "         parameter3,\n"
14069             "======= text by the vcs\n"
14070             "              parameter2, parameter3),\n"
14071             ">>>>>>> text by the vcs\n"
14072             "         otherparameter);\n",
14073             format("int a;\n"
14074                    "void f() {\n"
14075                    "  callme(some(parameter1,\n"
14076                    "<<<<<<< text by the vcs\n"
14077                    "  parameter2),\n"
14078                    "||||||| text by the vcs\n"
14079                    "  parameter2),\n"
14080                    "  parameter3,\n"
14081                    "======= text by the vcs\n"
14082                    "  parameter2,\n"
14083                    "  parameter3),\n"
14084                    ">>>>>>> text by the vcs\n"
14085                    "  otherparameter);\n"));
14086 
14087   // Perforce markers.
14088   EXPECT_EQ("void f() {\n"
14089             "  function(\n"
14090             ">>>> text by the vcs\n"
14091             "      parameter,\n"
14092             "==== text by the vcs\n"
14093             "      parameter,\n"
14094             "==== text by the vcs\n"
14095             "      parameter,\n"
14096             "<<<< text by the vcs\n"
14097             "      parameter);\n",
14098             format("void f() {\n"
14099                    "  function(\n"
14100                    ">>>> text by the vcs\n"
14101                    "  parameter,\n"
14102                    "==== text by the vcs\n"
14103                    "  parameter,\n"
14104                    "==== text by the vcs\n"
14105                    "  parameter,\n"
14106                    "<<<< text by the vcs\n"
14107                    "  parameter);\n"));
14108 
14109   EXPECT_EQ("<<<<<<<\n"
14110             "|||||||\n"
14111             "=======\n"
14112             ">>>>>>>",
14113             format("<<<<<<<\n"
14114                    "|||||||\n"
14115                    "=======\n"
14116                    ">>>>>>>"));
14117 
14118   EXPECT_EQ("<<<<<<<\n"
14119             "|||||||\n"
14120             "int i;\n"
14121             "=======\n"
14122             ">>>>>>>",
14123             format("<<<<<<<\n"
14124                    "|||||||\n"
14125                    "int i;\n"
14126                    "=======\n"
14127                    ">>>>>>>"));
14128 
14129   // FIXME: Handle parsing of macros around conflict markers correctly:
14130   EXPECT_EQ("#define Macro \\\n"
14131             "<<<<<<<\n"
14132             "Something \\\n"
14133             "|||||||\n"
14134             "Else \\\n"
14135             "=======\n"
14136             "Other \\\n"
14137             ">>>>>>>\n"
14138             "    End int i;\n",
14139             format("#define Macro \\\n"
14140                    "<<<<<<<\n"
14141                    "  Something \\\n"
14142                    "|||||||\n"
14143                    "  Else \\\n"
14144                    "=======\n"
14145                    "  Other \\\n"
14146                    ">>>>>>>\n"
14147                    "  End\n"
14148                    "int i;\n"));
14149 }
14150 
14151 TEST_F(FormatTest, DisableRegions) {
14152   EXPECT_EQ("int i;\n"
14153             "// clang-format off\n"
14154             "  int j;\n"
14155             "// clang-format on\n"
14156             "int k;",
14157             format(" int  i;\n"
14158                    "   // clang-format off\n"
14159                    "  int j;\n"
14160                    " // clang-format on\n"
14161                    "   int   k;"));
14162   EXPECT_EQ("int i;\n"
14163             "/* clang-format off */\n"
14164             "  int j;\n"
14165             "/* clang-format on */\n"
14166             "int k;",
14167             format(" int  i;\n"
14168                    "   /* clang-format off */\n"
14169                    "  int j;\n"
14170                    " /* clang-format on */\n"
14171                    "   int   k;"));
14172 
14173   // Don't reflow comments within disabled regions.
14174   EXPECT_EQ("// clang-format off\n"
14175             "// long long long long long long line\n"
14176             "/* clang-format on */\n"
14177             "/* long long long\n"
14178             " * long long long\n"
14179             " * line */\n"
14180             "int i;\n"
14181             "/* clang-format off */\n"
14182             "/* long long long long long long line */\n",
14183             format("// clang-format off\n"
14184                    "// long long long long long long line\n"
14185                    "/* clang-format on */\n"
14186                    "/* long long long long long long line */\n"
14187                    "int i;\n"
14188                    "/* clang-format off */\n"
14189                    "/* long long long long long long line */\n",
14190                    getLLVMStyleWithColumns(20)));
14191 }
14192 
14193 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
14194   format("? ) =");
14195   verifyNoCrash("#define a\\\n /**/}");
14196 }
14197 
14198 TEST_F(FormatTest, FormatsTableGenCode) {
14199   FormatStyle Style = getLLVMStyle();
14200   Style.Language = FormatStyle::LK_TableGen;
14201   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
14202 }
14203 
14204 TEST_F(FormatTest, ArrayOfTemplates) {
14205   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
14206             format("auto a = new unique_ptr<int > [ 10];"));
14207 
14208   FormatStyle Spaces = getLLVMStyle();
14209   Spaces.SpacesInSquareBrackets = true;
14210   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
14211             format("auto a = new unique_ptr<int > [10];", Spaces));
14212 }
14213 
14214 TEST_F(FormatTest, ArrayAsTemplateType) {
14215   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
14216             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
14217 
14218   FormatStyle Spaces = getLLVMStyle();
14219   Spaces.SpacesInSquareBrackets = true;
14220   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
14221             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
14222 }
14223 
14224 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
14225 
14226 TEST(FormatStyle, GetStyleWithEmptyFileName) {
14227   llvm::vfs::InMemoryFileSystem FS;
14228   auto Style1 = getStyle("file", "", "Google", "", &FS);
14229   ASSERT_TRUE((bool)Style1);
14230   ASSERT_EQ(*Style1, getGoogleStyle());
14231 }
14232 
14233 TEST(FormatStyle, GetStyleOfFile) {
14234   llvm::vfs::InMemoryFileSystem FS;
14235   // Test 1: format file in the same directory.
14236   ASSERT_TRUE(
14237       FS.addFile("/a/.clang-format", 0,
14238                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
14239   ASSERT_TRUE(
14240       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
14241   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
14242   ASSERT_TRUE((bool)Style1);
14243   ASSERT_EQ(*Style1, getLLVMStyle());
14244 
14245   // Test 2.1: fallback to default.
14246   ASSERT_TRUE(
14247       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
14248   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
14249   ASSERT_TRUE((bool)Style2);
14250   ASSERT_EQ(*Style2, getMozillaStyle());
14251 
14252   // Test 2.2: no format on 'none' fallback style.
14253   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
14254   ASSERT_TRUE((bool)Style2);
14255   ASSERT_EQ(*Style2, getNoStyle());
14256 
14257   // Test 2.3: format if config is found with no based style while fallback is
14258   // 'none'.
14259   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
14260                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
14261   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
14262   ASSERT_TRUE((bool)Style2);
14263   ASSERT_EQ(*Style2, getLLVMStyle());
14264 
14265   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
14266   Style2 = getStyle("{}", "a.h", "none", "", &FS);
14267   ASSERT_TRUE((bool)Style2);
14268   ASSERT_EQ(*Style2, getLLVMStyle());
14269 
14270   // Test 3: format file in parent directory.
14271   ASSERT_TRUE(
14272       FS.addFile("/c/.clang-format", 0,
14273                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
14274   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
14275                          llvm::MemoryBuffer::getMemBuffer("int i;")));
14276   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
14277   ASSERT_TRUE((bool)Style3);
14278   ASSERT_EQ(*Style3, getGoogleStyle());
14279 
14280   // Test 4: error on invalid fallback style
14281   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
14282   ASSERT_FALSE((bool)Style4);
14283   llvm::consumeError(Style4.takeError());
14284 
14285   // Test 5: error on invalid yaml on command line
14286   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
14287   ASSERT_FALSE((bool)Style5);
14288   llvm::consumeError(Style5.takeError());
14289 
14290   // Test 6: error on invalid style
14291   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
14292   ASSERT_FALSE((bool)Style6);
14293   llvm::consumeError(Style6.takeError());
14294 
14295   // Test 7: found config file, error on parsing it
14296   ASSERT_TRUE(
14297       FS.addFile("/d/.clang-format", 0,
14298                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
14299                                                   "InvalidKey: InvalidValue")));
14300   ASSERT_TRUE(
14301       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
14302   auto Style7 = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
14303   ASSERT_FALSE((bool)Style7);
14304   llvm::consumeError(Style7.takeError());
14305 
14306   // Test 8: inferred per-language defaults apply.
14307   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
14308   ASSERT_TRUE((bool)StyleTd);
14309   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
14310 }
14311 
14312 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
14313   // Column limit is 20.
14314   std::string Code = "Type *a =\n"
14315                      "    new Type();\n"
14316                      "g(iiiii, 0, jjjjj,\n"
14317                      "  0, kkkkk, 0, mm);\n"
14318                      "int  bad     = format   ;";
14319   std::string Expected = "auto a = new Type();\n"
14320                          "g(iiiii, nullptr,\n"
14321                          "  jjjjj, nullptr,\n"
14322                          "  kkkkk, nullptr,\n"
14323                          "  mm);\n"
14324                          "int  bad     = format   ;";
14325   FileID ID = Context.createInMemoryFile("format.cpp", Code);
14326   tooling::Replacements Replaces = toReplacements(
14327       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
14328                             "auto "),
14329        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
14330                             "nullptr"),
14331        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
14332                             "nullptr"),
14333        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
14334                             "nullptr")});
14335 
14336   format::FormatStyle Style = format::getLLVMStyle();
14337   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
14338   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
14339   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
14340       << llvm::toString(FormattedReplaces.takeError()) << "\n";
14341   auto Result = applyAllReplacements(Code, *FormattedReplaces);
14342   EXPECT_TRUE(static_cast<bool>(Result));
14343   EXPECT_EQ(Expected, *Result);
14344 }
14345 
14346 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
14347   std::string Code = "#include \"a.h\"\n"
14348                      "#include \"c.h\"\n"
14349                      "\n"
14350                      "int main() {\n"
14351                      "  return 0;\n"
14352                      "}";
14353   std::string Expected = "#include \"a.h\"\n"
14354                          "#include \"b.h\"\n"
14355                          "#include \"c.h\"\n"
14356                          "\n"
14357                          "int main() {\n"
14358                          "  return 0;\n"
14359                          "}";
14360   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
14361   tooling::Replacements Replaces = toReplacements(
14362       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
14363                             "#include \"b.h\"\n")});
14364 
14365   format::FormatStyle Style = format::getLLVMStyle();
14366   Style.SortIncludes = true;
14367   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
14368   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
14369       << llvm::toString(FormattedReplaces.takeError()) << "\n";
14370   auto Result = applyAllReplacements(Code, *FormattedReplaces);
14371   EXPECT_TRUE(static_cast<bool>(Result));
14372   EXPECT_EQ(Expected, *Result);
14373 }
14374 
14375 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
14376   EXPECT_EQ("using std::cin;\n"
14377             "using std::cout;",
14378             format("using std::cout;\n"
14379                    "using std::cin;",
14380                    getGoogleStyle()));
14381 }
14382 
14383 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
14384   format::FormatStyle Style = format::getLLVMStyle();
14385   Style.Standard = FormatStyle::LS_Cpp03;
14386   // cpp03 recognize this string as identifier u8 and literal character 'a'
14387   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
14388 }
14389 
14390 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
14391   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
14392   // all modes, including C++11, C++14 and C++17
14393   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
14394 }
14395 
14396 TEST_F(FormatTest, DoNotFormatLikelyXml) {
14397   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
14398   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
14399 }
14400 
14401 TEST_F(FormatTest, StructuredBindings) {
14402   // Structured bindings is a C++17 feature.
14403   // all modes, including C++11, C++14 and C++17
14404   verifyFormat("auto [a, b] = f();");
14405   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
14406   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
14407   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
14408   EXPECT_EQ("auto const volatile [a, b] = f();",
14409             format("auto  const   volatile[a, b] = f();"));
14410   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
14411   EXPECT_EQ("auto &[a, b, c] = f();",
14412             format("auto   &[  a  ,  b,c   ] = f();"));
14413   EXPECT_EQ("auto &&[a, b, c] = f();",
14414             format("auto   &&[  a  ,  b,c   ] = f();"));
14415   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
14416   EXPECT_EQ("auto const volatile &&[a, b] = f();",
14417             format("auto  const  volatile  &&[a, b] = f();"));
14418   EXPECT_EQ("auto const &&[a, b] = f();",
14419             format("auto  const   &&  [a, b] = f();"));
14420   EXPECT_EQ("const auto &[a, b] = f();",
14421             format("const  auto  &  [a, b] = f();"));
14422   EXPECT_EQ("const auto volatile &&[a, b] = f();",
14423             format("const  auto   volatile  &&[a, b] = f();"));
14424   EXPECT_EQ("volatile const auto &&[a, b] = f();",
14425             format("volatile  const  auto   &&[a, b] = f();"));
14426   EXPECT_EQ("const auto &&[a, b] = f();",
14427             format("const  auto  &&  [a, b] = f();"));
14428 
14429   // Make sure we don't mistake structured bindings for lambdas.
14430   FormatStyle PointerMiddle = getLLVMStyle();
14431   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
14432   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
14433   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
14434   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
14435   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
14436   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
14437   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
14438   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
14439   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
14440   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
14441   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
14442   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
14443   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
14444 
14445   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
14446             format("for (const auto   &&   [a, b] : some_range) {\n}"));
14447   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
14448             format("for (const auto   &   [a, b] : some_range) {\n}"));
14449   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
14450             format("for (const auto[a, b] : some_range) {\n}"));
14451   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
14452   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
14453   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
14454   EXPECT_EQ("auto const &[x, y](expr);",
14455             format("auto  const  &  [x,y]  (expr);"));
14456   EXPECT_EQ("auto const &&[x, y](expr);",
14457             format("auto  const  &&  [x,y]  (expr);"));
14458   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
14459   EXPECT_EQ("auto const &[x, y]{expr};",
14460             format("auto  const  &  [x,y]  {expr};"));
14461   EXPECT_EQ("auto const &&[x, y]{expr};",
14462             format("auto  const  &&  [x,y]  {expr};"));
14463 
14464   format::FormatStyle Spaces = format::getLLVMStyle();
14465   Spaces.SpacesInSquareBrackets = true;
14466   verifyFormat("auto [ a, b ] = f();", Spaces);
14467   verifyFormat("auto &&[ a, b ] = f();", Spaces);
14468   verifyFormat("auto &[ a, b ] = f();", Spaces);
14469   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
14470   verifyFormat("auto const &[ a, b ] = f();", Spaces);
14471 }
14472 
14473 TEST_F(FormatTest, FileAndCode) {
14474   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
14475   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
14476   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
14477   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
14478   EXPECT_EQ(FormatStyle::LK_ObjC,
14479             guessLanguage("foo.h", "@interface Foo\n@end\n"));
14480   EXPECT_EQ(
14481       FormatStyle::LK_ObjC,
14482       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
14483   EXPECT_EQ(FormatStyle::LK_ObjC,
14484             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
14485   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
14486   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
14487   EXPECT_EQ(FormatStyle::LK_ObjC,
14488             guessLanguage("foo", "@interface Foo\n@end\n"));
14489   EXPECT_EQ(FormatStyle::LK_ObjC,
14490             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
14491   EXPECT_EQ(
14492       FormatStyle::LK_ObjC,
14493       guessLanguage("foo.h",
14494                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
14495   EXPECT_EQ(
14496       FormatStyle::LK_Cpp,
14497       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
14498 }
14499 
14500 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
14501   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
14502   EXPECT_EQ(FormatStyle::LK_ObjC,
14503             guessLanguage("foo.h", "array[[calculator getIndex]];"));
14504   EXPECT_EQ(FormatStyle::LK_Cpp,
14505             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
14506   EXPECT_EQ(
14507       FormatStyle::LK_Cpp,
14508       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
14509   EXPECT_EQ(FormatStyle::LK_ObjC,
14510             guessLanguage("foo.h", "[[noreturn foo] bar];"));
14511   EXPECT_EQ(FormatStyle::LK_Cpp,
14512             guessLanguage("foo.h", "[[clang::fallthrough]];"));
14513   EXPECT_EQ(FormatStyle::LK_ObjC,
14514             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
14515   EXPECT_EQ(FormatStyle::LK_Cpp,
14516             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
14517   EXPECT_EQ(FormatStyle::LK_Cpp,
14518             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
14519   EXPECT_EQ(FormatStyle::LK_ObjC,
14520             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
14521   EXPECT_EQ(FormatStyle::LK_Cpp,
14522             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
14523   EXPECT_EQ(
14524       FormatStyle::LK_Cpp,
14525       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
14526   EXPECT_EQ(
14527       FormatStyle::LK_Cpp,
14528       guessLanguage("foo.h",
14529                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
14530   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
14531 }
14532 
14533 TEST_F(FormatTest, GuessLanguageWithCaret) {
14534   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
14535   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
14536   EXPECT_EQ(FormatStyle::LK_ObjC,
14537             guessLanguage("foo.h", "int(^)(char, float);"));
14538   EXPECT_EQ(FormatStyle::LK_ObjC,
14539             guessLanguage("foo.h", "int(^foo)(char, float);"));
14540   EXPECT_EQ(FormatStyle::LK_ObjC,
14541             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
14542   EXPECT_EQ(FormatStyle::LK_ObjC,
14543             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
14544   EXPECT_EQ(
14545       FormatStyle::LK_ObjC,
14546       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
14547 }
14548 
14549 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
14550   EXPECT_EQ(FormatStyle::LK_Cpp,
14551             guessLanguage("foo.h", "void f() {\n"
14552                                    "  asm (\"mov %[e], %[d]\"\n"
14553                                    "     : [d] \"=rm\" (d)\n"
14554                                    "       [e] \"rm\" (*e));\n"
14555                                    "}"));
14556   EXPECT_EQ(FormatStyle::LK_Cpp,
14557             guessLanguage("foo.h", "void f() {\n"
14558                                    "  _asm (\"mov %[e], %[d]\"\n"
14559                                    "     : [d] \"=rm\" (d)\n"
14560                                    "       [e] \"rm\" (*e));\n"
14561                                    "}"));
14562   EXPECT_EQ(FormatStyle::LK_Cpp,
14563             guessLanguage("foo.h", "void f() {\n"
14564                                    "  __asm (\"mov %[e], %[d]\"\n"
14565                                    "     : [d] \"=rm\" (d)\n"
14566                                    "       [e] \"rm\" (*e));\n"
14567                                    "}"));
14568   EXPECT_EQ(FormatStyle::LK_Cpp,
14569             guessLanguage("foo.h", "void f() {\n"
14570                                    "  __asm__ (\"mov %[e], %[d]\"\n"
14571                                    "     : [d] \"=rm\" (d)\n"
14572                                    "       [e] \"rm\" (*e));\n"
14573                                    "}"));
14574   EXPECT_EQ(FormatStyle::LK_Cpp,
14575             guessLanguage("foo.h", "void f() {\n"
14576                                    "  asm (\"mov %[e], %[d]\"\n"
14577                                    "     : [d] \"=rm\" (d),\n"
14578                                    "       [e] \"rm\" (*e));\n"
14579                                    "}"));
14580   EXPECT_EQ(FormatStyle::LK_Cpp,
14581             guessLanguage("foo.h", "void f() {\n"
14582                                    "  asm volatile (\"mov %[e], %[d]\"\n"
14583                                    "     : [d] \"=rm\" (d)\n"
14584                                    "       [e] \"rm\" (*e));\n"
14585                                    "}"));
14586 }
14587 
14588 TEST_F(FormatTest, GuessLanguageWithChildLines) {
14589   EXPECT_EQ(FormatStyle::LK_Cpp,
14590             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
14591   EXPECT_EQ(FormatStyle::LK_ObjC,
14592             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
14593   EXPECT_EQ(
14594       FormatStyle::LK_Cpp,
14595       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
14596   EXPECT_EQ(
14597       FormatStyle::LK_ObjC,
14598       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
14599 }
14600 
14601 TEST_F(FormatTest, TypenameMacros) {
14602   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
14603 
14604   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
14605   FormatStyle Google = getGoogleStyleWithColumns(0);
14606   Google.TypenameMacros = TypenameMacros;
14607   verifyFormat("struct foo {\n"
14608                "  int bar;\n"
14609                "  TAILQ_ENTRY(a) bleh;\n"
14610                "};",
14611                Google);
14612 
14613   FormatStyle Macros = getLLVMStyle();
14614   Macros.TypenameMacros = TypenameMacros;
14615 
14616   verifyFormat("STACK_OF(int) a;", Macros);
14617   verifyFormat("STACK_OF(int) *a;", Macros);
14618   verifyFormat("STACK_OF(int const *) *a;", Macros);
14619   verifyFormat("STACK_OF(int *const) *a;", Macros);
14620   verifyFormat("STACK_OF(int, string) a;", Macros);
14621   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
14622   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
14623   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
14624   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
14625 
14626   Macros.PointerAlignment = FormatStyle::PAS_Left;
14627   verifyFormat("STACK_OF(int)* a;", Macros);
14628   verifyFormat("STACK_OF(int*)* a;", Macros);
14629 }
14630 
14631 TEST_F(FormatTest, AmbersandInLamda) {
14632   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
14633   FormatStyle AlignStyle = getLLVMStyle();
14634   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
14635   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
14636   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
14637   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
14638 }
14639 
14640 TEST_F(FormatTest, AlternativeOperators) {
14641   // Test case for ensuring alternate operators are not
14642   // combined with their right most neighbour.
14643   verifyFormat("int a and b;");
14644   verifyFormat("int a and_eq b;");
14645   verifyFormat("int a bitand b;");
14646   verifyFormat("int a bitor b;");
14647   verifyFormat("int a compl b;");
14648   verifyFormat("int a not b;");
14649   verifyFormat("int a not_eq b;");
14650   verifyFormat("int a or b;");
14651   verifyFormat("int a xor b;");
14652   verifyFormat("int a xor_eq b;");
14653   verifyFormat("return this not_eq bitand other;");
14654   verifyFormat("bool operator not_eq(const X bitand other)");
14655 
14656   verifyFormat("int a and 5;");
14657   verifyFormat("int a and_eq 5;");
14658   verifyFormat("int a bitand 5;");
14659   verifyFormat("int a bitor 5;");
14660   verifyFormat("int a compl 5;");
14661   verifyFormat("int a not 5;");
14662   verifyFormat("int a not_eq 5;");
14663   verifyFormat("int a or 5;");
14664   verifyFormat("int a xor 5;");
14665   verifyFormat("int a xor_eq 5;");
14666 
14667   verifyFormat("int a compl(5);");
14668   verifyFormat("int a not(5);");
14669 
14670   /* FIXME handle alternate tokens
14671    * https://en.cppreference.com/w/cpp/language/operator_alternative
14672   // alternative tokens
14673   verifyFormat("compl foo();");     //  ~foo();
14674   verifyFormat("foo() <%%>;");      // foo();
14675   verifyFormat("void foo() <%%>;"); // void foo(){}
14676   verifyFormat("int a <:1:>;");     // int a[1];[
14677   verifyFormat("%:define ABC abc"); // #define ABC abc
14678   verifyFormat("%:%:");             // ##
14679   */
14680 }
14681 
14682 } // end namespace
14683 } // end namespace format
14684 } // end namespace clang
14685