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 "llvm/Support/Debug.h"
15 #include "llvm/Support/MemoryBuffer.h"
16 #include "gtest/gtest.h"
17 
18 #define DEBUG_TYPE "format-test"
19 
20 using clang::tooling::ReplacementTest;
21 using clang::tooling::toReplacements;
22 using testing::internal::ScopedTrace;
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(const char *File, int Line, llvm::StringRef Expected,
69                      llvm::StringRef Code,
70                      const FormatStyle &Style = getLLVMStyle()) {
71     ScopedTrace t(File, Line, ::testing::Message() << Code.str());
72     EXPECT_EQ(Expected.str(), format(Expected, Style))
73         << "Expected code is not stable";
74     EXPECT_EQ(Expected.str(), format(Code, Style));
75     if (Style.Language == FormatStyle::LK_Cpp) {
76       // Objective-C++ is a superset of C++, so everything checked for C++
77       // needs to be checked for Objective-C++ as well.
78       FormatStyle ObjCStyle = Style;
79       ObjCStyle.Language = FormatStyle::LK_ObjC;
80       EXPECT_EQ(Expected.str(), format(test::messUp(Code), ObjCStyle));
81     }
82   }
83 
84   void _verifyFormat(const char *File, int Line, llvm::StringRef Code,
85                      const FormatStyle &Style = getLLVMStyle()) {
86     _verifyFormat(File, Line, Code, test::messUp(Code), Style);
87   }
88 
89   void _verifyIncompleteFormat(const char *File, int Line, llvm::StringRef Code,
90                                const FormatStyle &Style = getLLVMStyle()) {
91     ScopedTrace t(File, Line, ::testing::Message() << Code.str());
92     EXPECT_EQ(Code.str(),
93               format(test::messUp(Code), Style, SC_ExpectIncomplete));
94   }
95 
96   void _verifyIndependentOfContext(const char *File, int Line,
97                                    llvm::StringRef Text,
98                                    const FormatStyle &Style = getLLVMStyle()) {
99     _verifyFormat(File, Line, Text, Style);
100     _verifyFormat(File, Line, llvm::Twine("void f() { " + Text + " }").str(),
101                   Style);
102   }
103 
104   /// \brief Verify that clang-format does not crash on the given input.
105   void verifyNoCrash(llvm::StringRef Code,
106                      const FormatStyle &Style = getLLVMStyle()) {
107     format(Code, Style, SC_DoNotCheck);
108   }
109 
110   int ReplacementCount;
111 };
112 
113 #define verifyIndependentOfContext(...)                                        \
114   _verifyIndependentOfContext(__FILE__, __LINE__, __VA_ARGS__)
115 #define verifyIncompleteFormat(...)                                            \
116   _verifyIncompleteFormat(__FILE__, __LINE__, __VA_ARGS__)
117 #define verifyFormat(...) _verifyFormat(__FILE__, __LINE__, __VA_ARGS__)
118 #define verifyGoogleFormat(Code) verifyFormat(Code, getGoogleStyle())
119 
120 TEST_F(FormatTest, MessUp) {
121   EXPECT_EQ("1 2 3", test::messUp("1 2 3"));
122   EXPECT_EQ("1 2 3\n", test::messUp("1\n2\n3\n"));
123   EXPECT_EQ("a\n//b\nc", test::messUp("a\n//b\nc"));
124   EXPECT_EQ("a\n#b\nc", test::messUp("a\n#b\nc"));
125   EXPECT_EQ("a\n#b c d\ne", test::messUp("a\n#b\\\nc\\\nd\ne"));
126 }
127 
128 TEST_F(FormatTest, DefaultLLVMStyleIsCpp) {
129   EXPECT_EQ(FormatStyle::LK_Cpp, getLLVMStyle().Language);
130 }
131 
132 TEST_F(FormatTest, LLVMStyleOverride) {
133   EXPECT_EQ(FormatStyle::LK_Proto,
134             getLLVMStyle(FormatStyle::LK_Proto).Language);
135 }
136 
137 //===----------------------------------------------------------------------===//
138 // Basic function tests.
139 //===----------------------------------------------------------------------===//
140 
141 TEST_F(FormatTest, DoesNotChangeCorrectlyFormattedCode) {
142   EXPECT_EQ(";", format(";"));
143 }
144 
145 TEST_F(FormatTest, FormatsGlobalStatementsAt0) {
146   EXPECT_EQ("int i;", format("  int i;"));
147   EXPECT_EQ("\nint i;", format(" \n\t \v \f  int i;"));
148   EXPECT_EQ("int i;\nint j;", format("    int i; int j;"));
149   EXPECT_EQ("int i;\nint j;", format("    int i;\n  int j;"));
150 }
151 
152 TEST_F(FormatTest, FormatsUnwrappedLinesAtFirstFormat) {
153   EXPECT_EQ("int i;", format("int\ni;"));
154 }
155 
156 TEST_F(FormatTest, FormatsNestedBlockStatements) {
157   EXPECT_EQ("{\n  {\n    {}\n  }\n}", format("{{{}}}"));
158 }
159 
160 TEST_F(FormatTest, FormatsNestedCall) {
161   verifyFormat("Method(f1, f2(f3));");
162   verifyFormat("Method(f1(f2, f3()));");
163   verifyFormat("Method(f1(f2, (f3())));");
164 }
165 
166 TEST_F(FormatTest, NestedNameSpecifiers) {
167   verifyFormat("vector<::Type> v;");
168   verifyFormat("::ns::SomeFunction(::ns::SomeOtherFunction())");
169   verifyFormat("static constexpr bool Bar = decltype(bar())::value;");
170   verifyFormat("static constexpr bool Bar = typeof(bar())::value;");
171   verifyFormat("static constexpr bool Bar = __underlying_type(bar())::value;");
172   verifyFormat("static constexpr bool Bar = _Atomic(bar())::value;");
173   verifyFormat("bool a = 2 < ::SomeFunction();");
174   verifyFormat("ALWAYS_INLINE ::std::string getName();");
175   verifyFormat("some::string getName();");
176 }
177 
178 TEST_F(FormatTest, OnlyGeneratesNecessaryReplacements) {
179   EXPECT_EQ("if (a) {\n"
180             "  f();\n"
181             "}",
182             format("if(a){f();}"));
183   EXPECT_EQ(4, ReplacementCount);
184   EXPECT_EQ("if (a) {\n"
185             "  f();\n"
186             "}",
187             format("if (a) {\n"
188                    "  f();\n"
189                    "}"));
190   EXPECT_EQ(0, ReplacementCount);
191   EXPECT_EQ("/*\r\n"
192             "\r\n"
193             "*/\r\n",
194             format("/*\r\n"
195                    "\r\n"
196                    "*/\r\n"));
197   EXPECT_EQ(0, ReplacementCount);
198 }
199 
200 TEST_F(FormatTest, RemovesEmptyLines) {
201   EXPECT_EQ("class C {\n"
202             "  int i;\n"
203             "};",
204             format("class C {\n"
205                    " int i;\n"
206                    "\n"
207                    "};"));
208 
209   // Don't remove empty lines at the start of namespaces or extern "C" blocks.
210   EXPECT_EQ("namespace N {\n"
211             "\n"
212             "int i;\n"
213             "}",
214             format("namespace N {\n"
215                    "\n"
216                    "int    i;\n"
217                    "}",
218                    getGoogleStyle()));
219   EXPECT_EQ("/* something */ namespace N {\n"
220             "\n"
221             "int i;\n"
222             "}",
223             format("/* something */ namespace N {\n"
224                    "\n"
225                    "int    i;\n"
226                    "}",
227                    getGoogleStyle()));
228   EXPECT_EQ("inline namespace N {\n"
229             "\n"
230             "int i;\n"
231             "}",
232             format("inline namespace N {\n"
233                    "\n"
234                    "int    i;\n"
235                    "}",
236                    getGoogleStyle()));
237   EXPECT_EQ("/* something */ inline namespace N {\n"
238             "\n"
239             "int i;\n"
240             "}",
241             format("/* something */ inline namespace N {\n"
242                    "\n"
243                    "int    i;\n"
244                    "}",
245                    getGoogleStyle()));
246   EXPECT_EQ("export namespace N {\n"
247             "\n"
248             "int i;\n"
249             "}",
250             format("export namespace N {\n"
251                    "\n"
252                    "int    i;\n"
253                    "}",
254                    getGoogleStyle()));
255   EXPECT_EQ("extern /**/ \"C\" /**/ {\n"
256             "\n"
257             "int i;\n"
258             "}",
259             format("extern /**/ \"C\" /**/ {\n"
260                    "\n"
261                    "int    i;\n"
262                    "}",
263                    getGoogleStyle()));
264 
265   // ...but do keep inlining and removing empty lines for non-block extern "C"
266   // functions.
267   verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
268   EXPECT_EQ("extern \"C\" int f() {\n"
269             "  int i = 42;\n"
270             "  return i;\n"
271             "}",
272             format("extern \"C\" int f() {\n"
273                    "\n"
274                    "  int i = 42;\n"
275                    "  return i;\n"
276                    "}",
277                    getGoogleStyle()));
278 
279   // Remove empty lines at the beginning and end of blocks.
280   EXPECT_EQ("void f() {\n"
281             "\n"
282             "  if (a) {\n"
283             "\n"
284             "    f();\n"
285             "  }\n"
286             "}",
287             format("void f() {\n"
288                    "\n"
289                    "  if (a) {\n"
290                    "\n"
291                    "    f();\n"
292                    "\n"
293                    "  }\n"
294                    "\n"
295                    "}",
296                    getLLVMStyle()));
297   EXPECT_EQ("void f() {\n"
298             "  if (a) {\n"
299             "    f();\n"
300             "  }\n"
301             "}",
302             format("void f() {\n"
303                    "\n"
304                    "  if (a) {\n"
305                    "\n"
306                    "    f();\n"
307                    "\n"
308                    "  }\n"
309                    "\n"
310                    "}",
311                    getGoogleStyle()));
312 
313   // Don't remove empty lines in more complex control statements.
314   EXPECT_EQ("void f() {\n"
315             "  if (a) {\n"
316             "    f();\n"
317             "\n"
318             "  } else if (b) {\n"
319             "    f();\n"
320             "  }\n"
321             "}",
322             format("void f() {\n"
323                    "  if (a) {\n"
324                    "    f();\n"
325                    "\n"
326                    "  } else if (b) {\n"
327                    "    f();\n"
328                    "\n"
329                    "  }\n"
330                    "\n"
331                    "}"));
332 
333   // Don't remove empty lines before namespace endings.
334   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
335   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
336   EXPECT_EQ("namespace {\n"
337             "int i;\n"
338             "\n"
339             "}",
340             format("namespace {\n"
341                    "int i;\n"
342                    "\n"
343                    "}",
344                    LLVMWithNoNamespaceFix));
345   EXPECT_EQ("namespace {\n"
346             "int i;\n"
347             "}",
348             format("namespace {\n"
349                    "int i;\n"
350                    "}",
351                    LLVMWithNoNamespaceFix));
352   EXPECT_EQ("namespace {\n"
353             "int i;\n"
354             "\n"
355             "};",
356             format("namespace {\n"
357                    "int i;\n"
358                    "\n"
359                    "};",
360                    LLVMWithNoNamespaceFix));
361   EXPECT_EQ("namespace {\n"
362             "int i;\n"
363             "};",
364             format("namespace {\n"
365                    "int i;\n"
366                    "};",
367                    LLVMWithNoNamespaceFix));
368   EXPECT_EQ("namespace {\n"
369             "int i;\n"
370             "\n"
371             "}",
372             format("namespace {\n"
373                    "int i;\n"
374                    "\n"
375                    "}"));
376   EXPECT_EQ("namespace {\n"
377             "int i;\n"
378             "\n"
379             "} // namespace",
380             format("namespace {\n"
381                    "int i;\n"
382                    "\n"
383                    "}  // namespace"));
384 
385   FormatStyle Style = getLLVMStyle();
386   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
387   Style.MaxEmptyLinesToKeep = 2;
388   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
389   Style.BraceWrapping.AfterClass = true;
390   Style.BraceWrapping.AfterFunction = true;
391   Style.KeepEmptyLinesAtTheStartOfBlocks = false;
392 
393   EXPECT_EQ("class Foo\n"
394             "{\n"
395             "  Foo() {}\n"
396             "\n"
397             "  void funk() {}\n"
398             "};",
399             format("class Foo\n"
400                    "{\n"
401                    "  Foo()\n"
402                    "  {\n"
403                    "  }\n"
404                    "\n"
405                    "  void funk() {}\n"
406                    "};",
407                    Style));
408 }
409 
410 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
411   verifyFormat("x = (a) and (b);");
412   verifyFormat("x = (a) or (b);");
413   verifyFormat("x = (a) bitand (b);");
414   verifyFormat("x = (a) bitor (b);");
415   verifyFormat("x = (a) not_eq (b);");
416   verifyFormat("x = (a) and_eq (b);");
417   verifyFormat("x = (a) or_eq (b);");
418   verifyFormat("x = (a) xor (b);");
419 }
420 
421 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) {
422   verifyFormat("x = compl(a);");
423   verifyFormat("x = not(a);");
424   verifyFormat("x = bitand(a);");
425   // Unary operator must not be merged with the next identifier
426   verifyFormat("x = compl a;");
427   verifyFormat("x = not a;");
428   verifyFormat("x = bitand a;");
429 }
430 
431 //===----------------------------------------------------------------------===//
432 // Tests for control statements.
433 //===----------------------------------------------------------------------===//
434 
435 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
436   verifyFormat("if (true)\n  f();\ng();");
437   verifyFormat("if (a)\n  if (b)\n    if (c)\n      g();\nh();");
438   verifyFormat("if (a)\n  if (b) {\n    f();\n  }\ng();");
439   verifyFormat("if constexpr (true)\n"
440                "  f();\ng();");
441   verifyFormat("if CONSTEXPR (true)\n"
442                "  f();\ng();");
443   verifyFormat("if constexpr (a)\n"
444                "  if constexpr (b)\n"
445                "    if constexpr (c)\n"
446                "      g();\n"
447                "h();");
448   verifyFormat("if CONSTEXPR (a)\n"
449                "  if CONSTEXPR (b)\n"
450                "    if CONSTEXPR (c)\n"
451                "      g();\n"
452                "h();");
453   verifyFormat("if constexpr (a)\n"
454                "  if constexpr (b) {\n"
455                "    f();\n"
456                "  }\n"
457                "g();");
458   verifyFormat("if CONSTEXPR (a)\n"
459                "  if CONSTEXPR (b) {\n"
460                "    f();\n"
461                "  }\n"
462                "g();");
463 
464   FormatStyle AllowsMergedIf = getLLVMStyle();
465   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
466   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
467       FormatStyle::SIS_WithoutElse;
468   verifyFormat("if (a)\n"
469                "  // comment\n"
470                "  f();",
471                AllowsMergedIf);
472   verifyFormat("{\n"
473                "  if (a)\n"
474                "  label:\n"
475                "    f();\n"
476                "}",
477                AllowsMergedIf);
478   verifyFormat("#define A \\\n"
479                "  if (a)  \\\n"
480                "  label:  \\\n"
481                "    f()",
482                AllowsMergedIf);
483   verifyFormat("if (a)\n"
484                "  ;",
485                AllowsMergedIf);
486   verifyFormat("if (a)\n"
487                "  if (b) return;",
488                AllowsMergedIf);
489 
490   verifyFormat("if (a) // Can't merge this\n"
491                "  f();\n",
492                AllowsMergedIf);
493   verifyFormat("if (a) /* still don't merge */\n"
494                "  f();",
495                AllowsMergedIf);
496   verifyFormat("if (a) { // Never merge this\n"
497                "  f();\n"
498                "}",
499                AllowsMergedIf);
500   verifyFormat("if (a) { /* Never merge this */\n"
501                "  f();\n"
502                "}",
503                AllowsMergedIf);
504 
505   AllowsMergedIf.ColumnLimit = 14;
506   verifyFormat("if (a) return;", AllowsMergedIf);
507   verifyFormat("if (aaaaaaaaa)\n"
508                "  return;",
509                AllowsMergedIf);
510 
511   AllowsMergedIf.ColumnLimit = 13;
512   verifyFormat("if (a)\n  return;", AllowsMergedIf);
513 }
514 
515 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) {
516   FormatStyle AllowsMergedIf = getLLVMStyle();
517   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
518   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
519       FormatStyle::SIS_WithoutElse;
520   verifyFormat("if (a)\n"
521                "  f();\n"
522                "else {\n"
523                "  g();\n"
524                "}",
525                AllowsMergedIf);
526   verifyFormat("if (a)\n"
527                "  f();\n"
528                "else\n"
529                "  g();\n",
530                AllowsMergedIf);
531 
532   AllowsMergedIf.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
533 
534   verifyFormat("if (a) f();\n"
535                "else {\n"
536                "  g();\n"
537                "}",
538                AllowsMergedIf);
539   verifyFormat("if (a) f();\n"
540                "else {\n"
541                "  if (a) f();\n"
542                "  else {\n"
543                "    g();\n"
544                "  }\n"
545                "  g();\n"
546                "}",
547                AllowsMergedIf);
548 }
549 
550 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
551   FormatStyle AllowsMergedLoops = getLLVMStyle();
552   AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
553   verifyFormat("while (true) continue;", AllowsMergedLoops);
554   verifyFormat("for (;;) continue;", AllowsMergedLoops);
555   verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
556   verifyFormat("while (true)\n"
557                "  ;",
558                AllowsMergedLoops);
559   verifyFormat("for (;;)\n"
560                "  ;",
561                AllowsMergedLoops);
562   verifyFormat("for (;;)\n"
563                "  for (;;) continue;",
564                AllowsMergedLoops);
565   verifyFormat("for (;;) // Can't merge this\n"
566                "  continue;",
567                AllowsMergedLoops);
568   verifyFormat("for (;;) /* still don't merge */\n"
569                "  continue;",
570                AllowsMergedLoops);
571   verifyFormat("do a++;\n"
572                "while (true);",
573                AllowsMergedLoops);
574   verifyFormat("do /* Don't merge */\n"
575                "  a++;\n"
576                "while (true);",
577                AllowsMergedLoops);
578   verifyFormat("do // Don't merge\n"
579                "  a++;\n"
580                "while (true);",
581                AllowsMergedLoops);
582   verifyFormat("do\n"
583                "  // Don't merge\n"
584                "  a++;\n"
585                "while (true);",
586                AllowsMergedLoops);
587   // Without braces labels are interpreted differently.
588   verifyFormat("{\n"
589                "  do\n"
590                "  label:\n"
591                "    a++;\n"
592                "  while (true);\n"
593                "}",
594                AllowsMergedLoops);
595 }
596 
597 TEST_F(FormatTest, FormatShortBracedStatements) {
598   FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
599   AllowSimpleBracedStatements.ColumnLimit = 40;
600   AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine =
601       FormatStyle::SBS_Always;
602 
603   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
604       FormatStyle::SIS_WithoutElse;
605   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
606 
607   AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom;
608   AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true;
609   AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false;
610 
611   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
612   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
613   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
614   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
615   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
616   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
617   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
618   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
619   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
620   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
621   verifyFormat("if (true) { fffffffffffffffffffffff(); }",
622                AllowSimpleBracedStatements);
623   verifyFormat("if (true) {\n"
624                "  ffffffffffffffffffffffff();\n"
625                "}",
626                AllowSimpleBracedStatements);
627   verifyFormat("if (true) {\n"
628                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
629                "}",
630                AllowSimpleBracedStatements);
631   verifyFormat("if (true) { //\n"
632                "  f();\n"
633                "}",
634                AllowSimpleBracedStatements);
635   verifyFormat("if (true) {\n"
636                "  f();\n"
637                "  f();\n"
638                "}",
639                AllowSimpleBracedStatements);
640   verifyFormat("if (true) {\n"
641                "  f();\n"
642                "} else {\n"
643                "  f();\n"
644                "}",
645                AllowSimpleBracedStatements);
646 
647   verifyFormat("struct A2 {\n"
648                "  int X;\n"
649                "};",
650                AllowSimpleBracedStatements);
651   verifyFormat("typedef struct A2 {\n"
652                "  int X;\n"
653                "} A2_t;",
654                AllowSimpleBracedStatements);
655   verifyFormat("template <int> struct A2 {\n"
656                "  struct B {};\n"
657                "};",
658                AllowSimpleBracedStatements);
659 
660   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
661       FormatStyle::SIS_Never;
662   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
663   verifyFormat("if (true) {\n"
664                "  f();\n"
665                "}",
666                AllowSimpleBracedStatements);
667   verifyFormat("if (true) {\n"
668                "  f();\n"
669                "} else {\n"
670                "  f();\n"
671                "}",
672                AllowSimpleBracedStatements);
673 
674   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
675   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
676   verifyFormat("while (true) {\n"
677                "  f();\n"
678                "}",
679                AllowSimpleBracedStatements);
680   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
681   verifyFormat("for (;;) {\n"
682                "  f();\n"
683                "}",
684                AllowSimpleBracedStatements);
685 
686   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
687       FormatStyle::SIS_WithoutElse;
688   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
689   AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement =
690       FormatStyle::BWACS_Always;
691 
692   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
693   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
694   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
695   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
696   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
697   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
698   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
699   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
700   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
701   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
702   verifyFormat("if (true) { fffffffffffffffffffffff(); }",
703                AllowSimpleBracedStatements);
704   verifyFormat("if (true)\n"
705                "{\n"
706                "  ffffffffffffffffffffffff();\n"
707                "}",
708                AllowSimpleBracedStatements);
709   verifyFormat("if (true)\n"
710                "{\n"
711                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
712                "}",
713                AllowSimpleBracedStatements);
714   verifyFormat("if (true)\n"
715                "{ //\n"
716                "  f();\n"
717                "}",
718                AllowSimpleBracedStatements);
719   verifyFormat("if (true)\n"
720                "{\n"
721                "  f();\n"
722                "  f();\n"
723                "}",
724                AllowSimpleBracedStatements);
725   verifyFormat("if (true)\n"
726                "{\n"
727                "  f();\n"
728                "} else\n"
729                "{\n"
730                "  f();\n"
731                "}",
732                AllowSimpleBracedStatements);
733 
734   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
735       FormatStyle::SIS_Never;
736   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
737   verifyFormat("if (true)\n"
738                "{\n"
739                "  f();\n"
740                "}",
741                AllowSimpleBracedStatements);
742   verifyFormat("if (true)\n"
743                "{\n"
744                "  f();\n"
745                "} else\n"
746                "{\n"
747                "  f();\n"
748                "}",
749                AllowSimpleBracedStatements);
750 
751   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
752   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
753   verifyFormat("while (true)\n"
754                "{\n"
755                "  f();\n"
756                "}",
757                AllowSimpleBracedStatements);
758   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
759   verifyFormat("for (;;)\n"
760                "{\n"
761                "  f();\n"
762                "}",
763                AllowSimpleBracedStatements);
764 }
765 
766 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) {
767   FormatStyle Style = getLLVMStyleWithColumns(60);
768   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
769   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
770   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
771   EXPECT_EQ("#define A                                                  \\\n"
772             "  if (HANDLEwernufrnuLwrmviferuvnierv)                     \\\n"
773             "  {                                                        \\\n"
774             "    RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier;               \\\n"
775             "  }\n"
776             "X;",
777             format("#define A \\\n"
778                    "   if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"
779                    "      RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
780                    "   }\n"
781                    "X;",
782                    Style));
783 }
784 
785 TEST_F(FormatTest, ParseIfElse) {
786   verifyFormat("if (true)\n"
787                "  if (true)\n"
788                "    if (true)\n"
789                "      f();\n"
790                "    else\n"
791                "      g();\n"
792                "  else\n"
793                "    h();\n"
794                "else\n"
795                "  i();");
796   verifyFormat("if (true)\n"
797                "  if (true)\n"
798                "    if (true) {\n"
799                "      if (true)\n"
800                "        f();\n"
801                "    } else {\n"
802                "      g();\n"
803                "    }\n"
804                "  else\n"
805                "    h();\n"
806                "else {\n"
807                "  i();\n"
808                "}");
809   verifyFormat("if (true)\n"
810                "  if constexpr (true)\n"
811                "    if (true) {\n"
812                "      if constexpr (true)\n"
813                "        f();\n"
814                "    } else {\n"
815                "      g();\n"
816                "    }\n"
817                "  else\n"
818                "    h();\n"
819                "else {\n"
820                "  i();\n"
821                "}");
822   verifyFormat("if (true)\n"
823                "  if CONSTEXPR (true)\n"
824                "    if (true) {\n"
825                "      if CONSTEXPR (true)\n"
826                "        f();\n"
827                "    } else {\n"
828                "      g();\n"
829                "    }\n"
830                "  else\n"
831                "    h();\n"
832                "else {\n"
833                "  i();\n"
834                "}");
835   verifyFormat("void f() {\n"
836                "  if (a) {\n"
837                "  } else {\n"
838                "  }\n"
839                "}");
840 }
841 
842 TEST_F(FormatTest, ElseIf) {
843   verifyFormat("if (a) {\n} else if (b) {\n}");
844   verifyFormat("if (a)\n"
845                "  f();\n"
846                "else if (b)\n"
847                "  g();\n"
848                "else\n"
849                "  h();");
850   verifyFormat("if constexpr (a)\n"
851                "  f();\n"
852                "else if constexpr (b)\n"
853                "  g();\n"
854                "else\n"
855                "  h();");
856   verifyFormat("if CONSTEXPR (a)\n"
857                "  f();\n"
858                "else if CONSTEXPR (b)\n"
859                "  g();\n"
860                "else\n"
861                "  h();");
862   verifyFormat("if (a) {\n"
863                "  f();\n"
864                "}\n"
865                "// or else ..\n"
866                "else {\n"
867                "  g()\n"
868                "}");
869 
870   verifyFormat("if (a) {\n"
871                "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
872                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
873                "}");
874   verifyFormat("if (a) {\n"
875                "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
876                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
877                "}");
878   verifyFormat("if (a) {\n"
879                "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
880                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
881                "}");
882   verifyFormat("if (a) {\n"
883                "} else if (\n"
884                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
885                "}",
886                getLLVMStyleWithColumns(62));
887   verifyFormat("if (a) {\n"
888                "} else if constexpr (\n"
889                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
890                "}",
891                getLLVMStyleWithColumns(62));
892   verifyFormat("if (a) {\n"
893                "} else if CONSTEXPR (\n"
894                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
895                "}",
896                getLLVMStyleWithColumns(62));
897 }
898 
899 TEST_F(FormatTest, FormatsForLoop) {
900   verifyFormat(
901       "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
902       "     ++VeryVeryLongLoopVariable)\n"
903       "  ;");
904   verifyFormat("for (;;)\n"
905                "  f();");
906   verifyFormat("for (;;) {\n}");
907   verifyFormat("for (;;) {\n"
908                "  f();\n"
909                "}");
910   verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
911 
912   verifyFormat(
913       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
914       "                                          E = UnwrappedLines.end();\n"
915       "     I != E; ++I) {\n}");
916 
917   verifyFormat(
918       "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
919       "     ++IIIII) {\n}");
920   verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
921                "         aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
922                "     aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
923   verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
924                "         I = FD->getDeclsInPrototypeScope().begin(),\n"
925                "         E = FD->getDeclsInPrototypeScope().end();\n"
926                "     I != E; ++I) {\n}");
927   verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
928                "         I = Container.begin(),\n"
929                "         E = Container.end();\n"
930                "     I != E; ++I) {\n}",
931                getLLVMStyleWithColumns(76));
932 
933   verifyFormat(
934       "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
935       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
936       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
937       "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
938       "     ++aaaaaaaaaaa) {\n}");
939   verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
940                "                bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
941                "     ++i) {\n}");
942   verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
943                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
944                "}");
945   verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
946                "         aaaaaaaaaa);\n"
947                "     iter; ++iter) {\n"
948                "}");
949   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
950                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
951                "     aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
952                "     ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
953 
954   // These should not be formatted as Objective-C for-in loops.
955   verifyFormat("for (Foo *x = 0; x != in; x++) {\n}");
956   verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}");
957   verifyFormat("Foo *x;\nfor (x in y) {\n}");
958   verifyFormat(
959       "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}");
960 
961   FormatStyle NoBinPacking = getLLVMStyle();
962   NoBinPacking.BinPackParameters = false;
963   verifyFormat("for (int aaaaaaaaaaa = 1;\n"
964                "     aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
965                "                                           aaaaaaaaaaaaaaaa,\n"
966                "                                           aaaaaaaaaaaaaaaa,\n"
967                "                                           aaaaaaaaaaaaaaaa);\n"
968                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
969                "}",
970                NoBinPacking);
971   verifyFormat(
972       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
973       "                                          E = UnwrappedLines.end();\n"
974       "     I != E;\n"
975       "     ++I) {\n}",
976       NoBinPacking);
977 
978   FormatStyle AlignLeft = getLLVMStyle();
979   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
980   verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
981 }
982 
983 TEST_F(FormatTest, RangeBasedForLoops) {
984   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
985                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
986   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
987                "     aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
988   verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
989                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
990   verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
991                "     aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
992 }
993 
994 TEST_F(FormatTest, ForEachLoops) {
995   verifyFormat("void f() {\n"
996                "  foreach (Item *item, itemlist) {}\n"
997                "  Q_FOREACH (Item *item, itemlist) {}\n"
998                "  BOOST_FOREACH (Item *item, itemlist) {}\n"
999                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
1000                "}");
1001 
1002   FormatStyle Style = getLLVMStyle();
1003   Style.SpaceBeforeParens =
1004       FormatStyle::SBPO_ControlStatementsExceptForEachMacros;
1005   verifyFormat("void f() {\n"
1006                "  foreach(Item *item, itemlist) {}\n"
1007                "  Q_FOREACH(Item *item, itemlist) {}\n"
1008                "  BOOST_FOREACH(Item *item, itemlist) {}\n"
1009                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
1010                "}",
1011                Style);
1012 
1013   // As function-like macros.
1014   verifyFormat("#define foreach(x, y)\n"
1015                "#define Q_FOREACH(x, y)\n"
1016                "#define BOOST_FOREACH(x, y)\n"
1017                "#define UNKNOWN_FOREACH(x, y)\n");
1018 
1019   // Not as function-like macros.
1020   verifyFormat("#define foreach (x, y)\n"
1021                "#define Q_FOREACH (x, y)\n"
1022                "#define BOOST_FOREACH (x, y)\n"
1023                "#define UNKNOWN_FOREACH (x, y)\n");
1024 
1025   // handle microsoft non standard extension
1026   verifyFormat("for each (char c in x->MyStringProperty)");
1027 }
1028 
1029 TEST_F(FormatTest, FormatsWhileLoop) {
1030   verifyFormat("while (true) {\n}");
1031   verifyFormat("while (true)\n"
1032                "  f();");
1033   verifyFormat("while () {\n}");
1034   verifyFormat("while () {\n"
1035                "  f();\n"
1036                "}");
1037 }
1038 
1039 TEST_F(FormatTest, FormatsDoWhile) {
1040   verifyFormat("do {\n"
1041                "  do_something();\n"
1042                "} while (something());");
1043   verifyFormat("do\n"
1044                "  do_something();\n"
1045                "while (something());");
1046 }
1047 
1048 TEST_F(FormatTest, FormatsSwitchStatement) {
1049   verifyFormat("switch (x) {\n"
1050                "case 1:\n"
1051                "  f();\n"
1052                "  break;\n"
1053                "case kFoo:\n"
1054                "case ns::kBar:\n"
1055                "case kBaz:\n"
1056                "  break;\n"
1057                "default:\n"
1058                "  g();\n"
1059                "  break;\n"
1060                "}");
1061   verifyFormat("switch (x) {\n"
1062                "case 1: {\n"
1063                "  f();\n"
1064                "  break;\n"
1065                "}\n"
1066                "case 2: {\n"
1067                "  break;\n"
1068                "}\n"
1069                "}");
1070   verifyFormat("switch (x) {\n"
1071                "case 1: {\n"
1072                "  f();\n"
1073                "  {\n"
1074                "    g();\n"
1075                "    h();\n"
1076                "  }\n"
1077                "  break;\n"
1078                "}\n"
1079                "}");
1080   verifyFormat("switch (x) {\n"
1081                "case 1: {\n"
1082                "  f();\n"
1083                "  if (foo) {\n"
1084                "    g();\n"
1085                "    h();\n"
1086                "  }\n"
1087                "  break;\n"
1088                "}\n"
1089                "}");
1090   verifyFormat("switch (x) {\n"
1091                "case 1: {\n"
1092                "  f();\n"
1093                "  g();\n"
1094                "} break;\n"
1095                "}");
1096   verifyFormat("switch (test)\n"
1097                "  ;");
1098   verifyFormat("switch (x) {\n"
1099                "default: {\n"
1100                "  // Do nothing.\n"
1101                "}\n"
1102                "}");
1103   verifyFormat("switch (x) {\n"
1104                "// comment\n"
1105                "// if 1, do f()\n"
1106                "case 1:\n"
1107                "  f();\n"
1108                "}");
1109   verifyFormat("switch (x) {\n"
1110                "case 1:\n"
1111                "  // Do amazing stuff\n"
1112                "  {\n"
1113                "    f();\n"
1114                "    g();\n"
1115                "  }\n"
1116                "  break;\n"
1117                "}");
1118   verifyFormat("#define A          \\\n"
1119                "  switch (x) {     \\\n"
1120                "  case a:          \\\n"
1121                "    foo = b;       \\\n"
1122                "  }",
1123                getLLVMStyleWithColumns(20));
1124   verifyFormat("#define OPERATION_CASE(name)           \\\n"
1125                "  case OP_name:                        \\\n"
1126                "    return operations::Operation##name\n",
1127                getLLVMStyleWithColumns(40));
1128   verifyFormat("switch (x) {\n"
1129                "case 1:;\n"
1130                "default:;\n"
1131                "  int i;\n"
1132                "}");
1133 
1134   verifyGoogleFormat("switch (x) {\n"
1135                      "  case 1:\n"
1136                      "    f();\n"
1137                      "    break;\n"
1138                      "  case kFoo:\n"
1139                      "  case ns::kBar:\n"
1140                      "  case kBaz:\n"
1141                      "    break;\n"
1142                      "  default:\n"
1143                      "    g();\n"
1144                      "    break;\n"
1145                      "}");
1146   verifyGoogleFormat("switch (x) {\n"
1147                      "  case 1: {\n"
1148                      "    f();\n"
1149                      "    break;\n"
1150                      "  }\n"
1151                      "}");
1152   verifyGoogleFormat("switch (test)\n"
1153                      "  ;");
1154 
1155   verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
1156                      "  case OP_name:              \\\n"
1157                      "    return operations::Operation##name\n");
1158   verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
1159                      "  // Get the correction operation class.\n"
1160                      "  switch (OpCode) {\n"
1161                      "    CASE(Add);\n"
1162                      "    CASE(Subtract);\n"
1163                      "    default:\n"
1164                      "      return operations::Unknown;\n"
1165                      "  }\n"
1166                      "#undef OPERATION_CASE\n"
1167                      "}");
1168   verifyFormat("DEBUG({\n"
1169                "  switch (x) {\n"
1170                "  case A:\n"
1171                "    f();\n"
1172                "    break;\n"
1173                "    // fallthrough\n"
1174                "  case B:\n"
1175                "    g();\n"
1176                "    break;\n"
1177                "  }\n"
1178                "});");
1179   EXPECT_EQ("DEBUG({\n"
1180             "  switch (x) {\n"
1181             "  case A:\n"
1182             "    f();\n"
1183             "    break;\n"
1184             "  // On B:\n"
1185             "  case B:\n"
1186             "    g();\n"
1187             "    break;\n"
1188             "  }\n"
1189             "});",
1190             format("DEBUG({\n"
1191                    "  switch (x) {\n"
1192                    "  case A:\n"
1193                    "    f();\n"
1194                    "    break;\n"
1195                    "  // On B:\n"
1196                    "  case B:\n"
1197                    "    g();\n"
1198                    "    break;\n"
1199                    "  }\n"
1200                    "});",
1201                    getLLVMStyle()));
1202   EXPECT_EQ("switch (n) {\n"
1203             "case 0: {\n"
1204             "  return false;\n"
1205             "}\n"
1206             "default: {\n"
1207             "  return true;\n"
1208             "}\n"
1209             "}",
1210             format("switch (n)\n"
1211                    "{\n"
1212                    "case 0: {\n"
1213                    "  return false;\n"
1214                    "}\n"
1215                    "default: {\n"
1216                    "  return true;\n"
1217                    "}\n"
1218                    "}",
1219                    getLLVMStyle()));
1220   verifyFormat("switch (a) {\n"
1221                "case (b):\n"
1222                "  return;\n"
1223                "}");
1224 
1225   verifyFormat("switch (a) {\n"
1226                "case some_namespace::\n"
1227                "    some_constant:\n"
1228                "  return;\n"
1229                "}",
1230                getLLVMStyleWithColumns(34));
1231 
1232   FormatStyle Style = getLLVMStyle();
1233   Style.IndentCaseLabels = true;
1234   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
1235   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1236   Style.BraceWrapping.AfterCaseLabel = true;
1237   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1238   EXPECT_EQ("switch (n)\n"
1239             "{\n"
1240             "  case 0:\n"
1241             "  {\n"
1242             "    return false;\n"
1243             "  }\n"
1244             "  default:\n"
1245             "  {\n"
1246             "    return true;\n"
1247             "  }\n"
1248             "}",
1249             format("switch (n) {\n"
1250                    "  case 0: {\n"
1251                    "    return false;\n"
1252                    "  }\n"
1253                    "  default: {\n"
1254                    "    return true;\n"
1255                    "  }\n"
1256                    "}",
1257                    Style));
1258   Style.BraceWrapping.AfterCaseLabel = false;
1259   EXPECT_EQ("switch (n)\n"
1260             "{\n"
1261             "  case 0: {\n"
1262             "    return false;\n"
1263             "  }\n"
1264             "  default: {\n"
1265             "    return true;\n"
1266             "  }\n"
1267             "}",
1268             format("switch (n) {\n"
1269                    "  case 0:\n"
1270                    "  {\n"
1271                    "    return false;\n"
1272                    "  }\n"
1273                    "  default:\n"
1274                    "  {\n"
1275                    "    return true;\n"
1276                    "  }\n"
1277                    "}",
1278                    Style));
1279   Style.IndentCaseLabels = false;
1280   Style.IndentCaseBlocks = true;
1281   EXPECT_EQ("switch (n)\n"
1282             "{\n"
1283             "case 0:\n"
1284             "  {\n"
1285             "    return false;\n"
1286             "  }\n"
1287             "case 1:\n"
1288             "  break;\n"
1289             "default:\n"
1290             "  {\n"
1291             "    return true;\n"
1292             "  }\n"
1293             "}",
1294             format("switch (n) {\n"
1295                    "case 0: {\n"
1296                    "  return false;\n"
1297                    "}\n"
1298                    "case 1:\n"
1299                    "  break;\n"
1300                    "default: {\n"
1301                    "  return true;\n"
1302                    "}\n"
1303                    "}",
1304                    Style));
1305   Style.IndentCaseLabels = true;
1306   Style.IndentCaseBlocks = true;
1307   EXPECT_EQ("switch (n)\n"
1308             "{\n"
1309             "  case 0:\n"
1310             "    {\n"
1311             "      return false;\n"
1312             "    }\n"
1313             "  case 1:\n"
1314             "    break;\n"
1315             "  default:\n"
1316             "    {\n"
1317             "      return true;\n"
1318             "    }\n"
1319             "}",
1320             format("switch (n) {\n"
1321                    "case 0: {\n"
1322                    "  return false;\n"
1323                    "}\n"
1324                    "case 1:\n"
1325                    "  break;\n"
1326                    "default: {\n"
1327                    "  return true;\n"
1328                    "}\n"
1329                    "}",
1330                    Style));
1331 }
1332 
1333 TEST_F(FormatTest, CaseRanges) {
1334   verifyFormat("switch (x) {\n"
1335                "case 'A' ... 'Z':\n"
1336                "case 1 ... 5:\n"
1337                "case a ... b:\n"
1338                "  break;\n"
1339                "}");
1340 }
1341 
1342 TEST_F(FormatTest, ShortEnums) {
1343   FormatStyle Style = getLLVMStyle();
1344   Style.AllowShortEnumsOnASingleLine = true;
1345   verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style);
1346   Style.AllowShortEnumsOnASingleLine = false;
1347   verifyFormat("enum\n"
1348                "{\n"
1349                "  A,\n"
1350                "  B,\n"
1351                "  C\n"
1352                "} ShortEnum1, ShortEnum2;",
1353                Style);
1354 }
1355 
1356 TEST_F(FormatTest, ShortCaseLabels) {
1357   FormatStyle Style = getLLVMStyle();
1358   Style.AllowShortCaseLabelsOnASingleLine = true;
1359   verifyFormat("switch (a) {\n"
1360                "case 1: x = 1; break;\n"
1361                "case 2: return;\n"
1362                "case 3:\n"
1363                "case 4:\n"
1364                "case 5: return;\n"
1365                "case 6: // comment\n"
1366                "  return;\n"
1367                "case 7:\n"
1368                "  // comment\n"
1369                "  return;\n"
1370                "case 8:\n"
1371                "  x = 8; // comment\n"
1372                "  break;\n"
1373                "default: y = 1; break;\n"
1374                "}",
1375                Style);
1376   verifyFormat("switch (a) {\n"
1377                "case 0: return; // comment\n"
1378                "case 1: break;  // comment\n"
1379                "case 2: return;\n"
1380                "// comment\n"
1381                "case 3: return;\n"
1382                "// comment 1\n"
1383                "// comment 2\n"
1384                "// comment 3\n"
1385                "case 4: break; /* comment */\n"
1386                "case 5:\n"
1387                "  // comment\n"
1388                "  break;\n"
1389                "case 6: /* comment */ x = 1; break;\n"
1390                "case 7: x = /* comment */ 1; break;\n"
1391                "case 8:\n"
1392                "  x = 1; /* comment */\n"
1393                "  break;\n"
1394                "case 9:\n"
1395                "  break; // comment line 1\n"
1396                "         // comment line 2\n"
1397                "}",
1398                Style);
1399   EXPECT_EQ("switch (a) {\n"
1400             "case 1:\n"
1401             "  x = 8;\n"
1402             "  // fall through\n"
1403             "case 2: x = 8;\n"
1404             "// comment\n"
1405             "case 3:\n"
1406             "  return; /* comment line 1\n"
1407             "           * comment line 2 */\n"
1408             "case 4: i = 8;\n"
1409             "// something else\n"
1410             "#if FOO\n"
1411             "case 5: break;\n"
1412             "#endif\n"
1413             "}",
1414             format("switch (a) {\n"
1415                    "case 1: x = 8;\n"
1416                    "  // fall through\n"
1417                    "case 2:\n"
1418                    "  x = 8;\n"
1419                    "// comment\n"
1420                    "case 3:\n"
1421                    "  return; /* comment line 1\n"
1422                    "           * comment line 2 */\n"
1423                    "case 4:\n"
1424                    "  i = 8;\n"
1425                    "// something else\n"
1426                    "#if FOO\n"
1427                    "case 5: break;\n"
1428                    "#endif\n"
1429                    "}",
1430                    Style));
1431   EXPECT_EQ("switch (a) {\n"
1432             "case 0:\n"
1433             "  return; // long long long long long long long long long long "
1434             "long long comment\n"
1435             "          // line\n"
1436             "}",
1437             format("switch (a) {\n"
1438                    "case 0: return; // long long long long long long long long "
1439                    "long long long long comment line\n"
1440                    "}",
1441                    Style));
1442   EXPECT_EQ("switch (a) {\n"
1443             "case 0:\n"
1444             "  return; /* long long long long long long long long long long "
1445             "long long comment\n"
1446             "             line */\n"
1447             "}",
1448             format("switch (a) {\n"
1449                    "case 0: return; /* long long long long long long long long "
1450                    "long long long long comment line */\n"
1451                    "}",
1452                    Style));
1453   verifyFormat("switch (a) {\n"
1454                "#if FOO\n"
1455                "case 0: return 0;\n"
1456                "#endif\n"
1457                "}",
1458                Style);
1459   verifyFormat("switch (a) {\n"
1460                "case 1: {\n"
1461                "}\n"
1462                "case 2: {\n"
1463                "  return;\n"
1464                "}\n"
1465                "case 3: {\n"
1466                "  x = 1;\n"
1467                "  return;\n"
1468                "}\n"
1469                "case 4:\n"
1470                "  if (x)\n"
1471                "    return;\n"
1472                "}",
1473                Style);
1474   Style.ColumnLimit = 21;
1475   verifyFormat("switch (a) {\n"
1476                "case 1: x = 1; break;\n"
1477                "case 2: return;\n"
1478                "case 3:\n"
1479                "case 4:\n"
1480                "case 5: return;\n"
1481                "default:\n"
1482                "  y = 1;\n"
1483                "  break;\n"
1484                "}",
1485                Style);
1486   Style.ColumnLimit = 80;
1487   Style.AllowShortCaseLabelsOnASingleLine = false;
1488   Style.IndentCaseLabels = true;
1489   EXPECT_EQ("switch (n) {\n"
1490             "  default /*comments*/:\n"
1491             "    return true;\n"
1492             "  case 0:\n"
1493             "    return false;\n"
1494             "}",
1495             format("switch (n) {\n"
1496                    "default/*comments*/:\n"
1497                    "  return true;\n"
1498                    "case 0:\n"
1499                    "  return false;\n"
1500                    "}",
1501                    Style));
1502   Style.AllowShortCaseLabelsOnASingleLine = true;
1503   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
1504   Style.BraceWrapping.AfterCaseLabel = true;
1505   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
1506   EXPECT_EQ("switch (n)\n"
1507             "{\n"
1508             "  case 0:\n"
1509             "  {\n"
1510             "    return false;\n"
1511             "  }\n"
1512             "  default:\n"
1513             "  {\n"
1514             "    return true;\n"
1515             "  }\n"
1516             "}",
1517             format("switch (n) {\n"
1518                    "  case 0: {\n"
1519                    "    return false;\n"
1520                    "  }\n"
1521                    "  default:\n"
1522                    "  {\n"
1523                    "    return true;\n"
1524                    "  }\n"
1525                    "}",
1526                    Style));
1527 }
1528 
1529 TEST_F(FormatTest, FormatsLabels) {
1530   verifyFormat("void f() {\n"
1531                "  some_code();\n"
1532                "test_label:\n"
1533                "  some_other_code();\n"
1534                "  {\n"
1535                "    some_more_code();\n"
1536                "  another_label:\n"
1537                "    some_more_code();\n"
1538                "  }\n"
1539                "}");
1540   verifyFormat("{\n"
1541                "  some_code();\n"
1542                "test_label:\n"
1543                "  some_other_code();\n"
1544                "}");
1545   verifyFormat("{\n"
1546                "  some_code();\n"
1547                "test_label:;\n"
1548                "  int i = 0;\n"
1549                "}");
1550   FormatStyle Style = getLLVMStyle();
1551   Style.IndentGotoLabels = false;
1552   verifyFormat("void f() {\n"
1553                "  some_code();\n"
1554                "test_label:\n"
1555                "  some_other_code();\n"
1556                "  {\n"
1557                "    some_more_code();\n"
1558                "another_label:\n"
1559                "    some_more_code();\n"
1560                "  }\n"
1561                "}",
1562                Style);
1563   verifyFormat("{\n"
1564                "  some_code();\n"
1565                "test_label:\n"
1566                "  some_other_code();\n"
1567                "}",
1568                Style);
1569   verifyFormat("{\n"
1570                "  some_code();\n"
1571                "test_label:;\n"
1572                "  int i = 0;\n"
1573                "}");
1574 }
1575 
1576 TEST_F(FormatTest, MultiLineControlStatements) {
1577   FormatStyle Style = getLLVMStyle();
1578   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1579   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine;
1580   Style.ColumnLimit = 20;
1581   // Short lines should keep opening brace on same line.
1582   EXPECT_EQ("if (foo) {\n"
1583             "  bar();\n"
1584             "}",
1585             format("if(foo){bar();}", Style));
1586   EXPECT_EQ("if (foo) {\n"
1587             "  bar();\n"
1588             "} else {\n"
1589             "  baz();\n"
1590             "}",
1591             format("if(foo){bar();}else{baz();}", Style));
1592   EXPECT_EQ("if (foo && bar) {\n"
1593             "  baz();\n"
1594             "}",
1595             format("if(foo&&bar){baz();}", Style));
1596   EXPECT_EQ("if (foo) {\n"
1597             "  bar();\n"
1598             "} else if (baz) {\n"
1599             "  quux();\n"
1600             "}",
1601             format("if(foo){bar();}else if(baz){quux();}", Style));
1602   EXPECT_EQ(
1603       "if (foo) {\n"
1604       "  bar();\n"
1605       "} else if (baz) {\n"
1606       "  quux();\n"
1607       "} else {\n"
1608       "  foobar();\n"
1609       "}",
1610       format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style));
1611   EXPECT_EQ("for (;;) {\n"
1612             "  foo();\n"
1613             "}",
1614             format("for(;;){foo();}"));
1615   EXPECT_EQ("while (1) {\n"
1616             "  foo();\n"
1617             "}",
1618             format("while(1){foo();}", Style));
1619   EXPECT_EQ("switch (foo) {\n"
1620             "case bar:\n"
1621             "  return;\n"
1622             "}",
1623             format("switch(foo){case bar:return;}", Style));
1624   EXPECT_EQ("try {\n"
1625             "  foo();\n"
1626             "} catch (...) {\n"
1627             "  bar();\n"
1628             "}",
1629             format("try{foo();}catch(...){bar();}", Style));
1630   EXPECT_EQ("do {\n"
1631             "  foo();\n"
1632             "} while (bar &&\n"
1633             "         baz);",
1634             format("do{foo();}while(bar&&baz);", Style));
1635   // Long lines should put opening brace on new line.
1636   EXPECT_EQ("if (foo && bar &&\n"
1637             "    baz)\n"
1638             "{\n"
1639             "  quux();\n"
1640             "}",
1641             format("if(foo&&bar&&baz){quux();}", Style));
1642   EXPECT_EQ("if (foo && bar &&\n"
1643             "    baz)\n"
1644             "{\n"
1645             "  quux();\n"
1646             "}",
1647             format("if (foo && bar &&\n"
1648                    "    baz) {\n"
1649                    "  quux();\n"
1650                    "}",
1651                    Style));
1652   EXPECT_EQ("if (foo) {\n"
1653             "  bar();\n"
1654             "} else if (baz ||\n"
1655             "           quux)\n"
1656             "{\n"
1657             "  foobar();\n"
1658             "}",
1659             format("if(foo){bar();}else if(baz||quux){foobar();}", Style));
1660   EXPECT_EQ(
1661       "if (foo) {\n"
1662       "  bar();\n"
1663       "} else if (baz ||\n"
1664       "           quux)\n"
1665       "{\n"
1666       "  foobar();\n"
1667       "} else {\n"
1668       "  barbaz();\n"
1669       "}",
1670       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1671              Style));
1672   EXPECT_EQ("for (int i = 0;\n"
1673             "     i < 10; ++i)\n"
1674             "{\n"
1675             "  foo();\n"
1676             "}",
1677             format("for(int i=0;i<10;++i){foo();}", Style));
1678   EXPECT_EQ("foreach (int i,\n"
1679             "         list)\n"
1680             "{\n"
1681             "  foo();\n"
1682             "}",
1683             format("foreach(int i, list){foo();}", Style));
1684   Style.ColumnLimit =
1685       40; // to concentrate at brace wrapping, not line wrap due to column limit
1686   EXPECT_EQ("foreach (int i, list) {\n"
1687             "  foo();\n"
1688             "}",
1689             format("foreach(int i, list){foo();}", Style));
1690   Style.ColumnLimit =
1691       20; // to concentrate at brace wrapping, not line wrap due to column limit
1692   EXPECT_EQ("while (foo || bar ||\n"
1693             "       baz)\n"
1694             "{\n"
1695             "  quux();\n"
1696             "}",
1697             format("while(foo||bar||baz){quux();}", Style));
1698   EXPECT_EQ("switch (\n"
1699             "    foo = barbaz)\n"
1700             "{\n"
1701             "case quux:\n"
1702             "  return;\n"
1703             "}",
1704             format("switch(foo=barbaz){case quux:return;}", Style));
1705   EXPECT_EQ("try {\n"
1706             "  foo();\n"
1707             "} catch (\n"
1708             "    Exception &bar)\n"
1709             "{\n"
1710             "  baz();\n"
1711             "}",
1712             format("try{foo();}catch(Exception&bar){baz();}", Style));
1713   Style.ColumnLimit =
1714       40; // to concentrate at brace wrapping, not line wrap due to column limit
1715   EXPECT_EQ("try {\n"
1716             "  foo();\n"
1717             "} catch (Exception &bar) {\n"
1718             "  baz();\n"
1719             "}",
1720             format("try{foo();}catch(Exception&bar){baz();}", Style));
1721   Style.ColumnLimit =
1722       20; // to concentrate at brace wrapping, not line wrap due to column limit
1723 
1724   Style.BraceWrapping.BeforeElse = true;
1725   EXPECT_EQ(
1726       "if (foo) {\n"
1727       "  bar();\n"
1728       "}\n"
1729       "else if (baz ||\n"
1730       "         quux)\n"
1731       "{\n"
1732       "  foobar();\n"
1733       "}\n"
1734       "else {\n"
1735       "  barbaz();\n"
1736       "}",
1737       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
1738              Style));
1739 
1740   Style.BraceWrapping.BeforeCatch = true;
1741   EXPECT_EQ("try {\n"
1742             "  foo();\n"
1743             "}\n"
1744             "catch (...) {\n"
1745             "  baz();\n"
1746             "}",
1747             format("try{foo();}catch(...){baz();}", Style));
1748 }
1749 
1750 TEST_F(FormatTest, BeforeWhile) {
1751   FormatStyle Style = getLLVMStyle();
1752   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
1753 
1754   verifyFormat("do {\n"
1755                "  foo();\n"
1756                "} while (1);",
1757                Style);
1758   Style.BraceWrapping.BeforeWhile = true;
1759   verifyFormat("do {\n"
1760                "  foo();\n"
1761                "}\n"
1762                "while (1);",
1763                Style);
1764 }
1765 
1766 //===----------------------------------------------------------------------===//
1767 // Tests for classes, namespaces, etc.
1768 //===----------------------------------------------------------------------===//
1769 
1770 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
1771   verifyFormat("class A {};");
1772 }
1773 
1774 TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
1775   verifyFormat("class A {\n"
1776                "public:\n"
1777                "public: // comment\n"
1778                "protected:\n"
1779                "private:\n"
1780                "  void f() {}\n"
1781                "};");
1782   verifyFormat("export class A {\n"
1783                "public:\n"
1784                "public: // comment\n"
1785                "protected:\n"
1786                "private:\n"
1787                "  void f() {}\n"
1788                "};");
1789   verifyGoogleFormat("class A {\n"
1790                      " public:\n"
1791                      " protected:\n"
1792                      " private:\n"
1793                      "  void f() {}\n"
1794                      "};");
1795   verifyGoogleFormat("export class A {\n"
1796                      " public:\n"
1797                      " protected:\n"
1798                      " private:\n"
1799                      "  void f() {}\n"
1800                      "};");
1801   verifyFormat("class A {\n"
1802                "public slots:\n"
1803                "  void f1() {}\n"
1804                "public Q_SLOTS:\n"
1805                "  void f2() {}\n"
1806                "protected slots:\n"
1807                "  void f3() {}\n"
1808                "protected Q_SLOTS:\n"
1809                "  void f4() {}\n"
1810                "private slots:\n"
1811                "  void f5() {}\n"
1812                "private Q_SLOTS:\n"
1813                "  void f6() {}\n"
1814                "signals:\n"
1815                "  void g1();\n"
1816                "Q_SIGNALS:\n"
1817                "  void g2();\n"
1818                "};");
1819 
1820   // Don't interpret 'signals' the wrong way.
1821   verifyFormat("signals.set();");
1822   verifyFormat("for (Signals signals : f()) {\n}");
1823   verifyFormat("{\n"
1824                "  signals.set(); // This needs indentation.\n"
1825                "}");
1826   verifyFormat("void f() {\n"
1827                "label:\n"
1828                "  signals.baz();\n"
1829                "}");
1830 }
1831 
1832 TEST_F(FormatTest, SeparatesLogicalBlocks) {
1833   EXPECT_EQ("class A {\n"
1834             "public:\n"
1835             "  void f();\n"
1836             "\n"
1837             "private:\n"
1838             "  void g() {}\n"
1839             "  // test\n"
1840             "protected:\n"
1841             "  int h;\n"
1842             "};",
1843             format("class A {\n"
1844                    "public:\n"
1845                    "void f();\n"
1846                    "private:\n"
1847                    "void g() {}\n"
1848                    "// test\n"
1849                    "protected:\n"
1850                    "int h;\n"
1851                    "};"));
1852   EXPECT_EQ("class A {\n"
1853             "protected:\n"
1854             "public:\n"
1855             "  void f();\n"
1856             "};",
1857             format("class A {\n"
1858                    "protected:\n"
1859                    "\n"
1860                    "public:\n"
1861                    "\n"
1862                    "  void f();\n"
1863                    "};"));
1864 
1865   // Even ensure proper spacing inside macros.
1866   EXPECT_EQ("#define B     \\\n"
1867             "  class A {   \\\n"
1868             "   protected: \\\n"
1869             "   public:    \\\n"
1870             "    void f(); \\\n"
1871             "  };",
1872             format("#define B     \\\n"
1873                    "  class A {   \\\n"
1874                    "   protected: \\\n"
1875                    "              \\\n"
1876                    "   public:    \\\n"
1877                    "              \\\n"
1878                    "    void f(); \\\n"
1879                    "  };",
1880                    getGoogleStyle()));
1881   // But don't remove empty lines after macros ending in access specifiers.
1882   EXPECT_EQ("#define A private:\n"
1883             "\n"
1884             "int i;",
1885             format("#define A         private:\n"
1886                    "\n"
1887                    "int              i;"));
1888 }
1889 
1890 TEST_F(FormatTest, FormatsClasses) {
1891   verifyFormat("class A : public B {};");
1892   verifyFormat("class A : public ::B {};");
1893 
1894   verifyFormat(
1895       "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1896       "                             public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1897   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
1898                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1899                "      public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
1900   verifyFormat(
1901       "class A : public B, public C, public D, public E, public F {};");
1902   verifyFormat("class AAAAAAAAAAAA : public B,\n"
1903                "                     public C,\n"
1904                "                     public D,\n"
1905                "                     public E,\n"
1906                "                     public F,\n"
1907                "                     public G {};");
1908 
1909   verifyFormat("class\n"
1910                "    ReallyReallyLongClassName {\n"
1911                "  int i;\n"
1912                "};",
1913                getLLVMStyleWithColumns(32));
1914   verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
1915                "                           aaaaaaaaaaaaaaaa> {};");
1916   verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
1917                "    : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
1918                "                                 aaaaaaaaaaaaaaaaaaaaaa> {};");
1919   verifyFormat("template <class R, class C>\n"
1920                "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
1921                "    : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
1922   verifyFormat("class ::A::B {};");
1923 }
1924 
1925 TEST_F(FormatTest, BreakInheritanceStyle) {
1926   FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle();
1927   StyleWithInheritanceBreakBeforeComma.BreakInheritanceList =
1928       FormatStyle::BILS_BeforeComma;
1929   verifyFormat("class MyClass : public X {};",
1930                StyleWithInheritanceBreakBeforeComma);
1931   verifyFormat("class MyClass\n"
1932                "    : public X\n"
1933                "    , public Y {};",
1934                StyleWithInheritanceBreakBeforeComma);
1935   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
1936                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"
1937                "    , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1938                StyleWithInheritanceBreakBeforeComma);
1939   verifyFormat("struct aaaaaaaaaaaaa\n"
1940                "    : public aaaaaaaaaaaaaaaaaaa< // break\n"
1941                "          aaaaaaaaaaaaaaaa> {};",
1942                StyleWithInheritanceBreakBeforeComma);
1943 
1944   FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle();
1945   StyleWithInheritanceBreakAfterColon.BreakInheritanceList =
1946       FormatStyle::BILS_AfterColon;
1947   verifyFormat("class MyClass : public X {};",
1948                StyleWithInheritanceBreakAfterColon);
1949   verifyFormat("class MyClass : public X, public Y {};",
1950                StyleWithInheritanceBreakAfterColon);
1951   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
1952                "    public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
1953                "    public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
1954                StyleWithInheritanceBreakAfterColon);
1955   verifyFormat("struct aaaaaaaaaaaaa :\n"
1956                "    public aaaaaaaaaaaaaaaaaaa< // break\n"
1957                "        aaaaaaaaaaaaaaaa> {};",
1958                StyleWithInheritanceBreakAfterColon);
1959 }
1960 
1961 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
1962   verifyFormat("class A {\n} a, b;");
1963   verifyFormat("struct A {\n} a, b;");
1964   verifyFormat("union A {\n} a;");
1965 }
1966 
1967 TEST_F(FormatTest, FormatsEnum) {
1968   verifyFormat("enum {\n"
1969                "  Zero,\n"
1970                "  One = 1,\n"
1971                "  Two = One + 1,\n"
1972                "  Three = (One + Two),\n"
1973                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1974                "  Five = (One, Two, Three, Four, 5)\n"
1975                "};");
1976   verifyGoogleFormat("enum {\n"
1977                      "  Zero,\n"
1978                      "  One = 1,\n"
1979                      "  Two = One + 1,\n"
1980                      "  Three = (One + Two),\n"
1981                      "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
1982                      "  Five = (One, Two, Three, Four, 5)\n"
1983                      "};");
1984   verifyFormat("enum Enum {};");
1985   verifyFormat("enum {};");
1986   verifyFormat("enum X E {} d;");
1987   verifyFormat("enum __attribute__((...)) E {} d;");
1988   verifyFormat("enum __declspec__((...)) E {} d;");
1989   verifyFormat("enum {\n"
1990                "  Bar = Foo<int, int>::value\n"
1991                "};",
1992                getLLVMStyleWithColumns(30));
1993 
1994   verifyFormat("enum ShortEnum { A, B, C };");
1995   verifyGoogleFormat("enum ShortEnum { A, B, C };");
1996 
1997   EXPECT_EQ("enum KeepEmptyLines {\n"
1998             "  ONE,\n"
1999             "\n"
2000             "  TWO,\n"
2001             "\n"
2002             "  THREE\n"
2003             "}",
2004             format("enum KeepEmptyLines {\n"
2005                    "  ONE,\n"
2006                    "\n"
2007                    "  TWO,\n"
2008                    "\n"
2009                    "\n"
2010                    "  THREE\n"
2011                    "}"));
2012   verifyFormat("enum E { // comment\n"
2013                "  ONE,\n"
2014                "  TWO\n"
2015                "};\n"
2016                "int i;");
2017 
2018   FormatStyle EightIndent = getLLVMStyle();
2019   EightIndent.IndentWidth = 8;
2020   verifyFormat("enum {\n"
2021                "        VOID,\n"
2022                "        CHAR,\n"
2023                "        SHORT,\n"
2024                "        INT,\n"
2025                "        LONG,\n"
2026                "        SIGNED,\n"
2027                "        UNSIGNED,\n"
2028                "        BOOL,\n"
2029                "        FLOAT,\n"
2030                "        DOUBLE,\n"
2031                "        COMPLEX\n"
2032                "};",
2033                EightIndent);
2034 
2035   // Not enums.
2036   verifyFormat("enum X f() {\n"
2037                "  a();\n"
2038                "  return 42;\n"
2039                "}");
2040   verifyFormat("enum X Type::f() {\n"
2041                "  a();\n"
2042                "  return 42;\n"
2043                "}");
2044   verifyFormat("enum ::X f() {\n"
2045                "  a();\n"
2046                "  return 42;\n"
2047                "}");
2048   verifyFormat("enum ns::X f() {\n"
2049                "  a();\n"
2050                "  return 42;\n"
2051                "}");
2052 }
2053 
2054 TEST_F(FormatTest, FormatsEnumsWithErrors) {
2055   verifyFormat("enum Type {\n"
2056                "  One = 0; // These semicolons should be commas.\n"
2057                "  Two = 1;\n"
2058                "};");
2059   verifyFormat("namespace n {\n"
2060                "enum Type {\n"
2061                "  One,\n"
2062                "  Two, // missing };\n"
2063                "  int i;\n"
2064                "}\n"
2065                "void g() {}");
2066 }
2067 
2068 TEST_F(FormatTest, FormatsEnumStruct) {
2069   verifyFormat("enum struct {\n"
2070                "  Zero,\n"
2071                "  One = 1,\n"
2072                "  Two = One + 1,\n"
2073                "  Three = (One + Two),\n"
2074                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2075                "  Five = (One, Two, Three, Four, 5)\n"
2076                "};");
2077   verifyFormat("enum struct Enum {};");
2078   verifyFormat("enum struct {};");
2079   verifyFormat("enum struct X E {} d;");
2080   verifyFormat("enum struct __attribute__((...)) E {} d;");
2081   verifyFormat("enum struct __declspec__((...)) E {} d;");
2082   verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
2083 }
2084 
2085 TEST_F(FormatTest, FormatsEnumClass) {
2086   verifyFormat("enum class {\n"
2087                "  Zero,\n"
2088                "  One = 1,\n"
2089                "  Two = One + 1,\n"
2090                "  Three = (One + Two),\n"
2091                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
2092                "  Five = (One, Two, Three, Four, 5)\n"
2093                "};");
2094   verifyFormat("enum class Enum {};");
2095   verifyFormat("enum class {};");
2096   verifyFormat("enum class X E {} d;");
2097   verifyFormat("enum class __attribute__((...)) E {} d;");
2098   verifyFormat("enum class __declspec__((...)) E {} d;");
2099   verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
2100 }
2101 
2102 TEST_F(FormatTest, FormatsEnumTypes) {
2103   verifyFormat("enum X : int {\n"
2104                "  A, // Force multiple lines.\n"
2105                "  B\n"
2106                "};");
2107   verifyFormat("enum X : int { A, B };");
2108   verifyFormat("enum X : std::uint32_t { A, B };");
2109 }
2110 
2111 TEST_F(FormatTest, FormatsTypedefEnum) {
2112   FormatStyle Style = getLLVMStyle();
2113   Style.ColumnLimit = 40;
2114   verifyFormat("typedef enum {} EmptyEnum;");
2115   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2116   verifyFormat("typedef enum {\n"
2117                "  ZERO = 0,\n"
2118                "  ONE = 1,\n"
2119                "  TWO = 2,\n"
2120                "  THREE = 3\n"
2121                "} LongEnum;",
2122                Style);
2123   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2124   Style.BraceWrapping.AfterEnum = true;
2125   verifyFormat("typedef enum {} EmptyEnum;");
2126   verifyFormat("typedef enum { A, B, C } ShortEnum;");
2127   verifyFormat("typedef enum\n"
2128                "{\n"
2129                "  ZERO = 0,\n"
2130                "  ONE = 1,\n"
2131                "  TWO = 2,\n"
2132                "  THREE = 3\n"
2133                "} LongEnum;",
2134                Style);
2135 }
2136 
2137 TEST_F(FormatTest, FormatsNSEnums) {
2138   verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
2139   verifyGoogleFormat(
2140       "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }");
2141   verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
2142                      "  // Information about someDecentlyLongValue.\n"
2143                      "  someDecentlyLongValue,\n"
2144                      "  // Information about anotherDecentlyLongValue.\n"
2145                      "  anotherDecentlyLongValue,\n"
2146                      "  // Information about aThirdDecentlyLongValue.\n"
2147                      "  aThirdDecentlyLongValue\n"
2148                      "};");
2149   verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n"
2150                      "  // Information about someDecentlyLongValue.\n"
2151                      "  someDecentlyLongValue,\n"
2152                      "  // Information about anotherDecentlyLongValue.\n"
2153                      "  anotherDecentlyLongValue,\n"
2154                      "  // Information about aThirdDecentlyLongValue.\n"
2155                      "  aThirdDecentlyLongValue\n"
2156                      "};");
2157   verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
2158                      "  a = 1,\n"
2159                      "  b = 2,\n"
2160                      "  c = 3,\n"
2161                      "};");
2162   verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
2163                      "  a = 1,\n"
2164                      "  b = 2,\n"
2165                      "  c = 3,\n"
2166                      "};");
2167   verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n"
2168                      "  a = 1,\n"
2169                      "  b = 2,\n"
2170                      "  c = 3,\n"
2171                      "};");
2172   verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
2173                      "  a = 1,\n"
2174                      "  b = 2,\n"
2175                      "  c = 3,\n"
2176                      "};");
2177 }
2178 
2179 TEST_F(FormatTest, FormatsBitfields) {
2180   verifyFormat("struct Bitfields {\n"
2181                "  unsigned sClass : 8;\n"
2182                "  unsigned ValueKind : 2;\n"
2183                "};");
2184   verifyFormat("struct A {\n"
2185                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
2186                "      bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
2187                "};");
2188   verifyFormat("struct MyStruct {\n"
2189                "  uchar data;\n"
2190                "  uchar : 8;\n"
2191                "  uchar : 8;\n"
2192                "  uchar other;\n"
2193                "};");
2194   FormatStyle Style = getLLVMStyle();
2195   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
2196   verifyFormat("struct Bitfields {\n"
2197                "  unsigned sClass:8;\n"
2198                "  unsigned ValueKind:2;\n"
2199                "  uchar other;\n"
2200                "};",
2201                Style);
2202   verifyFormat("struct A {\n"
2203                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:1,\n"
2204                "      bbbbbbbbbbbbbbbbbbbbbbbbb:2;\n"
2205                "};",
2206                Style);
2207   Style.BitFieldColonSpacing = FormatStyle::BFCS_Before;
2208   verifyFormat("struct Bitfields {\n"
2209                "  unsigned sClass :8;\n"
2210                "  unsigned ValueKind :2;\n"
2211                "  uchar other;\n"
2212                "};",
2213                Style);
2214   Style.BitFieldColonSpacing = FormatStyle::BFCS_After;
2215   verifyFormat("struct Bitfields {\n"
2216                "  unsigned sClass: 8;\n"
2217                "  unsigned ValueKind: 2;\n"
2218                "  uchar other;\n"
2219                "};",
2220                Style);
2221 }
2222 
2223 TEST_F(FormatTest, FormatsNamespaces) {
2224   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
2225   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
2226 
2227   verifyFormat("namespace some_namespace {\n"
2228                "class A {};\n"
2229                "void f() { f(); }\n"
2230                "}",
2231                LLVMWithNoNamespaceFix);
2232   verifyFormat("namespace N::inline D {\n"
2233                "class A {};\n"
2234                "void f() { f(); }\n"
2235                "}",
2236                LLVMWithNoNamespaceFix);
2237   verifyFormat("namespace N::inline D::E {\n"
2238                "class A {};\n"
2239                "void f() { f(); }\n"
2240                "}",
2241                LLVMWithNoNamespaceFix);
2242   verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
2243                "class A {};\n"
2244                "void f() { f(); }\n"
2245                "}",
2246                LLVMWithNoNamespaceFix);
2247   verifyFormat("/* something */ namespace some_namespace {\n"
2248                "class A {};\n"
2249                "void f() { f(); }\n"
2250                "}",
2251                LLVMWithNoNamespaceFix);
2252   verifyFormat("namespace {\n"
2253                "class A {};\n"
2254                "void f() { f(); }\n"
2255                "}",
2256                LLVMWithNoNamespaceFix);
2257   verifyFormat("/* something */ namespace {\n"
2258                "class A {};\n"
2259                "void f() { f(); }\n"
2260                "}",
2261                LLVMWithNoNamespaceFix);
2262   verifyFormat("inline namespace X {\n"
2263                "class A {};\n"
2264                "void f() { f(); }\n"
2265                "}",
2266                LLVMWithNoNamespaceFix);
2267   verifyFormat("/* something */ inline namespace X {\n"
2268                "class A {};\n"
2269                "void f() { f(); }\n"
2270                "}",
2271                LLVMWithNoNamespaceFix);
2272   verifyFormat("export namespace X {\n"
2273                "class A {};\n"
2274                "void f() { f(); }\n"
2275                "}",
2276                LLVMWithNoNamespaceFix);
2277   verifyFormat("using namespace some_namespace;\n"
2278                "class A {};\n"
2279                "void f() { f(); }",
2280                LLVMWithNoNamespaceFix);
2281 
2282   // This code is more common than we thought; if we
2283   // layout this correctly the semicolon will go into
2284   // its own line, which is undesirable.
2285   verifyFormat("namespace {};", LLVMWithNoNamespaceFix);
2286   verifyFormat("namespace {\n"
2287                "class A {};\n"
2288                "};",
2289                LLVMWithNoNamespaceFix);
2290 
2291   verifyFormat("namespace {\n"
2292                "int SomeVariable = 0; // comment\n"
2293                "} // namespace",
2294                LLVMWithNoNamespaceFix);
2295   EXPECT_EQ("#ifndef HEADER_GUARD\n"
2296             "#define HEADER_GUARD\n"
2297             "namespace my_namespace {\n"
2298             "int i;\n"
2299             "} // my_namespace\n"
2300             "#endif // HEADER_GUARD",
2301             format("#ifndef HEADER_GUARD\n"
2302                    " #define HEADER_GUARD\n"
2303                    "   namespace my_namespace {\n"
2304                    "int i;\n"
2305                    "}    // my_namespace\n"
2306                    "#endif    // HEADER_GUARD",
2307                    LLVMWithNoNamespaceFix));
2308 
2309   EXPECT_EQ("namespace A::B {\n"
2310             "class C {};\n"
2311             "}",
2312             format("namespace A::B {\n"
2313                    "class C {};\n"
2314                    "}",
2315                    LLVMWithNoNamespaceFix));
2316 
2317   FormatStyle Style = getLLVMStyle();
2318   Style.NamespaceIndentation = FormatStyle::NI_All;
2319   EXPECT_EQ("namespace out {\n"
2320             "  int i;\n"
2321             "  namespace in {\n"
2322             "    int i;\n"
2323             "  } // namespace in\n"
2324             "} // namespace out",
2325             format("namespace out {\n"
2326                    "int i;\n"
2327                    "namespace in {\n"
2328                    "int i;\n"
2329                    "} // namespace in\n"
2330                    "} // namespace out",
2331                    Style));
2332 
2333   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2334   EXPECT_EQ("namespace out {\n"
2335             "int i;\n"
2336             "namespace in {\n"
2337             "  int i;\n"
2338             "} // namespace in\n"
2339             "} // namespace out",
2340             format("namespace out {\n"
2341                    "int i;\n"
2342                    "namespace in {\n"
2343                    "int i;\n"
2344                    "} // namespace in\n"
2345                    "} // namespace out",
2346                    Style));
2347 }
2348 
2349 TEST_F(FormatTest, NamespaceMacros) {
2350   FormatStyle Style = getLLVMStyle();
2351   Style.NamespaceMacros.push_back("TESTSUITE");
2352 
2353   verifyFormat("TESTSUITE(A) {\n"
2354                "int foo();\n"
2355                "} // TESTSUITE(A)",
2356                Style);
2357 
2358   verifyFormat("TESTSUITE(A, B) {\n"
2359                "int foo();\n"
2360                "} // TESTSUITE(A)",
2361                Style);
2362 
2363   // Properly indent according to NamespaceIndentation style
2364   Style.NamespaceIndentation = FormatStyle::NI_All;
2365   verifyFormat("TESTSUITE(A) {\n"
2366                "  int foo();\n"
2367                "} // TESTSUITE(A)",
2368                Style);
2369   verifyFormat("TESTSUITE(A) {\n"
2370                "  namespace B {\n"
2371                "    int foo();\n"
2372                "  } // namespace B\n"
2373                "} // TESTSUITE(A)",
2374                Style);
2375   verifyFormat("namespace A {\n"
2376                "  TESTSUITE(B) {\n"
2377                "    int foo();\n"
2378                "  } // TESTSUITE(B)\n"
2379                "} // namespace A",
2380                Style);
2381 
2382   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2383   verifyFormat("TESTSUITE(A) {\n"
2384                "TESTSUITE(B) {\n"
2385                "  int foo();\n"
2386                "} // TESTSUITE(B)\n"
2387                "} // TESTSUITE(A)",
2388                Style);
2389   verifyFormat("TESTSUITE(A) {\n"
2390                "namespace B {\n"
2391                "  int foo();\n"
2392                "} // namespace B\n"
2393                "} // TESTSUITE(A)",
2394                Style);
2395   verifyFormat("namespace A {\n"
2396                "TESTSUITE(B) {\n"
2397                "  int foo();\n"
2398                "} // TESTSUITE(B)\n"
2399                "} // namespace A",
2400                Style);
2401 
2402   // Properly merge namespace-macros blocks in CompactNamespaces mode
2403   Style.NamespaceIndentation = FormatStyle::NI_None;
2404   Style.CompactNamespaces = true;
2405   verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
2406                "}} // TESTSUITE(A::B)",
2407                Style);
2408 
2409   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2410             "}} // TESTSUITE(out::in)",
2411             format("TESTSUITE(out) {\n"
2412                    "TESTSUITE(in) {\n"
2413                    "} // TESTSUITE(in)\n"
2414                    "} // TESTSUITE(out)",
2415                    Style));
2416 
2417   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
2418             "}} // TESTSUITE(out::in)",
2419             format("TESTSUITE(out) {\n"
2420                    "TESTSUITE(in) {\n"
2421                    "} // TESTSUITE(in)\n"
2422                    "} // TESTSUITE(out)",
2423                    Style));
2424 
2425   // Do not merge different namespaces/macros
2426   EXPECT_EQ("namespace out {\n"
2427             "TESTSUITE(in) {\n"
2428             "} // TESTSUITE(in)\n"
2429             "} // namespace out",
2430             format("namespace out {\n"
2431                    "TESTSUITE(in) {\n"
2432                    "} // TESTSUITE(in)\n"
2433                    "} // namespace out",
2434                    Style));
2435   EXPECT_EQ("TESTSUITE(out) {\n"
2436             "namespace in {\n"
2437             "} // namespace in\n"
2438             "} // TESTSUITE(out)",
2439             format("TESTSUITE(out) {\n"
2440                    "namespace in {\n"
2441                    "} // namespace in\n"
2442                    "} // TESTSUITE(out)",
2443                    Style));
2444   Style.NamespaceMacros.push_back("FOOBAR");
2445   EXPECT_EQ("TESTSUITE(out) {\n"
2446             "FOOBAR(in) {\n"
2447             "} // FOOBAR(in)\n"
2448             "} // TESTSUITE(out)",
2449             format("TESTSUITE(out) {\n"
2450                    "FOOBAR(in) {\n"
2451                    "} // FOOBAR(in)\n"
2452                    "} // TESTSUITE(out)",
2453                    Style));
2454 }
2455 
2456 TEST_F(FormatTest, FormatsCompactNamespaces) {
2457   FormatStyle Style = getLLVMStyle();
2458   Style.CompactNamespaces = true;
2459   Style.NamespaceMacros.push_back("TESTSUITE");
2460 
2461   verifyFormat("namespace A { namespace B {\n"
2462                "}} // namespace A::B",
2463                Style);
2464 
2465   EXPECT_EQ("namespace out { namespace in {\n"
2466             "}} // namespace out::in",
2467             format("namespace out {\n"
2468                    "namespace in {\n"
2469                    "} // namespace in\n"
2470                    "} // namespace out",
2471                    Style));
2472 
2473   // Only namespaces which have both consecutive opening and end get compacted
2474   EXPECT_EQ("namespace out {\n"
2475             "namespace in1 {\n"
2476             "} // namespace in1\n"
2477             "namespace in2 {\n"
2478             "} // namespace in2\n"
2479             "} // namespace out",
2480             format("namespace out {\n"
2481                    "namespace in1 {\n"
2482                    "} // namespace in1\n"
2483                    "namespace in2 {\n"
2484                    "} // namespace in2\n"
2485                    "} // namespace out",
2486                    Style));
2487 
2488   EXPECT_EQ("namespace out {\n"
2489             "int i;\n"
2490             "namespace in {\n"
2491             "int j;\n"
2492             "} // namespace in\n"
2493             "int k;\n"
2494             "} // namespace out",
2495             format("namespace out { int i;\n"
2496                    "namespace in { int j; } // namespace in\n"
2497                    "int k; } // namespace out",
2498                    Style));
2499 
2500   EXPECT_EQ("namespace A { namespace B { namespace C {\n"
2501             "}}} // namespace A::B::C\n",
2502             format("namespace A { namespace B {\n"
2503                    "namespace C {\n"
2504                    "}} // namespace B::C\n"
2505                    "} // namespace A\n",
2506                    Style));
2507 
2508   Style.ColumnLimit = 40;
2509   EXPECT_EQ("namespace aaaaaaaaaa {\n"
2510             "namespace bbbbbbbbbb {\n"
2511             "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
2512             format("namespace aaaaaaaaaa {\n"
2513                    "namespace bbbbbbbbbb {\n"
2514                    "} // namespace bbbbbbbbbb\n"
2515                    "} // namespace aaaaaaaaaa",
2516                    Style));
2517 
2518   EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
2519             "namespace cccccc {\n"
2520             "}}} // namespace aaaaaa::bbbbbb::cccccc",
2521             format("namespace aaaaaa {\n"
2522                    "namespace bbbbbb {\n"
2523                    "namespace cccccc {\n"
2524                    "} // namespace cccccc\n"
2525                    "} // namespace bbbbbb\n"
2526                    "} // namespace aaaaaa",
2527                    Style));
2528   Style.ColumnLimit = 80;
2529 
2530   // Extra semicolon after 'inner' closing brace prevents merging
2531   EXPECT_EQ("namespace out { namespace in {\n"
2532             "}; } // namespace out::in",
2533             format("namespace out {\n"
2534                    "namespace in {\n"
2535                    "}; // namespace in\n"
2536                    "} // namespace out",
2537                    Style));
2538 
2539   // Extra semicolon after 'outer' closing brace is conserved
2540   EXPECT_EQ("namespace out { namespace in {\n"
2541             "}}; // namespace out::in",
2542             format("namespace out {\n"
2543                    "namespace in {\n"
2544                    "} // namespace in\n"
2545                    "}; // namespace out",
2546                    Style));
2547 
2548   Style.NamespaceIndentation = FormatStyle::NI_All;
2549   EXPECT_EQ("namespace out { namespace in {\n"
2550             "  int i;\n"
2551             "}} // namespace out::in",
2552             format("namespace out {\n"
2553                    "namespace in {\n"
2554                    "int i;\n"
2555                    "} // namespace in\n"
2556                    "} // namespace out",
2557                    Style));
2558   EXPECT_EQ("namespace out { namespace mid {\n"
2559             "  namespace in {\n"
2560             "    int j;\n"
2561             "  } // namespace in\n"
2562             "  int k;\n"
2563             "}} // namespace out::mid",
2564             format("namespace out { namespace mid {\n"
2565                    "namespace in { int j; } // namespace in\n"
2566                    "int k; }} // namespace out::mid",
2567                    Style));
2568 
2569   Style.NamespaceIndentation = FormatStyle::NI_Inner;
2570   EXPECT_EQ("namespace out { namespace in {\n"
2571             "  int i;\n"
2572             "}} // namespace out::in",
2573             format("namespace out {\n"
2574                    "namespace in {\n"
2575                    "int i;\n"
2576                    "} // namespace in\n"
2577                    "} // namespace out",
2578                    Style));
2579   EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
2580             "  int i;\n"
2581             "}}} // namespace out::mid::in",
2582             format("namespace out {\n"
2583                    "namespace mid {\n"
2584                    "namespace in {\n"
2585                    "int i;\n"
2586                    "} // namespace in\n"
2587                    "} // namespace mid\n"
2588                    "} // namespace out",
2589                    Style));
2590 }
2591 
2592 TEST_F(FormatTest, FormatsExternC) {
2593   verifyFormat("extern \"C\" {\nint a;");
2594   verifyFormat("extern \"C\" {}");
2595   verifyFormat("extern \"C\" {\n"
2596                "int foo();\n"
2597                "}");
2598   verifyFormat("extern \"C\" int foo() {}");
2599   verifyFormat("extern \"C\" int foo();");
2600   verifyFormat("extern \"C\" int foo() {\n"
2601                "  int i = 42;\n"
2602                "  return i;\n"
2603                "}");
2604 
2605   FormatStyle Style = getLLVMStyle();
2606   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2607   Style.BraceWrapping.AfterFunction = true;
2608   verifyFormat("extern \"C\" int foo() {}", Style);
2609   verifyFormat("extern \"C\" int foo();", Style);
2610   verifyFormat("extern \"C\" int foo()\n"
2611                "{\n"
2612                "  int i = 42;\n"
2613                "  return i;\n"
2614                "}",
2615                Style);
2616 
2617   Style.BraceWrapping.AfterExternBlock = true;
2618   Style.BraceWrapping.SplitEmptyRecord = false;
2619   verifyFormat("extern \"C\"\n"
2620                "{}",
2621                Style);
2622   verifyFormat("extern \"C\"\n"
2623                "{\n"
2624                "  int foo();\n"
2625                "}",
2626                Style);
2627 }
2628 
2629 TEST_F(FormatTest, IndentExternBlockStyle) {
2630   FormatStyle Style = getLLVMStyle();
2631   Style.IndentWidth = 2;
2632 
2633   Style.IndentExternBlock = FormatStyle::IEBS_Indent;
2634   verifyFormat("extern \"C\" { /*9*/\n}", Style);
2635   verifyFormat("extern \"C\" {\n"
2636                "  int foo10();\n"
2637                "}",
2638                Style);
2639 
2640   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
2641   verifyFormat("extern \"C\" { /*11*/\n}", Style);
2642   verifyFormat("extern \"C\" {\n"
2643                "int foo12();\n"
2644                "}",
2645                Style);
2646 
2647   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2648   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2649   Style.BraceWrapping.AfterExternBlock = true;
2650   verifyFormat("extern \"C\"\n{ /*13*/\n}", Style);
2651   verifyFormat("extern \"C\"\n{\n"
2652                "  int foo14();\n"
2653                "}",
2654                Style);
2655 
2656   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
2657   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2658   Style.BraceWrapping.AfterExternBlock = false;
2659   verifyFormat("extern \"C\" { /*15*/\n}", Style);
2660   verifyFormat("extern \"C\" {\n"
2661                "int foo16();\n"
2662                "}",
2663                Style);
2664 }
2665 
2666 TEST_F(FormatTest, FormatsInlineASM) {
2667   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
2668   verifyFormat("asm(\"nop\" ::: \"memory\");");
2669   verifyFormat(
2670       "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
2671       "    \"cpuid\\n\\t\"\n"
2672       "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
2673       "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
2674       "    : \"a\"(value));");
2675   EXPECT_EQ(
2676       "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
2677       "  __asm {\n"
2678       "        mov     edx,[that] // vtable in edx\n"
2679       "        mov     eax,methodIndex\n"
2680       "        call    [edx][eax*4] // stdcall\n"
2681       "  }\n"
2682       "}",
2683       format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
2684              "    __asm {\n"
2685              "        mov     edx,[that] // vtable in edx\n"
2686              "        mov     eax,methodIndex\n"
2687              "        call    [edx][eax*4] // stdcall\n"
2688              "    }\n"
2689              "}"));
2690   EXPECT_EQ("_asm {\n"
2691             "  xor eax, eax;\n"
2692             "  cpuid;\n"
2693             "}",
2694             format("_asm {\n"
2695                    "  xor eax, eax;\n"
2696                    "  cpuid;\n"
2697                    "}"));
2698   verifyFormat("void function() {\n"
2699                "  // comment\n"
2700                "  asm(\"\");\n"
2701                "}");
2702   EXPECT_EQ("__asm {\n"
2703             "}\n"
2704             "int i;",
2705             format("__asm   {\n"
2706                    "}\n"
2707                    "int   i;"));
2708 }
2709 
2710 TEST_F(FormatTest, FormatTryCatch) {
2711   verifyFormat("try {\n"
2712                "  throw a * b;\n"
2713                "} catch (int a) {\n"
2714                "  // Do nothing.\n"
2715                "} catch (...) {\n"
2716                "  exit(42);\n"
2717                "}");
2718 
2719   // Function-level try statements.
2720   verifyFormat("int f() try { return 4; } catch (...) {\n"
2721                "  return 5;\n"
2722                "}");
2723   verifyFormat("class A {\n"
2724                "  int a;\n"
2725                "  A() try : a(0) {\n"
2726                "  } catch (...) {\n"
2727                "    throw;\n"
2728                "  }\n"
2729                "};\n");
2730 
2731   // Incomplete try-catch blocks.
2732   verifyIncompleteFormat("try {} catch (");
2733 }
2734 
2735 TEST_F(FormatTest, FormatTryAsAVariable) {
2736   verifyFormat("int try;");
2737   verifyFormat("int try, size;");
2738   verifyFormat("try = foo();");
2739   verifyFormat("if (try < size) {\n  return true;\n}");
2740 
2741   verifyFormat("int catch;");
2742   verifyFormat("int catch, size;");
2743   verifyFormat("catch = foo();");
2744   verifyFormat("if (catch < size) {\n  return true;\n}");
2745 
2746   FormatStyle Style = getLLVMStyle();
2747   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2748   Style.BraceWrapping.AfterFunction = true;
2749   Style.BraceWrapping.BeforeCatch = true;
2750   verifyFormat("try {\n"
2751                "  int bar = 1;\n"
2752                "}\n"
2753                "catch (...) {\n"
2754                "  int bar = 1;\n"
2755                "}",
2756                Style);
2757   verifyFormat("#if NO_EX\n"
2758                "try\n"
2759                "#endif\n"
2760                "{\n"
2761                "}\n"
2762                "#if NO_EX\n"
2763                "catch (...) {\n"
2764                "}",
2765                Style);
2766   verifyFormat("try /* abc */ {\n"
2767                "  int bar = 1;\n"
2768                "}\n"
2769                "catch (...) {\n"
2770                "  int bar = 1;\n"
2771                "}",
2772                Style);
2773   verifyFormat("try\n"
2774                "// abc\n"
2775                "{\n"
2776                "  int bar = 1;\n"
2777                "}\n"
2778                "catch (...) {\n"
2779                "  int bar = 1;\n"
2780                "}",
2781                Style);
2782 }
2783 
2784 TEST_F(FormatTest, FormatSEHTryCatch) {
2785   verifyFormat("__try {\n"
2786                "  int a = b * c;\n"
2787                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2788                "  // Do nothing.\n"
2789                "}");
2790 
2791   verifyFormat("__try {\n"
2792                "  int a = b * c;\n"
2793                "} __finally {\n"
2794                "  // Do nothing.\n"
2795                "}");
2796 
2797   verifyFormat("DEBUG({\n"
2798                "  __try {\n"
2799                "  } __finally {\n"
2800                "  }\n"
2801                "});\n");
2802 }
2803 
2804 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2805   verifyFormat("try {\n"
2806                "  f();\n"
2807                "} catch {\n"
2808                "  g();\n"
2809                "}");
2810   verifyFormat("try {\n"
2811                "  f();\n"
2812                "} catch (A a) MACRO(x) {\n"
2813                "  g();\n"
2814                "} catch (B b) MACRO(x) {\n"
2815                "  g();\n"
2816                "}");
2817 }
2818 
2819 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2820   FormatStyle Style = getLLVMStyle();
2821   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2822                           FormatStyle::BS_WebKit}) {
2823     Style.BreakBeforeBraces = BraceStyle;
2824     verifyFormat("try {\n"
2825                  "  // something\n"
2826                  "} catch (...) {\n"
2827                  "  // something\n"
2828                  "}",
2829                  Style);
2830   }
2831   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2832   verifyFormat("try {\n"
2833                "  // something\n"
2834                "}\n"
2835                "catch (...) {\n"
2836                "  // something\n"
2837                "}",
2838                Style);
2839   verifyFormat("__try {\n"
2840                "  // something\n"
2841                "}\n"
2842                "__finally {\n"
2843                "  // something\n"
2844                "}",
2845                Style);
2846   verifyFormat("@try {\n"
2847                "  // something\n"
2848                "}\n"
2849                "@finally {\n"
2850                "  // something\n"
2851                "}",
2852                Style);
2853   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2854   verifyFormat("try\n"
2855                "{\n"
2856                "  // something\n"
2857                "}\n"
2858                "catch (...)\n"
2859                "{\n"
2860                "  // something\n"
2861                "}",
2862                Style);
2863   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2864   verifyFormat("try\n"
2865                "  {\n"
2866                "  // something white\n"
2867                "  }\n"
2868                "catch (...)\n"
2869                "  {\n"
2870                "  // something white\n"
2871                "  }",
2872                Style);
2873   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2874   verifyFormat("try\n"
2875                "  {\n"
2876                "    // something\n"
2877                "  }\n"
2878                "catch (...)\n"
2879                "  {\n"
2880                "    // something\n"
2881                "  }",
2882                Style);
2883   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2884   Style.BraceWrapping.BeforeCatch = true;
2885   verifyFormat("try {\n"
2886                "  // something\n"
2887                "}\n"
2888                "catch (...) {\n"
2889                "  // something\n"
2890                "}",
2891                Style);
2892 }
2893 
2894 TEST_F(FormatTest, StaticInitializers) {
2895   verifyFormat("static SomeClass SC = {1, 'a'};");
2896 
2897   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2898                "    100000000, "
2899                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2900 
2901   // Here, everything other than the "}" would fit on a line.
2902   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2903                "    10000000000000000000000000};");
2904   EXPECT_EQ("S s = {a,\n"
2905             "\n"
2906             "       b};",
2907             format("S s = {\n"
2908                    "  a,\n"
2909                    "\n"
2910                    "  b\n"
2911                    "};"));
2912 
2913   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2914   // line. However, the formatting looks a bit off and this probably doesn't
2915   // happen often in practice.
2916   verifyFormat("static int Variable[1] = {\n"
2917                "    {1000000000000000000000000000000000000}};",
2918                getLLVMStyleWithColumns(40));
2919 }
2920 
2921 TEST_F(FormatTest, DesignatedInitializers) {
2922   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2923   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2924                "                    .bbbbbbbbbb = 2,\n"
2925                "                    .cccccccccc = 3,\n"
2926                "                    .dddddddddd = 4,\n"
2927                "                    .eeeeeeeeee = 5};");
2928   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2929                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2930                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2931                "    .ccccccccccccccccccccccccccc = 3,\n"
2932                "    .ddddddddddddddddddddddddddd = 4,\n"
2933                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2934 
2935   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2936 
2937   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2938   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2939                "                    [2] = bbbbbbbbbb,\n"
2940                "                    [3] = cccccccccc,\n"
2941                "                    [4] = dddddddddd,\n"
2942                "                    [5] = eeeeeeeeee};");
2943   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2944                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2945                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2946                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2947                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2948                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2949 }
2950 
2951 TEST_F(FormatTest, NestedStaticInitializers) {
2952   verifyFormat("static A x = {{{}}};\n");
2953   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2954                "               {init1, init2, init3, init4}}};",
2955                getLLVMStyleWithColumns(50));
2956 
2957   verifyFormat("somes Status::global_reps[3] = {\n"
2958                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2959                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2960                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2961                getLLVMStyleWithColumns(60));
2962   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2963                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2964                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2965                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2966   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2967                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
2968                "rect.fTop}};");
2969 
2970   verifyFormat(
2971       "SomeArrayOfSomeType a = {\n"
2972       "    {{1, 2, 3},\n"
2973       "     {1, 2, 3},\n"
2974       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
2975       "      333333333333333333333333333333},\n"
2976       "     {1, 2, 3},\n"
2977       "     {1, 2, 3}}};");
2978   verifyFormat(
2979       "SomeArrayOfSomeType a = {\n"
2980       "    {{1, 2, 3}},\n"
2981       "    {{1, 2, 3}},\n"
2982       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
2983       "      333333333333333333333333333333}},\n"
2984       "    {{1, 2, 3}},\n"
2985       "    {{1, 2, 3}}};");
2986 
2987   verifyFormat("struct {\n"
2988                "  unsigned bit;\n"
2989                "  const char *const name;\n"
2990                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
2991                "                 {kOsWin, \"Windows\"},\n"
2992                "                 {kOsLinux, \"Linux\"},\n"
2993                "                 {kOsCrOS, \"Chrome OS\"}};");
2994   verifyFormat("struct {\n"
2995                "  unsigned bit;\n"
2996                "  const char *const name;\n"
2997                "} kBitsToOs[] = {\n"
2998                "    {kOsMac, \"Mac\"},\n"
2999                "    {kOsWin, \"Windows\"},\n"
3000                "    {kOsLinux, \"Linux\"},\n"
3001                "    {kOsCrOS, \"Chrome OS\"},\n"
3002                "};");
3003 }
3004 
3005 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
3006   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3007                "                      \\\n"
3008                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
3009 }
3010 
3011 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
3012   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
3013                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
3014 
3015   // Do break defaulted and deleted functions.
3016   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
3017                "    default;",
3018                getLLVMStyleWithColumns(40));
3019   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
3020                "    delete;",
3021                getLLVMStyleWithColumns(40));
3022 }
3023 
3024 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
3025   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
3026                getLLVMStyleWithColumns(40));
3027   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
3028                getLLVMStyleWithColumns(40));
3029   EXPECT_EQ("#define Q                              \\\n"
3030             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
3031             "  \"aaaaaaaa.cpp\"",
3032             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
3033                    getLLVMStyleWithColumns(40)));
3034 }
3035 
3036 TEST_F(FormatTest, UnderstandsLinePPDirective) {
3037   EXPECT_EQ("# 123 \"A string literal\"",
3038             format("   #     123    \"A string literal\""));
3039 }
3040 
3041 TEST_F(FormatTest, LayoutUnknownPPDirective) {
3042   EXPECT_EQ("#;", format("#;"));
3043   verifyFormat("#\n;\n;\n;");
3044 }
3045 
3046 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
3047   EXPECT_EQ("#line 42 \"test\"\n",
3048             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
3049   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
3050                                     getLLVMStyleWithColumns(12)));
3051 }
3052 
3053 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
3054   EXPECT_EQ("#line 42 \"test\"",
3055             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
3056   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
3057 }
3058 
3059 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
3060   verifyFormat("#define A \\x20");
3061   verifyFormat("#define A \\ x20");
3062   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
3063   verifyFormat("#define A ''");
3064   verifyFormat("#define A ''qqq");
3065   verifyFormat("#define A `qqq");
3066   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
3067   EXPECT_EQ("const char *c = STRINGIFY(\n"
3068             "\\na : b);",
3069             format("const char * c = STRINGIFY(\n"
3070                    "\\na : b);"));
3071 
3072   verifyFormat("a\r\\");
3073   verifyFormat("a\v\\");
3074   verifyFormat("a\f\\");
3075 }
3076 
3077 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
3078   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
3079   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
3080   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
3081   // FIXME: We never break before the macro name.
3082   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
3083 
3084   verifyFormat("#define A A\n#define A A");
3085   verifyFormat("#define A(X) A\n#define A A");
3086 
3087   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
3088   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
3089 }
3090 
3091 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
3092   EXPECT_EQ("// somecomment\n"
3093             "#include \"a.h\"\n"
3094             "#define A(  \\\n"
3095             "    A, B)\n"
3096             "#include \"b.h\"\n"
3097             "// somecomment\n",
3098             format("  // somecomment\n"
3099                    "  #include \"a.h\"\n"
3100                    "#define A(A,\\\n"
3101                    "    B)\n"
3102                    "    #include \"b.h\"\n"
3103                    " // somecomment\n",
3104                    getLLVMStyleWithColumns(13)));
3105 }
3106 
3107 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
3108 
3109 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
3110   EXPECT_EQ("#define A    \\\n"
3111             "  c;         \\\n"
3112             "  e;\n"
3113             "f;",
3114             format("#define A c; e;\n"
3115                    "f;",
3116                    getLLVMStyleWithColumns(14)));
3117 }
3118 
3119 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
3120 
3121 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
3122   EXPECT_EQ("int x,\n"
3123             "#define A\n"
3124             "    y;",
3125             format("int x,\n#define A\ny;"));
3126 }
3127 
3128 TEST_F(FormatTest, HashInMacroDefinition) {
3129   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
3130   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
3131   verifyFormat("#define A  \\\n"
3132                "  {        \\\n"
3133                "    f(#c); \\\n"
3134                "  }",
3135                getLLVMStyleWithColumns(11));
3136 
3137   verifyFormat("#define A(X)         \\\n"
3138                "  void function##X()",
3139                getLLVMStyleWithColumns(22));
3140 
3141   verifyFormat("#define A(a, b, c)   \\\n"
3142                "  void a##b##c()",
3143                getLLVMStyleWithColumns(22));
3144 
3145   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
3146 }
3147 
3148 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
3149   EXPECT_EQ("#define A (x)", format("#define A (x)"));
3150   EXPECT_EQ("#define A(x)", format("#define A(x)"));
3151 
3152   FormatStyle Style = getLLVMStyle();
3153   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
3154   verifyFormat("#define true ((foo)1)", Style);
3155   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
3156   verifyFormat("#define false((foo)0)", Style);
3157 }
3158 
3159 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
3160   EXPECT_EQ("#define A b;", format("#define A \\\n"
3161                                    "          \\\n"
3162                                    "  b;",
3163                                    getLLVMStyleWithColumns(25)));
3164   EXPECT_EQ("#define A \\\n"
3165             "          \\\n"
3166             "  a;      \\\n"
3167             "  b;",
3168             format("#define A \\\n"
3169                    "          \\\n"
3170                    "  a;      \\\n"
3171                    "  b;",
3172                    getLLVMStyleWithColumns(11)));
3173   EXPECT_EQ("#define A \\\n"
3174             "  a;      \\\n"
3175             "          \\\n"
3176             "  b;",
3177             format("#define A \\\n"
3178                    "  a;      \\\n"
3179                    "          \\\n"
3180                    "  b;",
3181                    getLLVMStyleWithColumns(11)));
3182 }
3183 
3184 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
3185   verifyIncompleteFormat("#define A :");
3186   verifyFormat("#define SOMECASES  \\\n"
3187                "  case 1:          \\\n"
3188                "  case 2\n",
3189                getLLVMStyleWithColumns(20));
3190   verifyFormat("#define MACRO(a) \\\n"
3191                "  if (a)         \\\n"
3192                "    f();         \\\n"
3193                "  else           \\\n"
3194                "    g()",
3195                getLLVMStyleWithColumns(18));
3196   verifyFormat("#define A template <typename T>");
3197   verifyIncompleteFormat("#define STR(x) #x\n"
3198                          "f(STR(this_is_a_string_literal{));");
3199   verifyFormat("#pragma omp threadprivate( \\\n"
3200                "    y)), // expected-warning",
3201                getLLVMStyleWithColumns(28));
3202   verifyFormat("#d, = };");
3203   verifyFormat("#if \"a");
3204   verifyIncompleteFormat("({\n"
3205                          "#define b     \\\n"
3206                          "  }           \\\n"
3207                          "  a\n"
3208                          "a",
3209                          getLLVMStyleWithColumns(15));
3210   verifyFormat("#define A     \\\n"
3211                "  {           \\\n"
3212                "    {\n"
3213                "#define B     \\\n"
3214                "  }           \\\n"
3215                "  }",
3216                getLLVMStyleWithColumns(15));
3217   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
3218   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
3219   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
3220   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
3221 }
3222 
3223 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
3224   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
3225   EXPECT_EQ("class A : public QObject {\n"
3226             "  Q_OBJECT\n"
3227             "\n"
3228             "  A() {}\n"
3229             "};",
3230             format("class A  :  public QObject {\n"
3231                    "     Q_OBJECT\n"
3232                    "\n"
3233                    "  A() {\n}\n"
3234                    "}  ;"));
3235   EXPECT_EQ("MACRO\n"
3236             "/*static*/ int i;",
3237             format("MACRO\n"
3238                    " /*static*/ int   i;"));
3239   EXPECT_EQ("SOME_MACRO\n"
3240             "namespace {\n"
3241             "void f();\n"
3242             "} // namespace",
3243             format("SOME_MACRO\n"
3244                    "  namespace    {\n"
3245                    "void   f(  );\n"
3246                    "} // namespace"));
3247   // Only if the identifier contains at least 5 characters.
3248   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
3249   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
3250   // Only if everything is upper case.
3251   EXPECT_EQ("class A : public QObject {\n"
3252             "  Q_Object A() {}\n"
3253             "};",
3254             format("class A  :  public QObject {\n"
3255                    "     Q_Object\n"
3256                    "  A() {\n}\n"
3257                    "}  ;"));
3258 
3259   // Only if the next line can actually start an unwrapped line.
3260   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
3261             format("SOME_WEIRD_LOG_MACRO\n"
3262                    "<< SomeThing;"));
3263 
3264   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3265                "(n, buffers))\n",
3266                getChromiumStyle(FormatStyle::LK_Cpp));
3267 
3268   // See PR41483
3269   EXPECT_EQ("/**/ FOO(a)\n"
3270             "FOO(b)",
3271             format("/**/ FOO(a)\n"
3272                    "FOO(b)"));
3273 }
3274 
3275 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
3276   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3277             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3278             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3279             "class X {};\n"
3280             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3281             "int *createScopDetectionPass() { return 0; }",
3282             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3283                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3284                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3285                    "  class X {};\n"
3286                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3287                    "  int *createScopDetectionPass() { return 0; }"));
3288   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
3289   // braces, so that inner block is indented one level more.
3290   EXPECT_EQ("int q() {\n"
3291             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3292             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3293             "  IPC_END_MESSAGE_MAP()\n"
3294             "}",
3295             format("int q() {\n"
3296                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3297                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3298                    "  IPC_END_MESSAGE_MAP()\n"
3299                    "}"));
3300 
3301   // Same inside macros.
3302   EXPECT_EQ("#define LIST(L) \\\n"
3303             "  L(A)          \\\n"
3304             "  L(B)          \\\n"
3305             "  L(C)",
3306             format("#define LIST(L) \\\n"
3307                    "  L(A) \\\n"
3308                    "  L(B) \\\n"
3309                    "  L(C)",
3310                    getGoogleStyle()));
3311 
3312   // These must not be recognized as macros.
3313   EXPECT_EQ("int q() {\n"
3314             "  f(x);\n"
3315             "  f(x) {}\n"
3316             "  f(x)->g();\n"
3317             "  f(x)->*g();\n"
3318             "  f(x).g();\n"
3319             "  f(x) = x;\n"
3320             "  f(x) += x;\n"
3321             "  f(x) -= x;\n"
3322             "  f(x) *= x;\n"
3323             "  f(x) /= x;\n"
3324             "  f(x) %= x;\n"
3325             "  f(x) &= x;\n"
3326             "  f(x) |= x;\n"
3327             "  f(x) ^= x;\n"
3328             "  f(x) >>= x;\n"
3329             "  f(x) <<= x;\n"
3330             "  f(x)[y].z();\n"
3331             "  LOG(INFO) << x;\n"
3332             "  ifstream(x) >> x;\n"
3333             "}\n",
3334             format("int q() {\n"
3335                    "  f(x)\n;\n"
3336                    "  f(x)\n {}\n"
3337                    "  f(x)\n->g();\n"
3338                    "  f(x)\n->*g();\n"
3339                    "  f(x)\n.g();\n"
3340                    "  f(x)\n = x;\n"
3341                    "  f(x)\n += x;\n"
3342                    "  f(x)\n -= x;\n"
3343                    "  f(x)\n *= x;\n"
3344                    "  f(x)\n /= x;\n"
3345                    "  f(x)\n %= x;\n"
3346                    "  f(x)\n &= x;\n"
3347                    "  f(x)\n |= x;\n"
3348                    "  f(x)\n ^= x;\n"
3349                    "  f(x)\n >>= x;\n"
3350                    "  f(x)\n <<= x;\n"
3351                    "  f(x)\n[y].z();\n"
3352                    "  LOG(INFO)\n << x;\n"
3353                    "  ifstream(x)\n >> x;\n"
3354                    "}\n"));
3355   EXPECT_EQ("int q() {\n"
3356             "  F(x)\n"
3357             "  if (1) {\n"
3358             "  }\n"
3359             "  F(x)\n"
3360             "  while (1) {\n"
3361             "  }\n"
3362             "  F(x)\n"
3363             "  G(x);\n"
3364             "  F(x)\n"
3365             "  try {\n"
3366             "    Q();\n"
3367             "  } catch (...) {\n"
3368             "  }\n"
3369             "}\n",
3370             format("int q() {\n"
3371                    "F(x)\n"
3372                    "if (1) {}\n"
3373                    "F(x)\n"
3374                    "while (1) {}\n"
3375                    "F(x)\n"
3376                    "G(x);\n"
3377                    "F(x)\n"
3378                    "try { Q(); } catch (...) {}\n"
3379                    "}\n"));
3380   EXPECT_EQ("class A {\n"
3381             "  A() : t(0) {}\n"
3382             "  A(int i) noexcept() : {}\n"
3383             "  A(X x)\n" // FIXME: function-level try blocks are broken.
3384             "  try : t(0) {\n"
3385             "  } catch (...) {\n"
3386             "  }\n"
3387             "};",
3388             format("class A {\n"
3389                    "  A()\n : t(0) {}\n"
3390                    "  A(int i)\n noexcept() : {}\n"
3391                    "  A(X x)\n"
3392                    "  try : t(0) {} catch (...) {}\n"
3393                    "};"));
3394   FormatStyle Style = getLLVMStyle();
3395   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3396   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3397   Style.BraceWrapping.AfterFunction = true;
3398   EXPECT_EQ("void f()\n"
3399             "try\n"
3400             "{\n"
3401             "}",
3402             format("void f() try {\n"
3403                    "}",
3404                    Style));
3405   EXPECT_EQ("class SomeClass {\n"
3406             "public:\n"
3407             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3408             "};",
3409             format("class SomeClass {\n"
3410                    "public:\n"
3411                    "  SomeClass()\n"
3412                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3413                    "};"));
3414   EXPECT_EQ("class SomeClass {\n"
3415             "public:\n"
3416             "  SomeClass()\n"
3417             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3418             "};",
3419             format("class SomeClass {\n"
3420                    "public:\n"
3421                    "  SomeClass()\n"
3422                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3423                    "};",
3424                    getLLVMStyleWithColumns(40)));
3425 
3426   verifyFormat("MACRO(>)");
3427 
3428   // Some macros contain an implicit semicolon.
3429   Style = getLLVMStyle();
3430   Style.StatementMacros.push_back("FOO");
3431   verifyFormat("FOO(a) int b = 0;");
3432   verifyFormat("FOO(a)\n"
3433                "int b = 0;",
3434                Style);
3435   verifyFormat("FOO(a);\n"
3436                "int b = 0;",
3437                Style);
3438   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3439                "int b = 0;",
3440                Style);
3441   verifyFormat("FOO()\n"
3442                "int b = 0;",
3443                Style);
3444   verifyFormat("FOO\n"
3445                "int b = 0;",
3446                Style);
3447   verifyFormat("void f() {\n"
3448                "  FOO(a)\n"
3449                "  return a;\n"
3450                "}",
3451                Style);
3452   verifyFormat("FOO(a)\n"
3453                "FOO(b)",
3454                Style);
3455   verifyFormat("int a = 0;\n"
3456                "FOO(b)\n"
3457                "int c = 0;",
3458                Style);
3459   verifyFormat("int a = 0;\n"
3460                "int x = FOO(a)\n"
3461                "int b = 0;",
3462                Style);
3463   verifyFormat("void foo(int a) { FOO(a) }\n"
3464                "uint32_t bar() {}",
3465                Style);
3466 }
3467 
3468 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3469   verifyFormat("#define A \\\n"
3470                "  f({     \\\n"
3471                "    g();  \\\n"
3472                "  });",
3473                getLLVMStyleWithColumns(11));
3474 }
3475 
3476 TEST_F(FormatTest, IndentPreprocessorDirectives) {
3477   FormatStyle Style = getLLVMStyle();
3478   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3479   Style.ColumnLimit = 40;
3480   verifyFormat("#ifdef _WIN32\n"
3481                "#define A 0\n"
3482                "#ifdef VAR2\n"
3483                "#define B 1\n"
3484                "#include <someheader.h>\n"
3485                "#define MACRO                          \\\n"
3486                "  some_very_long_func_aaaaaaaaaa();\n"
3487                "#endif\n"
3488                "#else\n"
3489                "#define A 1\n"
3490                "#endif",
3491                Style);
3492   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3493   verifyFormat("#ifdef _WIN32\n"
3494                "#  define A 0\n"
3495                "#  ifdef VAR2\n"
3496                "#    define B 1\n"
3497                "#    include <someheader.h>\n"
3498                "#    define MACRO                      \\\n"
3499                "      some_very_long_func_aaaaaaaaaa();\n"
3500                "#  endif\n"
3501                "#else\n"
3502                "#  define A 1\n"
3503                "#endif",
3504                Style);
3505   verifyFormat("#if A\n"
3506                "#  define MACRO                        \\\n"
3507                "    void a(int x) {                    \\\n"
3508                "      b();                             \\\n"
3509                "      c();                             \\\n"
3510                "      d();                             \\\n"
3511                "      e();                             \\\n"
3512                "      f();                             \\\n"
3513                "    }\n"
3514                "#endif",
3515                Style);
3516   // Comments before include guard.
3517   verifyFormat("// file comment\n"
3518                "// file comment\n"
3519                "#ifndef HEADER_H\n"
3520                "#define HEADER_H\n"
3521                "code();\n"
3522                "#endif",
3523                Style);
3524   // Test with include guards.
3525   verifyFormat("#ifndef HEADER_H\n"
3526                "#define HEADER_H\n"
3527                "code();\n"
3528                "#endif",
3529                Style);
3530   // Include guards must have a #define with the same variable immediately
3531   // after #ifndef.
3532   verifyFormat("#ifndef NOT_GUARD\n"
3533                "#  define FOO\n"
3534                "code();\n"
3535                "#endif",
3536                Style);
3537 
3538   // Include guards must cover the entire file.
3539   verifyFormat("code();\n"
3540                "code();\n"
3541                "#ifndef NOT_GUARD\n"
3542                "#  define NOT_GUARD\n"
3543                "code();\n"
3544                "#endif",
3545                Style);
3546   verifyFormat("#ifndef NOT_GUARD\n"
3547                "#  define NOT_GUARD\n"
3548                "code();\n"
3549                "#endif\n"
3550                "code();",
3551                Style);
3552   // Test with trailing blank lines.
3553   verifyFormat("#ifndef HEADER_H\n"
3554                "#define HEADER_H\n"
3555                "code();\n"
3556                "#endif\n",
3557                Style);
3558   // Include guards don't have #else.
3559   verifyFormat("#ifndef NOT_GUARD\n"
3560                "#  define NOT_GUARD\n"
3561                "code();\n"
3562                "#else\n"
3563                "#endif",
3564                Style);
3565   verifyFormat("#ifndef NOT_GUARD\n"
3566                "#  define NOT_GUARD\n"
3567                "code();\n"
3568                "#elif FOO\n"
3569                "#endif",
3570                Style);
3571   // Non-identifier #define after potential include guard.
3572   verifyFormat("#ifndef FOO\n"
3573                "#  define 1\n"
3574                "#endif\n",
3575                Style);
3576   // #if closes past last non-preprocessor line.
3577   verifyFormat("#ifndef FOO\n"
3578                "#define FOO\n"
3579                "#if 1\n"
3580                "int i;\n"
3581                "#  define A 0\n"
3582                "#endif\n"
3583                "#endif\n",
3584                Style);
3585   // Don't crash if there is an #elif directive without a condition.
3586   verifyFormat("#if 1\n"
3587                "int x;\n"
3588                "#elif\n"
3589                "int y;\n"
3590                "#else\n"
3591                "int z;\n"
3592                "#endif",
3593                Style);
3594   // FIXME: This doesn't handle the case where there's code between the
3595   // #ifndef and #define but all other conditions hold. This is because when
3596   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3597   // previous code line yet, so we can't detect it.
3598   EXPECT_EQ("#ifndef NOT_GUARD\n"
3599             "code();\n"
3600             "#define NOT_GUARD\n"
3601             "code();\n"
3602             "#endif",
3603             format("#ifndef NOT_GUARD\n"
3604                    "code();\n"
3605                    "#  define NOT_GUARD\n"
3606                    "code();\n"
3607                    "#endif",
3608                    Style));
3609   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3610   // be outside an include guard. Examples are #pragma once and
3611   // #pragma GCC diagnostic, or anything else that does not change the meaning
3612   // of the file if it's included multiple times.
3613   EXPECT_EQ("#ifdef WIN32\n"
3614             "#  pragma once\n"
3615             "#endif\n"
3616             "#ifndef HEADER_H\n"
3617             "#  define HEADER_H\n"
3618             "code();\n"
3619             "#endif",
3620             format("#ifdef WIN32\n"
3621                    "#  pragma once\n"
3622                    "#endif\n"
3623                    "#ifndef HEADER_H\n"
3624                    "#define HEADER_H\n"
3625                    "code();\n"
3626                    "#endif",
3627                    Style));
3628   // FIXME: This does not detect when there is a single non-preprocessor line
3629   // in front of an include-guard-like structure where other conditions hold
3630   // because ScopedLineState hides the line.
3631   EXPECT_EQ("code();\n"
3632             "#ifndef HEADER_H\n"
3633             "#define HEADER_H\n"
3634             "code();\n"
3635             "#endif",
3636             format("code();\n"
3637                    "#ifndef HEADER_H\n"
3638                    "#  define HEADER_H\n"
3639                    "code();\n"
3640                    "#endif",
3641                    Style));
3642   // Keep comments aligned with #, otherwise indent comments normally. These
3643   // tests cannot use verifyFormat because messUp manipulates leading
3644   // whitespace.
3645   {
3646     const char *Expected = ""
3647                            "void f() {\n"
3648                            "#if 1\n"
3649                            "// Preprocessor aligned.\n"
3650                            "#  define A 0\n"
3651                            "  // Code. Separated by blank line.\n"
3652                            "\n"
3653                            "#  define B 0\n"
3654                            "  // Code. Not aligned with #\n"
3655                            "#  define C 0\n"
3656                            "#endif";
3657     const char *ToFormat = ""
3658                            "void f() {\n"
3659                            "#if 1\n"
3660                            "// Preprocessor aligned.\n"
3661                            "#  define A 0\n"
3662                            "// Code. Separated by blank line.\n"
3663                            "\n"
3664                            "#  define B 0\n"
3665                            "   // Code. Not aligned with #\n"
3666                            "#  define C 0\n"
3667                            "#endif";
3668     EXPECT_EQ(Expected, format(ToFormat, Style));
3669     EXPECT_EQ(Expected, format(Expected, Style));
3670   }
3671   // Keep block quotes aligned.
3672   {
3673     const char *Expected = ""
3674                            "void f() {\n"
3675                            "#if 1\n"
3676                            "/* Preprocessor aligned. */\n"
3677                            "#  define A 0\n"
3678                            "  /* Code. Separated by blank line. */\n"
3679                            "\n"
3680                            "#  define B 0\n"
3681                            "  /* Code. Not aligned with # */\n"
3682                            "#  define C 0\n"
3683                            "#endif";
3684     const char *ToFormat = ""
3685                            "void f() {\n"
3686                            "#if 1\n"
3687                            "/* Preprocessor aligned. */\n"
3688                            "#  define A 0\n"
3689                            "/* Code. Separated by blank line. */\n"
3690                            "\n"
3691                            "#  define B 0\n"
3692                            "   /* Code. Not aligned with # */\n"
3693                            "#  define C 0\n"
3694                            "#endif";
3695     EXPECT_EQ(Expected, format(ToFormat, Style));
3696     EXPECT_EQ(Expected, format(Expected, Style));
3697   }
3698   // Keep comments aligned with un-indented directives.
3699   {
3700     const char *Expected = ""
3701                            "void f() {\n"
3702                            "// Preprocessor aligned.\n"
3703                            "#define A 0\n"
3704                            "  // Code. Separated by blank line.\n"
3705                            "\n"
3706                            "#define B 0\n"
3707                            "  // Code. Not aligned with #\n"
3708                            "#define C 0\n";
3709     const char *ToFormat = ""
3710                            "void f() {\n"
3711                            "// Preprocessor aligned.\n"
3712                            "#define A 0\n"
3713                            "// Code. Separated by blank line.\n"
3714                            "\n"
3715                            "#define B 0\n"
3716                            "   // Code. Not aligned with #\n"
3717                            "#define C 0\n";
3718     EXPECT_EQ(Expected, format(ToFormat, Style));
3719     EXPECT_EQ(Expected, format(Expected, Style));
3720   }
3721   // Test AfterHash with tabs.
3722   {
3723     FormatStyle Tabbed = Style;
3724     Tabbed.UseTab = FormatStyle::UT_Always;
3725     Tabbed.IndentWidth = 8;
3726     Tabbed.TabWidth = 8;
3727     verifyFormat("#ifdef _WIN32\n"
3728                  "#\tdefine A 0\n"
3729                  "#\tifdef VAR2\n"
3730                  "#\t\tdefine B 1\n"
3731                  "#\t\tinclude <someheader.h>\n"
3732                  "#\t\tdefine MACRO          \\\n"
3733                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3734                  "#\tendif\n"
3735                  "#else\n"
3736                  "#\tdefine A 1\n"
3737                  "#endif",
3738                  Tabbed);
3739   }
3740 
3741   // Regression test: Multiline-macro inside include guards.
3742   verifyFormat("#ifndef HEADER_H\n"
3743                "#define HEADER_H\n"
3744                "#define A()        \\\n"
3745                "  int i;           \\\n"
3746                "  int j;\n"
3747                "#endif // HEADER_H",
3748                getLLVMStyleWithColumns(20));
3749 
3750   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3751   // Basic before hash indent tests
3752   verifyFormat("#ifdef _WIN32\n"
3753                "  #define A 0\n"
3754                "  #ifdef VAR2\n"
3755                "    #define B 1\n"
3756                "    #include <someheader.h>\n"
3757                "    #define MACRO                      \\\n"
3758                "      some_very_long_func_aaaaaaaaaa();\n"
3759                "  #endif\n"
3760                "#else\n"
3761                "  #define A 1\n"
3762                "#endif",
3763                Style);
3764   verifyFormat("#if A\n"
3765                "  #define MACRO                        \\\n"
3766                "    void a(int x) {                    \\\n"
3767                "      b();                             \\\n"
3768                "      c();                             \\\n"
3769                "      d();                             \\\n"
3770                "      e();                             \\\n"
3771                "      f();                             \\\n"
3772                "    }\n"
3773                "#endif",
3774                Style);
3775   // Keep comments aligned with indented directives. These
3776   // tests cannot use verifyFormat because messUp manipulates leading
3777   // whitespace.
3778   {
3779     const char *Expected = "void f() {\n"
3780                            "// Aligned to preprocessor.\n"
3781                            "#if 1\n"
3782                            "  // Aligned to code.\n"
3783                            "  int a;\n"
3784                            "  #if 1\n"
3785                            "    // Aligned to preprocessor.\n"
3786                            "    #define A 0\n"
3787                            "  // Aligned to code.\n"
3788                            "  int b;\n"
3789                            "  #endif\n"
3790                            "#endif\n"
3791                            "}";
3792     const char *ToFormat = "void f() {\n"
3793                            "// Aligned to preprocessor.\n"
3794                            "#if 1\n"
3795                            "// Aligned to code.\n"
3796                            "int a;\n"
3797                            "#if 1\n"
3798                            "// Aligned to preprocessor.\n"
3799                            "#define A 0\n"
3800                            "// Aligned to code.\n"
3801                            "int b;\n"
3802                            "#endif\n"
3803                            "#endif\n"
3804                            "}";
3805     EXPECT_EQ(Expected, format(ToFormat, Style));
3806     EXPECT_EQ(Expected, format(Expected, Style));
3807   }
3808   {
3809     const char *Expected = "void f() {\n"
3810                            "/* Aligned to preprocessor. */\n"
3811                            "#if 1\n"
3812                            "  /* Aligned to code. */\n"
3813                            "  int a;\n"
3814                            "  #if 1\n"
3815                            "    /* Aligned to preprocessor. */\n"
3816                            "    #define A 0\n"
3817                            "  /* Aligned to code. */\n"
3818                            "  int b;\n"
3819                            "  #endif\n"
3820                            "#endif\n"
3821                            "}";
3822     const char *ToFormat = "void f() {\n"
3823                            "/* Aligned to preprocessor. */\n"
3824                            "#if 1\n"
3825                            "/* Aligned to code. */\n"
3826                            "int a;\n"
3827                            "#if 1\n"
3828                            "/* Aligned to preprocessor. */\n"
3829                            "#define A 0\n"
3830                            "/* Aligned to code. */\n"
3831                            "int b;\n"
3832                            "#endif\n"
3833                            "#endif\n"
3834                            "}";
3835     EXPECT_EQ(Expected, format(ToFormat, Style));
3836     EXPECT_EQ(Expected, format(Expected, Style));
3837   }
3838 
3839   // Test single comment before preprocessor
3840   verifyFormat("// Comment\n"
3841                "\n"
3842                "#if 1\n"
3843                "#endif",
3844                Style);
3845 }
3846 
3847 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3848   verifyFormat("{\n  { a #c; }\n}");
3849 }
3850 
3851 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3852   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
3853             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3854   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
3855             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3856 }
3857 
3858 TEST_F(FormatTest, EscapedNewlines) {
3859   FormatStyle Narrow = getLLVMStyleWithColumns(11);
3860   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
3861             format("#define A \\\nint i;\\\n  int j;", Narrow));
3862   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3863   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3864   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
3865   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3866 
3867   FormatStyle AlignLeft = getLLVMStyle();
3868   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3869   EXPECT_EQ("#define MACRO(x) \\\n"
3870             "private:         \\\n"
3871             "  int x(int a);\n",
3872             format("#define MACRO(x) \\\n"
3873                    "private:         \\\n"
3874                    "  int x(int a);\n",
3875                    AlignLeft));
3876 
3877   // CRLF line endings
3878   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
3879             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
3880   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3881   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3882   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
3883   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3884   EXPECT_EQ("#define MACRO(x) \\\r\n"
3885             "private:         \\\r\n"
3886             "  int x(int a);\r\n",
3887             format("#define MACRO(x) \\\r\n"
3888                    "private:         \\\r\n"
3889                    "  int x(int a);\r\n",
3890                    AlignLeft));
3891 
3892   FormatStyle DontAlign = getLLVMStyle();
3893   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3894   DontAlign.MaxEmptyLinesToKeep = 3;
3895   // FIXME: can't use verifyFormat here because the newline before
3896   // "public:" is not inserted the first time it's reformatted
3897   EXPECT_EQ("#define A \\\n"
3898             "  class Foo { \\\n"
3899             "    void bar(); \\\n"
3900             "\\\n"
3901             "\\\n"
3902             "\\\n"
3903             "  public: \\\n"
3904             "    void baz(); \\\n"
3905             "  };",
3906             format("#define A \\\n"
3907                    "  class Foo { \\\n"
3908                    "    void bar(); \\\n"
3909                    "\\\n"
3910                    "\\\n"
3911                    "\\\n"
3912                    "  public: \\\n"
3913                    "    void baz(); \\\n"
3914                    "  };",
3915                    DontAlign));
3916 }
3917 
3918 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3919   verifyFormat("#define A \\\n"
3920                "  int v(  \\\n"
3921                "      a); \\\n"
3922                "  int i;",
3923                getLLVMStyleWithColumns(11));
3924 }
3925 
3926 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3927   EXPECT_EQ(
3928       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3929       "                      \\\n"
3930       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3931       "\n"
3932       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3933       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3934       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
3935              "\\\n"
3936              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3937              "  \n"
3938              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3939              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3940 }
3941 
3942 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3943   EXPECT_EQ("int\n"
3944             "#define A\n"
3945             "    a;",
3946             format("int\n#define A\na;"));
3947   verifyFormat("functionCallTo(\n"
3948                "    someOtherFunction(\n"
3949                "        withSomeParameters, whichInSequence,\n"
3950                "        areLongerThanALine(andAnotherCall,\n"
3951                "#define A B\n"
3952                "                           withMoreParamters,\n"
3953                "                           whichStronglyInfluenceTheLayout),\n"
3954                "        andMoreParameters),\n"
3955                "    trailing);",
3956                getLLVMStyleWithColumns(69));
3957   verifyFormat("Foo::Foo()\n"
3958                "#ifdef BAR\n"
3959                "    : baz(0)\n"
3960                "#endif\n"
3961                "{\n"
3962                "}");
3963   verifyFormat("void f() {\n"
3964                "  if (true)\n"
3965                "#ifdef A\n"
3966                "    f(42);\n"
3967                "  x();\n"
3968                "#else\n"
3969                "    g();\n"
3970                "  x();\n"
3971                "#endif\n"
3972                "}");
3973   verifyFormat("void f(param1, param2,\n"
3974                "       param3,\n"
3975                "#ifdef A\n"
3976                "       param4(param5,\n"
3977                "#ifdef A1\n"
3978                "              param6,\n"
3979                "#ifdef A2\n"
3980                "              param7),\n"
3981                "#else\n"
3982                "              param8),\n"
3983                "       param9,\n"
3984                "#endif\n"
3985                "       param10,\n"
3986                "#endif\n"
3987                "       param11)\n"
3988                "#else\n"
3989                "       param12)\n"
3990                "#endif\n"
3991                "{\n"
3992                "  x();\n"
3993                "}",
3994                getLLVMStyleWithColumns(28));
3995   verifyFormat("#if 1\n"
3996                "int i;");
3997   verifyFormat("#if 1\n"
3998                "#endif\n"
3999                "#if 1\n"
4000                "#else\n"
4001                "#endif\n");
4002   verifyFormat("DEBUG({\n"
4003                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4004                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
4005                "});\n"
4006                "#if a\n"
4007                "#else\n"
4008                "#endif");
4009 
4010   verifyIncompleteFormat("void f(\n"
4011                          "#if A\n"
4012                          ");\n"
4013                          "#else\n"
4014                          "#endif");
4015 }
4016 
4017 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
4018   verifyFormat("#endif\n"
4019                "#if B");
4020 }
4021 
4022 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
4023   FormatStyle SingleLine = getLLVMStyle();
4024   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
4025   verifyFormat("#if 0\n"
4026                "#elif 1\n"
4027                "#endif\n"
4028                "void foo() {\n"
4029                "  if (test) foo2();\n"
4030                "}",
4031                SingleLine);
4032 }
4033 
4034 TEST_F(FormatTest, LayoutBlockInsideParens) {
4035   verifyFormat("functionCall({ int i; });");
4036   verifyFormat("functionCall({\n"
4037                "  int i;\n"
4038                "  int j;\n"
4039                "});");
4040   verifyFormat("functionCall(\n"
4041                "    {\n"
4042                "      int i;\n"
4043                "      int j;\n"
4044                "    },\n"
4045                "    aaaa, bbbb, cccc);");
4046   verifyFormat("functionA(functionB({\n"
4047                "            int i;\n"
4048                "            int j;\n"
4049                "          }),\n"
4050                "          aaaa, bbbb, cccc);");
4051   verifyFormat("functionCall(\n"
4052                "    {\n"
4053                "      int i;\n"
4054                "      int j;\n"
4055                "    },\n"
4056                "    aaaa, bbbb, // comment\n"
4057                "    cccc);");
4058   verifyFormat("functionA(functionB({\n"
4059                "            int i;\n"
4060                "            int j;\n"
4061                "          }),\n"
4062                "          aaaa, bbbb, // comment\n"
4063                "          cccc);");
4064   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
4065   verifyFormat("functionCall(aaaa, bbbb, {\n"
4066                "  int i;\n"
4067                "  int j;\n"
4068                "});");
4069   verifyFormat(
4070       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
4071       "    {\n"
4072       "      int i; // break\n"
4073       "    },\n"
4074       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
4075       "                                     ccccccccccccccccc));");
4076   verifyFormat("DEBUG({\n"
4077                "  if (a)\n"
4078                "    f();\n"
4079                "});");
4080 }
4081 
4082 TEST_F(FormatTest, LayoutBlockInsideStatement) {
4083   EXPECT_EQ("SOME_MACRO { int i; }\n"
4084             "int i;",
4085             format("  SOME_MACRO  {int i;}  int i;"));
4086 }
4087 
4088 TEST_F(FormatTest, LayoutNestedBlocks) {
4089   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
4090                "  struct s {\n"
4091                "    int i;\n"
4092                "  };\n"
4093                "  s kBitsToOs[] = {{10}};\n"
4094                "  for (int i = 0; i < 10; ++i)\n"
4095                "    return;\n"
4096                "}");
4097   verifyFormat("call(parameter, {\n"
4098                "  something();\n"
4099                "  // Comment using all columns.\n"
4100                "  somethingelse();\n"
4101                "});",
4102                getLLVMStyleWithColumns(40));
4103   verifyFormat("DEBUG( //\n"
4104                "    { f(); }, a);");
4105   verifyFormat("DEBUG( //\n"
4106                "    {\n"
4107                "      f(); //\n"
4108                "    },\n"
4109                "    a);");
4110 
4111   EXPECT_EQ("call(parameter, {\n"
4112             "  something();\n"
4113             "  // Comment too\n"
4114             "  // looooooooooong.\n"
4115             "  somethingElse();\n"
4116             "});",
4117             format("call(parameter, {\n"
4118                    "  something();\n"
4119                    "  // Comment too looooooooooong.\n"
4120                    "  somethingElse();\n"
4121                    "});",
4122                    getLLVMStyleWithColumns(29)));
4123   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
4124   EXPECT_EQ("DEBUG({ // comment\n"
4125             "  int i;\n"
4126             "});",
4127             format("DEBUG({ // comment\n"
4128                    "int  i;\n"
4129                    "});"));
4130   EXPECT_EQ("DEBUG({\n"
4131             "  int i;\n"
4132             "\n"
4133             "  // comment\n"
4134             "  int j;\n"
4135             "});",
4136             format("DEBUG({\n"
4137                    "  int  i;\n"
4138                    "\n"
4139                    "  // comment\n"
4140                    "  int  j;\n"
4141                    "});"));
4142 
4143   verifyFormat("DEBUG({\n"
4144                "  if (a)\n"
4145                "    return;\n"
4146                "});");
4147   verifyGoogleFormat("DEBUG({\n"
4148                      "  if (a) return;\n"
4149                      "});");
4150   FormatStyle Style = getGoogleStyle();
4151   Style.ColumnLimit = 45;
4152   verifyFormat("Debug(\n"
4153                "    aaaaa,\n"
4154                "    {\n"
4155                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
4156                "    },\n"
4157                "    a);",
4158                Style);
4159 
4160   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
4161 
4162   verifyNoCrash("^{v^{a}}");
4163 }
4164 
4165 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
4166   EXPECT_EQ("#define MACRO()                     \\\n"
4167             "  Debug(aaa, /* force line break */ \\\n"
4168             "        {                           \\\n"
4169             "          int i;                    \\\n"
4170             "          int j;                    \\\n"
4171             "        })",
4172             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
4173                    "          {  int   i;  int  j;   })",
4174                    getGoogleStyle()));
4175 
4176   EXPECT_EQ("#define A                                       \\\n"
4177             "  [] {                                          \\\n"
4178             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
4179             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
4180             "  }",
4181             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4182                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
4183                    getGoogleStyle()));
4184 }
4185 
4186 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
4187   EXPECT_EQ("{}", format("{}"));
4188   verifyFormat("enum E {};");
4189   verifyFormat("enum E {}");
4190   FormatStyle Style = getLLVMStyle();
4191   Style.SpaceInEmptyBlock = true;
4192   EXPECT_EQ("void f() { }", format("void f() {}", Style));
4193   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
4194   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4195 }
4196 
4197 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
4198   FormatStyle Style = getLLVMStyle();
4199   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
4200   Style.MacroBlockEnd = "^[A-Z_]+_END$";
4201   verifyFormat("FOO_BEGIN\n"
4202                "  FOO_ENTRY\n"
4203                "FOO_END",
4204                Style);
4205   verifyFormat("FOO_BEGIN\n"
4206                "  NESTED_FOO_BEGIN\n"
4207                "    NESTED_FOO_ENTRY\n"
4208                "  NESTED_FOO_END\n"
4209                "FOO_END",
4210                Style);
4211   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
4212                "  int x;\n"
4213                "  x = 1;\n"
4214                "FOO_END(Baz)",
4215                Style);
4216 }
4217 
4218 //===----------------------------------------------------------------------===//
4219 // Line break tests.
4220 //===----------------------------------------------------------------------===//
4221 
4222 TEST_F(FormatTest, PreventConfusingIndents) {
4223   verifyFormat(
4224       "void f() {\n"
4225       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
4226       "                         parameter, parameter, parameter)),\n"
4227       "                     SecondLongCall(parameter));\n"
4228       "}");
4229   verifyFormat(
4230       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4231       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4232       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4233       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
4234   verifyFormat(
4235       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4236       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
4237       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4238       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
4239   verifyFormat(
4240       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
4241       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
4242       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
4243       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
4244   verifyFormat("int a = bbbb && ccc &&\n"
4245                "        fffff(\n"
4246                "#define A Just forcing a new line\n"
4247                "            ddd);");
4248 }
4249 
4250 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
4251   verifyFormat(
4252       "bool aaaaaaa =\n"
4253       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
4254       "    bbbbbbbb();");
4255   verifyFormat(
4256       "bool aaaaaaa =\n"
4257       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
4258       "    bbbbbbbb();");
4259 
4260   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4261                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
4262                "    ccccccccc == ddddddddddd;");
4263   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4264                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
4265                "    ccccccccc == ddddddddddd;");
4266   verifyFormat(
4267       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
4268       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
4269       "    ccccccccc == ddddddddddd;");
4270 
4271   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4272                "                 aaaaaa) &&\n"
4273                "         bbbbbb && cccccc;");
4274   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4275                "                 aaaaaa) >>\n"
4276                "         bbbbbb;");
4277   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
4278                "    SourceMgr.getSpellingColumnNumber(\n"
4279                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
4280                "    1);");
4281 
4282   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4283                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
4284                "    cccccc) {\n}");
4285   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4286                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4287                "              cccccc) {\n}");
4288   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4289                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4290                "              cccccc) {\n}");
4291   verifyFormat("b = a &&\n"
4292                "    // Comment\n"
4293                "    b.c && d;");
4294 
4295   // If the LHS of a comparison is not a binary expression itself, the
4296   // additional linebreak confuses many people.
4297   verifyFormat(
4298       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4299       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
4300       "}");
4301   verifyFormat(
4302       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4303       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4304       "}");
4305   verifyFormat(
4306       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
4307       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4308       "}");
4309   verifyFormat(
4310       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4311       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
4312       "}");
4313   // Even explicit parentheses stress the precedence enough to make the
4314   // additional break unnecessary.
4315   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4316                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4317                "}");
4318   // This cases is borderline, but with the indentation it is still readable.
4319   verifyFormat(
4320       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4321       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4322       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4323       "}",
4324       getLLVMStyleWithColumns(75));
4325 
4326   // If the LHS is a binary expression, we should still use the additional break
4327   // as otherwise the formatting hides the operator precedence.
4328   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4329                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4330                "    5) {\n"
4331                "}");
4332   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4333                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4334                "    5) {\n"
4335                "}");
4336 
4337   FormatStyle OnePerLine = getLLVMStyle();
4338   OnePerLine.BinPackParameters = false;
4339   verifyFormat(
4340       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4341       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4342       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4343       OnePerLine);
4344 
4345   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4346                "                .aaa(aaaaaaaaaaaaa) *\n"
4347                "            aaaaaaa +\n"
4348                "        aaaaaaa;",
4349                getLLVMStyleWithColumns(40));
4350 }
4351 
4352 TEST_F(FormatTest, ExpressionIndentation) {
4353   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4354                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4355                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4356                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4357                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4358                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4359                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4360                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4361                "                 ccccccccccccccccccccccccccccccccccccccccc;");
4362   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4363                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4364                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4365                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4366   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4367                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4368                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4369                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4370   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4371                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4372                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4373                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4374   verifyFormat("if () {\n"
4375                "} else if (aaaaa && bbbbb > // break\n"
4376                "                        ccccc) {\n"
4377                "}");
4378   verifyFormat("if () {\n"
4379                "} else if constexpr (aaaaa && bbbbb > // break\n"
4380                "                                  ccccc) {\n"
4381                "}");
4382   verifyFormat("if () {\n"
4383                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4384                "                                  ccccc) {\n"
4385                "}");
4386   verifyFormat("if () {\n"
4387                "} else if (aaaaa &&\n"
4388                "           bbbbb > // break\n"
4389                "               ccccc &&\n"
4390                "           ddddd) {\n"
4391                "}");
4392 
4393   // Presence of a trailing comment used to change indentation of b.
4394   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4395                "       b;\n"
4396                "return aaaaaaaaaaaaaaaaaaa +\n"
4397                "       b; //",
4398                getLLVMStyleWithColumns(30));
4399 }
4400 
4401 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4402   // Not sure what the best system is here. Like this, the LHS can be found
4403   // immediately above an operator (everything with the same or a higher
4404   // indent). The RHS is aligned right of the operator and so compasses
4405   // everything until something with the same indent as the operator is found.
4406   // FIXME: Is this a good system?
4407   FormatStyle Style = getLLVMStyle();
4408   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4409   verifyFormat(
4410       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4411       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4412       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4413       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4414       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4415       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4416       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4417       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4418       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
4419       Style);
4420   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4421                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4422                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4423                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4424                Style);
4425   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4426                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4427                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4428                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4429                Style);
4430   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4431                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4432                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4433                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4434                Style);
4435   verifyFormat("if () {\n"
4436                "} else if (aaaaa\n"
4437                "           && bbbbb // break\n"
4438                "                  > ccccc) {\n"
4439                "}",
4440                Style);
4441   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4442                "       && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4443                Style);
4444   verifyFormat("return (a)\n"
4445                "       // comment\n"
4446                "       + b;",
4447                Style);
4448   verifyFormat(
4449       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4450       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4451       "             + cc;",
4452       Style);
4453 
4454   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4455                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4456                Style);
4457 
4458   // Forced by comments.
4459   verifyFormat(
4460       "unsigned ContentSize =\n"
4461       "    sizeof(int16_t)   // DWARF ARange version number\n"
4462       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4463       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4464       "    + sizeof(int8_t); // Segment Size (in bytes)");
4465 
4466   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4467                "       == boost::fusion::at_c<1>(iiii).second;",
4468                Style);
4469 
4470   Style.ColumnLimit = 60;
4471   verifyFormat("zzzzzzzzzz\n"
4472                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4473                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4474                Style);
4475 
4476   Style.ColumnLimit = 80;
4477   Style.IndentWidth = 4;
4478   Style.TabWidth = 4;
4479   Style.UseTab = FormatStyle::UT_Always;
4480   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4481   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4482   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4483             "\t&& (someOtherLongishConditionPart1\n"
4484             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4485             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4486                    "(someOtherLongishConditionPart1 || "
4487                    "someOtherEvenLongerNestedConditionPart2);",
4488                    Style));
4489 }
4490 
4491 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
4492   FormatStyle Style = getLLVMStyle();
4493   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4494   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
4495 
4496   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4497                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4498                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4499                "              == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4500                "                         * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4501                "                     + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4502                "          && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4503                "                     * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4504                "                 > ccccccccccccccccccccccccccccccccccccccccc;",
4505                Style);
4506   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4507                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4508                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4509                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4510                Style);
4511   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4512                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4513                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4514                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4515                Style);
4516   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4517                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4518                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4519                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4520                Style);
4521   verifyFormat("if () {\n"
4522                "} else if (aaaaa\n"
4523                "           && bbbbb // break\n"
4524                "                  > ccccc) {\n"
4525                "}",
4526                Style);
4527   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4528                "    && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4529                Style);
4530   verifyFormat("return (a)\n"
4531                "     // comment\n"
4532                "     + b;",
4533                Style);
4534   verifyFormat(
4535       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4536       "               * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4537       "           + cc;",
4538       Style);
4539   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
4540                "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4541                "                        : 3333333333333333;",
4542                Style);
4543   verifyFormat(
4544       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
4545       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
4546       "                                             : eeeeeeeeeeeeeeeeee)\n"
4547       "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4548       "                        : 3333333333333333;",
4549       Style);
4550   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4551                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4552                Style);
4553 
4554   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4555                "    == boost::fusion::at_c<1>(iiii).second;",
4556                Style);
4557 
4558   Style.ColumnLimit = 60;
4559   verifyFormat("zzzzzzzzzzzzz\n"
4560                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4561                "   >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4562                Style);
4563 
4564   // Forced by comments.
4565   Style.ColumnLimit = 80;
4566   verifyFormat(
4567       "unsigned ContentSize\n"
4568       "    = sizeof(int16_t) // DWARF ARange version number\n"
4569       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4570       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4571       "    + sizeof(int8_t); // Segment Size (in bytes)",
4572       Style);
4573 
4574   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4575   verifyFormat(
4576       "unsigned ContentSize =\n"
4577       "    sizeof(int16_t)   // DWARF ARange version number\n"
4578       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4579       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4580       "    + sizeof(int8_t); // Segment Size (in bytes)",
4581       Style);
4582 
4583   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4584   verifyFormat(
4585       "unsigned ContentSize =\n"
4586       "    sizeof(int16_t)   // DWARF ARange version number\n"
4587       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4588       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4589       "    + sizeof(int8_t); // Segment Size (in bytes)",
4590       Style);
4591 }
4592 
4593 TEST_F(FormatTest, EnforcedOperatorWraps) {
4594   // Here we'd like to wrap after the || operators, but a comment is forcing an
4595   // earlier wrap.
4596   verifyFormat("bool x = aaaaa //\n"
4597                "         || bbbbb\n"
4598                "         //\n"
4599                "         || cccc;");
4600 }
4601 
4602 TEST_F(FormatTest, NoOperandAlignment) {
4603   FormatStyle Style = getLLVMStyle();
4604   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4605   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4606                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4607                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4608                Style);
4609   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4610   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4611                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4612                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4613                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4614                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4615                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4616                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4617                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4618                "        > ccccccccccccccccccccccccccccccccccccccccc;",
4619                Style);
4620 
4621   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4622                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4623                "    + cc;",
4624                Style);
4625   verifyFormat("int a = aa\n"
4626                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4627                "        * cccccccccccccccccccccccccccccccccccc;\n",
4628                Style);
4629 
4630   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4631   verifyFormat("return (a > b\n"
4632                "    // comment1\n"
4633                "    // comment2\n"
4634                "    || c);",
4635                Style);
4636 }
4637 
4638 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4639   FormatStyle Style = getLLVMStyle();
4640   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4641   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4642                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4643                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4644                Style);
4645 }
4646 
4647 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4648   FormatStyle Style = getLLVMStyle();
4649   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4650   Style.BinPackArguments = false;
4651   Style.ColumnLimit = 40;
4652   verifyFormat("void test() {\n"
4653                "  someFunction(\n"
4654                "      this + argument + is + quite\n"
4655                "      + long + so + it + gets + wrapped\n"
4656                "      + but + remains + bin - packed);\n"
4657                "}",
4658                Style);
4659   verifyFormat("void test() {\n"
4660                "  someFunction(arg1,\n"
4661                "               this + argument + is\n"
4662                "                   + quite + long + so\n"
4663                "                   + it + gets + wrapped\n"
4664                "                   + but + remains + bin\n"
4665                "                   - packed,\n"
4666                "               arg3);\n"
4667                "}",
4668                Style);
4669   verifyFormat("void test() {\n"
4670                "  someFunction(\n"
4671                "      arg1,\n"
4672                "      this + argument + has\n"
4673                "          + anotherFunc(nested,\n"
4674                "                        calls + whose\n"
4675                "                            + arguments\n"
4676                "                            + are + also\n"
4677                "                            + wrapped,\n"
4678                "                        in + addition)\n"
4679                "          + to + being + bin - packed,\n"
4680                "      arg3);\n"
4681                "}",
4682                Style);
4683 
4684   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4685   verifyFormat("void test() {\n"
4686                "  someFunction(\n"
4687                "      arg1,\n"
4688                "      this + argument + has +\n"
4689                "          anotherFunc(nested,\n"
4690                "                      calls + whose +\n"
4691                "                          arguments +\n"
4692                "                          are + also +\n"
4693                "                          wrapped,\n"
4694                "                      in + addition) +\n"
4695                "          to + being + bin - packed,\n"
4696                "      arg3);\n"
4697                "}",
4698                Style);
4699 }
4700 
4701 TEST_F(FormatTest, ConstructorInitializers) {
4702   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4703   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4704                getLLVMStyleWithColumns(45));
4705   verifyFormat("Constructor()\n"
4706                "    : Inttializer(FitsOnTheLine) {}",
4707                getLLVMStyleWithColumns(44));
4708   verifyFormat("Constructor()\n"
4709                "    : Inttializer(FitsOnTheLine) {}",
4710                getLLVMStyleWithColumns(43));
4711 
4712   verifyFormat("template <typename T>\n"
4713                "Constructor() : Initializer(FitsOnTheLine) {}",
4714                getLLVMStyleWithColumns(45));
4715 
4716   verifyFormat(
4717       "SomeClass::Constructor()\n"
4718       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4719 
4720   verifyFormat(
4721       "SomeClass::Constructor()\n"
4722       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4723       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4724   verifyFormat(
4725       "SomeClass::Constructor()\n"
4726       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4727       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4728   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4729                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4730                "    : aaaaaaaaaa(aaaaaa) {}");
4731 
4732   verifyFormat("Constructor()\n"
4733                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4734                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4735                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4736                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
4737 
4738   verifyFormat("Constructor()\n"
4739                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4740                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4741 
4742   verifyFormat("Constructor(int Parameter = 0)\n"
4743                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4744                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4745   verifyFormat("Constructor()\n"
4746                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4747                "}",
4748                getLLVMStyleWithColumns(60));
4749   verifyFormat("Constructor()\n"
4750                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4751                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4752 
4753   // Here a line could be saved by splitting the second initializer onto two
4754   // lines, but that is not desirable.
4755   verifyFormat("Constructor()\n"
4756                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4757                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
4758                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4759 
4760   FormatStyle OnePerLine = getLLVMStyle();
4761   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4762   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4763   verifyFormat("SomeClass::Constructor()\n"
4764                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4765                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4766                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4767                OnePerLine);
4768   verifyFormat("SomeClass::Constructor()\n"
4769                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4770                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4771                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4772                OnePerLine);
4773   verifyFormat("MyClass::MyClass(int var)\n"
4774                "    : some_var_(var),            // 4 space indent\n"
4775                "      some_other_var_(var + 1) { // lined up\n"
4776                "}",
4777                OnePerLine);
4778   verifyFormat("Constructor()\n"
4779                "    : aaaaa(aaaaaa),\n"
4780                "      aaaaa(aaaaaa),\n"
4781                "      aaaaa(aaaaaa),\n"
4782                "      aaaaa(aaaaaa),\n"
4783                "      aaaaa(aaaaaa) {}",
4784                OnePerLine);
4785   verifyFormat("Constructor()\n"
4786                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4787                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
4788                OnePerLine);
4789   OnePerLine.BinPackParameters = false;
4790   verifyFormat(
4791       "Constructor()\n"
4792       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4793       "          aaaaaaaaaaa().aaa(),\n"
4794       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4795       OnePerLine);
4796   OnePerLine.ColumnLimit = 60;
4797   verifyFormat("Constructor()\n"
4798                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4799                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4800                OnePerLine);
4801 
4802   EXPECT_EQ("Constructor()\n"
4803             "    : // Comment forcing unwanted break.\n"
4804             "      aaaa(aaaa) {}",
4805             format("Constructor() :\n"
4806                    "    // Comment forcing unwanted break.\n"
4807                    "    aaaa(aaaa) {}"));
4808 }
4809 
4810 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4811   FormatStyle Style = getLLVMStyle();
4812   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4813   Style.ColumnLimit = 60;
4814   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4815   Style.AllowAllConstructorInitializersOnNextLine = true;
4816   Style.BinPackParameters = false;
4817 
4818   for (int i = 0; i < 4; ++i) {
4819     // Test all combinations of parameters that should not have an effect.
4820     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4821     Style.AllowAllArgumentsOnNextLine = i & 2;
4822 
4823     Style.AllowAllConstructorInitializersOnNextLine = true;
4824     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4825     verifyFormat("Constructor()\n"
4826                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4827                  Style);
4828     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4829 
4830     Style.AllowAllConstructorInitializersOnNextLine = false;
4831     verifyFormat("Constructor()\n"
4832                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4833                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4834                  Style);
4835     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4836 
4837     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4838     Style.AllowAllConstructorInitializersOnNextLine = true;
4839     verifyFormat("Constructor()\n"
4840                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4841                  Style);
4842 
4843     Style.AllowAllConstructorInitializersOnNextLine = false;
4844     verifyFormat("Constructor()\n"
4845                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4846                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4847                  Style);
4848 
4849     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4850     Style.AllowAllConstructorInitializersOnNextLine = true;
4851     verifyFormat("Constructor() :\n"
4852                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4853                  Style);
4854 
4855     Style.AllowAllConstructorInitializersOnNextLine = false;
4856     verifyFormat("Constructor() :\n"
4857                  "    aaaaaaaaaaaaaaaaaa(a),\n"
4858                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4859                  Style);
4860   }
4861 
4862   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4863   // AllowAllConstructorInitializersOnNextLine in all
4864   // BreakConstructorInitializers modes
4865   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4866   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4867   Style.AllowAllConstructorInitializersOnNextLine = false;
4868   verifyFormat("SomeClassWithALongName::Constructor(\n"
4869                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4870                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4871                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4872                Style);
4873 
4874   Style.AllowAllConstructorInitializersOnNextLine = true;
4875   verifyFormat("SomeClassWithALongName::Constructor(\n"
4876                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4877                "    int bbbbbbbbbbbbb,\n"
4878                "    int cccccccccccccccc)\n"
4879                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4880                Style);
4881 
4882   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4883   Style.AllowAllConstructorInitializersOnNextLine = false;
4884   verifyFormat("SomeClassWithALongName::Constructor(\n"
4885                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4886                "    int bbbbbbbbbbbbb)\n"
4887                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4888                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4889                Style);
4890 
4891   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4892 
4893   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4894   verifyFormat("SomeClassWithALongName::Constructor(\n"
4895                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4896                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4897                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4898                Style);
4899 
4900   Style.AllowAllConstructorInitializersOnNextLine = true;
4901   verifyFormat("SomeClassWithALongName::Constructor(\n"
4902                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4903                "    int bbbbbbbbbbbbb,\n"
4904                "    int cccccccccccccccc)\n"
4905                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4906                Style);
4907 
4908   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4909   Style.AllowAllConstructorInitializersOnNextLine = false;
4910   verifyFormat("SomeClassWithALongName::Constructor(\n"
4911                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4912                "    int bbbbbbbbbbbbb)\n"
4913                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4914                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4915                Style);
4916 
4917   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4918   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4919   verifyFormat("SomeClassWithALongName::Constructor(\n"
4920                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4921                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4922                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4923                Style);
4924 
4925   Style.AllowAllConstructorInitializersOnNextLine = true;
4926   verifyFormat("SomeClassWithALongName::Constructor(\n"
4927                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4928                "    int bbbbbbbbbbbbb,\n"
4929                "    int cccccccccccccccc) :\n"
4930                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4931                Style);
4932 
4933   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4934   Style.AllowAllConstructorInitializersOnNextLine = false;
4935   verifyFormat("SomeClassWithALongName::Constructor(\n"
4936                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4937                "    int bbbbbbbbbbbbb) :\n"
4938                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4939                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4940                Style);
4941 }
4942 
4943 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4944   FormatStyle Style = getLLVMStyle();
4945   Style.ColumnLimit = 60;
4946   Style.BinPackArguments = false;
4947   for (int i = 0; i < 4; ++i) {
4948     // Test all combinations of parameters that should not have an effect.
4949     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4950     Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4951 
4952     Style.AllowAllArgumentsOnNextLine = true;
4953     verifyFormat("void foo() {\n"
4954                  "  FunctionCallWithReallyLongName(\n"
4955                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4956                  "}",
4957                  Style);
4958     Style.AllowAllArgumentsOnNextLine = false;
4959     verifyFormat("void foo() {\n"
4960                  "  FunctionCallWithReallyLongName(\n"
4961                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4962                  "      bbbbbbbbbbbb);\n"
4963                  "}",
4964                  Style);
4965 
4966     Style.AllowAllArgumentsOnNextLine = true;
4967     verifyFormat("void foo() {\n"
4968                  "  auto VariableWithReallyLongName = {\n"
4969                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4970                  "}",
4971                  Style);
4972     Style.AllowAllArgumentsOnNextLine = false;
4973     verifyFormat("void foo() {\n"
4974                  "  auto VariableWithReallyLongName = {\n"
4975                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4976                  "      bbbbbbbbbbbb};\n"
4977                  "}",
4978                  Style);
4979   }
4980 
4981   // This parameter should not affect declarations.
4982   Style.BinPackParameters = false;
4983   Style.AllowAllArgumentsOnNextLine = false;
4984   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4985   verifyFormat("void FunctionCallWithReallyLongName(\n"
4986                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
4987                Style);
4988   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4989   verifyFormat("void FunctionCallWithReallyLongName(\n"
4990                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
4991                "    int bbbbbbbbbbbb);",
4992                Style);
4993 }
4994 
4995 TEST_F(FormatTest, AllowAllArgumentsOnNextLineDontAlign) {
4996   // Check that AllowAllArgumentsOnNextLine is respected for both BAS_DontAlign
4997   // and BAS_Align.
4998   auto Style = getLLVMStyle();
4999   Style.ColumnLimit = 35;
5000   StringRef Input = "functionCall(paramA, paramB, paramC);\n"
5001                     "void functionDecl(int A, int B, int C);";
5002   Style.AllowAllArgumentsOnNextLine = false;
5003   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5004   EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
5005                       "    paramC);\n"
5006                       "void functionDecl(int A, int B,\n"
5007                       "    int C);"),
5008             format(Input, Style));
5009   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
5010   EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
5011                       "             paramC);\n"
5012                       "void functionDecl(int A, int B,\n"
5013                       "                  int C);"),
5014             format(Input, Style));
5015   // However, BAS_AlwaysBreak should take precedence over
5016   // AllowAllArgumentsOnNextLine.
5017   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5018   EXPECT_EQ(StringRef("functionCall(\n"
5019                       "    paramA, paramB, paramC);\n"
5020                       "void functionDecl(\n"
5021                       "    int A, int B, int C);"),
5022             format(Input, Style));
5023 
5024   // When AllowAllArgumentsOnNextLine is set, we prefer breaking before the
5025   // first argument.
5026   Style.AllowAllArgumentsOnNextLine = true;
5027   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5028   EXPECT_EQ(StringRef("functionCall(\n"
5029                       "    paramA, paramB, paramC);\n"
5030                       "void functionDecl(\n"
5031                       "    int A, int B, int C);"),
5032             format(Input, Style));
5033   // It wouldn't fit on one line with aligned parameters so this setting
5034   // doesn't change anything for BAS_Align.
5035   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
5036   EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
5037                       "             paramC);\n"
5038                       "void functionDecl(int A, int B,\n"
5039                       "                  int C);"),
5040             format(Input, Style));
5041   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5042   EXPECT_EQ(StringRef("functionCall(\n"
5043                       "    paramA, paramB, paramC);\n"
5044                       "void functionDecl(\n"
5045                       "    int A, int B, int C);"),
5046             format(Input, Style));
5047 }
5048 
5049 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
5050   FormatStyle Style = getLLVMStyle();
5051   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
5052 
5053   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
5054   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
5055                getStyleWithColumns(Style, 45));
5056   verifyFormat("Constructor() :\n"
5057                "    Initializer(FitsOnTheLine) {}",
5058                getStyleWithColumns(Style, 44));
5059   verifyFormat("Constructor() :\n"
5060                "    Initializer(FitsOnTheLine) {}",
5061                getStyleWithColumns(Style, 43));
5062 
5063   verifyFormat("template <typename T>\n"
5064                "Constructor() : Initializer(FitsOnTheLine) {}",
5065                getStyleWithColumns(Style, 50));
5066   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5067   verifyFormat(
5068       "SomeClass::Constructor() :\n"
5069       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5070       Style);
5071 
5072   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
5073   verifyFormat(
5074       "SomeClass::Constructor() :\n"
5075       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5076       Style);
5077 
5078   verifyFormat(
5079       "SomeClass::Constructor() :\n"
5080       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5081       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5082       Style);
5083   verifyFormat(
5084       "SomeClass::Constructor() :\n"
5085       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5086       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5087       Style);
5088   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5089                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
5090                "    aaaaaaaaaa(aaaaaa) {}",
5091                Style);
5092 
5093   verifyFormat("Constructor() :\n"
5094                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5095                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5096                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5097                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
5098                Style);
5099 
5100   verifyFormat("Constructor() :\n"
5101                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5102                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5103                Style);
5104 
5105   verifyFormat("Constructor(int Parameter = 0) :\n"
5106                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
5107                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
5108                Style);
5109   verifyFormat("Constructor() :\n"
5110                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
5111                "}",
5112                getStyleWithColumns(Style, 60));
5113   verifyFormat("Constructor() :\n"
5114                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5115                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
5116                Style);
5117 
5118   // Here a line could be saved by splitting the second initializer onto two
5119   // lines, but that is not desirable.
5120   verifyFormat("Constructor() :\n"
5121                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
5122                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
5123                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5124                Style);
5125 
5126   FormatStyle OnePerLine = Style;
5127   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5128   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
5129   verifyFormat("SomeClass::Constructor() :\n"
5130                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5131                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5132                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5133                OnePerLine);
5134   verifyFormat("SomeClass::Constructor() :\n"
5135                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
5136                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5137                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5138                OnePerLine);
5139   verifyFormat("MyClass::MyClass(int var) :\n"
5140                "    some_var_(var),            // 4 space indent\n"
5141                "    some_other_var_(var + 1) { // lined up\n"
5142                "}",
5143                OnePerLine);
5144   verifyFormat("Constructor() :\n"
5145                "    aaaaa(aaaaaa),\n"
5146                "    aaaaa(aaaaaa),\n"
5147                "    aaaaa(aaaaaa),\n"
5148                "    aaaaa(aaaaaa),\n"
5149                "    aaaaa(aaaaaa) {}",
5150                OnePerLine);
5151   verifyFormat("Constructor() :\n"
5152                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5153                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
5154                OnePerLine);
5155   OnePerLine.BinPackParameters = false;
5156   verifyFormat("Constructor() :\n"
5157                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5158                "        aaaaaaaaaaa().aaa(),\n"
5159                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5160                OnePerLine);
5161   OnePerLine.ColumnLimit = 60;
5162   verifyFormat("Constructor() :\n"
5163                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
5164                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
5165                OnePerLine);
5166 
5167   EXPECT_EQ("Constructor() :\n"
5168             "    // Comment forcing unwanted break.\n"
5169             "    aaaa(aaaa) {}",
5170             format("Constructor() :\n"
5171                    "    // Comment forcing unwanted break.\n"
5172                    "    aaaa(aaaa) {}",
5173                    Style));
5174 
5175   Style.ColumnLimit = 0;
5176   verifyFormat("SomeClass::Constructor() :\n"
5177                "    a(a) {}",
5178                Style);
5179   verifyFormat("SomeClass::Constructor() noexcept :\n"
5180                "    a(a) {}",
5181                Style);
5182   verifyFormat("SomeClass::Constructor() :\n"
5183                "    a(a), b(b), c(c) {}",
5184                Style);
5185   verifyFormat("SomeClass::Constructor() :\n"
5186                "    a(a) {\n"
5187                "  foo();\n"
5188                "  bar();\n"
5189                "}",
5190                Style);
5191 
5192   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5193   verifyFormat("SomeClass::Constructor() :\n"
5194                "    a(a), b(b), c(c) {\n"
5195                "}",
5196                Style);
5197   verifyFormat("SomeClass::Constructor() :\n"
5198                "    a(a) {\n"
5199                "}",
5200                Style);
5201 
5202   Style.ColumnLimit = 80;
5203   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5204   Style.ConstructorInitializerIndentWidth = 2;
5205   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5206   verifyFormat("SomeClass::Constructor() :\n"
5207                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5208                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5209                Style);
5210 
5211   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5212   // well
5213   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5214   verifyFormat(
5215       "class SomeClass\n"
5216       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5217       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5218       Style);
5219   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5220   verifyFormat(
5221       "class SomeClass\n"
5222       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5223       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5224       Style);
5225   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5226   verifyFormat(
5227       "class SomeClass :\n"
5228       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5229       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5230       Style);
5231 }
5232 
5233 #ifndef EXPENSIVE_CHECKS
5234 // Expensive checks enables libstdc++ checking which includes validating the
5235 // state of ranges used in std::priority_queue - this blows out the
5236 // runtime/scalability of the function and makes this test unacceptably slow.
5237 TEST_F(FormatTest, MemoizationTests) {
5238   // This breaks if the memoization lookup does not take \c Indent and
5239   // \c LastSpace into account.
5240   verifyFormat(
5241       "extern CFRunLoopTimerRef\n"
5242       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5243       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
5244       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
5245       "                     CFRunLoopTimerContext *context) {}");
5246 
5247   // Deep nesting somewhat works around our memoization.
5248   verifyFormat(
5249       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5250       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5251       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5252       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5253       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
5254       getLLVMStyleWithColumns(65));
5255   verifyFormat(
5256       "aaaaa(\n"
5257       "    aaaaa,\n"
5258       "    aaaaa(\n"
5259       "        aaaaa,\n"
5260       "        aaaaa(\n"
5261       "            aaaaa,\n"
5262       "            aaaaa(\n"
5263       "                aaaaa,\n"
5264       "                aaaaa(\n"
5265       "                    aaaaa,\n"
5266       "                    aaaaa(\n"
5267       "                        aaaaa,\n"
5268       "                        aaaaa(\n"
5269       "                            aaaaa,\n"
5270       "                            aaaaa(\n"
5271       "                                aaaaa,\n"
5272       "                                aaaaa(\n"
5273       "                                    aaaaa,\n"
5274       "                                    aaaaa(\n"
5275       "                                        aaaaa,\n"
5276       "                                        aaaaa(\n"
5277       "                                            aaaaa,\n"
5278       "                                            aaaaa(\n"
5279       "                                                aaaaa,\n"
5280       "                                                aaaaa))))))))))));",
5281       getLLVMStyleWithColumns(65));
5282   verifyFormat(
5283       "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"
5284       "                                  a),\n"
5285       "                                a),\n"
5286       "                              a),\n"
5287       "                            a),\n"
5288       "                          a),\n"
5289       "                        a),\n"
5290       "                      a),\n"
5291       "                    a),\n"
5292       "                  a),\n"
5293       "                a),\n"
5294       "              a),\n"
5295       "            a),\n"
5296       "          a),\n"
5297       "        a),\n"
5298       "      a),\n"
5299       "    a),\n"
5300       "  a)",
5301       getLLVMStyleWithColumns(65));
5302 
5303   // This test takes VERY long when memoization is broken.
5304   FormatStyle OnePerLine = getLLVMStyle();
5305   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5306   OnePerLine.BinPackParameters = false;
5307   std::string input = "Constructor()\n"
5308                       "    : aaaa(a,\n";
5309   for (unsigned i = 0, e = 80; i != e; ++i) {
5310     input += "           a,\n";
5311   }
5312   input += "           a) {}";
5313   verifyFormat(input, OnePerLine);
5314 }
5315 #endif
5316 
5317 TEST_F(FormatTest, BreaksAsHighAsPossible) {
5318   verifyFormat(
5319       "void f() {\n"
5320       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5321       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5322       "    f();\n"
5323       "}");
5324   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5325                "    Intervals[i - 1].getRange().getLast()) {\n}");
5326 }
5327 
5328 TEST_F(FormatTest, BreaksFunctionDeclarations) {
5329   // Principially, we break function declarations in a certain order:
5330   // 1) break amongst arguments.
5331   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5332                "                              Cccccccccccccc cccccccccccccc);");
5333   verifyFormat("template <class TemplateIt>\n"
5334                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5335                "                            TemplateIt *stop) {}");
5336 
5337   // 2) break after return type.
5338   verifyFormat(
5339       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5340       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5341       getGoogleStyle());
5342 
5343   // 3) break after (.
5344   verifyFormat(
5345       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5346       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5347       getGoogleStyle());
5348 
5349   // 4) break before after nested name specifiers.
5350   verifyFormat(
5351       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5352       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5353       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5354       getGoogleStyle());
5355 
5356   // However, there are exceptions, if a sufficient amount of lines can be
5357   // saved.
5358   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5359   // more adjusting.
5360   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5361                "                                  Cccccccccccccc cccccccccc,\n"
5362                "                                  Cccccccccccccc cccccccccc,\n"
5363                "                                  Cccccccccccccc cccccccccc,\n"
5364                "                                  Cccccccccccccc cccccccccc);");
5365   verifyFormat(
5366       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5367       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5368       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5369       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5370       getGoogleStyle());
5371   verifyFormat(
5372       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5373       "                                          Cccccccccccccc cccccccccc,\n"
5374       "                                          Cccccccccccccc cccccccccc,\n"
5375       "                                          Cccccccccccccc cccccccccc,\n"
5376       "                                          Cccccccccccccc cccccccccc,\n"
5377       "                                          Cccccccccccccc cccccccccc,\n"
5378       "                                          Cccccccccccccc cccccccccc);");
5379   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5380                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5381                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5382                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5383                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5384 
5385   // Break after multi-line parameters.
5386   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5387                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5388                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5389                "    bbbb bbbb);");
5390   verifyFormat("void SomeLoooooooooooongFunction(\n"
5391                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5392                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5393                "    int bbbbbbbbbbbbb);");
5394 
5395   // Treat overloaded operators like other functions.
5396   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5397                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5398   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5399                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5400   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5401                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5402   verifyGoogleFormat(
5403       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5404       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5405   verifyGoogleFormat(
5406       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5407       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5408   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5409                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5410   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5411                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5412   verifyGoogleFormat(
5413       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5414       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5415       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5416   verifyGoogleFormat("template <typename T>\n"
5417                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5418                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5419                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5420 
5421   FormatStyle Style = getLLVMStyle();
5422   Style.PointerAlignment = FormatStyle::PAS_Left;
5423   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5424                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5425                Style);
5426   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5427                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5428                Style);
5429 }
5430 
5431 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5432   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5433   // Prefer keeping `::` followed by `operator` together.
5434   EXPECT_EQ("const aaaa::bbbbbbb &\n"
5435             "ccccccccc::operator++() {\n"
5436             "  stuff();\n"
5437             "}",
5438             format("const aaaa::bbbbbbb\n"
5439                    "&ccccccccc::operator++() { stuff(); }",
5440                    getLLVMStyleWithColumns(40)));
5441 }
5442 
5443 TEST_F(FormatTest, TrailingReturnType) {
5444   verifyFormat("auto foo() -> int;\n");
5445   // correct trailing return type spacing
5446   verifyFormat("auto operator->() -> int;\n");
5447   verifyFormat("auto operator++(int) -> int;\n");
5448 
5449   verifyFormat("struct S {\n"
5450                "  auto bar() const -> int;\n"
5451                "};");
5452   verifyFormat("template <size_t Order, typename T>\n"
5453                "auto load_img(const std::string &filename)\n"
5454                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
5455   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5456                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5457   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5458   verifyFormat("template <typename T>\n"
5459                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5460                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5461 
5462   // Not trailing return types.
5463   verifyFormat("void f() { auto a = b->c(); }");
5464 }
5465 
5466 TEST_F(FormatTest, DeductionGuides) {
5467   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5468   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5469   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5470   verifyFormat(
5471       "template <class... T>\n"
5472       "array(T &&...t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5473   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5474   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5475   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5476   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5477   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5478   verifyFormat("template <class T> x() -> x<1>;");
5479   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5480 
5481   // Ensure not deduction guides.
5482   verifyFormat("c()->f<int>();");
5483   verifyFormat("x()->foo<1>;");
5484   verifyFormat("x = p->foo<3>();");
5485   verifyFormat("x()->x<1>();");
5486   verifyFormat("x()->x<1>;");
5487 }
5488 
5489 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5490   // Avoid breaking before trailing 'const' or other trailing annotations, if
5491   // they are not function-like.
5492   FormatStyle Style = getGoogleStyle();
5493   Style.ColumnLimit = 47;
5494   verifyFormat("void someLongFunction(\n"
5495                "    int someLoooooooooooooongParameter) const {\n}",
5496                getLLVMStyleWithColumns(47));
5497   verifyFormat("LoooooongReturnType\n"
5498                "someLoooooooongFunction() const {}",
5499                getLLVMStyleWithColumns(47));
5500   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5501                "    const {}",
5502                Style);
5503   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5504                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5505   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5506                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5507   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5508                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5509   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5510                "                   aaaaaaaaaaa aaaaa) const override;");
5511   verifyGoogleFormat(
5512       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5513       "    const override;");
5514 
5515   // Even if the first parameter has to be wrapped.
5516   verifyFormat("void someLongFunction(\n"
5517                "    int someLongParameter) const {}",
5518                getLLVMStyleWithColumns(46));
5519   verifyFormat("void someLongFunction(\n"
5520                "    int someLongParameter) const {}",
5521                Style);
5522   verifyFormat("void someLongFunction(\n"
5523                "    int someLongParameter) override {}",
5524                Style);
5525   verifyFormat("void someLongFunction(\n"
5526                "    int someLongParameter) OVERRIDE {}",
5527                Style);
5528   verifyFormat("void someLongFunction(\n"
5529                "    int someLongParameter) final {}",
5530                Style);
5531   verifyFormat("void someLongFunction(\n"
5532                "    int someLongParameter) FINAL {}",
5533                Style);
5534   verifyFormat("void someLongFunction(\n"
5535                "    int parameter) const override {}",
5536                Style);
5537 
5538   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5539   verifyFormat("void someLongFunction(\n"
5540                "    int someLongParameter) const\n"
5541                "{\n"
5542                "}",
5543                Style);
5544 
5545   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5546   verifyFormat("void someLongFunction(\n"
5547                "    int someLongParameter) const\n"
5548                "  {\n"
5549                "  }",
5550                Style);
5551 
5552   // Unless these are unknown annotations.
5553   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5554                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5555                "    LONG_AND_UGLY_ANNOTATION;");
5556 
5557   // Breaking before function-like trailing annotations is fine to keep them
5558   // close to their arguments.
5559   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5560                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5561   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5562                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5563   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5564                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5565   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5566                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5567   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5568 
5569   verifyFormat(
5570       "void aaaaaaaaaaaaaaaaaa()\n"
5571       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5572       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5573   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5574                "    __attribute__((unused));");
5575   verifyGoogleFormat(
5576       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5577       "    GUARDED_BY(aaaaaaaaaaaa);");
5578   verifyGoogleFormat(
5579       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5580       "    GUARDED_BY(aaaaaaaaaaaa);");
5581   verifyGoogleFormat(
5582       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5583       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5584   verifyGoogleFormat(
5585       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5586       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5587 }
5588 
5589 TEST_F(FormatTest, FunctionAnnotations) {
5590   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5591                "int OldFunction(const string &parameter) {}");
5592   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5593                "string OldFunction(const string &parameter) {}");
5594   verifyFormat("template <typename T>\n"
5595                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5596                "string OldFunction(const string &parameter) {}");
5597 
5598   // Not function annotations.
5599   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5600                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5601   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5602                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5603   verifyFormat("MACRO(abc).function() // wrap\n"
5604                "    << abc;");
5605   verifyFormat("MACRO(abc)->function() // wrap\n"
5606                "    << abc;");
5607   verifyFormat("MACRO(abc)::function() // wrap\n"
5608                "    << abc;");
5609 }
5610 
5611 TEST_F(FormatTest, BreaksDesireably) {
5612   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5613                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5614                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5615   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5616                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5617                "}");
5618 
5619   verifyFormat(
5620       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5621       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5622 
5623   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5624                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5625                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5626 
5627   verifyFormat(
5628       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5629       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5630       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5631       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5632       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5633 
5634   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5635                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5636 
5637   verifyFormat(
5638       "void f() {\n"
5639       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5640       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5641       "}");
5642   verifyFormat(
5643       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5644       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5645   verifyFormat(
5646       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5647       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5648   verifyFormat(
5649       "aaaaaa(aaa,\n"
5650       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5651       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5652       "       aaaa);");
5653   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5654                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5655                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5656 
5657   // Indent consistently independent of call expression and unary operator.
5658   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5659                "    dddddddddddddddddddddddddddddd));");
5660   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5661                "    dddddddddddddddddddddddddddddd));");
5662   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5663                "    dddddddddddddddddddddddddddddd));");
5664 
5665   // This test case breaks on an incorrect memoization, i.e. an optimization not
5666   // taking into account the StopAt value.
5667   verifyFormat(
5668       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5669       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5670       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5671       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5672 
5673   verifyFormat("{\n  {\n    {\n"
5674                "      Annotation.SpaceRequiredBefore =\n"
5675                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5676                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5677                "    }\n  }\n}");
5678 
5679   // Break on an outer level if there was a break on an inner level.
5680   EXPECT_EQ("f(g(h(a, // comment\n"
5681             "      b, c),\n"
5682             "    d, e),\n"
5683             "  x, y);",
5684             format("f(g(h(a, // comment\n"
5685                    "    b, c), d, e), x, y);"));
5686 
5687   // Prefer breaking similar line breaks.
5688   verifyFormat(
5689       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5690       "                             NSTrackingMouseEnteredAndExited |\n"
5691       "                             NSTrackingActiveAlways;");
5692 }
5693 
5694 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5695   FormatStyle NoBinPacking = getGoogleStyle();
5696   NoBinPacking.BinPackParameters = false;
5697   NoBinPacking.BinPackArguments = true;
5698   verifyFormat("void f() {\n"
5699                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5700                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5701                "}",
5702                NoBinPacking);
5703   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5704                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5705                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5706                NoBinPacking);
5707 
5708   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5709   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5710                "                        vector<int> bbbbbbbbbbbbbbb);",
5711                NoBinPacking);
5712   // FIXME: This behavior difference is probably not wanted. However, currently
5713   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5714   // template arguments from BreakBeforeParameter being set because of the
5715   // one-per-line formatting.
5716   verifyFormat(
5717       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5718       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5719       NoBinPacking);
5720   verifyFormat(
5721       "void fffffffffff(\n"
5722       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5723       "        aaaaaaaaaa);");
5724 }
5725 
5726 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5727   FormatStyle NoBinPacking = getGoogleStyle();
5728   NoBinPacking.BinPackParameters = false;
5729   NoBinPacking.BinPackArguments = false;
5730   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5731                "  aaaaaaaaaaaaaaaaaaaa,\n"
5732                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5733                NoBinPacking);
5734   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5735                "        aaaaaaaaaaaaa,\n"
5736                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5737                NoBinPacking);
5738   verifyFormat(
5739       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5740       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5741       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5742       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5743       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5744       NoBinPacking);
5745   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5746                "    .aaaaaaaaaaaaaaaaaa();",
5747                NoBinPacking);
5748   verifyFormat("void f() {\n"
5749                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5750                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5751                "}",
5752                NoBinPacking);
5753 
5754   verifyFormat(
5755       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5756       "             aaaaaaaaaaaa,\n"
5757       "             aaaaaaaaaaaa);",
5758       NoBinPacking);
5759   verifyFormat(
5760       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5761       "                               ddddddddddddddddddddddddddddd),\n"
5762       "             test);",
5763       NoBinPacking);
5764 
5765   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5766                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5767                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5768                "    aaaaaaaaaaaaaaaaaa;",
5769                NoBinPacking);
5770   verifyFormat("a(\"a\"\n"
5771                "  \"a\",\n"
5772                "  a);");
5773 
5774   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5775   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5776                "                aaaaaaaaa,\n"
5777                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5778                NoBinPacking);
5779   verifyFormat(
5780       "void f() {\n"
5781       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5782       "      .aaaaaaa();\n"
5783       "}",
5784       NoBinPacking);
5785   verifyFormat(
5786       "template <class SomeType, class SomeOtherType>\n"
5787       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5788       NoBinPacking);
5789 }
5790 
5791 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5792   FormatStyle Style = getLLVMStyleWithColumns(15);
5793   Style.ExperimentalAutoDetectBinPacking = true;
5794   EXPECT_EQ("aaa(aaaa,\n"
5795             "    aaaa,\n"
5796             "    aaaa);\n"
5797             "aaa(aaaa,\n"
5798             "    aaaa,\n"
5799             "    aaaa);",
5800             format("aaa(aaaa,\n" // one-per-line
5801                    "  aaaa,\n"
5802                    "    aaaa  );\n"
5803                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5804                    Style));
5805   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5806             "    aaaa);\n"
5807             "aaa(aaaa, aaaa,\n"
5808             "    aaaa);",
5809             format("aaa(aaaa,  aaaa,\n" // bin-packed
5810                    "    aaaa  );\n"
5811                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5812                    Style));
5813 }
5814 
5815 TEST_F(FormatTest, FormatsBuilderPattern) {
5816   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5817                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5818                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5819                "    .StartsWith(\".init\", ORDER_INIT)\n"
5820                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5821                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5822                "    .Default(ORDER_TEXT);\n");
5823 
5824   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5825                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5826   verifyFormat("aaaaaaa->aaaaaaa\n"
5827                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5828                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5829                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5830   verifyFormat(
5831       "aaaaaaa->aaaaaaa\n"
5832       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5833       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5834   verifyFormat(
5835       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5836       "    aaaaaaaaaaaaaa);");
5837   verifyFormat(
5838       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5839       "    aaaaaa->aaaaaaaaaaaa()\n"
5840       "        ->aaaaaaaaaaaaaaaa(\n"
5841       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5842       "        ->aaaaaaaaaaaaaaaaa();");
5843   verifyGoogleFormat(
5844       "void f() {\n"
5845       "  someo->Add((new util::filetools::Handler(dir))\n"
5846       "                 ->OnEvent1(NewPermanentCallback(\n"
5847       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5848       "                 ->OnEvent2(NewPermanentCallback(\n"
5849       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5850       "                 ->OnEvent3(NewPermanentCallback(\n"
5851       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5852       "                 ->OnEvent5(NewPermanentCallback(\n"
5853       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5854       "                 ->OnEvent6(NewPermanentCallback(\n"
5855       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5856       "}");
5857 
5858   verifyFormat(
5859       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5860   verifyFormat("aaaaaaaaaaaaaaa()\n"
5861                "    .aaaaaaaaaaaaaaa()\n"
5862                "    .aaaaaaaaaaaaaaa()\n"
5863                "    .aaaaaaaaaaaaaaa()\n"
5864                "    .aaaaaaaaaaaaaaa();");
5865   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5866                "    .aaaaaaaaaaaaaaa()\n"
5867                "    .aaaaaaaaaaaaaaa()\n"
5868                "    .aaaaaaaaaaaaaaa();");
5869   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5870                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5871                "    .aaaaaaaaaaaaaaa();");
5872   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5873                "    ->aaaaaaaaaaaaaae(0)\n"
5874                "    ->aaaaaaaaaaaaaaa();");
5875 
5876   // Don't linewrap after very short segments.
5877   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5878                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5879                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5880   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5881                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5882                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5883   verifyFormat("aaa()\n"
5884                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5885                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5886                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5887 
5888   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5889                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5890                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5891   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5892                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5893                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5894 
5895   // Prefer not to break after empty parentheses.
5896   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5897                "    First->LastNewlineOffset);");
5898 
5899   // Prefer not to create "hanging" indents.
5900   verifyFormat(
5901       "return !soooooooooooooome_map\n"
5902       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5903       "            .second;");
5904   verifyFormat(
5905       "return aaaaaaaaaaaaaaaa\n"
5906       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5907       "    .aaaa(aaaaaaaaaaaaaa);");
5908   // No hanging indent here.
5909   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5910                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5911   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5912                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5913   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5914                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5915                getLLVMStyleWithColumns(60));
5916   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5917                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5918                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5919                getLLVMStyleWithColumns(59));
5920   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5921                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5922                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5923 
5924   // Dont break if only closing statements before member call
5925   verifyFormat("test() {\n"
5926                "  ([]() -> {\n"
5927                "    int b = 32;\n"
5928                "    return 3;\n"
5929                "  }).foo();\n"
5930                "}");
5931   verifyFormat("test() {\n"
5932                "  (\n"
5933                "      []() -> {\n"
5934                "        int b = 32;\n"
5935                "        return 3;\n"
5936                "      },\n"
5937                "      foo, bar)\n"
5938                "      .foo();\n"
5939                "}");
5940   verifyFormat("test() {\n"
5941                "  ([]() -> {\n"
5942                "    int b = 32;\n"
5943                "    return 3;\n"
5944                "  })\n"
5945                "      .foo()\n"
5946                "      .bar();\n"
5947                "}");
5948   verifyFormat("test() {\n"
5949                "  ([]() -> {\n"
5950                "    int b = 32;\n"
5951                "    return 3;\n"
5952                "  })\n"
5953                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5954                "           \"bbbb\");\n"
5955                "}",
5956                getLLVMStyleWithColumns(30));
5957 }
5958 
5959 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5960   verifyFormat(
5961       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5962       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5963   verifyFormat(
5964       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5965       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5966 
5967   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5968                "    ccccccccccccccccccccccccc) {\n}");
5969   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5970                "    ccccccccccccccccccccccccc) {\n}");
5971 
5972   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5973                "    ccccccccccccccccccccccccc) {\n}");
5974   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5975                "    ccccccccccccccccccccccccc) {\n}");
5976 
5977   verifyFormat(
5978       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
5979       "    ccccccccccccccccccccccccc) {\n}");
5980   verifyFormat(
5981       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
5982       "    ccccccccccccccccccccccccc) {\n}");
5983 
5984   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5985                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
5986                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
5987                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5988   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5989                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
5990                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
5991                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5992 
5993   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5994                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
5995                "    aaaaaaaaaaaaaaa != aa) {\n}");
5996   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5997                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
5998                "    aaaaaaaaaaaaaaa != aa) {\n}");
5999 }
6000 
6001 TEST_F(FormatTest, BreaksAfterAssignments) {
6002   verifyFormat(
6003       "unsigned Cost =\n"
6004       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
6005       "                        SI->getPointerAddressSpaceee());\n");
6006   verifyFormat(
6007       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
6008       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
6009 
6010   verifyFormat(
6011       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
6012       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
6013   verifyFormat("unsigned OriginalStartColumn =\n"
6014                "    SourceMgr.getSpellingColumnNumber(\n"
6015                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
6016                "    1;");
6017 }
6018 
6019 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
6020   FormatStyle Style = getLLVMStyle();
6021   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6022                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
6023                Style);
6024 
6025   Style.PenaltyBreakAssignment = 20;
6026   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
6027                "                                 cccccccccccccccccccccccccc;",
6028                Style);
6029 }
6030 
6031 TEST_F(FormatTest, AlignsAfterAssignments) {
6032   verifyFormat(
6033       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6034       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
6035   verifyFormat(
6036       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6037       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
6038   verifyFormat(
6039       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6040       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
6041   verifyFormat(
6042       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6043       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
6044   verifyFormat(
6045       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
6046       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
6047       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
6048 }
6049 
6050 TEST_F(FormatTest, AlignsAfterReturn) {
6051   verifyFormat(
6052       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6053       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
6054   verifyFormat(
6055       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6056       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
6057   verifyFormat(
6058       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
6059       "       aaaaaaaaaaaaaaaaaaaaaa();");
6060   verifyFormat(
6061       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
6062       "        aaaaaaaaaaaaaaaaaaaaaa());");
6063   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6064                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6065   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6066                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
6067                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6068   verifyFormat("return\n"
6069                "    // true if code is one of a or b.\n"
6070                "    code == a || code == b;");
6071 }
6072 
6073 TEST_F(FormatTest, AlignsAfterOpenBracket) {
6074   verifyFormat(
6075       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
6076       "                                                aaaaaaaaa aaaaaaa) {}");
6077   verifyFormat(
6078       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
6079       "                                               aaaaaaaaaaa aaaaaaaaa);");
6080   verifyFormat(
6081       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6082       "                                             aaaaaaaaaaaaaaaaaaaaa));");
6083   FormatStyle Style = getLLVMStyle();
6084   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6085   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6086                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
6087                Style);
6088   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6089                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
6090                Style);
6091   verifyFormat("SomeLongVariableName->someFunction(\n"
6092                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
6093                Style);
6094   verifyFormat(
6095       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
6096       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6097       Style);
6098   verifyFormat(
6099       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
6100       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6101       Style);
6102   verifyFormat(
6103       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6104       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6105       Style);
6106 
6107   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
6108                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
6109                "        b));",
6110                Style);
6111 
6112   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6113   Style.BinPackArguments = false;
6114   Style.BinPackParameters = false;
6115   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6116                "    aaaaaaaaaaa aaaaaaaa,\n"
6117                "    aaaaaaaaa aaaaaaa,\n"
6118                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6119                Style);
6120   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6121                "    aaaaaaaaaaa aaaaaaaaa,\n"
6122                "    aaaaaaaaaaa aaaaaaaaa,\n"
6123                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6124                Style);
6125   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
6126                "    aaaaaaaaaaaaaaa,\n"
6127                "    aaaaaaaaaaaaaaaaaaaaa,\n"
6128                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6129                Style);
6130   verifyFormat(
6131       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
6132       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6133       Style);
6134   verifyFormat(
6135       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
6136       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6137       Style);
6138   verifyFormat(
6139       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6140       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6141       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
6142       "    aaaaaaaaaaaaaaaa);",
6143       Style);
6144   verifyFormat(
6145       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6146       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6147       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
6148       "    aaaaaaaaaaaaaaaa);",
6149       Style);
6150 }
6151 
6152 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
6153   FormatStyle Style = getLLVMStyleWithColumns(40);
6154   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6155                "          bbbbbbbbbbbbbbbbbbbbbb);",
6156                Style);
6157   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6158   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6159   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6160                "          bbbbbbbbbbbbbbbbbbbbbb);",
6161                Style);
6162   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6163   Style.AlignOperands = FormatStyle::OAS_Align;
6164   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6165                "          bbbbbbbbbbbbbbbbbbbbbb);",
6166                Style);
6167   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6168   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6169   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6170                "    bbbbbbbbbbbbbbbbbbbbbb);",
6171                Style);
6172 }
6173 
6174 TEST_F(FormatTest, BreaksConditionalExpressions) {
6175   verifyFormat(
6176       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6177       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6178       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6179   verifyFormat(
6180       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6181       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6182       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6183   verifyFormat(
6184       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6185       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6186   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6187                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6188                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6189   verifyFormat(
6190       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6191       "                                                    : aaaaaaaaaaaaa);");
6192   verifyFormat(
6193       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6194       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6195       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6196       "                   aaaaaaaaaaaaa);");
6197   verifyFormat(
6198       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6199       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6200       "                   aaaaaaaaaaaaa);");
6201   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6202                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6203                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6204                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6205                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6206   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6207                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6208                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6209                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6210                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6211                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6212                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6213   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6214                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6215                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6216                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6217                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6218   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6219                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6220                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6221   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6222                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6223                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6224                "        : aaaaaaaaaaaaaaaa;");
6225   verifyFormat(
6226       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6227       "    ? aaaaaaaaaaaaaaa\n"
6228       "    : aaaaaaaaaaaaaaa;");
6229   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6230                "          aaaaaaaaa\n"
6231                "      ? b\n"
6232                "      : c);");
6233   verifyFormat("return aaaa == bbbb\n"
6234                "           // comment\n"
6235                "           ? aaaa\n"
6236                "           : bbbb;");
6237   verifyFormat("unsigned Indent =\n"
6238                "    format(TheLine.First,\n"
6239                "           IndentForLevel[TheLine.Level] >= 0\n"
6240                "               ? IndentForLevel[TheLine.Level]\n"
6241                "               : TheLine * 2,\n"
6242                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6243                getLLVMStyleWithColumns(60));
6244   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6245                "                  ? aaaaaaaaaaaaaaa\n"
6246                "                  : bbbbbbbbbbbbbbb //\n"
6247                "                        ? ccccccccccccccc\n"
6248                "                        : ddddddddddddddd;");
6249   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6250                "                  ? aaaaaaaaaaaaaaa\n"
6251                "                  : (bbbbbbbbbbbbbbb //\n"
6252                "                         ? ccccccccccccccc\n"
6253                "                         : ddddddddddddddd);");
6254   verifyFormat(
6255       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6256       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6257       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
6258       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
6259       "                                      : aaaaaaaaaa;");
6260   verifyFormat(
6261       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6262       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
6263       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6264 
6265   FormatStyle NoBinPacking = getLLVMStyle();
6266   NoBinPacking.BinPackArguments = false;
6267   verifyFormat(
6268       "void f() {\n"
6269       "  g(aaa,\n"
6270       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6271       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6272       "        ? aaaaaaaaaaaaaaa\n"
6273       "        : aaaaaaaaaaaaaaa);\n"
6274       "}",
6275       NoBinPacking);
6276   verifyFormat(
6277       "void f() {\n"
6278       "  g(aaa,\n"
6279       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6280       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6281       "        ?: aaaaaaaaaaaaaaa);\n"
6282       "}",
6283       NoBinPacking);
6284 
6285   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6286                "             // comment.\n"
6287                "             ccccccccccccccccccccccccccccccccccccccc\n"
6288                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6289                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6290 
6291   // Assignments in conditional expressions. Apparently not uncommon :-(.
6292   verifyFormat("return a != b\n"
6293                "           // comment\n"
6294                "           ? a = b\n"
6295                "           : a = b;");
6296   verifyFormat("return a != b\n"
6297                "           // comment\n"
6298                "           ? a = a != b\n"
6299                "                     // comment\n"
6300                "                     ? a = b\n"
6301                "                     : a\n"
6302                "           : a;\n");
6303   verifyFormat("return a != b\n"
6304                "           // comment\n"
6305                "           ? a\n"
6306                "           : a = a != b\n"
6307                "                     // comment\n"
6308                "                     ? a = b\n"
6309                "                     : a;");
6310 
6311   // Chained conditionals
6312   FormatStyle Style = getLLVMStyle();
6313   Style.ColumnLimit = 70;
6314   Style.AlignOperands = FormatStyle::OAS_Align;
6315   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6316                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6317                "                        : 3333333333333333;",
6318                Style);
6319   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6320                "       : bbbbbbbbbb     ? 2222222222222222\n"
6321                "                        : 3333333333333333;",
6322                Style);
6323   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
6324                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6325                "                          : 3333333333333333;",
6326                Style);
6327   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6328                "       : bbbbbbbbbbbbbb ? 222222\n"
6329                "                        : 333333;",
6330                Style);
6331   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6332                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6333                "       : cccccccccccccc ? 3333333333333333\n"
6334                "                        : 4444444444444444;",
6335                Style);
6336   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6337                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6338                "                        : 3333333333333333;",
6339                Style);
6340   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6341                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6342                "                        : (aaa ? bbb : ccc);",
6343                Style);
6344   verifyFormat(
6345       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6346       "                                             : cccccccccccccccccc)\n"
6347       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6348       "                        : 3333333333333333;",
6349       Style);
6350   verifyFormat(
6351       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6352       "                                             : cccccccccccccccccc)\n"
6353       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6354       "                        : 3333333333333333;",
6355       Style);
6356   verifyFormat(
6357       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6358       "                                             : dddddddddddddddddd)\n"
6359       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6360       "                        : 3333333333333333;",
6361       Style);
6362   verifyFormat(
6363       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6364       "                                             : dddddddddddddddddd)\n"
6365       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6366       "                        : 3333333333333333;",
6367       Style);
6368   verifyFormat(
6369       "return aaaaaaaaa        ? 1111111111111111\n"
6370       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6371       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6372       "                                             : dddddddddddddddddd)\n",
6373       Style);
6374   verifyFormat(
6375       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6376       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6377       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6378       "                                             : cccccccccccccccccc);",
6379       Style);
6380   verifyFormat(
6381       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6382       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6383       "                                             : eeeeeeeeeeeeeeeeee)\n"
6384       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6385       "                        : 3333333333333333;",
6386       Style);
6387   verifyFormat(
6388       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
6389       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6390       "                                             : eeeeeeeeeeeeeeeeee)\n"
6391       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6392       "                        : 3333333333333333;",
6393       Style);
6394   verifyFormat(
6395       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6396       "                           : cccccccccccc    ? dddddddddddddddddd\n"
6397       "                                             : eeeeeeeeeeeeeeeeee)\n"
6398       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6399       "                        : 3333333333333333;",
6400       Style);
6401   verifyFormat(
6402       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6403       "                                             : cccccccccccccccccc\n"
6404       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6405       "                        : 3333333333333333;",
6406       Style);
6407   verifyFormat(
6408       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6409       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
6410       "                                             : eeeeeeeeeeeeeeeeee\n"
6411       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6412       "                        : 3333333333333333;",
6413       Style);
6414   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6415                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
6416                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
6417                "                                   : eeeeeeeeeeeeeeeeee)\n"
6418                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6419                "                             : 3333333333333333;",
6420                Style);
6421   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6422                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6423                "             : cccccccccccccccc ? dddddddddddddddddd\n"
6424                "                                : eeeeeeeeeeeeeeeeee\n"
6425                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6426                "                                 : 3333333333333333;",
6427                Style);
6428 
6429   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6430   Style.BreakBeforeTernaryOperators = false;
6431   // FIXME: Aligning the question marks is weird given DontAlign.
6432   // Consider disabling this alignment in this case. Also check whether this
6433   // will render the adjustment from https://reviews.llvm.org/D82199
6434   // unnecessary.
6435   verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
6436                "    bbbb                ? cccccccccccccccccc :\n"
6437                "                          ddddd;\n",
6438                Style);
6439 }
6440 
6441 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6442   FormatStyle Style = getLLVMStyle();
6443   Style.BreakBeforeTernaryOperators = false;
6444   Style.ColumnLimit = 70;
6445   verifyFormat(
6446       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6447       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6448       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6449       Style);
6450   verifyFormat(
6451       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6452       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6453       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6454       Style);
6455   verifyFormat(
6456       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6457       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6458       Style);
6459   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6460                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6461                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6462                Style);
6463   verifyFormat(
6464       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6465       "                                                      aaaaaaaaaaaaa);",
6466       Style);
6467   verifyFormat(
6468       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6469       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6470       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6471       "                   aaaaaaaaaaaaa);",
6472       Style);
6473   verifyFormat(
6474       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6475       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6476       "                   aaaaaaaaaaaaa);",
6477       Style);
6478   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6479                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6480                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6481                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6482                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6483                Style);
6484   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6485                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6486                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6487                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6488                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6489                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6490                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6491                Style);
6492   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6493                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6494                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6495                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6496                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6497                Style);
6498   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6499                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6500                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6501                Style);
6502   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6503                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6504                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6505                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6506                Style);
6507   verifyFormat(
6508       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6509       "    aaaaaaaaaaaaaaa :\n"
6510       "    aaaaaaaaaaaaaaa;",
6511       Style);
6512   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6513                "          aaaaaaaaa ?\n"
6514                "      b :\n"
6515                "      c);",
6516                Style);
6517   verifyFormat("unsigned Indent =\n"
6518                "    format(TheLine.First,\n"
6519                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
6520                "               IndentForLevel[TheLine.Level] :\n"
6521                "               TheLine * 2,\n"
6522                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6523                Style);
6524   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6525                "                  aaaaaaaaaaaaaaa :\n"
6526                "                  bbbbbbbbbbbbbbb ? //\n"
6527                "                      ccccccccccccccc :\n"
6528                "                      ddddddddddddddd;",
6529                Style);
6530   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6531                "                  aaaaaaaaaaaaaaa :\n"
6532                "                  (bbbbbbbbbbbbbbb ? //\n"
6533                "                       ccccccccccccccc :\n"
6534                "                       ddddddddddddddd);",
6535                Style);
6536   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6537                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6538                "            ccccccccccccccccccccccccccc;",
6539                Style);
6540   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6541                "           aaaaa :\n"
6542                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
6543                Style);
6544 
6545   // Chained conditionals
6546   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6547                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6548                "                          3333333333333333;",
6549                Style);
6550   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6551                "       bbbbbbbbbb       ? 2222222222222222 :\n"
6552                "                          3333333333333333;",
6553                Style);
6554   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
6555                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6556                "                          3333333333333333;",
6557                Style);
6558   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6559                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
6560                "                          333333;",
6561                Style);
6562   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6563                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6564                "       cccccccccccccccc ? 3333333333333333 :\n"
6565                "                          4444444444444444;",
6566                Style);
6567   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6568                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6569                "                          3333333333333333;",
6570                Style);
6571   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6572                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6573                "                          (aaa ? bbb : ccc);",
6574                Style);
6575   verifyFormat(
6576       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6577       "                                               cccccccccccccccccc) :\n"
6578       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6579       "                          3333333333333333;",
6580       Style);
6581   verifyFormat(
6582       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6583       "                                               cccccccccccccccccc) :\n"
6584       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6585       "                          3333333333333333;",
6586       Style);
6587   verifyFormat(
6588       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6589       "                                               dddddddddddddddddd) :\n"
6590       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6591       "                          3333333333333333;",
6592       Style);
6593   verifyFormat(
6594       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6595       "                                               dddddddddddddddddd) :\n"
6596       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6597       "                          3333333333333333;",
6598       Style);
6599   verifyFormat(
6600       "return aaaaaaaaa        ? 1111111111111111 :\n"
6601       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6602       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6603       "                                               dddddddddddddddddd)\n",
6604       Style);
6605   verifyFormat(
6606       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6607       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6608       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6609       "                                               cccccccccccccccccc);",
6610       Style);
6611   verifyFormat(
6612       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6613       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6614       "                                               eeeeeeeeeeeeeeeeee) :\n"
6615       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6616       "                          3333333333333333;",
6617       Style);
6618   verifyFormat(
6619       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6620       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
6621       "                                               eeeeeeeeeeeeeeeeee) :\n"
6622       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6623       "                          3333333333333333;",
6624       Style);
6625   verifyFormat(
6626       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
6627       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6628       "                                               eeeeeeeeeeeeeeeeee) :\n"
6629       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6630       "                          3333333333333333;",
6631       Style);
6632   verifyFormat(
6633       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6634       "                                               cccccccccccccccccc :\n"
6635       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6636       "                          3333333333333333;",
6637       Style);
6638   verifyFormat(
6639       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6640       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
6641       "                                               eeeeeeeeeeeeeeeeee :\n"
6642       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6643       "                          3333333333333333;",
6644       Style);
6645   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6646                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6647                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
6648                "                                 eeeeeeeeeeeeeeeeee) :\n"
6649                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6650                "                               3333333333333333;",
6651                Style);
6652   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6653                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6654                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
6655                "                                  eeeeeeeeeeeeeeeeee :\n"
6656                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6657                "                               3333333333333333;",
6658                Style);
6659 }
6660 
6661 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6662   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6663                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6664   verifyFormat("bool a = true, b = false;");
6665 
6666   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6667                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6668                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6669                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6670   verifyFormat(
6671       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6672       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6673       "     d = e && f;");
6674   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6675                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6676   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6677                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6678   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6679                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6680 
6681   FormatStyle Style = getGoogleStyle();
6682   Style.PointerAlignment = FormatStyle::PAS_Left;
6683   Style.DerivePointerAlignment = false;
6684   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6685                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6686                "    *b = bbbbbbbbbbbbbbbbbbb;",
6687                Style);
6688   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6689                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6690                Style);
6691   verifyFormat("vector<int*> a, b;", Style);
6692   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6693 }
6694 
6695 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6696   verifyFormat("arr[foo ? bar : baz];");
6697   verifyFormat("f()[foo ? bar : baz];");
6698   verifyFormat("(a + b)[foo ? bar : baz];");
6699   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6700 }
6701 
6702 TEST_F(FormatTest, AlignsStringLiterals) {
6703   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6704                "                                      \"short literal\");");
6705   verifyFormat(
6706       "looooooooooooooooooooooooongFunction(\n"
6707       "    \"short literal\"\n"
6708       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6709   verifyFormat("someFunction(\"Always break between multi-line\"\n"
6710                "             \" string literals\",\n"
6711                "             and, other, parameters);");
6712   EXPECT_EQ("fun + \"1243\" /* comment */\n"
6713             "      \"5678\";",
6714             format("fun + \"1243\" /* comment */\n"
6715                    "    \"5678\";",
6716                    getLLVMStyleWithColumns(28)));
6717   EXPECT_EQ(
6718       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6719       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6720       "         \"aaaaaaaaaaaaaaaa\";",
6721       format("aaaaaa ="
6722              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6723              "aaaaaaaaaaaaaaaaaaaaa\" "
6724              "\"aaaaaaaaaaaaaaaa\";"));
6725   verifyFormat("a = a + \"a\"\n"
6726                "        \"a\"\n"
6727                "        \"a\";");
6728   verifyFormat("f(\"a\", \"b\"\n"
6729                "       \"c\");");
6730 
6731   verifyFormat(
6732       "#define LL_FORMAT \"ll\"\n"
6733       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6734       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6735 
6736   verifyFormat("#define A(X)          \\\n"
6737                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
6738                "  \"ccccc\"",
6739                getLLVMStyleWithColumns(23));
6740   verifyFormat("#define A \"def\"\n"
6741                "f(\"abc\" A \"ghi\"\n"
6742                "  \"jkl\");");
6743 
6744   verifyFormat("f(L\"a\"\n"
6745                "  L\"b\");");
6746   verifyFormat("#define A(X)            \\\n"
6747                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6748                "  L\"ccccc\"",
6749                getLLVMStyleWithColumns(25));
6750 
6751   verifyFormat("f(@\"a\"\n"
6752                "  @\"b\");");
6753   verifyFormat("NSString s = @\"a\"\n"
6754                "             @\"b\"\n"
6755                "             @\"c\";");
6756   verifyFormat("NSString s = @\"a\"\n"
6757                "              \"b\"\n"
6758                "              \"c\";");
6759 }
6760 
6761 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6762   FormatStyle Style = getLLVMStyle();
6763   // No declarations or definitions should be moved to own line.
6764   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6765   verifyFormat("class A {\n"
6766                "  int f() { return 1; }\n"
6767                "  int g();\n"
6768                "};\n"
6769                "int f() { return 1; }\n"
6770                "int g();\n",
6771                Style);
6772 
6773   // All declarations and definitions should have the return type moved to its
6774   // own line.
6775   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6776   Style.TypenameMacros = {"LIST"};
6777   verifyFormat("SomeType\n"
6778                "funcdecl(LIST(uint64_t));",
6779                Style);
6780   verifyFormat("class E {\n"
6781                "  int\n"
6782                "  f() {\n"
6783                "    return 1;\n"
6784                "  }\n"
6785                "  int\n"
6786                "  g();\n"
6787                "};\n"
6788                "int\n"
6789                "f() {\n"
6790                "  return 1;\n"
6791                "}\n"
6792                "int\n"
6793                "g();\n",
6794                Style);
6795 
6796   // Top-level definitions, and no kinds of declarations should have the
6797   // return type moved to its own line.
6798   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6799   verifyFormat("class B {\n"
6800                "  int f() { return 1; }\n"
6801                "  int g();\n"
6802                "};\n"
6803                "int\n"
6804                "f() {\n"
6805                "  return 1;\n"
6806                "}\n"
6807                "int g();\n",
6808                Style);
6809 
6810   // Top-level definitions and declarations should have the return type moved
6811   // to its own line.
6812   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6813   verifyFormat("class C {\n"
6814                "  int f() { return 1; }\n"
6815                "  int g();\n"
6816                "};\n"
6817                "int\n"
6818                "f() {\n"
6819                "  return 1;\n"
6820                "}\n"
6821                "int\n"
6822                "g();\n",
6823                Style);
6824 
6825   // All definitions should have the return type moved to its own line, but no
6826   // kinds of declarations.
6827   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6828   verifyFormat("class D {\n"
6829                "  int\n"
6830                "  f() {\n"
6831                "    return 1;\n"
6832                "  }\n"
6833                "  int g();\n"
6834                "};\n"
6835                "int\n"
6836                "f() {\n"
6837                "  return 1;\n"
6838                "}\n"
6839                "int g();\n",
6840                Style);
6841   verifyFormat("const char *\n"
6842                "f(void) {\n" // Break here.
6843                "  return \"\";\n"
6844                "}\n"
6845                "const char *bar(void);\n", // No break here.
6846                Style);
6847   verifyFormat("template <class T>\n"
6848                "T *\n"
6849                "f(T &c) {\n" // Break here.
6850                "  return NULL;\n"
6851                "}\n"
6852                "template <class T> T *f(T &c);\n", // No break here.
6853                Style);
6854   verifyFormat("class C {\n"
6855                "  int\n"
6856                "  operator+() {\n"
6857                "    return 1;\n"
6858                "  }\n"
6859                "  int\n"
6860                "  operator()() {\n"
6861                "    return 1;\n"
6862                "  }\n"
6863                "};\n",
6864                Style);
6865   verifyFormat("void\n"
6866                "A::operator()() {}\n"
6867                "void\n"
6868                "A::operator>>() {}\n"
6869                "void\n"
6870                "A::operator+() {}\n"
6871                "void\n"
6872                "A::operator*() {}\n"
6873                "void\n"
6874                "A::operator->() {}\n"
6875                "void\n"
6876                "A::operator void *() {}\n"
6877                "void\n"
6878                "A::operator void &() {}\n"
6879                "void\n"
6880                "A::operator void &&() {}\n"
6881                "void\n"
6882                "A::operator char *() {}\n"
6883                "void\n"
6884                "A::operator[]() {}\n"
6885                "void\n"
6886                "A::operator!() {}\n"
6887                "void\n"
6888                "A::operator**() {}\n"
6889                "void\n"
6890                "A::operator<Foo> *() {}\n"
6891                "void\n"
6892                "A::operator<Foo> **() {}\n"
6893                "void\n"
6894                "A::operator<Foo> &() {}\n"
6895                "void\n"
6896                "A::operator void **() {}\n",
6897                Style);
6898   verifyFormat("constexpr auto\n"
6899                "operator()() const -> reference {}\n"
6900                "constexpr auto\n"
6901                "operator>>() const -> reference {}\n"
6902                "constexpr auto\n"
6903                "operator+() const -> reference {}\n"
6904                "constexpr auto\n"
6905                "operator*() const -> reference {}\n"
6906                "constexpr auto\n"
6907                "operator->() const -> reference {}\n"
6908                "constexpr auto\n"
6909                "operator++() const -> reference {}\n"
6910                "constexpr auto\n"
6911                "operator void *() const -> reference {}\n"
6912                "constexpr auto\n"
6913                "operator void **() const -> reference {}\n"
6914                "constexpr auto\n"
6915                "operator void *() const -> reference {}\n"
6916                "constexpr auto\n"
6917                "operator void &() const -> reference {}\n"
6918                "constexpr auto\n"
6919                "operator void &&() const -> reference {}\n"
6920                "constexpr auto\n"
6921                "operator char *() const -> reference {}\n"
6922                "constexpr auto\n"
6923                "operator!() const -> reference {}\n"
6924                "constexpr auto\n"
6925                "operator[]() const -> reference {}\n",
6926                Style);
6927   verifyFormat("void *operator new(std::size_t s);", // No break here.
6928                Style);
6929   verifyFormat("void *\n"
6930                "operator new(std::size_t s) {}",
6931                Style);
6932   verifyFormat("void *\n"
6933                "operator delete[](void *ptr) {}",
6934                Style);
6935   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6936   verifyFormat("const char *\n"
6937                "f(void)\n" // Break here.
6938                "{\n"
6939                "  return \"\";\n"
6940                "}\n"
6941                "const char *bar(void);\n", // No break here.
6942                Style);
6943   verifyFormat("template <class T>\n"
6944                "T *\n"     // Problem here: no line break
6945                "f(T &c)\n" // Break here.
6946                "{\n"
6947                "  return NULL;\n"
6948                "}\n"
6949                "template <class T> T *f(T &c);\n", // No break here.
6950                Style);
6951   verifyFormat("int\n"
6952                "foo(A<bool> a)\n"
6953                "{\n"
6954                "  return a;\n"
6955                "}\n",
6956                Style);
6957   verifyFormat("int\n"
6958                "foo(A<8> a)\n"
6959                "{\n"
6960                "  return a;\n"
6961                "}\n",
6962                Style);
6963   verifyFormat("int\n"
6964                "foo(A<B<bool>, 8> a)\n"
6965                "{\n"
6966                "  return a;\n"
6967                "}\n",
6968                Style);
6969   verifyFormat("int\n"
6970                "foo(A<B<8>, bool> a)\n"
6971                "{\n"
6972                "  return a;\n"
6973                "}\n",
6974                Style);
6975   verifyFormat("int\n"
6976                "foo(A<B<bool>, bool> a)\n"
6977                "{\n"
6978                "  return a;\n"
6979                "}\n",
6980                Style);
6981   verifyFormat("int\n"
6982                "foo(A<B<8>, 8> a)\n"
6983                "{\n"
6984                "  return a;\n"
6985                "}\n",
6986                Style);
6987 
6988   Style = getGNUStyle();
6989 
6990   // Test for comments at the end of function declarations.
6991   verifyFormat("void\n"
6992                "foo (int a, /*abc*/ int b) // def\n"
6993                "{\n"
6994                "}\n",
6995                Style);
6996 
6997   verifyFormat("void\n"
6998                "foo (int a, /* abc */ int b) /* def */\n"
6999                "{\n"
7000                "}\n",
7001                Style);
7002 
7003   // Definitions that should not break after return type
7004   verifyFormat("void foo (int a, int b); // def\n", Style);
7005   verifyFormat("void foo (int a, int b); /* def */\n", Style);
7006   verifyFormat("void foo (int a, int b);\n", Style);
7007 }
7008 
7009 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
7010   FormatStyle NoBreak = getLLVMStyle();
7011   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
7012   FormatStyle Break = getLLVMStyle();
7013   Break.AlwaysBreakBeforeMultilineStrings = true;
7014   verifyFormat("aaaa = \"bbbb\"\n"
7015                "       \"cccc\";",
7016                NoBreak);
7017   verifyFormat("aaaa =\n"
7018                "    \"bbbb\"\n"
7019                "    \"cccc\";",
7020                Break);
7021   verifyFormat("aaaa(\"bbbb\"\n"
7022                "     \"cccc\");",
7023                NoBreak);
7024   verifyFormat("aaaa(\n"
7025                "    \"bbbb\"\n"
7026                "    \"cccc\");",
7027                Break);
7028   verifyFormat("aaaa(qqq, \"bbbb\"\n"
7029                "          \"cccc\");",
7030                NoBreak);
7031   verifyFormat("aaaa(qqq,\n"
7032                "     \"bbbb\"\n"
7033                "     \"cccc\");",
7034                Break);
7035   verifyFormat("aaaa(qqq,\n"
7036                "     L\"bbbb\"\n"
7037                "     L\"cccc\");",
7038                Break);
7039   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
7040                "                      \"bbbb\"));",
7041                Break);
7042   verifyFormat("string s = someFunction(\n"
7043                "    \"abc\"\n"
7044                "    \"abc\");",
7045                Break);
7046 
7047   // As we break before unary operators, breaking right after them is bad.
7048   verifyFormat("string foo = abc ? \"x\"\n"
7049                "                   \"blah blah blah blah blah blah\"\n"
7050                "                 : \"y\";",
7051                Break);
7052 
7053   // Don't break if there is no column gain.
7054   verifyFormat("f(\"aaaa\"\n"
7055                "  \"bbbb\");",
7056                Break);
7057 
7058   // Treat literals with escaped newlines like multi-line string literals.
7059   EXPECT_EQ("x = \"a\\\n"
7060             "b\\\n"
7061             "c\";",
7062             format("x = \"a\\\n"
7063                    "b\\\n"
7064                    "c\";",
7065                    NoBreak));
7066   EXPECT_EQ("xxxx =\n"
7067             "    \"a\\\n"
7068             "b\\\n"
7069             "c\";",
7070             format("xxxx = \"a\\\n"
7071                    "b\\\n"
7072                    "c\";",
7073                    Break));
7074 
7075   EXPECT_EQ("NSString *const kString =\n"
7076             "    @\"aaaa\"\n"
7077             "    @\"bbbb\";",
7078             format("NSString *const kString = @\"aaaa\"\n"
7079                    "@\"bbbb\";",
7080                    Break));
7081 
7082   Break.ColumnLimit = 0;
7083   verifyFormat("const char *hello = \"hello llvm\";", Break);
7084 }
7085 
7086 TEST_F(FormatTest, AlignsPipes) {
7087   verifyFormat(
7088       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7089       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7090       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7091   verifyFormat(
7092       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
7093       "                     << aaaaaaaaaaaaaaaaaaaa;");
7094   verifyFormat(
7095       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7096       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7097   verifyFormat(
7098       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7099       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7100   verifyFormat(
7101       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
7102       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
7103       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
7104   verifyFormat(
7105       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7106       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7107       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7108   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7109                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7110                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7111                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7112   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
7113                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
7114   verifyFormat(
7115       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7116       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7117   verifyFormat(
7118       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
7119       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
7120 
7121   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
7122                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
7123   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7124                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7125                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
7126                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
7127   verifyFormat("LOG_IF(aaa == //\n"
7128                "       bbb)\n"
7129                "    << a << b;");
7130 
7131   // But sometimes, breaking before the first "<<" is desirable.
7132   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7133                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
7134   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
7135                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7136                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7137   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
7138                "    << BEF << IsTemplate << Description << E->getType();");
7139   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7140                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7141                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7142   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7143                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7144                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7145                "    << aaa;");
7146 
7147   verifyFormat(
7148       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7149       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7150 
7151   // Incomplete string literal.
7152   EXPECT_EQ("llvm::errs() << \"\n"
7153             "             << a;",
7154             format("llvm::errs() << \"\n<<a;"));
7155 
7156   verifyFormat("void f() {\n"
7157                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
7158                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
7159                "}");
7160 
7161   // Handle 'endl'.
7162   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
7163                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7164   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7165 
7166   // Handle '\n'.
7167   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
7168                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7169   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
7170                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
7171   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
7172                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
7173   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7174 }
7175 
7176 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
7177   verifyFormat("return out << \"somepacket = {\\n\"\n"
7178                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
7179                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
7180                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
7181                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
7182                "           << \"}\";");
7183 
7184   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7185                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7186                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7187   verifyFormat(
7188       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7189       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7190       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7191       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7192       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7193   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7194                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7195   verifyFormat(
7196       "void f() {\n"
7197       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7198       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7199       "}");
7200 
7201   // Breaking before the first "<<" is generally not desirable.
7202   verifyFormat(
7203       "llvm::errs()\n"
7204       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7205       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7206       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7207       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7208       getLLVMStyleWithColumns(70));
7209   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7210                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7211                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7212                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7213                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7214                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7215                getLLVMStyleWithColumns(70));
7216 
7217   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7218                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7219                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7220   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7221                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7222                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7223   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7224                "           (aaaa + aaaa);",
7225                getLLVMStyleWithColumns(40));
7226   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7227                "                  (aaaaaaa + aaaaa));",
7228                getLLVMStyleWithColumns(40));
7229   verifyFormat(
7230       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7231       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7232       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
7233 }
7234 
7235 TEST_F(FormatTest, UnderstandsEquals) {
7236   verifyFormat(
7237       "aaaaaaaaaaaaaaaaa =\n"
7238       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7239   verifyFormat(
7240       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7241       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7242   verifyFormat(
7243       "if (a) {\n"
7244       "  f();\n"
7245       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7246       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7247       "}");
7248 
7249   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7250                "        100000000 + 10000000) {\n}");
7251 }
7252 
7253 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7254   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7255                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
7256 
7257   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7258                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
7259 
7260   verifyFormat(
7261       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7262       "                                                          Parameter2);");
7263 
7264   verifyFormat(
7265       "ShortObject->shortFunction(\n"
7266       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7267       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7268 
7269   verifyFormat("loooooooooooooongFunction(\n"
7270                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
7271 
7272   verifyFormat(
7273       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7274       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7275 
7276   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7277                "    .WillRepeatedly(Return(SomeValue));");
7278   verifyFormat("void f() {\n"
7279                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7280                "      .Times(2)\n"
7281                "      .WillRepeatedly(Return(SomeValue));\n"
7282                "}");
7283   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7284                "    ccccccccccccccccccccccc);");
7285   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7286                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7287                "          .aaaaa(aaaaa),\n"
7288                "      aaaaaaaaaaaaaaaaaaaaa);");
7289   verifyFormat("void f() {\n"
7290                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7291                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7292                "}");
7293   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7294                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7295                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7296                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7297                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7298   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7299                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7300                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7301                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7302                "}");
7303 
7304   // Here, it is not necessary to wrap at "." or "->".
7305   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7306                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7307   verifyFormat(
7308       "aaaaaaaaaaa->aaaaaaaaa(\n"
7309       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7310       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7311 
7312   verifyFormat(
7313       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7314       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7315   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7316                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7317   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7318                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7319 
7320   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7321                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7322                "    .a();");
7323 
7324   FormatStyle NoBinPacking = getLLVMStyle();
7325   NoBinPacking.BinPackParameters = false;
7326   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7327                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7328                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7329                "                         aaaaaaaaaaaaaaaaaaa,\n"
7330                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7331                NoBinPacking);
7332 
7333   // If there is a subsequent call, change to hanging indentation.
7334   verifyFormat(
7335       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7336       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7337       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7338   verifyFormat(
7339       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7340       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7341   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7342                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7343                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7344   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7345                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7346                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7347 }
7348 
7349 TEST_F(FormatTest, WrapsTemplateDeclarations) {
7350   verifyFormat("template <typename T>\n"
7351                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7352   verifyFormat("template <typename T>\n"
7353                "// T should be one of {A, B}.\n"
7354                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7355   verifyFormat(
7356       "template <typename T>\n"
7357       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7358   verifyFormat("template <typename T>\n"
7359                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7360                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7361   verifyFormat(
7362       "template <typename T>\n"
7363       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7364       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
7365   verifyFormat(
7366       "template <typename T>\n"
7367       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7368       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7369       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7370   verifyFormat("template <typename T>\n"
7371                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7372                "    int aaaaaaaaaaaaaaaaaaaaaa);");
7373   verifyFormat(
7374       "template <typename T1, typename T2 = char, typename T3 = char,\n"
7375       "          typename T4 = char>\n"
7376       "void f();");
7377   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7378                "          template <typename> class cccccccccccccccccccccc,\n"
7379                "          typename ddddddddddddd>\n"
7380                "class C {};");
7381   verifyFormat(
7382       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7383       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7384 
7385   verifyFormat("void f() {\n"
7386                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7387                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7388                "}");
7389 
7390   verifyFormat("template <typename T> class C {};");
7391   verifyFormat("template <typename T> void f();");
7392   verifyFormat("template <typename T> void f() {}");
7393   verifyFormat(
7394       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7395       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7396       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7397       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7398       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7399       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7400       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
7401       getLLVMStyleWithColumns(72));
7402   EXPECT_EQ("static_cast<A< //\n"
7403             "    B> *>(\n"
7404             "\n"
7405             ");",
7406             format("static_cast<A<//\n"
7407                    "    B>*>(\n"
7408                    "\n"
7409                    "    );"));
7410   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7411                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7412 
7413   FormatStyle AlwaysBreak = getLLVMStyle();
7414   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7415   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7416   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7417   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7418   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7419                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7420                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
7421   verifyFormat("template <template <typename> class Fooooooo,\n"
7422                "          template <typename> class Baaaaaaar>\n"
7423                "struct C {};",
7424                AlwaysBreak);
7425   verifyFormat("template <typename T> // T can be A, B or C.\n"
7426                "struct C {};",
7427                AlwaysBreak);
7428   verifyFormat("template <enum E> class A {\n"
7429                "public:\n"
7430                "  E *f();\n"
7431                "};");
7432 
7433   FormatStyle NeverBreak = getLLVMStyle();
7434   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7435   verifyFormat("template <typename T> class C {};", NeverBreak);
7436   verifyFormat("template <typename T> void f();", NeverBreak);
7437   verifyFormat("template <typename T> void f() {}", NeverBreak);
7438   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7439                "bbbbbbbbbbbbbbbbbbbb) {}",
7440                NeverBreak);
7441   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7442                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7443                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
7444                NeverBreak);
7445   verifyFormat("template <template <typename> class Fooooooo,\n"
7446                "          template <typename> class Baaaaaaar>\n"
7447                "struct C {};",
7448                NeverBreak);
7449   verifyFormat("template <typename T> // T can be A, B or C.\n"
7450                "struct C {};",
7451                NeverBreak);
7452   verifyFormat("template <enum E> class A {\n"
7453                "public:\n"
7454                "  E *f();\n"
7455                "};",
7456                NeverBreak);
7457   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7458   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7459                "bbbbbbbbbbbbbbbbbbbb) {}",
7460                NeverBreak);
7461 }
7462 
7463 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7464   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7465   Style.ColumnLimit = 60;
7466   EXPECT_EQ("// Baseline - no comments.\n"
7467             "template <\n"
7468             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7469             "void f() {}",
7470             format("// Baseline - no comments.\n"
7471                    "template <\n"
7472                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7473                    "void f() {}",
7474                    Style));
7475 
7476   EXPECT_EQ("template <\n"
7477             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7478             "void f() {}",
7479             format("template <\n"
7480                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7481                    "void f() {}",
7482                    Style));
7483 
7484   EXPECT_EQ(
7485       "template <\n"
7486       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7487       "void f() {}",
7488       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
7489              "void f() {}",
7490              Style));
7491 
7492   EXPECT_EQ(
7493       "template <\n"
7494       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7495       "                                               // multiline\n"
7496       "void f() {}",
7497       format("template <\n"
7498              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7499              "                                              // multiline\n"
7500              "void f() {}",
7501              Style));
7502 
7503   EXPECT_EQ(
7504       "template <typename aaaaaaaaaa<\n"
7505       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
7506       "void f() {}",
7507       format(
7508           "template <\n"
7509           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7510           "void f() {}",
7511           Style));
7512 }
7513 
7514 TEST_F(FormatTest, WrapsTemplateParameters) {
7515   FormatStyle Style = getLLVMStyle();
7516   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7517   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7518   verifyFormat(
7519       "template <typename... a> struct q {};\n"
7520       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7521       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7522       "    y;",
7523       Style);
7524   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7525   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7526   verifyFormat(
7527       "template <typename... a> struct r {};\n"
7528       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7529       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7530       "    y;",
7531       Style);
7532   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7533   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7534   verifyFormat("template <typename... a> struct s {};\n"
7535                "extern s<\n"
7536                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7537                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7538                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7539                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7540                "    y;",
7541                Style);
7542   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7543   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7544   verifyFormat("template <typename... a> struct t {};\n"
7545                "extern t<\n"
7546                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7547                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7548                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7549                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7550                "    y;",
7551                Style);
7552 }
7553 
7554 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7555   verifyFormat(
7556       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7557       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7558   verifyFormat(
7559       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7560       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7561       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7562 
7563   // FIXME: Should we have the extra indent after the second break?
7564   verifyFormat(
7565       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7566       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7567       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7568 
7569   verifyFormat(
7570       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7571       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
7572 
7573   // Breaking at nested name specifiers is generally not desirable.
7574   verifyFormat(
7575       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7576       "    aaaaaaaaaaaaaaaaaaaaaaa);");
7577 
7578   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7579                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7580                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7581                "                   aaaaaaaaaaaaaaaaaaaaa);",
7582                getLLVMStyleWithColumns(74));
7583 
7584   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7585                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7586                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7587 }
7588 
7589 TEST_F(FormatTest, UnderstandsTemplateParameters) {
7590   verifyFormat("A<int> a;");
7591   verifyFormat("A<A<A<int>>> a;");
7592   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7593   verifyFormat("bool x = a < 1 || 2 > a;");
7594   verifyFormat("bool x = 5 < f<int>();");
7595   verifyFormat("bool x = f<int>() > 5;");
7596   verifyFormat("bool x = 5 < a<int>::x;");
7597   verifyFormat("bool x = a < 4 ? a > 2 : false;");
7598   verifyFormat("bool x = f() ? a < 2 : a > 2;");
7599 
7600   verifyGoogleFormat("A<A<int>> a;");
7601   verifyGoogleFormat("A<A<A<int>>> a;");
7602   verifyGoogleFormat("A<A<A<A<int>>>> a;");
7603   verifyGoogleFormat("A<A<int> > a;");
7604   verifyGoogleFormat("A<A<A<int> > > a;");
7605   verifyGoogleFormat("A<A<A<A<int> > > > a;");
7606   verifyGoogleFormat("A<::A<int>> a;");
7607   verifyGoogleFormat("A<::A> a;");
7608   verifyGoogleFormat("A< ::A> a;");
7609   verifyGoogleFormat("A< ::A<int> > a;");
7610   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7611   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7612   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7613   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7614   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7615             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7616 
7617   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7618 
7619   // template closer followed by a token that starts with > or =
7620   verifyFormat("bool b = a<1> > 1;");
7621   verifyFormat("bool b = a<1> >= 1;");
7622   verifyFormat("int i = a<1> >> 1;");
7623   FormatStyle Style = getLLVMStyle();
7624   Style.SpaceBeforeAssignmentOperators = false;
7625   verifyFormat("bool b= a<1> == 1;", Style);
7626   verifyFormat("a<int> = 1;", Style);
7627   verifyFormat("a<int> >>= 1;", Style);
7628 
7629   verifyFormat("test >> a >> b;");
7630   verifyFormat("test << a >> b;");
7631 
7632   verifyFormat("f<int>();");
7633   verifyFormat("template <typename T> void f() {}");
7634   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7635   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7636                "sizeof(char)>::type>;");
7637   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7638   verifyFormat("f(a.operator()<A>());");
7639   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7640                "      .template operator()<A>());",
7641                getLLVMStyleWithColumns(35));
7642 
7643   // Not template parameters.
7644   verifyFormat("return a < b && c > d;");
7645   verifyFormat("void f() {\n"
7646                "  while (a < b && c > d) {\n"
7647                "  }\n"
7648                "}");
7649   verifyFormat("template <typename... Types>\n"
7650                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7651 
7652   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7653                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7654                getLLVMStyleWithColumns(60));
7655   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7656   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7657   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7658   verifyFormat("some_templated_type<decltype([](int i) { return i; })>");
7659 }
7660 
7661 TEST_F(FormatTest, UnderstandsShiftOperators) {
7662   verifyFormat("if (i < x >> 1)");
7663   verifyFormat("while (i < x >> 1)");
7664   verifyFormat("for (unsigned i = 0; i < i; ++i, v = v >> 1)");
7665   verifyFormat("for (unsigned i = 0; i < x >> 1; ++i, v = v >> 1)");
7666   verifyFormat(
7667       "for (std::vector<int>::iterator i = 0; i < x >> 1; ++i, v = v >> 1)");
7668   verifyFormat("Foo.call<Bar<Function>>()");
7669   verifyFormat("if (Foo.call<Bar<Function>>() == 0)");
7670   verifyFormat("for (std::vector<std::pair<int>>::iterator i = 0; i < x >> 1; "
7671                "++i, v = v >> 1)");
7672   verifyFormat("if (w<u<v<x>>, 1>::t)");
7673 }
7674 
7675 TEST_F(FormatTest, BitshiftOperatorWidth) {
7676   EXPECT_EQ("int a = 1 << 2; /* foo\n"
7677             "                   bar */",
7678             format("int    a=1<<2;  /* foo\n"
7679                    "                   bar */"));
7680 
7681   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7682             "                     bar */",
7683             format("int  b  =256>>1 ;  /* foo\n"
7684                    "                      bar */"));
7685 }
7686 
7687 TEST_F(FormatTest, UnderstandsBinaryOperators) {
7688   verifyFormat("COMPARE(a, ==, b);");
7689   verifyFormat("auto s = sizeof...(Ts) - 1;");
7690 }
7691 
7692 TEST_F(FormatTest, UnderstandsPointersToMembers) {
7693   verifyFormat("int A::*x;");
7694   verifyFormat("int (S::*func)(void *);");
7695   verifyFormat("void f() { int (S::*func)(void *); }");
7696   verifyFormat("typedef bool *(Class::*Member)() const;");
7697   verifyFormat("void f() {\n"
7698                "  (a->*f)();\n"
7699                "  a->*x;\n"
7700                "  (a.*f)();\n"
7701                "  ((*a).*f)();\n"
7702                "  a.*x;\n"
7703                "}");
7704   verifyFormat("void f() {\n"
7705                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7706                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7707                "}");
7708   verifyFormat(
7709       "(aaaaaaaaaa->*bbbbbbb)(\n"
7710       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7711   FormatStyle Style = getLLVMStyle();
7712   Style.PointerAlignment = FormatStyle::PAS_Left;
7713   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7714 }
7715 
7716 TEST_F(FormatTest, UnderstandsUnaryOperators) {
7717   verifyFormat("int a = -2;");
7718   verifyFormat("f(-1, -2, -3);");
7719   verifyFormat("a[-1] = 5;");
7720   verifyFormat("int a = 5 + -2;");
7721   verifyFormat("if (i == -1) {\n}");
7722   verifyFormat("if (i != -1) {\n}");
7723   verifyFormat("if (i > -1) {\n}");
7724   verifyFormat("if (i < -1) {\n}");
7725   verifyFormat("++(a->f());");
7726   verifyFormat("--(a->f());");
7727   verifyFormat("(a->f())++;");
7728   verifyFormat("a[42]++;");
7729   verifyFormat("if (!(a->f())) {\n}");
7730   verifyFormat("if (!+i) {\n}");
7731   verifyFormat("~&a;");
7732 
7733   verifyFormat("a-- > b;");
7734   verifyFormat("b ? -a : c;");
7735   verifyFormat("n * sizeof char16;");
7736   verifyFormat("n * alignof char16;", getGoogleStyle());
7737   verifyFormat("sizeof(char);");
7738   verifyFormat("alignof(char);", getGoogleStyle());
7739 
7740   verifyFormat("return -1;");
7741   verifyFormat("throw -1;");
7742   verifyFormat("switch (a) {\n"
7743                "case -1:\n"
7744                "  break;\n"
7745                "}");
7746   verifyFormat("#define X -1");
7747   verifyFormat("#define X -kConstant");
7748 
7749   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7750   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7751 
7752   verifyFormat("int a = /* confusing comment */ -1;");
7753   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7754   verifyFormat("int a = i /* confusing comment */++;");
7755 
7756   verifyFormat("co_yield -1;");
7757   verifyFormat("co_return -1;");
7758 }
7759 
7760 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7761   verifyFormat("if (!aaaaaaaaaa( // break\n"
7762                "        aaaaa)) {\n"
7763                "}");
7764   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7765                "    aaaaa));");
7766   verifyFormat("*aaa = aaaaaaa( // break\n"
7767                "    bbbbbb);");
7768 }
7769 
7770 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7771   verifyFormat("bool operator<();");
7772   verifyFormat("bool operator>();");
7773   verifyFormat("bool operator=();");
7774   verifyFormat("bool operator==();");
7775   verifyFormat("bool operator!=();");
7776   verifyFormat("int operator+();");
7777   verifyFormat("int operator++();");
7778   verifyFormat("int operator++(int) volatile noexcept;");
7779   verifyFormat("bool operator,();");
7780   verifyFormat("bool operator();");
7781   verifyFormat("bool operator()();");
7782   verifyFormat("bool operator[]();");
7783   verifyFormat("operator bool();");
7784   verifyFormat("operator int();");
7785   verifyFormat("operator void *();");
7786   verifyFormat("operator SomeType<int>();");
7787   verifyFormat("operator SomeType<int, int>();");
7788   verifyFormat("operator SomeType<SomeType<int>>();");
7789   verifyFormat("void *operator new(std::size_t size);");
7790   verifyFormat("void *operator new[](std::size_t size);");
7791   verifyFormat("void operator delete(void *ptr);");
7792   verifyFormat("void operator delete[](void *ptr);");
7793   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7794                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7795   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7796                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7797 
7798   verifyFormat(
7799       "ostream &operator<<(ostream &OutputStream,\n"
7800       "                    SomeReallyLongType WithSomeReallyLongValue);");
7801   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7802                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7803                "  return left.group < right.group;\n"
7804                "}");
7805   verifyFormat("SomeType &operator=(const SomeType &S);");
7806   verifyFormat("f.template operator()<int>();");
7807 
7808   verifyGoogleFormat("operator void*();");
7809   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7810   verifyGoogleFormat("operator ::A();");
7811 
7812   verifyFormat("using A::operator+;");
7813   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7814                "int i;");
7815 }
7816 
7817 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7818   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7819   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7820   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7821   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7822   verifyFormat("Deleted &operator=(const Deleted &) &;");
7823   verifyFormat("Deleted &operator=(const Deleted &) &&;");
7824   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7825   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7826   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7827   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7828   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7829   verifyFormat("void Fn(T const &) const &;");
7830   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7831   verifyFormat("template <typename T>\n"
7832                "void F(T) && = delete;",
7833                getGoogleStyle());
7834 
7835   FormatStyle AlignLeft = getLLVMStyle();
7836   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7837   verifyFormat("void A::b() && {}", AlignLeft);
7838   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7839   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7840                AlignLeft);
7841   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7842   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7843   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7844   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7845   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7846   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7847   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7848   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7849 
7850   FormatStyle Spaces = getLLVMStyle();
7851   Spaces.SpacesInCStyleCastParentheses = true;
7852   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7853   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7854   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7855   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7856 
7857   Spaces.SpacesInCStyleCastParentheses = false;
7858   Spaces.SpacesInParentheses = true;
7859   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7860   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7861                Spaces);
7862   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7863   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7864 
7865   FormatStyle BreakTemplate = getLLVMStyle();
7866   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7867 
7868   verifyFormat("struct f {\n"
7869                "  template <class T>\n"
7870                "  int &foo(const std::string &str) &noexcept {}\n"
7871                "};",
7872                BreakTemplate);
7873 
7874   verifyFormat("struct f {\n"
7875                "  template <class T>\n"
7876                "  int &foo(const std::string &str) &&noexcept {}\n"
7877                "};",
7878                BreakTemplate);
7879 
7880   verifyFormat("struct f {\n"
7881                "  template <class T>\n"
7882                "  int &foo(const std::string &str) const &noexcept {}\n"
7883                "};",
7884                BreakTemplate);
7885 
7886   verifyFormat("struct f {\n"
7887                "  template <class T>\n"
7888                "  int &foo(const std::string &str) const &noexcept {}\n"
7889                "};",
7890                BreakTemplate);
7891 
7892   verifyFormat("struct f {\n"
7893                "  template <class T>\n"
7894                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
7895                "};",
7896                BreakTemplate);
7897 
7898   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7899   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7900       FormatStyle::BTDS_Yes;
7901   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7902 
7903   verifyFormat("struct f {\n"
7904                "  template <class T>\n"
7905                "  int& foo(const std::string& str) & noexcept {}\n"
7906                "};",
7907                AlignLeftBreakTemplate);
7908 
7909   verifyFormat("struct f {\n"
7910                "  template <class T>\n"
7911                "  int& foo(const std::string& str) && noexcept {}\n"
7912                "};",
7913                AlignLeftBreakTemplate);
7914 
7915   verifyFormat("struct f {\n"
7916                "  template <class T>\n"
7917                "  int& foo(const std::string& str) const& noexcept {}\n"
7918                "};",
7919                AlignLeftBreakTemplate);
7920 
7921   verifyFormat("struct f {\n"
7922                "  template <class T>\n"
7923                "  int& foo(const std::string& str) const&& noexcept {}\n"
7924                "};",
7925                AlignLeftBreakTemplate);
7926 
7927   verifyFormat("struct f {\n"
7928                "  template <class T>\n"
7929                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7930                "};",
7931                AlignLeftBreakTemplate);
7932 
7933   // The `&` in `Type&` should not be confused with a trailing `&` of
7934   // DEPRECATED(reason) member function.
7935   verifyFormat("struct f {\n"
7936                "  template <class T>\n"
7937                "  DEPRECATED(reason)\n"
7938                "  Type &foo(arguments) {}\n"
7939                "};",
7940                BreakTemplate);
7941 
7942   verifyFormat("struct f {\n"
7943                "  template <class T>\n"
7944                "  DEPRECATED(reason)\n"
7945                "  Type& foo(arguments) {}\n"
7946                "};",
7947                AlignLeftBreakTemplate);
7948 
7949   verifyFormat("void (*foopt)(int) = &func;");
7950 }
7951 
7952 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7953   verifyFormat("void f() {\n"
7954                "  A *a = new A;\n"
7955                "  A *a = new (placement) A;\n"
7956                "  delete a;\n"
7957                "  delete (A *)a;\n"
7958                "}");
7959   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7960                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7961   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7962                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7963                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7964   verifyFormat("delete[] h->p;");
7965 }
7966 
7967 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
7968   verifyFormat("int *f(int *a) {}");
7969   verifyFormat("int main(int argc, char **argv) {}");
7970   verifyFormat("Test::Test(int b) : a(b * b) {}");
7971   verifyIndependentOfContext("f(a, *a);");
7972   verifyFormat("void g() { f(*a); }");
7973   verifyIndependentOfContext("int a = b * 10;");
7974   verifyIndependentOfContext("int a = 10 * b;");
7975   verifyIndependentOfContext("int a = b * c;");
7976   verifyIndependentOfContext("int a += b * c;");
7977   verifyIndependentOfContext("int a -= b * c;");
7978   verifyIndependentOfContext("int a *= b * c;");
7979   verifyIndependentOfContext("int a /= b * c;");
7980   verifyIndependentOfContext("int a = *b;");
7981   verifyIndependentOfContext("int a = *b * c;");
7982   verifyIndependentOfContext("int a = b * *c;");
7983   verifyIndependentOfContext("int a = b * (10);");
7984   verifyIndependentOfContext("S << b * (10);");
7985   verifyIndependentOfContext("return 10 * b;");
7986   verifyIndependentOfContext("return *b * *c;");
7987   verifyIndependentOfContext("return a & ~b;");
7988   verifyIndependentOfContext("f(b ? *c : *d);");
7989   verifyIndependentOfContext("int a = b ? *c : *d;");
7990   verifyIndependentOfContext("*b = a;");
7991   verifyIndependentOfContext("a * ~b;");
7992   verifyIndependentOfContext("a * !b;");
7993   verifyIndependentOfContext("a * +b;");
7994   verifyIndependentOfContext("a * -b;");
7995   verifyIndependentOfContext("a * ++b;");
7996   verifyIndependentOfContext("a * --b;");
7997   verifyIndependentOfContext("a[4] * b;");
7998   verifyIndependentOfContext("a[a * a] = 1;");
7999   verifyIndependentOfContext("f() * b;");
8000   verifyIndependentOfContext("a * [self dostuff];");
8001   verifyIndependentOfContext("int x = a * (a + b);");
8002   verifyIndependentOfContext("(a *)(a + b);");
8003   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
8004   verifyIndependentOfContext("int *pa = (int *)&a;");
8005   verifyIndependentOfContext("return sizeof(int **);");
8006   verifyIndependentOfContext("return sizeof(int ******);");
8007   verifyIndependentOfContext("return (int **&)a;");
8008   verifyIndependentOfContext("f((*PointerToArray)[10]);");
8009   verifyFormat("void f(Type (*parameter)[10]) {}");
8010   verifyFormat("void f(Type (&parameter)[10]) {}");
8011   verifyGoogleFormat("return sizeof(int**);");
8012   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
8013   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
8014   verifyFormat("auto a = [](int **&, int ***) {};");
8015   verifyFormat("auto PointerBinding = [](const char *S) {};");
8016   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
8017   verifyFormat("[](const decltype(*a) &value) {}");
8018   verifyFormat("[](const typeof(*a) &value) {}");
8019   verifyFormat("[](const _Atomic(a *) &value) {}");
8020   verifyFormat("[](const __underlying_type(a) &value) {}");
8021   verifyFormat("decltype(a * b) F();");
8022   verifyFormat("typeof(a * b) F();");
8023   verifyFormat("#define MACRO() [](A *a) { return 1; }");
8024   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
8025   verifyIndependentOfContext("typedef void (*f)(int *a);");
8026   verifyIndependentOfContext("int i{a * b};");
8027   verifyIndependentOfContext("aaa && aaa->f();");
8028   verifyIndependentOfContext("int x = ~*p;");
8029   verifyFormat("Constructor() : a(a), area(width * height) {}");
8030   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
8031   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
8032   verifyFormat("void f() { f(a, c * d); }");
8033   verifyFormat("void f() { f(new a(), c * d); }");
8034   verifyFormat("void f(const MyOverride &override);");
8035   verifyFormat("void f(const MyFinal &final);");
8036   verifyIndependentOfContext("bool a = f() && override.f();");
8037   verifyIndependentOfContext("bool a = f() && final.f();");
8038 
8039   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
8040 
8041   verifyIndependentOfContext("A<int *> a;");
8042   verifyIndependentOfContext("A<int **> a;");
8043   verifyIndependentOfContext("A<int *, int *> a;");
8044   verifyIndependentOfContext("A<int *[]> a;");
8045   verifyIndependentOfContext(
8046       "const char *const p = reinterpret_cast<const char *const>(q);");
8047   verifyIndependentOfContext("A<int **, int **> a;");
8048   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
8049   verifyFormat("for (char **a = b; *a; ++a) {\n}");
8050   verifyFormat("for (; a && b;) {\n}");
8051   verifyFormat("bool foo = true && [] { return false; }();");
8052 
8053   verifyFormat(
8054       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8055       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8056 
8057   verifyGoogleFormat("int const* a = &b;");
8058   verifyGoogleFormat("**outparam = 1;");
8059   verifyGoogleFormat("*outparam = a * b;");
8060   verifyGoogleFormat("int main(int argc, char** argv) {}");
8061   verifyGoogleFormat("A<int*> a;");
8062   verifyGoogleFormat("A<int**> a;");
8063   verifyGoogleFormat("A<int*, int*> a;");
8064   verifyGoogleFormat("A<int**, int**> a;");
8065   verifyGoogleFormat("f(b ? *c : *d);");
8066   verifyGoogleFormat("int a = b ? *c : *d;");
8067   verifyGoogleFormat("Type* t = **x;");
8068   verifyGoogleFormat("Type* t = *++*x;");
8069   verifyGoogleFormat("*++*x;");
8070   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
8071   verifyGoogleFormat("Type* t = x++ * y;");
8072   verifyGoogleFormat(
8073       "const char* const p = reinterpret_cast<const char* const>(q);");
8074   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
8075   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
8076   verifyGoogleFormat("template <typename T>\n"
8077                      "void f(int i = 0, SomeType** temps = NULL);");
8078 
8079   FormatStyle Left = getLLVMStyle();
8080   Left.PointerAlignment = FormatStyle::PAS_Left;
8081   verifyFormat("x = *a(x) = *a(y);", Left);
8082   verifyFormat("for (;; *a = b) {\n}", Left);
8083   verifyFormat("return *this += 1;", Left);
8084   verifyFormat("throw *x;", Left);
8085   verifyFormat("delete *x;", Left);
8086   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
8087   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
8088   verifyFormat("[](const typeof(*a)* ptr) {}", Left);
8089   verifyFormat("[](const _Atomic(a*)* ptr) {}", Left);
8090   verifyFormat("[](const __underlying_type(a)* ptr) {}", Left);
8091   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
8092   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
8093   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
8094   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
8095 
8096   verifyIndependentOfContext("a = *(x + y);");
8097   verifyIndependentOfContext("a = &(x + y);");
8098   verifyIndependentOfContext("*(x + y).call();");
8099   verifyIndependentOfContext("&(x + y)->call();");
8100   verifyFormat("void f() { &(*I).first; }");
8101 
8102   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
8103   verifyFormat(
8104       "int *MyValues = {\n"
8105       "    *A, // Operator detection might be confused by the '{'\n"
8106       "    *BB // Operator detection might be confused by previous comment\n"
8107       "};");
8108 
8109   verifyIndependentOfContext("if (int *a = &b)");
8110   verifyIndependentOfContext("if (int &a = *b)");
8111   verifyIndependentOfContext("if (a & b[i])");
8112   verifyIndependentOfContext("if constexpr (a & b[i])");
8113   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
8114   verifyIndependentOfContext("if (a * (b * c))");
8115   verifyIndependentOfContext("if constexpr (a * (b * c))");
8116   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
8117   verifyIndependentOfContext("if (a::b::c::d & b[i])");
8118   verifyIndependentOfContext("if (*b[i])");
8119   verifyIndependentOfContext("if (int *a = (&b))");
8120   verifyIndependentOfContext("while (int *a = &b)");
8121   verifyIndependentOfContext("while (a * (b * c))");
8122   verifyIndependentOfContext("size = sizeof *a;");
8123   verifyIndependentOfContext("if (a && (b = c))");
8124   verifyFormat("void f() {\n"
8125                "  for (const int &v : Values) {\n"
8126                "  }\n"
8127                "}");
8128   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
8129   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
8130   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
8131 
8132   verifyFormat("#define A (!a * b)");
8133   verifyFormat("#define MACRO     \\\n"
8134                "  int *i = a * b; \\\n"
8135                "  void f(a *b);",
8136                getLLVMStyleWithColumns(19));
8137 
8138   verifyIndependentOfContext("A = new SomeType *[Length];");
8139   verifyIndependentOfContext("A = new SomeType *[Length]();");
8140   verifyIndependentOfContext("T **t = new T *;");
8141   verifyIndependentOfContext("T **t = new T *();");
8142   verifyGoogleFormat("A = new SomeType*[Length]();");
8143   verifyGoogleFormat("A = new SomeType*[Length];");
8144   verifyGoogleFormat("T** t = new T*;");
8145   verifyGoogleFormat("T** t = new T*();");
8146 
8147   verifyFormat("STATIC_ASSERT((a & b) == 0);");
8148   verifyFormat("STATIC_ASSERT(0 == (a & b));");
8149   verifyFormat("template <bool a, bool b> "
8150                "typename t::if<x && y>::type f() {}");
8151   verifyFormat("template <int *y> f() {}");
8152   verifyFormat("vector<int *> v;");
8153   verifyFormat("vector<int *const> v;");
8154   verifyFormat("vector<int *const **const *> v;");
8155   verifyFormat("vector<int *volatile> v;");
8156   verifyFormat("vector<a *_Nonnull> v;");
8157   verifyFormat("vector<a *_Nullable> v;");
8158   verifyFormat("vector<a *_Null_unspecified> v;");
8159   verifyFormat("vector<a *__ptr32> v;");
8160   verifyFormat("vector<a *__ptr64> v;");
8161   verifyFormat("vector<a *__capability> v;");
8162   FormatStyle TypeMacros = getLLVMStyle();
8163   TypeMacros.TypenameMacros = {"LIST"};
8164   verifyFormat("vector<LIST(uint64_t)> v;", TypeMacros);
8165   verifyFormat("vector<LIST(uint64_t) *> v;", TypeMacros);
8166   verifyFormat("vector<LIST(uint64_t) **> v;", TypeMacros);
8167   verifyFormat("vector<LIST(uint64_t) *attr> v;", TypeMacros);
8168   verifyFormat("vector<A(uint64_t) * attr> v;", TypeMacros); // multiplication
8169 
8170   FormatStyle CustomQualifier = getLLVMStyle();
8171   // Add indentifers that should not be parsed as a qualifier by default.
8172   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8173   CustomQualifier.AttributeMacros.push_back("_My_qualifier");
8174   CustomQualifier.AttributeMacros.push_back("my_other_qualifier");
8175   verifyFormat("vector<a * __my_qualifier> parse_as_multiply;");
8176   verifyFormat("vector<a *__my_qualifier> v;", CustomQualifier);
8177   verifyFormat("vector<a * _My_qualifier> parse_as_multiply;");
8178   verifyFormat("vector<a *_My_qualifier> v;", CustomQualifier);
8179   verifyFormat("vector<a * my_other_qualifier> parse_as_multiply;");
8180   verifyFormat("vector<a *my_other_qualifier> v;", CustomQualifier);
8181   verifyFormat("vector<a * _NotAQualifier> v;");
8182   verifyFormat("vector<a * __not_a_qualifier> v;");
8183   verifyFormat("vector<a * b> v;");
8184   verifyFormat("foo<b && false>();");
8185   verifyFormat("foo<b & 1>();");
8186   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
8187   verifyFormat("typeof(*::std::declval<const T &>()) void F();");
8188   verifyFormat("_Atomic(*::std::declval<const T &>()) void F();");
8189   verifyFormat("__underlying_type(*::std::declval<const T &>()) void F();");
8190   verifyFormat(
8191       "template <class T, class = typename std::enable_if<\n"
8192       "                       std::is_integral<T>::value &&\n"
8193       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
8194       "void F();",
8195       getLLVMStyleWithColumns(70));
8196   verifyFormat("template <class T,\n"
8197                "          class = typename std::enable_if<\n"
8198                "              std::is_integral<T>::value &&\n"
8199                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
8200                "          class U>\n"
8201                "void F();",
8202                getLLVMStyleWithColumns(70));
8203   verifyFormat(
8204       "template <class T,\n"
8205       "          class = typename ::std::enable_if<\n"
8206       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
8207       "void F();",
8208       getGoogleStyleWithColumns(68));
8209 
8210   verifyIndependentOfContext("MACRO(int *i);");
8211   verifyIndependentOfContext("MACRO(auto *a);");
8212   verifyIndependentOfContext("MACRO(const A *a);");
8213   verifyIndependentOfContext("MACRO(_Atomic(A) *a);");
8214   verifyIndependentOfContext("MACRO(decltype(A) *a);");
8215   verifyIndependentOfContext("MACRO(typeof(A) *a);");
8216   verifyIndependentOfContext("MACRO(__underlying_type(A) *a);");
8217   verifyIndependentOfContext("MACRO(A *const a);");
8218   verifyIndependentOfContext("MACRO(A *restrict a);");
8219   verifyIndependentOfContext("MACRO(A *__restrict__ a);");
8220   verifyIndependentOfContext("MACRO(A *__restrict a);");
8221   verifyIndependentOfContext("MACRO(A *volatile a);");
8222   verifyIndependentOfContext("MACRO(A *__volatile a);");
8223   verifyIndependentOfContext("MACRO(A *__volatile__ a);");
8224   verifyIndependentOfContext("MACRO(A *_Nonnull a);");
8225   verifyIndependentOfContext("MACRO(A *_Nullable a);");
8226   verifyIndependentOfContext("MACRO(A *_Null_unspecified a);");
8227   verifyIndependentOfContext("MACRO(A *__attribute__((foo)) a);");
8228   verifyIndependentOfContext("MACRO(A *__attribute((foo)) a);");
8229   verifyIndependentOfContext("MACRO(A *[[clang::attr]] a);");
8230   verifyIndependentOfContext("MACRO(A *[[clang::attr(\"foo\")]] a);");
8231   verifyIndependentOfContext("MACRO(A *__ptr32 a);");
8232   verifyIndependentOfContext("MACRO(A *__ptr64 a);");
8233   verifyIndependentOfContext("MACRO(A *__capability);");
8234   verifyIndependentOfContext("MACRO(A &__capability);");
8235   verifyFormat("MACRO(A *__my_qualifier);");               // type declaration
8236   verifyFormat("void f() { MACRO(A * __my_qualifier); }"); // multiplication
8237   // If we add __my_qualifier to AttributeMacros it should always be parsed as
8238   // a type declaration:
8239   verifyFormat("MACRO(A *__my_qualifier);", CustomQualifier);
8240   verifyFormat("void f() { MACRO(A *__my_qualifier); }", CustomQualifier);
8241   // Also check that TypenameMacros prevents parsing it as multiplication:
8242   verifyIndependentOfContext("MACRO(LIST(uint64_t) * a);"); // multiplication
8243   verifyIndependentOfContext("MACRO(LIST(uint64_t) *a);", TypeMacros); // type
8244 
8245   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
8246   verifyFormat("void f() { f(float{1}, a * a); }");
8247   // FIXME: Is there a way to make this work?
8248   // verifyIndependentOfContext("MACRO(A *a);");
8249   verifyFormat("MACRO(A &B);");
8250   verifyFormat("MACRO(A *B);");
8251   verifyFormat("void f() { MACRO(A * B); }");
8252   verifyFormat("void f() { MACRO(A & B); }");
8253 
8254   // This lambda was mis-formatted after D88956 (treating it as a binop):
8255   verifyFormat("auto x = [](const decltype(x) &ptr) {};");
8256   verifyFormat("auto x = [](const decltype(x) *ptr) {};");
8257   verifyFormat("#define lambda [](const decltype(x) &ptr) {}");
8258   verifyFormat("#define lambda [](const decltype(x) *ptr) {}");
8259 
8260   verifyFormat("DatumHandle const *operator->() const { return input_; }");
8261   verifyFormat("return options != nullptr && operator==(*options);");
8262 
8263   EXPECT_EQ("#define OP(x)                                    \\\n"
8264             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
8265             "    return s << a.DebugString();                 \\\n"
8266             "  }",
8267             format("#define OP(x) \\\n"
8268                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
8269                    "    return s << a.DebugString(); \\\n"
8270                    "  }",
8271                    getLLVMStyleWithColumns(50)));
8272 
8273   // FIXME: We cannot handle this case yet; we might be able to figure out that
8274   // foo<x> d > v; doesn't make sense.
8275   verifyFormat("foo<a<b && c> d> v;");
8276 
8277   FormatStyle PointerMiddle = getLLVMStyle();
8278   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8279   verifyFormat("delete *x;", PointerMiddle);
8280   verifyFormat("int * x;", PointerMiddle);
8281   verifyFormat("int *[] x;", PointerMiddle);
8282   verifyFormat("template <int * y> f() {}", PointerMiddle);
8283   verifyFormat("int * f(int * a) {}", PointerMiddle);
8284   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8285   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8286   verifyFormat("A<int *> a;", PointerMiddle);
8287   verifyFormat("A<int **> a;", PointerMiddle);
8288   verifyFormat("A<int *, int *> a;", PointerMiddle);
8289   verifyFormat("A<int *[]> a;", PointerMiddle);
8290   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8291   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8292   verifyFormat("T ** t = new T *;", PointerMiddle);
8293 
8294   // Member function reference qualifiers aren't binary operators.
8295   verifyFormat("string // break\n"
8296                "operator()() & {}");
8297   verifyFormat("string // break\n"
8298                "operator()() && {}");
8299   verifyGoogleFormat("template <typename T>\n"
8300                      "auto x() & -> int {}");
8301 }
8302 
8303 TEST_F(FormatTest, UnderstandsAttributes) {
8304   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8305   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8306                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8307   FormatStyle AfterType = getLLVMStyle();
8308   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
8309   verifyFormat("__attribute__((nodebug)) void\n"
8310                "foo() {}\n",
8311                AfterType);
8312   verifyFormat("__unused void\n"
8313                "foo() {}",
8314                AfterType);
8315 
8316   FormatStyle CustomAttrs = getLLVMStyle();
8317   CustomAttrs.AttributeMacros.push_back("__unused");
8318   CustomAttrs.AttributeMacros.push_back("__attr1");
8319   CustomAttrs.AttributeMacros.push_back("__attr2");
8320   CustomAttrs.AttributeMacros.push_back("no_underscore_attr");
8321   verifyFormat("vector<SomeType *__attribute((foo))> v;");
8322   verifyFormat("vector<SomeType *__attribute__((foo))> v;");
8323   verifyFormat("vector<SomeType * __not_attribute__((foo))> v;");
8324   // Check that it is parsed as a multiplication without AttributeMacros and
8325   // as a pointer qualifier when we add __attr1/__attr2 to AttributeMacros.
8326   verifyFormat("vector<SomeType * __attr1> v;");
8327   verifyFormat("vector<SomeType __attr1 *> v;");
8328   verifyFormat("vector<SomeType __attr1 *const> v;");
8329   verifyFormat("vector<SomeType __attr1 * __attr2> v;");
8330   verifyFormat("vector<SomeType *__attr1> v;", CustomAttrs);
8331   verifyFormat("vector<SomeType *__attr2> v;", CustomAttrs);
8332   verifyFormat("vector<SomeType *no_underscore_attr> v;", CustomAttrs);
8333   verifyFormat("vector<SomeType __attr1 *> v;", CustomAttrs);
8334   verifyFormat("vector<SomeType __attr1 *const> v;", CustomAttrs);
8335   verifyFormat("vector<SomeType __attr1 *__attr2> v;", CustomAttrs);
8336   verifyFormat("vector<SomeType __attr1 *no_underscore_attr> v;", CustomAttrs);
8337 
8338   // Check that these are not parsed as function declarations:
8339   CustomAttrs.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8340   CustomAttrs.BreakBeforeBraces = FormatStyle::BS_Allman;
8341   verifyFormat("SomeType s(InitValue);", CustomAttrs);
8342   verifyFormat("SomeType s{InitValue};", CustomAttrs);
8343   verifyFormat("SomeType *__unused s(InitValue);", CustomAttrs);
8344   verifyFormat("SomeType *__unused s{InitValue};", CustomAttrs);
8345   verifyFormat("SomeType s __unused(InitValue);", CustomAttrs);
8346   verifyFormat("SomeType s __unused{InitValue};", CustomAttrs);
8347   verifyFormat("SomeType *__capability s(InitValue);", CustomAttrs);
8348   verifyFormat("SomeType *__capability s{InitValue};", CustomAttrs);
8349 }
8350 
8351 TEST_F(FormatTest, UnderstandsPointerQualifiersInCast) {
8352   // Check that qualifiers on pointers don't break parsing of casts.
8353   verifyFormat("x = (foo *const)*v;");
8354   verifyFormat("x = (foo *volatile)*v;");
8355   verifyFormat("x = (foo *restrict)*v;");
8356   verifyFormat("x = (foo *__attribute__((foo)))*v;");
8357   verifyFormat("x = (foo *_Nonnull)*v;");
8358   verifyFormat("x = (foo *_Nullable)*v;");
8359   verifyFormat("x = (foo *_Null_unspecified)*v;");
8360   verifyFormat("x = (foo *_Nonnull)*v;");
8361   verifyFormat("x = (foo *[[clang::attr]])*v;");
8362   verifyFormat("x = (foo *[[clang::attr(\"foo\")]])*v;");
8363   verifyFormat("x = (foo *__ptr32)*v;");
8364   verifyFormat("x = (foo *__ptr64)*v;");
8365   verifyFormat("x = (foo *__capability)*v;");
8366 
8367   // Check that we handle multiple trailing qualifiers and skip them all to
8368   // determine that the expression is a cast to a pointer type.
8369   FormatStyle LongPointerRight = getLLVMStyleWithColumns(999);
8370   FormatStyle LongPointerLeft = getLLVMStyleWithColumns(999);
8371   LongPointerLeft.PointerAlignment = FormatStyle::PAS_Left;
8372   StringRef AllQualifiers =
8373       "const volatile restrict __attribute__((foo)) _Nonnull _Null_unspecified "
8374       "_Nonnull [[clang::attr]] __ptr32 __ptr64 __capability";
8375   verifyFormat(("x = (foo *" + AllQualifiers + ")*v;").str(), LongPointerRight);
8376   verifyFormat(("x = (foo* " + AllQualifiers + ")*v;").str(), LongPointerLeft);
8377 
8378   // Also check that address-of is not parsed as a binary bitwise-and:
8379   verifyFormat("x = (foo *const)&v;");
8380   verifyFormat(("x = (foo *" + AllQualifiers + ")&v;").str(), LongPointerRight);
8381   verifyFormat(("x = (foo* " + AllQualifiers + ")&v;").str(), LongPointerLeft);
8382 
8383   // Check custom qualifiers:
8384   FormatStyle CustomQualifier = getLLVMStyleWithColumns(999);
8385   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8386   verifyFormat("x = (foo * __my_qualifier) * v;"); // not parsed as qualifier.
8387   verifyFormat("x = (foo *__my_qualifier)*v;", CustomQualifier);
8388   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)*v;").str(),
8389                CustomQualifier);
8390   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)&v;").str(),
8391                CustomQualifier);
8392 
8393   // Check that unknown identifiers result in binary operator parsing:
8394   verifyFormat("x = (foo * __unknown_qualifier) * v;");
8395   verifyFormat("x = (foo * __unknown_qualifier) & v;");
8396 }
8397 
8398 TEST_F(FormatTest, UnderstandsSquareAttributes) {
8399   verifyFormat("SomeType s [[unused]] (InitValue);");
8400   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8401   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8402   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8403   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8404   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8405                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8406   verifyFormat("[[nodiscard]] bool f() { return false; }");
8407   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
8408   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
8409   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
8410 
8411   // Make sure we do not mistake attributes for array subscripts.
8412   verifyFormat("int a() {}\n"
8413                "[[unused]] int b() {}\n");
8414   verifyFormat("NSArray *arr;\n"
8415                "arr[[Foo() bar]];");
8416 
8417   // On the other hand, we still need to correctly find array subscripts.
8418   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8419 
8420   // Make sure that we do not mistake Objective-C method inside array literals
8421   // as attributes, even if those method names are also keywords.
8422   verifyFormat("@[ [foo bar] ];");
8423   verifyFormat("@[ [NSArray class] ];");
8424   verifyFormat("@[ [foo enum] ];");
8425 
8426   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8427 
8428   // Make sure we do not parse attributes as lambda introducers.
8429   FormatStyle MultiLineFunctions = getLLVMStyle();
8430   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8431   verifyFormat("[[unused]] int b() {\n"
8432                "  return 42;\n"
8433                "}\n",
8434                MultiLineFunctions);
8435 }
8436 
8437 TEST_F(FormatTest, AttributeClass) {
8438   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8439   verifyFormat("class S {\n"
8440                "  S(S&&) = default;\n"
8441                "};",
8442                Style);
8443   verifyFormat("class [[nodiscard]] S {\n"
8444                "  S(S&&) = default;\n"
8445                "};",
8446                Style);
8447   verifyFormat("class __attribute((maybeunused)) S {\n"
8448                "  S(S&&) = default;\n"
8449                "};",
8450                Style);
8451   verifyFormat("struct S {\n"
8452                "  S(S&&) = default;\n"
8453                "};",
8454                Style);
8455   verifyFormat("struct [[nodiscard]] S {\n"
8456                "  S(S&&) = default;\n"
8457                "};",
8458                Style);
8459 }
8460 
8461 TEST_F(FormatTest, AttributesAfterMacro) {
8462   FormatStyle Style = getLLVMStyle();
8463   verifyFormat("MACRO;\n"
8464                "__attribute__((maybe_unused)) int foo() {\n"
8465                "  //...\n"
8466                "}");
8467 
8468   verifyFormat("MACRO;\n"
8469                "[[nodiscard]] int foo() {\n"
8470                "  //...\n"
8471                "}");
8472 
8473   EXPECT_EQ("MACRO\n\n"
8474             "__attribute__((maybe_unused)) int foo() {\n"
8475             "  //...\n"
8476             "}",
8477             format("MACRO\n\n"
8478                    "__attribute__((maybe_unused)) int foo() {\n"
8479                    "  //...\n"
8480                    "}"));
8481 
8482   EXPECT_EQ("MACRO\n\n"
8483             "[[nodiscard]] int foo() {\n"
8484             "  //...\n"
8485             "}",
8486             format("MACRO\n\n"
8487                    "[[nodiscard]] int foo() {\n"
8488                    "  //...\n"
8489                    "}"));
8490 }
8491 
8492 TEST_F(FormatTest, AttributePenaltyBreaking) {
8493   FormatStyle Style = getLLVMStyle();
8494   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8495                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8496                Style);
8497   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8498                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8499                Style);
8500   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8501                "shared_ptr<ALongTypeName> &C d) {\n}",
8502                Style);
8503 }
8504 
8505 TEST_F(FormatTest, UnderstandsEllipsis) {
8506   FormatStyle Style = getLLVMStyle();
8507   verifyFormat("int printf(const char *fmt, ...);");
8508   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8509   verifyFormat("template <class... Ts> void Foo(Ts *...ts) {}");
8510 
8511   verifyFormat("template <int *...PP> a;", Style);
8512 
8513   Style.PointerAlignment = FormatStyle::PAS_Left;
8514   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", Style);
8515 
8516   verifyFormat("template <int*... PP> a;", Style);
8517 
8518   Style.PointerAlignment = FormatStyle::PAS_Middle;
8519   verifyFormat("template <int *... PP> a;", Style);
8520 }
8521 
8522 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8523   EXPECT_EQ("int *a;\n"
8524             "int *a;\n"
8525             "int *a;",
8526             format("int *a;\n"
8527                    "int* a;\n"
8528                    "int *a;",
8529                    getGoogleStyle()));
8530   EXPECT_EQ("int* a;\n"
8531             "int* a;\n"
8532             "int* a;",
8533             format("int* a;\n"
8534                    "int* a;\n"
8535                    "int *a;",
8536                    getGoogleStyle()));
8537   EXPECT_EQ("int *a;\n"
8538             "int *a;\n"
8539             "int *a;",
8540             format("int *a;\n"
8541                    "int * a;\n"
8542                    "int *  a;",
8543                    getGoogleStyle()));
8544   EXPECT_EQ("auto x = [] {\n"
8545             "  int *a;\n"
8546             "  int *a;\n"
8547             "  int *a;\n"
8548             "};",
8549             format("auto x=[]{int *a;\n"
8550                    "int * a;\n"
8551                    "int *  a;};",
8552                    getGoogleStyle()));
8553 }
8554 
8555 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8556   verifyFormat("int f(int &&a) {}");
8557   verifyFormat("int f(int a, char &&b) {}");
8558   verifyFormat("void f() { int &&a = b; }");
8559   verifyGoogleFormat("int f(int a, char&& b) {}");
8560   verifyGoogleFormat("void f() { int&& a = b; }");
8561 
8562   verifyIndependentOfContext("A<int &&> a;");
8563   verifyIndependentOfContext("A<int &&, int &&> a;");
8564   verifyGoogleFormat("A<int&&> a;");
8565   verifyGoogleFormat("A<int&&, int&&> a;");
8566 
8567   // Not rvalue references:
8568   verifyFormat("template <bool B, bool C> class A {\n"
8569                "  static_assert(B && C, \"Something is wrong\");\n"
8570                "};");
8571   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8572   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8573   verifyFormat("#define A(a, b) (a && b)");
8574 }
8575 
8576 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8577   verifyFormat("void f() {\n"
8578                "  x[aaaaaaaaa -\n"
8579                "    b] = 23;\n"
8580                "}",
8581                getLLVMStyleWithColumns(15));
8582 }
8583 
8584 TEST_F(FormatTest, FormatsCasts) {
8585   verifyFormat("Type *A = static_cast<Type *>(P);");
8586   verifyFormat("Type *A = (Type *)P;");
8587   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8588   verifyFormat("int a = (int)(2.0f);");
8589   verifyFormat("int a = (int)2.0f;");
8590   verifyFormat("x[(int32)y];");
8591   verifyFormat("x = (int32)y;");
8592   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8593   verifyFormat("int a = (int)*b;");
8594   verifyFormat("int a = (int)2.0f;");
8595   verifyFormat("int a = (int)~0;");
8596   verifyFormat("int a = (int)++a;");
8597   verifyFormat("int a = (int)sizeof(int);");
8598   verifyFormat("int a = (int)+2;");
8599   verifyFormat("my_int a = (my_int)2.0f;");
8600   verifyFormat("my_int a = (my_int)sizeof(int);");
8601   verifyFormat("return (my_int)aaa;");
8602   verifyFormat("#define x ((int)-1)");
8603   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8604   verifyFormat("#define p(q) ((int *)&q)");
8605   verifyFormat("fn(a)(b) + 1;");
8606 
8607   verifyFormat("void f() { my_int a = (my_int)*b; }");
8608   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8609   verifyFormat("my_int a = (my_int)~0;");
8610   verifyFormat("my_int a = (my_int)++a;");
8611   verifyFormat("my_int a = (my_int)-2;");
8612   verifyFormat("my_int a = (my_int)1;");
8613   verifyFormat("my_int a = (my_int *)1;");
8614   verifyFormat("my_int a = (const my_int)-1;");
8615   verifyFormat("my_int a = (const my_int *)-1;");
8616   verifyFormat("my_int a = (my_int)(my_int)-1;");
8617   verifyFormat("my_int a = (ns::my_int)-2;");
8618   verifyFormat("case (my_int)ONE:");
8619   verifyFormat("auto x = (X)this;");
8620   // Casts in Obj-C style calls used to not be recognized as such.
8621   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8622 
8623   // FIXME: single value wrapped with paren will be treated as cast.
8624   verifyFormat("void f(int i = (kValue)*kMask) {}");
8625 
8626   verifyFormat("{ (void)F; }");
8627 
8628   // Don't break after a cast's
8629   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8630                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8631                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8632 
8633   // These are not casts.
8634   verifyFormat("void f(int *) {}");
8635   verifyFormat("f(foo)->b;");
8636   verifyFormat("f(foo).b;");
8637   verifyFormat("f(foo)(b);");
8638   verifyFormat("f(foo)[b];");
8639   verifyFormat("[](foo) { return 4; }(bar);");
8640   verifyFormat("(*funptr)(foo)[4];");
8641   verifyFormat("funptrs[4](foo)[4];");
8642   verifyFormat("void f(int *);");
8643   verifyFormat("void f(int *) = 0;");
8644   verifyFormat("void f(SmallVector<int>) {}");
8645   verifyFormat("void f(SmallVector<int>);");
8646   verifyFormat("void f(SmallVector<int>) = 0;");
8647   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8648   verifyFormat("int a = sizeof(int) * b;");
8649   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8650   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8651   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8652   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8653 
8654   // These are not casts, but at some point were confused with casts.
8655   verifyFormat("virtual void foo(int *) override;");
8656   verifyFormat("virtual void foo(char &) const;");
8657   verifyFormat("virtual void foo(int *a, char *) const;");
8658   verifyFormat("int a = sizeof(int *) + b;");
8659   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8660   verifyFormat("bool b = f(g<int>) && c;");
8661   verifyFormat("typedef void (*f)(int i) func;");
8662   verifyFormat("void operator++(int) noexcept;");
8663   verifyFormat("void operator++(int &) noexcept;");
8664   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8665                "&) noexcept;");
8666   verifyFormat(
8667       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8668   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8669   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8670   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8671   verifyFormat("void operator delete(foo &) noexcept;");
8672   verifyFormat("void operator delete(foo) noexcept;");
8673   verifyFormat("void operator delete(int) noexcept;");
8674   verifyFormat("void operator delete(int &) noexcept;");
8675   verifyFormat("void operator delete(int &) volatile noexcept;");
8676   verifyFormat("void operator delete(int &) const");
8677   verifyFormat("void operator delete(int &) = default");
8678   verifyFormat("void operator delete(int &) = delete");
8679   verifyFormat("void operator delete(int &) [[noreturn]]");
8680   verifyFormat("void operator delete(int &) throw();");
8681   verifyFormat("void operator delete(int &) throw(int);");
8682   verifyFormat("auto operator delete(int &) -> int;");
8683   verifyFormat("auto operator delete(int &) override");
8684   verifyFormat("auto operator delete(int &) final");
8685 
8686   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8687                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8688   // FIXME: The indentation here is not ideal.
8689   verifyFormat(
8690       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8691       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8692       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8693 }
8694 
8695 TEST_F(FormatTest, FormatsFunctionTypes) {
8696   verifyFormat("A<bool()> a;");
8697   verifyFormat("A<SomeType()> a;");
8698   verifyFormat("A<void (*)(int, std::string)> a;");
8699   verifyFormat("A<void *(int)>;");
8700   verifyFormat("void *(*a)(int *, SomeType *);");
8701   verifyFormat("int (*func)(void *);");
8702   verifyFormat("void f() { int (*func)(void *); }");
8703   verifyFormat("template <class CallbackClass>\n"
8704                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8705 
8706   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8707   verifyGoogleFormat("void* (*a)(int);");
8708   verifyGoogleFormat(
8709       "template <class CallbackClass>\n"
8710       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8711 
8712   // Other constructs can look somewhat like function types:
8713   verifyFormat("A<sizeof(*x)> a;");
8714   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8715   verifyFormat("some_var = function(*some_pointer_var)[0];");
8716   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8717   verifyFormat("int x = f(&h)();");
8718   verifyFormat("returnsFunction(&param1, &param2)(param);");
8719   verifyFormat("std::function<\n"
8720                "    LooooooooooongTemplatedType<\n"
8721                "        SomeType>*(\n"
8722                "        LooooooooooooooooongType type)>\n"
8723                "    function;",
8724                getGoogleStyleWithColumns(40));
8725 }
8726 
8727 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8728   verifyFormat("A (*foo_)[6];");
8729   verifyFormat("vector<int> (*foo_)[6];");
8730 }
8731 
8732 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8733   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8734                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8735   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8736                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8737   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8738                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8739 
8740   // Different ways of ()-initializiation.
8741   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8742                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8743   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8744                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8745   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8746                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8747   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8748                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8749 
8750   // Lambdas should not confuse the variable declaration heuristic.
8751   verifyFormat("LooooooooooooooooongType\n"
8752                "    variable(nullptr, [](A *a) {});",
8753                getLLVMStyleWithColumns(40));
8754 }
8755 
8756 TEST_F(FormatTest, BreaksLongDeclarations) {
8757   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8758                "    AnotherNameForTheLongType;");
8759   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8760                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8761   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8762                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8763   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8764                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8765   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8766                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8767   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8768                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8769   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8770                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8771   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8772                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8773   verifyFormat("typeof(LoooooooooooooooooooooooooooooooooooooooooongName)\n"
8774                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8775   verifyFormat("_Atomic(LooooooooooooooooooooooooooooooooooooooooongName)\n"
8776                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8777   verifyFormat("__underlying_type(LooooooooooooooooooooooooooooooongName)\n"
8778                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8779   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8780                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8781   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8782                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8783   FormatStyle Indented = getLLVMStyle();
8784   Indented.IndentWrappedFunctionNames = true;
8785   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8786                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8787                Indented);
8788   verifyFormat(
8789       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8790       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8791       Indented);
8792   verifyFormat(
8793       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8794       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8795       Indented);
8796   verifyFormat(
8797       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8798       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8799       Indented);
8800 
8801   // FIXME: Without the comment, this breaks after "(".
8802   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8803                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8804                getGoogleStyle());
8805 
8806   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8807                "                  int LoooooooooooooooooooongParam2) {}");
8808   verifyFormat(
8809       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8810       "                                   SourceLocation L, IdentifierIn *II,\n"
8811       "                                   Type *T) {}");
8812   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8813                "ReallyReaaallyLongFunctionName(\n"
8814                "    const std::string &SomeParameter,\n"
8815                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8816                "        &ReallyReallyLongParameterName,\n"
8817                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8818                "        &AnotherLongParameterName) {}");
8819   verifyFormat("template <typename A>\n"
8820                "SomeLoooooooooooooooooooooongType<\n"
8821                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8822                "Function() {}");
8823 
8824   verifyGoogleFormat(
8825       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8826       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8827   verifyGoogleFormat(
8828       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8829       "                                   SourceLocation L) {}");
8830   verifyGoogleFormat(
8831       "some_namespace::LongReturnType\n"
8832       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8833       "    int first_long_parameter, int second_parameter) {}");
8834 
8835   verifyGoogleFormat("template <typename T>\n"
8836                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8837                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8838   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8839                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8840 
8841   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8842                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8843                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8844   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8845                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8846                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8847   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8848                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8849                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8850                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8851 
8852   verifyFormat("template <typename T> // Templates on own line.\n"
8853                "static int            // Some comment.\n"
8854                "MyFunction(int a);",
8855                getLLVMStyle());
8856 }
8857 
8858 TEST_F(FormatTest, FormatsArrays) {
8859   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8860                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8861   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8862                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8863   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8864                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8865   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8866                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8867   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8868                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8869   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8870                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8871                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8872   verifyFormat(
8873       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8874       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8875       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8876   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8877                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8878 
8879   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8880                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8881   verifyFormat(
8882       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8883       "                                  .aaaaaaa[0]\n"
8884       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8885   verifyFormat("a[::b::c];");
8886 
8887   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8888 
8889   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8890   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8891 }
8892 
8893 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8894   verifyFormat("(a)->b();");
8895   verifyFormat("--a;");
8896 }
8897 
8898 TEST_F(FormatTest, HandlesIncludeDirectives) {
8899   verifyFormat("#include <string>\n"
8900                "#include <a/b/c.h>\n"
8901                "#include \"a/b/string\"\n"
8902                "#include \"string.h\"\n"
8903                "#include \"string.h\"\n"
8904                "#include <a-a>\n"
8905                "#include < path with space >\n"
8906                "#include_next <test.h>"
8907                "#include \"abc.h\" // this is included for ABC\n"
8908                "#include \"some long include\" // with a comment\n"
8909                "#include \"some very long include path\"\n"
8910                "#include <some/very/long/include/path>\n",
8911                getLLVMStyleWithColumns(35));
8912   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8913   EXPECT_EQ("#include <a>", format("#include<a>"));
8914 
8915   verifyFormat("#import <string>");
8916   verifyFormat("#import <a/b/c.h>");
8917   verifyFormat("#import \"a/b/string\"");
8918   verifyFormat("#import \"string.h\"");
8919   verifyFormat("#import \"string.h\"");
8920   verifyFormat("#if __has_include(<strstream>)\n"
8921                "#include <strstream>\n"
8922                "#endif");
8923 
8924   verifyFormat("#define MY_IMPORT <a/b>");
8925 
8926   verifyFormat("#if __has_include(<a/b>)");
8927   verifyFormat("#if __has_include_next(<a/b>)");
8928   verifyFormat("#define F __has_include(<a/b>)");
8929   verifyFormat("#define F __has_include_next(<a/b>)");
8930 
8931   // Protocol buffer definition or missing "#".
8932   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8933                getLLVMStyleWithColumns(30));
8934 
8935   FormatStyle Style = getLLVMStyle();
8936   Style.AlwaysBreakBeforeMultilineStrings = true;
8937   Style.ColumnLimit = 0;
8938   verifyFormat("#import \"abc.h\"", Style);
8939 
8940   // But 'import' might also be a regular C++ namespace.
8941   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8942                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8943 }
8944 
8945 //===----------------------------------------------------------------------===//
8946 // Error recovery tests.
8947 //===----------------------------------------------------------------------===//
8948 
8949 TEST_F(FormatTest, IncompleteParameterLists) {
8950   FormatStyle NoBinPacking = getLLVMStyle();
8951   NoBinPacking.BinPackParameters = false;
8952   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8953                "                        double *min_x,\n"
8954                "                        double *max_x,\n"
8955                "                        double *min_y,\n"
8956                "                        double *max_y,\n"
8957                "                        double *min_z,\n"
8958                "                        double *max_z, ) {}",
8959                NoBinPacking);
8960 }
8961 
8962 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8963   verifyFormat("void f() { return; }\n42");
8964   verifyFormat("void f() {\n"
8965                "  if (0)\n"
8966                "    return;\n"
8967                "}\n"
8968                "42");
8969   verifyFormat("void f() { return }\n42");
8970   verifyFormat("void f() {\n"
8971                "  if (0)\n"
8972                "    return\n"
8973                "}\n"
8974                "42");
8975 }
8976 
8977 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
8978   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
8979   EXPECT_EQ("void f() {\n"
8980             "  if (a)\n"
8981             "    return\n"
8982             "}",
8983             format("void  f  (  )  {  if  ( a )  return  }"));
8984   EXPECT_EQ("namespace N {\n"
8985             "void f()\n"
8986             "}",
8987             format("namespace  N  {  void f()  }"));
8988   EXPECT_EQ("namespace N {\n"
8989             "void f() {}\n"
8990             "void g()\n"
8991             "} // namespace N",
8992             format("namespace N  { void f( ) { } void g( ) }"));
8993 }
8994 
8995 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
8996   verifyFormat("int aaaaaaaa =\n"
8997                "    // Overlylongcomment\n"
8998                "    b;",
8999                getLLVMStyleWithColumns(20));
9000   verifyFormat("function(\n"
9001                "    ShortArgument,\n"
9002                "    LoooooooooooongArgument);\n",
9003                getLLVMStyleWithColumns(20));
9004 }
9005 
9006 TEST_F(FormatTest, IncorrectAccessSpecifier) {
9007   verifyFormat("public:");
9008   verifyFormat("class A {\n"
9009                "public\n"
9010                "  void f() {}\n"
9011                "};");
9012   verifyFormat("public\n"
9013                "int qwerty;");
9014   verifyFormat("public\n"
9015                "B {}");
9016   verifyFormat("public\n"
9017                "{}");
9018   verifyFormat("public\n"
9019                "B { int x; }");
9020 }
9021 
9022 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
9023   verifyFormat("{");
9024   verifyFormat("#})");
9025   verifyNoCrash("(/**/[:!] ?[).");
9026 }
9027 
9028 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
9029   // Found by oss-fuzz:
9030   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
9031   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
9032   Style.ColumnLimit = 60;
9033   verifyNoCrash(
9034       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
9035       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
9036       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
9037       Style);
9038 }
9039 
9040 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
9041   verifyFormat("do {\n}");
9042   verifyFormat("do {\n}\n"
9043                "f();");
9044   verifyFormat("do {\n}\n"
9045                "wheeee(fun);");
9046   verifyFormat("do {\n"
9047                "  f();\n"
9048                "}");
9049 }
9050 
9051 TEST_F(FormatTest, IncorrectCodeMissingParens) {
9052   verifyFormat("if {\n  foo;\n  foo();\n}");
9053   verifyFormat("switch {\n  foo;\n  foo();\n}");
9054   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
9055   verifyFormat("while {\n  foo;\n  foo();\n}");
9056   verifyFormat("do {\n  foo;\n  foo();\n} while;");
9057 }
9058 
9059 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
9060   verifyIncompleteFormat("namespace {\n"
9061                          "class Foo { Foo (\n"
9062                          "};\n"
9063                          "} // namespace");
9064 }
9065 
9066 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
9067   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
9068   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
9069   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
9070   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
9071 
9072   EXPECT_EQ("{\n"
9073             "  {\n"
9074             "    breakme(\n"
9075             "        qwe);\n"
9076             "  }\n",
9077             format("{\n"
9078                    "    {\n"
9079                    " breakme(qwe);\n"
9080                    "}\n",
9081                    getLLVMStyleWithColumns(10)));
9082 }
9083 
9084 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
9085   verifyFormat("int x = {\n"
9086                "    avariable,\n"
9087                "    b(alongervariable)};",
9088                getLLVMStyleWithColumns(25));
9089 }
9090 
9091 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
9092   verifyFormat("return (a)(b){1, 2, 3};");
9093 }
9094 
9095 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
9096   verifyFormat("vector<int> x{1, 2, 3, 4};");
9097   verifyFormat("vector<int> x{\n"
9098                "    1,\n"
9099                "    2,\n"
9100                "    3,\n"
9101                "    4,\n"
9102                "};");
9103   verifyFormat("vector<T> x{{}, {}, {}, {}};");
9104   verifyFormat("f({1, 2});");
9105   verifyFormat("auto v = Foo{-1};");
9106   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
9107   verifyFormat("Class::Class : member{1, 2, 3} {}");
9108   verifyFormat("new vector<int>{1, 2, 3};");
9109   verifyFormat("new int[3]{1, 2, 3};");
9110   verifyFormat("new int{1};");
9111   verifyFormat("return {arg1, arg2};");
9112   verifyFormat("return {arg1, SomeType{parameter}};");
9113   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
9114   verifyFormat("new T{arg1, arg2};");
9115   verifyFormat("f(MyMap[{composite, key}]);");
9116   verifyFormat("class Class {\n"
9117                "  T member = {arg1, arg2};\n"
9118                "};");
9119   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
9120   verifyFormat("const struct A a = {.a = 1, .b = 2};");
9121   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
9122   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
9123   verifyFormat("int a = std::is_integral<int>{} + 0;");
9124 
9125   verifyFormat("int foo(int i) { return fo1{}(i); }");
9126   verifyFormat("int foo(int i) { return fo1{}(i); }");
9127   verifyFormat("auto i = decltype(x){};");
9128   verifyFormat("auto i = typeof(x){};");
9129   verifyFormat("auto i = _Atomic(x){};");
9130   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
9131   verifyFormat("Node n{1, Node{1000}, //\n"
9132                "       2};");
9133   verifyFormat("Aaaa aaaaaaa{\n"
9134                "    {\n"
9135                "        aaaa,\n"
9136                "    },\n"
9137                "};");
9138   verifyFormat("class C : public D {\n"
9139                "  SomeClass SC{2};\n"
9140                "};");
9141   verifyFormat("class C : public A {\n"
9142                "  class D : public B {\n"
9143                "    void f() { int i{2}; }\n"
9144                "  };\n"
9145                "};");
9146   verifyFormat("#define A {a, a},");
9147 
9148   // Avoid breaking between equal sign and opening brace
9149   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
9150   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
9151   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
9152                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
9153                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
9154                "     {\"ccccccccccccccccccccc\", 2}};",
9155                AvoidBreakingFirstArgument);
9156 
9157   // Binpacking only if there is no trailing comma
9158   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
9159                "                      cccccccccc, dddddddddd};",
9160                getLLVMStyleWithColumns(50));
9161   verifyFormat("const Aaaaaa aaaaa = {\n"
9162                "    aaaaaaaaaaa,\n"
9163                "    bbbbbbbbbbb,\n"
9164                "    ccccccccccc,\n"
9165                "    ddddddddddd,\n"
9166                "};",
9167                getLLVMStyleWithColumns(50));
9168 
9169   // Cases where distinguising braced lists and blocks is hard.
9170   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
9171   verifyFormat("void f() {\n"
9172                "  return; // comment\n"
9173                "}\n"
9174                "SomeType t;");
9175   verifyFormat("void f() {\n"
9176                "  if (a) {\n"
9177                "    f();\n"
9178                "  }\n"
9179                "}\n"
9180                "SomeType t;");
9181 
9182   // In combination with BinPackArguments = false.
9183   FormatStyle NoBinPacking = getLLVMStyle();
9184   NoBinPacking.BinPackArguments = false;
9185   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
9186                "                      bbbbb,\n"
9187                "                      ccccc,\n"
9188                "                      ddddd,\n"
9189                "                      eeeee,\n"
9190                "                      ffffff,\n"
9191                "                      ggggg,\n"
9192                "                      hhhhhh,\n"
9193                "                      iiiiii,\n"
9194                "                      jjjjjj,\n"
9195                "                      kkkkkk};",
9196                NoBinPacking);
9197   verifyFormat("const Aaaaaa aaaaa = {\n"
9198                "    aaaaa,\n"
9199                "    bbbbb,\n"
9200                "    ccccc,\n"
9201                "    ddddd,\n"
9202                "    eeeee,\n"
9203                "    ffffff,\n"
9204                "    ggggg,\n"
9205                "    hhhhhh,\n"
9206                "    iiiiii,\n"
9207                "    jjjjjj,\n"
9208                "    kkkkkk,\n"
9209                "};",
9210                NoBinPacking);
9211   verifyFormat(
9212       "const Aaaaaa aaaaa = {\n"
9213       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
9214       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
9215       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
9216       "};",
9217       NoBinPacking);
9218 
9219   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
9220   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
9221             "    CDDDP83848_BMCR_REGISTER,\n"
9222             "    CDDDP83848_BMSR_REGISTER,\n"
9223             "    CDDDP83848_RBR_REGISTER};",
9224             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
9225                    "                                CDDDP83848_BMSR_REGISTER,\n"
9226                    "                                CDDDP83848_RBR_REGISTER};",
9227                    NoBinPacking));
9228 
9229   // FIXME: The alignment of these trailing comments might be bad. Then again,
9230   // this might be utterly useless in real code.
9231   verifyFormat("Constructor::Constructor()\n"
9232                "    : some_value{         //\n"
9233                "                 aaaaaaa, //\n"
9234                "                 bbbbbbb} {}");
9235 
9236   // In braced lists, the first comment is always assumed to belong to the
9237   // first element. Thus, it can be moved to the next or previous line as
9238   // appropriate.
9239   EXPECT_EQ("function({// First element:\n"
9240             "          1,\n"
9241             "          // Second element:\n"
9242             "          2});",
9243             format("function({\n"
9244                    "    // First element:\n"
9245                    "    1,\n"
9246                    "    // Second element:\n"
9247                    "    2});"));
9248   EXPECT_EQ("std::vector<int> MyNumbers{\n"
9249             "    // First element:\n"
9250             "    1,\n"
9251             "    // Second element:\n"
9252             "    2};",
9253             format("std::vector<int> MyNumbers{// First element:\n"
9254                    "                           1,\n"
9255                    "                           // Second element:\n"
9256                    "                           2};",
9257                    getLLVMStyleWithColumns(30)));
9258   // A trailing comma should still lead to an enforced line break and no
9259   // binpacking.
9260   EXPECT_EQ("vector<int> SomeVector = {\n"
9261             "    // aaa\n"
9262             "    1,\n"
9263             "    2,\n"
9264             "};",
9265             format("vector<int> SomeVector = { // aaa\n"
9266                    "    1, 2, };"));
9267 
9268   // C++11 brace initializer list l-braces should not be treated any differently
9269   // when breaking before lambda bodies is enabled
9270   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
9271   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
9272   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
9273   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
9274   verifyFormat(
9275       "std::runtime_error{\n"
9276       "    \"Long string which will force a break onto the next line...\"};",
9277       BreakBeforeLambdaBody);
9278 
9279   FormatStyle ExtraSpaces = getLLVMStyle();
9280   ExtraSpaces.Cpp11BracedListStyle = false;
9281   ExtraSpaces.ColumnLimit = 75;
9282   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
9283   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
9284   verifyFormat("f({ 1, 2 });", ExtraSpaces);
9285   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
9286   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
9287   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
9288   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
9289   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
9290   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
9291   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
9292   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
9293   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
9294   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
9295   verifyFormat("class Class {\n"
9296                "  T member = { arg1, arg2 };\n"
9297                "};",
9298                ExtraSpaces);
9299   verifyFormat(
9300       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9301       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
9302       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
9303       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
9304       ExtraSpaces);
9305   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
9306   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
9307                ExtraSpaces);
9308   verifyFormat(
9309       "someFunction(OtherParam,\n"
9310       "             BracedList{ // comment 1 (Forcing interesting break)\n"
9311       "                         param1, param2,\n"
9312       "                         // comment 2\n"
9313       "                         param3, param4 });",
9314       ExtraSpaces);
9315   verifyFormat(
9316       "std::this_thread::sleep_for(\n"
9317       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
9318       ExtraSpaces);
9319   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
9320                "    aaaaaaa,\n"
9321                "    aaaaaaaaaa,\n"
9322                "    aaaaa,\n"
9323                "    aaaaaaaaaaaaaaa,\n"
9324                "    aaa,\n"
9325                "    aaaaaaaaaa,\n"
9326                "    a,\n"
9327                "    aaaaaaaaaaaaaaaaaaaaa,\n"
9328                "    aaaaaaaaaaaa,\n"
9329                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
9330                "    aaaaaaa,\n"
9331                "    a};");
9332   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
9333   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
9334   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
9335 
9336   // Avoid breaking between initializer/equal sign and opening brace
9337   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
9338   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
9339                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9340                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9341                "  { \"ccccccccccccccccccccc\", 2 }\n"
9342                "};",
9343                ExtraSpaces);
9344   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
9345                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9346                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9347                "  { \"ccccccccccccccccccccc\", 2 }\n"
9348                "};",
9349                ExtraSpaces);
9350 
9351   FormatStyle SpaceBeforeBrace = getLLVMStyle();
9352   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9353   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9354   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9355 
9356   FormatStyle SpaceBetweenBraces = getLLVMStyle();
9357   SpaceBetweenBraces.SpacesInAngles = true;
9358   SpaceBetweenBraces.SpacesInParentheses = true;
9359   SpaceBetweenBraces.SpacesInSquareBrackets = true;
9360   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9361   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9362   verifyFormat("vector< int > x{ // comment 1\n"
9363                "                 1, 2, 3, 4 };",
9364                SpaceBetweenBraces);
9365   SpaceBetweenBraces.ColumnLimit = 20;
9366   EXPECT_EQ("vector< int > x{\n"
9367             "    1, 2, 3, 4 };",
9368             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9369   SpaceBetweenBraces.ColumnLimit = 24;
9370   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9371             "                 3, 4 };",
9372             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9373   EXPECT_EQ("vector< int > x{\n"
9374             "    1,\n"
9375             "    2,\n"
9376             "    3,\n"
9377             "    4,\n"
9378             "};",
9379             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9380   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9381   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9382   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9383 }
9384 
9385 TEST_F(FormatTest, FormatSpacesInAngles) {
9386   FormatStyle SpaceInAngles = getLLVMStyle();
9387   SpaceInAngles.SpacesInAngles = true;
9388   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9389   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9390   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9391 
9392   SpaceInAngles.SpacesInAngles = false;
9393   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9394   verifyFormat("vector<int> x5;", SpaceInAngles);
9395   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9396   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9397 }
9398 
9399 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9400   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9401                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9402                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9403                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9404                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9405                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9406   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9407                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9408                "                 1, 22, 333, 4444, 55555, //\n"
9409                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9410                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9411   verifyFormat(
9412       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9413       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9414       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9415       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9416       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9417       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9418       "                 7777777};");
9419   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9420                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9421                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9422   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9423                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9424                "    // Separating comment.\n"
9425                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9426   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9427                "    // Leading comment\n"
9428                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9429                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9430   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9431                "                 1, 1, 1, 1};",
9432                getLLVMStyleWithColumns(39));
9433   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9434                "                 1, 1, 1, 1};",
9435                getLLVMStyleWithColumns(38));
9436   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9437                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9438                getLLVMStyleWithColumns(43));
9439   verifyFormat(
9440       "static unsigned SomeValues[10][3] = {\n"
9441       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9442       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9443   verifyFormat("static auto fields = new vector<string>{\n"
9444                "    \"aaaaaaaaaaaaa\",\n"
9445                "    \"aaaaaaaaaaaaa\",\n"
9446                "    \"aaaaaaaaaaaa\",\n"
9447                "    \"aaaaaaaaaaaaaa\",\n"
9448                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9449                "    \"aaaaaaaaaaaa\",\n"
9450                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9451                "};");
9452   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9453   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9454                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9455                "                 3, cccccccccccccccccccccc};",
9456                getLLVMStyleWithColumns(60));
9457 
9458   // Trailing commas.
9459   verifyFormat("vector<int> x = {\n"
9460                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9461                "};",
9462                getLLVMStyleWithColumns(39));
9463   verifyFormat("vector<int> x = {\n"
9464                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9465                "};",
9466                getLLVMStyleWithColumns(39));
9467   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9468                "                 1, 1, 1, 1,\n"
9469                "                 /**/ /**/};",
9470                getLLVMStyleWithColumns(39));
9471 
9472   // Trailing comment in the first line.
9473   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9474                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9475                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9476                "    11111111,   22222222,   333333333,   44444444};");
9477   // Trailing comment in the last line.
9478   verifyFormat("int aaaaa[] = {\n"
9479                "    1, 2, 3, // comment\n"
9480                "    4, 5, 6  // comment\n"
9481                "};");
9482 
9483   // With nested lists, we should either format one item per line or all nested
9484   // lists one on line.
9485   // FIXME: For some nested lists, we can do better.
9486   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9487                "        {aaaaaaaaaaaaaaaaaaa},\n"
9488                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9489                "        {aaaaaaaaaaaaaaaaa}};",
9490                getLLVMStyleWithColumns(60));
9491   verifyFormat(
9492       "SomeStruct my_struct_array = {\n"
9493       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9494       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9495       "    {aaa, aaa},\n"
9496       "    {aaa, aaa},\n"
9497       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9498       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9499       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9500 
9501   // No column layout should be used here.
9502   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9503                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9504 
9505   verifyNoCrash("a<,");
9506 
9507   // No braced initializer here.
9508   verifyFormat("void f() {\n"
9509                "  struct Dummy {};\n"
9510                "  f(v);\n"
9511                "}");
9512 
9513   // Long lists should be formatted in columns even if they are nested.
9514   verifyFormat(
9515       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9516       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9517       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9518       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9519       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9520       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9521 
9522   // Allow "single-column" layout even if that violates the column limit. There
9523   // isn't going to be a better way.
9524   verifyFormat("std::vector<int> a = {\n"
9525                "    aaaaaaaa,\n"
9526                "    aaaaaaaa,\n"
9527                "    aaaaaaaa,\n"
9528                "    aaaaaaaa,\n"
9529                "    aaaaaaaaaa,\n"
9530                "    aaaaaaaa,\n"
9531                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9532                getLLVMStyleWithColumns(30));
9533   verifyFormat("vector<int> aaaa = {\n"
9534                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9535                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9536                "    aaaaaa.aaaaaaa,\n"
9537                "    aaaaaa.aaaaaaa,\n"
9538                "    aaaaaa.aaaaaaa,\n"
9539                "    aaaaaa.aaaaaaa,\n"
9540                "};");
9541 
9542   // Don't create hanging lists.
9543   verifyFormat("someFunction(Param, {List1, List2,\n"
9544                "                     List3});",
9545                getLLVMStyleWithColumns(35));
9546   verifyFormat("someFunction(Param, Param,\n"
9547                "             {List1, List2,\n"
9548                "              List3});",
9549                getLLVMStyleWithColumns(35));
9550   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9551                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9552 }
9553 
9554 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9555   FormatStyle DoNotMerge = getLLVMStyle();
9556   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9557 
9558   verifyFormat("void f() { return 42; }");
9559   verifyFormat("void f() {\n"
9560                "  return 42;\n"
9561                "}",
9562                DoNotMerge);
9563   verifyFormat("void f() {\n"
9564                "  // Comment\n"
9565                "}");
9566   verifyFormat("{\n"
9567                "#error {\n"
9568                "  int a;\n"
9569                "}");
9570   verifyFormat("{\n"
9571                "  int a;\n"
9572                "#error {\n"
9573                "}");
9574   verifyFormat("void f() {} // comment");
9575   verifyFormat("void f() { int a; } // comment");
9576   verifyFormat("void f() {\n"
9577                "} // comment",
9578                DoNotMerge);
9579   verifyFormat("void f() {\n"
9580                "  int a;\n"
9581                "} // comment",
9582                DoNotMerge);
9583   verifyFormat("void f() {\n"
9584                "} // comment",
9585                getLLVMStyleWithColumns(15));
9586 
9587   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9588   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9589 
9590   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9591   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9592   verifyFormat("class C {\n"
9593                "  C()\n"
9594                "      : iiiiiiii(nullptr),\n"
9595                "        kkkkkkk(nullptr),\n"
9596                "        mmmmmmm(nullptr),\n"
9597                "        nnnnnnn(nullptr) {}\n"
9598                "};",
9599                getGoogleStyle());
9600 
9601   FormatStyle NoColumnLimit = getLLVMStyle();
9602   NoColumnLimit.ColumnLimit = 0;
9603   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9604   EXPECT_EQ("class C {\n"
9605             "  A() : b(0) {}\n"
9606             "};",
9607             format("class C{A():b(0){}};", NoColumnLimit));
9608   EXPECT_EQ("A()\n"
9609             "    : b(0) {\n"
9610             "}",
9611             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9612 
9613   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9614   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9615       FormatStyle::SFS_None;
9616   EXPECT_EQ("A()\n"
9617             "    : b(0) {\n"
9618             "}",
9619             format("A():b(0){}", DoNotMergeNoColumnLimit));
9620   EXPECT_EQ("A()\n"
9621             "    : b(0) {\n"
9622             "}",
9623             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9624 
9625   verifyFormat("#define A          \\\n"
9626                "  void f() {       \\\n"
9627                "    int i;         \\\n"
9628                "  }",
9629                getLLVMStyleWithColumns(20));
9630   verifyFormat("#define A           \\\n"
9631                "  void f() { int i; }",
9632                getLLVMStyleWithColumns(21));
9633   verifyFormat("#define A            \\\n"
9634                "  void f() {         \\\n"
9635                "    int i;           \\\n"
9636                "  }                  \\\n"
9637                "  int j;",
9638                getLLVMStyleWithColumns(22));
9639   verifyFormat("#define A             \\\n"
9640                "  void f() { int i; } \\\n"
9641                "  int j;",
9642                getLLVMStyleWithColumns(23));
9643 }
9644 
9645 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9646   FormatStyle MergeEmptyOnly = getLLVMStyle();
9647   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9648   verifyFormat("class C {\n"
9649                "  int f() {}\n"
9650                "};",
9651                MergeEmptyOnly);
9652   verifyFormat("class C {\n"
9653                "  int f() {\n"
9654                "    return 42;\n"
9655                "  }\n"
9656                "};",
9657                MergeEmptyOnly);
9658   verifyFormat("int f() {}", MergeEmptyOnly);
9659   verifyFormat("int f() {\n"
9660                "  return 42;\n"
9661                "}",
9662                MergeEmptyOnly);
9663 
9664   // Also verify behavior when BraceWrapping.AfterFunction = true
9665   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9666   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9667   verifyFormat("int f() {}", MergeEmptyOnly);
9668   verifyFormat("class C {\n"
9669                "  int f() {}\n"
9670                "};",
9671                MergeEmptyOnly);
9672 }
9673 
9674 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9675   FormatStyle MergeInlineOnly = getLLVMStyle();
9676   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9677   verifyFormat("class C {\n"
9678                "  int f() { return 42; }\n"
9679                "};",
9680                MergeInlineOnly);
9681   verifyFormat("int f() {\n"
9682                "  return 42;\n"
9683                "}",
9684                MergeInlineOnly);
9685 
9686   // SFS_Inline implies SFS_Empty
9687   verifyFormat("class C {\n"
9688                "  int f() {}\n"
9689                "};",
9690                MergeInlineOnly);
9691   verifyFormat("int f() {}", MergeInlineOnly);
9692 
9693   // Also verify behavior when BraceWrapping.AfterFunction = true
9694   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9695   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9696   verifyFormat("class C {\n"
9697                "  int f() { return 42; }\n"
9698                "};",
9699                MergeInlineOnly);
9700   verifyFormat("int f()\n"
9701                "{\n"
9702                "  return 42;\n"
9703                "}",
9704                MergeInlineOnly);
9705 
9706   // SFS_Inline implies SFS_Empty
9707   verifyFormat("int f() {}", MergeInlineOnly);
9708   verifyFormat("class C {\n"
9709                "  int f() {}\n"
9710                "};",
9711                MergeInlineOnly);
9712 }
9713 
9714 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9715   FormatStyle MergeInlineOnly = getLLVMStyle();
9716   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9717       FormatStyle::SFS_InlineOnly;
9718   verifyFormat("class C {\n"
9719                "  int f() { return 42; }\n"
9720                "};",
9721                MergeInlineOnly);
9722   verifyFormat("int f() {\n"
9723                "  return 42;\n"
9724                "}",
9725                MergeInlineOnly);
9726 
9727   // SFS_InlineOnly does not imply SFS_Empty
9728   verifyFormat("class C {\n"
9729                "  int f() {}\n"
9730                "};",
9731                MergeInlineOnly);
9732   verifyFormat("int f() {\n"
9733                "}",
9734                MergeInlineOnly);
9735 
9736   // Also verify behavior when BraceWrapping.AfterFunction = true
9737   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9738   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9739   verifyFormat("class C {\n"
9740                "  int f() { return 42; }\n"
9741                "};",
9742                MergeInlineOnly);
9743   verifyFormat("int f()\n"
9744                "{\n"
9745                "  return 42;\n"
9746                "}",
9747                MergeInlineOnly);
9748 
9749   // SFS_InlineOnly does not imply SFS_Empty
9750   verifyFormat("int f()\n"
9751                "{\n"
9752                "}",
9753                MergeInlineOnly);
9754   verifyFormat("class C {\n"
9755                "  int f() {}\n"
9756                "};",
9757                MergeInlineOnly);
9758 }
9759 
9760 TEST_F(FormatTest, SplitEmptyFunction) {
9761   FormatStyle Style = getLLVMStyle();
9762   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9763   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9764   Style.BraceWrapping.AfterFunction = true;
9765   Style.BraceWrapping.SplitEmptyFunction = false;
9766   Style.ColumnLimit = 40;
9767 
9768   verifyFormat("int f()\n"
9769                "{}",
9770                Style);
9771   verifyFormat("int f()\n"
9772                "{\n"
9773                "  return 42;\n"
9774                "}",
9775                Style);
9776   verifyFormat("int f()\n"
9777                "{\n"
9778                "  // some comment\n"
9779                "}",
9780                Style);
9781 
9782   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9783   verifyFormat("int f() {}", Style);
9784   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9785                "{}",
9786                Style);
9787   verifyFormat("int f()\n"
9788                "{\n"
9789                "  return 0;\n"
9790                "}",
9791                Style);
9792 
9793   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9794   verifyFormat("class Foo {\n"
9795                "  int f() {}\n"
9796                "};\n",
9797                Style);
9798   verifyFormat("class Foo {\n"
9799                "  int f() { return 0; }\n"
9800                "};\n",
9801                Style);
9802   verifyFormat("class Foo {\n"
9803                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9804                "  {}\n"
9805                "};\n",
9806                Style);
9807   verifyFormat("class Foo {\n"
9808                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9809                "  {\n"
9810                "    return 0;\n"
9811                "  }\n"
9812                "};\n",
9813                Style);
9814 
9815   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9816   verifyFormat("int f() {}", Style);
9817   verifyFormat("int f() { return 0; }", Style);
9818   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9819                "{}",
9820                Style);
9821   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9822                "{\n"
9823                "  return 0;\n"
9824                "}",
9825                Style);
9826 }
9827 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9828   FormatStyle Style = getLLVMStyle();
9829   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9830   verifyFormat("#ifdef A\n"
9831                "int f() {}\n"
9832                "#else\n"
9833                "int g() {}\n"
9834                "#endif",
9835                Style);
9836 }
9837 
9838 TEST_F(FormatTest, SplitEmptyClass) {
9839   FormatStyle Style = getLLVMStyle();
9840   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9841   Style.BraceWrapping.AfterClass = true;
9842   Style.BraceWrapping.SplitEmptyRecord = false;
9843 
9844   verifyFormat("class Foo\n"
9845                "{};",
9846                Style);
9847   verifyFormat("/* something */ class Foo\n"
9848                "{};",
9849                Style);
9850   verifyFormat("template <typename X> class Foo\n"
9851                "{};",
9852                Style);
9853   verifyFormat("class Foo\n"
9854                "{\n"
9855                "  Foo();\n"
9856                "};",
9857                Style);
9858   verifyFormat("typedef class Foo\n"
9859                "{\n"
9860                "} Foo_t;",
9861                Style);
9862 }
9863 
9864 TEST_F(FormatTest, SplitEmptyStruct) {
9865   FormatStyle Style = getLLVMStyle();
9866   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9867   Style.BraceWrapping.AfterStruct = true;
9868   Style.BraceWrapping.SplitEmptyRecord = false;
9869 
9870   verifyFormat("struct Foo\n"
9871                "{};",
9872                Style);
9873   verifyFormat("/* something */ struct Foo\n"
9874                "{};",
9875                Style);
9876   verifyFormat("template <typename X> struct Foo\n"
9877                "{};",
9878                Style);
9879   verifyFormat("struct Foo\n"
9880                "{\n"
9881                "  Foo();\n"
9882                "};",
9883                Style);
9884   verifyFormat("typedef struct Foo\n"
9885                "{\n"
9886                "} Foo_t;",
9887                Style);
9888   // typedef struct Bar {} Bar_t;
9889 }
9890 
9891 TEST_F(FormatTest, SplitEmptyUnion) {
9892   FormatStyle Style = getLLVMStyle();
9893   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9894   Style.BraceWrapping.AfterUnion = true;
9895   Style.BraceWrapping.SplitEmptyRecord = false;
9896 
9897   verifyFormat("union Foo\n"
9898                "{};",
9899                Style);
9900   verifyFormat("/* something */ union Foo\n"
9901                "{};",
9902                Style);
9903   verifyFormat("union Foo\n"
9904                "{\n"
9905                "  A,\n"
9906                "};",
9907                Style);
9908   verifyFormat("typedef union Foo\n"
9909                "{\n"
9910                "} Foo_t;",
9911                Style);
9912 }
9913 
9914 TEST_F(FormatTest, SplitEmptyNamespace) {
9915   FormatStyle Style = getLLVMStyle();
9916   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9917   Style.BraceWrapping.AfterNamespace = true;
9918   Style.BraceWrapping.SplitEmptyNamespace = false;
9919 
9920   verifyFormat("namespace Foo\n"
9921                "{};",
9922                Style);
9923   verifyFormat("/* something */ namespace Foo\n"
9924                "{};",
9925                Style);
9926   verifyFormat("inline namespace Foo\n"
9927                "{};",
9928                Style);
9929   verifyFormat("/* something */ inline namespace Foo\n"
9930                "{};",
9931                Style);
9932   verifyFormat("export namespace Foo\n"
9933                "{};",
9934                Style);
9935   verifyFormat("namespace Foo\n"
9936                "{\n"
9937                "void Bar();\n"
9938                "};",
9939                Style);
9940 }
9941 
9942 TEST_F(FormatTest, NeverMergeShortRecords) {
9943   FormatStyle Style = getLLVMStyle();
9944 
9945   verifyFormat("class Foo {\n"
9946                "  Foo();\n"
9947                "};",
9948                Style);
9949   verifyFormat("typedef class Foo {\n"
9950                "  Foo();\n"
9951                "} Foo_t;",
9952                Style);
9953   verifyFormat("struct Foo {\n"
9954                "  Foo();\n"
9955                "};",
9956                Style);
9957   verifyFormat("typedef struct Foo {\n"
9958                "  Foo();\n"
9959                "} Foo_t;",
9960                Style);
9961   verifyFormat("union Foo {\n"
9962                "  A,\n"
9963                "};",
9964                Style);
9965   verifyFormat("typedef union Foo {\n"
9966                "  A,\n"
9967                "} Foo_t;",
9968                Style);
9969   verifyFormat("namespace Foo {\n"
9970                "void Bar();\n"
9971                "};",
9972                Style);
9973 
9974   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9975   Style.BraceWrapping.AfterClass = true;
9976   Style.BraceWrapping.AfterStruct = true;
9977   Style.BraceWrapping.AfterUnion = true;
9978   Style.BraceWrapping.AfterNamespace = true;
9979   verifyFormat("class Foo\n"
9980                "{\n"
9981                "  Foo();\n"
9982                "};",
9983                Style);
9984   verifyFormat("typedef class Foo\n"
9985                "{\n"
9986                "  Foo();\n"
9987                "} Foo_t;",
9988                Style);
9989   verifyFormat("struct Foo\n"
9990                "{\n"
9991                "  Foo();\n"
9992                "};",
9993                Style);
9994   verifyFormat("typedef struct Foo\n"
9995                "{\n"
9996                "  Foo();\n"
9997                "} Foo_t;",
9998                Style);
9999   verifyFormat("union Foo\n"
10000                "{\n"
10001                "  A,\n"
10002                "};",
10003                Style);
10004   verifyFormat("typedef union Foo\n"
10005                "{\n"
10006                "  A,\n"
10007                "} Foo_t;",
10008                Style);
10009   verifyFormat("namespace Foo\n"
10010                "{\n"
10011                "void Bar();\n"
10012                "};",
10013                Style);
10014 }
10015 
10016 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
10017   // Elaborate type variable declarations.
10018   verifyFormat("struct foo a = {bar};\nint n;");
10019   verifyFormat("class foo a = {bar};\nint n;");
10020   verifyFormat("union foo a = {bar};\nint n;");
10021 
10022   // Elaborate types inside function definitions.
10023   verifyFormat("struct foo f() {}\nint n;");
10024   verifyFormat("class foo f() {}\nint n;");
10025   verifyFormat("union foo f() {}\nint n;");
10026 
10027   // Templates.
10028   verifyFormat("template <class X> void f() {}\nint n;");
10029   verifyFormat("template <struct X> void f() {}\nint n;");
10030   verifyFormat("template <union X> void f() {}\nint n;");
10031 
10032   // Actual definitions...
10033   verifyFormat("struct {\n} n;");
10034   verifyFormat(
10035       "template <template <class T, class Y>, class Z> class X {\n} n;");
10036   verifyFormat("union Z {\n  int n;\n} x;");
10037   verifyFormat("class MACRO Z {\n} n;");
10038   verifyFormat("class MACRO(X) Z {\n} n;");
10039   verifyFormat("class __attribute__(X) Z {\n} n;");
10040   verifyFormat("class __declspec(X) Z {\n} n;");
10041   verifyFormat("class A##B##C {\n} n;");
10042   verifyFormat("class alignas(16) Z {\n} n;");
10043   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
10044   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
10045 
10046   // Redefinition from nested context:
10047   verifyFormat("class A::B::C {\n} n;");
10048 
10049   // Template definitions.
10050   verifyFormat(
10051       "template <typename F>\n"
10052       "Matcher(const Matcher<F> &Other,\n"
10053       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
10054       "                             !is_same<F, T>::value>::type * = 0)\n"
10055       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
10056 
10057   // FIXME: This is still incorrectly handled at the formatter side.
10058   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
10059   verifyFormat("int i = SomeFunction(a<b, a> b);");
10060 
10061   // FIXME:
10062   // This now gets parsed incorrectly as class definition.
10063   // verifyFormat("class A<int> f() {\n}\nint n;");
10064 
10065   // Elaborate types where incorrectly parsing the structural element would
10066   // break the indent.
10067   verifyFormat("if (true)\n"
10068                "  class X x;\n"
10069                "else\n"
10070                "  f();\n");
10071 
10072   // This is simply incomplete. Formatting is not important, but must not crash.
10073   verifyFormat("class A:");
10074 }
10075 
10076 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
10077   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
10078             format("#error Leave     all         white!!!!! space* alone!\n"));
10079   EXPECT_EQ(
10080       "#warning Leave     all         white!!!!! space* alone!\n",
10081       format("#warning Leave     all         white!!!!! space* alone!\n"));
10082   EXPECT_EQ("#error 1", format("  #  error   1"));
10083   EXPECT_EQ("#warning 1", format("  #  warning 1"));
10084 }
10085 
10086 TEST_F(FormatTest, FormatHashIfExpressions) {
10087   verifyFormat("#if AAAA && BBBB");
10088   verifyFormat("#if (AAAA && BBBB)");
10089   verifyFormat("#elif (AAAA && BBBB)");
10090   // FIXME: Come up with a better indentation for #elif.
10091   verifyFormat(
10092       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
10093       "    defined(BBBBBBBB)\n"
10094       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
10095       "    defined(BBBBBBBB)\n"
10096       "#endif",
10097       getLLVMStyleWithColumns(65));
10098 }
10099 
10100 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
10101   FormatStyle AllowsMergedIf = getGoogleStyle();
10102   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
10103       FormatStyle::SIS_WithoutElse;
10104   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
10105   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
10106   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
10107   EXPECT_EQ("if (true) return 42;",
10108             format("if (true)\nreturn 42;", AllowsMergedIf));
10109   FormatStyle ShortMergedIf = AllowsMergedIf;
10110   ShortMergedIf.ColumnLimit = 25;
10111   verifyFormat("#define A \\\n"
10112                "  if (true) return 42;",
10113                ShortMergedIf);
10114   verifyFormat("#define A \\\n"
10115                "  f();    \\\n"
10116                "  if (true)\n"
10117                "#define B",
10118                ShortMergedIf);
10119   verifyFormat("#define A \\\n"
10120                "  f();    \\\n"
10121                "  if (true)\n"
10122                "g();",
10123                ShortMergedIf);
10124   verifyFormat("{\n"
10125                "#ifdef A\n"
10126                "  // Comment\n"
10127                "  if (true) continue;\n"
10128                "#endif\n"
10129                "  // Comment\n"
10130                "  if (true) continue;\n"
10131                "}",
10132                ShortMergedIf);
10133   ShortMergedIf.ColumnLimit = 33;
10134   verifyFormat("#define A \\\n"
10135                "  if constexpr (true) return 42;",
10136                ShortMergedIf);
10137   verifyFormat("#define A \\\n"
10138                "  if CONSTEXPR (true) return 42;",
10139                ShortMergedIf);
10140   ShortMergedIf.ColumnLimit = 29;
10141   verifyFormat("#define A                   \\\n"
10142                "  if (aaaaaaaaaa) return 1; \\\n"
10143                "  return 2;",
10144                ShortMergedIf);
10145   ShortMergedIf.ColumnLimit = 28;
10146   verifyFormat("#define A         \\\n"
10147                "  if (aaaaaaaaaa) \\\n"
10148                "    return 1;     \\\n"
10149                "  return 2;",
10150                ShortMergedIf);
10151   verifyFormat("#define A                \\\n"
10152                "  if constexpr (aaaaaaa) \\\n"
10153                "    return 1;            \\\n"
10154                "  return 2;",
10155                ShortMergedIf);
10156   verifyFormat("#define A                \\\n"
10157                "  if CONSTEXPR (aaaaaaa) \\\n"
10158                "    return 1;            \\\n"
10159                "  return 2;",
10160                ShortMergedIf);
10161 }
10162 
10163 TEST_F(FormatTest, FormatStarDependingOnContext) {
10164   verifyFormat("void f(int *a);");
10165   verifyFormat("void f() { f(fint * b); }");
10166   verifyFormat("class A {\n  void f(int *a);\n};");
10167   verifyFormat("class A {\n  int *a;\n};");
10168   verifyFormat("namespace a {\n"
10169                "namespace b {\n"
10170                "class A {\n"
10171                "  void f() {}\n"
10172                "  int *a;\n"
10173                "};\n"
10174                "} // namespace b\n"
10175                "} // namespace a");
10176 }
10177 
10178 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
10179   verifyFormat("while");
10180   verifyFormat("operator");
10181 }
10182 
10183 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
10184   // This code would be painfully slow to format if we didn't skip it.
10185   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
10186                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10187                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10188                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10189                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10190                    "A(1, 1)\n"
10191                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
10192                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10193                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10194                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10195                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10196                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10197                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10198                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10199                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10200                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
10201   // Deeply nested part is untouched, rest is formatted.
10202   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
10203             format(std::string("int    i;\n") + Code + "int    j;\n",
10204                    getLLVMStyle(), SC_ExpectIncomplete));
10205 }
10206 
10207 //===----------------------------------------------------------------------===//
10208 // Objective-C tests.
10209 //===----------------------------------------------------------------------===//
10210 
10211 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
10212   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
10213   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
10214             format("-(NSUInteger)indexOfObject:(id)anObject;"));
10215   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
10216   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
10217   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
10218             format("-(NSInteger)Method3:(id)anObject;"));
10219   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
10220             format("-(NSInteger)Method4:(id)anObject;"));
10221   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
10222             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
10223   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
10224             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
10225   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10226             "forAllCells:(BOOL)flag;",
10227             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10228                    "forAllCells:(BOOL)flag;"));
10229 
10230   // Very long objectiveC method declaration.
10231   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
10232                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
10233   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
10234                "                    inRange:(NSRange)range\n"
10235                "                   outRange:(NSRange)out_range\n"
10236                "                  outRange1:(NSRange)out_range1\n"
10237                "                  outRange2:(NSRange)out_range2\n"
10238                "                  outRange3:(NSRange)out_range3\n"
10239                "                  outRange4:(NSRange)out_range4\n"
10240                "                  outRange5:(NSRange)out_range5\n"
10241                "                  outRange6:(NSRange)out_range6\n"
10242                "                  outRange7:(NSRange)out_range7\n"
10243                "                  outRange8:(NSRange)out_range8\n"
10244                "                  outRange9:(NSRange)out_range9;");
10245 
10246   // When the function name has to be wrapped.
10247   FormatStyle Style = getLLVMStyle();
10248   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
10249   // and always indents instead.
10250   Style.IndentWrappedFunctionNames = false;
10251   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10252                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
10253                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
10254                "}",
10255                Style);
10256   Style.IndentWrappedFunctionNames = true;
10257   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10258                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
10259                "               anotherName:(NSString)dddddddddddddd {\n"
10260                "}",
10261                Style);
10262 
10263   verifyFormat("- (int)sum:(vector<int>)numbers;");
10264   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
10265   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
10266   // protocol lists (but not for template classes):
10267   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
10268 
10269   verifyFormat("- (int (*)())foo:(int (*)())f;");
10270   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
10271 
10272   // If there's no return type (very rare in practice!), LLVM and Google style
10273   // agree.
10274   verifyFormat("- foo;");
10275   verifyFormat("- foo:(int)f;");
10276   verifyGoogleFormat("- foo:(int)foo;");
10277 }
10278 
10279 TEST_F(FormatTest, BreaksStringLiterals) {
10280   EXPECT_EQ("\"some text \"\n"
10281             "\"other\";",
10282             format("\"some text other\";", getLLVMStyleWithColumns(12)));
10283   EXPECT_EQ("\"some text \"\n"
10284             "\"other\";",
10285             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
10286   EXPECT_EQ(
10287       "#define A  \\\n"
10288       "  \"some \"  \\\n"
10289       "  \"text \"  \\\n"
10290       "  \"other\";",
10291       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
10292   EXPECT_EQ(
10293       "#define A  \\\n"
10294       "  \"so \"    \\\n"
10295       "  \"text \"  \\\n"
10296       "  \"other\";",
10297       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
10298 
10299   EXPECT_EQ("\"some text\"",
10300             format("\"some text\"", getLLVMStyleWithColumns(1)));
10301   EXPECT_EQ("\"some text\"",
10302             format("\"some text\"", getLLVMStyleWithColumns(11)));
10303   EXPECT_EQ("\"some \"\n"
10304             "\"text\"",
10305             format("\"some text\"", getLLVMStyleWithColumns(10)));
10306   EXPECT_EQ("\"some \"\n"
10307             "\"text\"",
10308             format("\"some text\"", getLLVMStyleWithColumns(7)));
10309   EXPECT_EQ("\"some\"\n"
10310             "\" tex\"\n"
10311             "\"t\"",
10312             format("\"some text\"", getLLVMStyleWithColumns(6)));
10313   EXPECT_EQ("\"some\"\n"
10314             "\" tex\"\n"
10315             "\" and\"",
10316             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
10317   EXPECT_EQ("\"some\"\n"
10318             "\"/tex\"\n"
10319             "\"/and\"",
10320             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
10321 
10322   EXPECT_EQ("variable =\n"
10323             "    \"long string \"\n"
10324             "    \"literal\";",
10325             format("variable = \"long string literal\";",
10326                    getLLVMStyleWithColumns(20)));
10327 
10328   EXPECT_EQ("variable = f(\n"
10329             "    \"long string \"\n"
10330             "    \"literal\",\n"
10331             "    short,\n"
10332             "    loooooooooooooooooooong);",
10333             format("variable = f(\"long string literal\", short, "
10334                    "loooooooooooooooooooong);",
10335                    getLLVMStyleWithColumns(20)));
10336 
10337   EXPECT_EQ(
10338       "f(g(\"long string \"\n"
10339       "    \"literal\"),\n"
10340       "  b);",
10341       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
10342   EXPECT_EQ("f(g(\"long string \"\n"
10343             "    \"literal\",\n"
10344             "    a),\n"
10345             "  b);",
10346             format("f(g(\"long string literal\", a), b);",
10347                    getLLVMStyleWithColumns(20)));
10348   EXPECT_EQ(
10349       "f(\"one two\".split(\n"
10350       "    variable));",
10351       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10352   EXPECT_EQ("f(\"one two three four five six \"\n"
10353             "  \"seven\".split(\n"
10354             "      really_looooong_variable));",
10355             format("f(\"one two three four five six seven\"."
10356                    "split(really_looooong_variable));",
10357                    getLLVMStyleWithColumns(33)));
10358 
10359   EXPECT_EQ("f(\"some \"\n"
10360             "  \"text\",\n"
10361             "  other);",
10362             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10363 
10364   // Only break as a last resort.
10365   verifyFormat(
10366       "aaaaaaaaaaaaaaaaaaaa(\n"
10367       "    aaaaaaaaaaaaaaaaaaaa,\n"
10368       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10369 
10370   EXPECT_EQ("\"splitmea\"\n"
10371             "\"trandomp\"\n"
10372             "\"oint\"",
10373             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10374 
10375   EXPECT_EQ("\"split/\"\n"
10376             "\"pathat/\"\n"
10377             "\"slashes\"",
10378             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10379 
10380   EXPECT_EQ("\"split/\"\n"
10381             "\"pathat/\"\n"
10382             "\"slashes\"",
10383             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10384   EXPECT_EQ("\"split at \"\n"
10385             "\"spaces/at/\"\n"
10386             "\"slashes.at.any$\"\n"
10387             "\"non-alphanumeric%\"\n"
10388             "\"1111111111characte\"\n"
10389             "\"rs\"",
10390             format("\"split at "
10391                    "spaces/at/"
10392                    "slashes.at."
10393                    "any$non-"
10394                    "alphanumeric%"
10395                    "1111111111characte"
10396                    "rs\"",
10397                    getLLVMStyleWithColumns(20)));
10398 
10399   // Verify that splitting the strings understands
10400   // Style::AlwaysBreakBeforeMultilineStrings.
10401   EXPECT_EQ("aaaaaaaaaaaa(\n"
10402             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10403             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10404             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10405                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10406                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10407                    getGoogleStyle()));
10408   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10409             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10410             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10411                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10412                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10413                    getGoogleStyle()));
10414   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10415             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10416             format("llvm::outs() << "
10417                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10418                    "aaaaaaaaaaaaaaaaaaa\";"));
10419   EXPECT_EQ("ffff(\n"
10420             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10421             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10422             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10423                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10424                    getGoogleStyle()));
10425 
10426   FormatStyle Style = getLLVMStyleWithColumns(12);
10427   Style.BreakStringLiterals = false;
10428   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10429 
10430   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10431   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10432   EXPECT_EQ("#define A \\\n"
10433             "  \"some \" \\\n"
10434             "  \"text \" \\\n"
10435             "  \"other\";",
10436             format("#define A \"some text other\";", AlignLeft));
10437 }
10438 
10439 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10440   EXPECT_EQ("C a = \"some more \"\n"
10441             "      \"text\";",
10442             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10443 }
10444 
10445 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10446   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10447   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10448   EXPECT_EQ("int i = a(b());",
10449             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10450 }
10451 
10452 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10453   EXPECT_EQ(
10454       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10455       "(\n"
10456       "    \"x\t\");",
10457       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10458              "aaaaaaa("
10459              "\"x\t\");"));
10460 }
10461 
10462 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10463   EXPECT_EQ(
10464       "u8\"utf8 string \"\n"
10465       "u8\"literal\";",
10466       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10467   EXPECT_EQ(
10468       "u\"utf16 string \"\n"
10469       "u\"literal\";",
10470       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10471   EXPECT_EQ(
10472       "U\"utf32 string \"\n"
10473       "U\"literal\";",
10474       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10475   EXPECT_EQ("L\"wide string \"\n"
10476             "L\"literal\";",
10477             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10478   EXPECT_EQ("@\"NSString \"\n"
10479             "@\"literal\";",
10480             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10481   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10482 
10483   // This input makes clang-format try to split the incomplete unicode escape
10484   // sequence, which used to lead to a crasher.
10485   verifyNoCrash(
10486       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10487       getLLVMStyleWithColumns(60));
10488 }
10489 
10490 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10491   FormatStyle Style = getGoogleStyleWithColumns(15);
10492   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10493   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10494   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10495   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10496   EXPECT_EQ("u8R\"x(raw literal)x\";",
10497             format("u8R\"x(raw literal)x\";", Style));
10498 }
10499 
10500 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10501   FormatStyle Style = getLLVMStyleWithColumns(20);
10502   EXPECT_EQ(
10503       "_T(\"aaaaaaaaaaaaaa\")\n"
10504       "_T(\"aaaaaaaaaaaaaa\")\n"
10505       "_T(\"aaaaaaaaaaaa\")",
10506       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10507   EXPECT_EQ("f(x,\n"
10508             "  _T(\"aaaaaaaaaaaa\")\n"
10509             "  _T(\"aaa\"),\n"
10510             "  z);",
10511             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10512 
10513   // FIXME: Handle embedded spaces in one iteration.
10514   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10515   //            "_T(\"aaaaaaaaaaaaa\")\n"
10516   //            "_T(\"aaaaaaaaaaaaa\")\n"
10517   //            "_T(\"a\")",
10518   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10519   //                   getLLVMStyleWithColumns(20)));
10520   EXPECT_EQ(
10521       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10522       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10523   EXPECT_EQ("f(\n"
10524             "#if !TEST\n"
10525             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10526             "#endif\n"
10527             ");",
10528             format("f(\n"
10529                    "#if !TEST\n"
10530                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10531                    "#endif\n"
10532                    ");"));
10533   EXPECT_EQ("f(\n"
10534             "\n"
10535             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10536             format("f(\n"
10537                    "\n"
10538                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10539 }
10540 
10541 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10542   // In a function call with two operands, the second can be broken with no line
10543   // break before it.
10544   EXPECT_EQ(
10545       "func(a, \"long long \"\n"
10546       "        \"long long\");",
10547       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10548   // In a function call with three operands, the second must be broken with a
10549   // line break before it.
10550   EXPECT_EQ("func(a,\n"
10551             "     \"long long long \"\n"
10552             "     \"long\",\n"
10553             "     c);",
10554             format("func(a, \"long long long long\", c);",
10555                    getLLVMStyleWithColumns(24)));
10556   // In a function call with three operands, the third must be broken with a
10557   // line break before it.
10558   EXPECT_EQ("func(a, b,\n"
10559             "     \"long long long \"\n"
10560             "     \"long\");",
10561             format("func(a, b, \"long long long long\");",
10562                    getLLVMStyleWithColumns(24)));
10563   // In a function call with three operands, both the second and the third must
10564   // be broken with a line break before them.
10565   EXPECT_EQ("func(a,\n"
10566             "     \"long long long \"\n"
10567             "     \"long\",\n"
10568             "     \"long long long \"\n"
10569             "     \"long\");",
10570             format("func(a, \"long long long long\", \"long long long long\");",
10571                    getLLVMStyleWithColumns(24)));
10572   // In a chain of << with two operands, the second can be broken with no line
10573   // break before it.
10574   EXPECT_EQ("a << \"line line \"\n"
10575             "     \"line\";",
10576             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10577   // In a chain of << with three operands, the second can be broken with no line
10578   // break before it.
10579   EXPECT_EQ(
10580       "abcde << \"line \"\n"
10581       "         \"line line\"\n"
10582       "      << c;",
10583       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10584   // In a chain of << with three operands, the third must be broken with a line
10585   // break before it.
10586   EXPECT_EQ(
10587       "a << b\n"
10588       "  << \"line line \"\n"
10589       "     \"line\";",
10590       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10591   // In a chain of << with three operands, the second can be broken with no line
10592   // break before it and the third must be broken with a line break before it.
10593   EXPECT_EQ("abcd << \"line line \"\n"
10594             "        \"line\"\n"
10595             "     << \"line line \"\n"
10596             "        \"line\";",
10597             format("abcd << \"line line line\" << \"line line line\";",
10598                    getLLVMStyleWithColumns(20)));
10599   // In a chain of binary operators with two operands, the second can be broken
10600   // with no line break before it.
10601   EXPECT_EQ(
10602       "abcd + \"line line \"\n"
10603       "       \"line line\";",
10604       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10605   // In a chain of binary operators with three operands, the second must be
10606   // broken with a line break before it.
10607   EXPECT_EQ("abcd +\n"
10608             "    \"line line \"\n"
10609             "    \"line line\" +\n"
10610             "    e;",
10611             format("abcd + \"line line line line\" + e;",
10612                    getLLVMStyleWithColumns(20)));
10613   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10614   // the first must be broken with a line break before it.
10615   FormatStyle Style = getLLVMStyleWithColumns(25);
10616   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10617   EXPECT_EQ("someFunction(\n"
10618             "    \"long long long \"\n"
10619             "    \"long\",\n"
10620             "    a);",
10621             format("someFunction(\"long long long long\", a);", Style));
10622 }
10623 
10624 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10625   EXPECT_EQ(
10626       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10627       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10628       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10629       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10630              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10631              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10632 }
10633 
10634 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10635   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10636             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10637   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10638             "multiline raw string literal xxxxxxxxxxxxxx\n"
10639             ")x\",\n"
10640             "              a),\n"
10641             "            b);",
10642             format("fffffffffff(g(R\"x(\n"
10643                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10644                    ")x\", a), b);",
10645                    getGoogleStyleWithColumns(20)));
10646   EXPECT_EQ("fffffffffff(\n"
10647             "    g(R\"x(qqq\n"
10648             "multiline raw string literal xxxxxxxxxxxxxx\n"
10649             ")x\",\n"
10650             "      a),\n"
10651             "    b);",
10652             format("fffffffffff(g(R\"x(qqq\n"
10653                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10654                    ")x\", a), b);",
10655                    getGoogleStyleWithColumns(20)));
10656 
10657   EXPECT_EQ("fffffffffff(R\"x(\n"
10658             "multiline raw string literal xxxxxxxxxxxxxx\n"
10659             ")x\");",
10660             format("fffffffffff(R\"x(\n"
10661                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10662                    ")x\");",
10663                    getGoogleStyleWithColumns(20)));
10664   EXPECT_EQ("fffffffffff(R\"x(\n"
10665             "multiline raw string literal xxxxxxxxxxxxxx\n"
10666             ")x\" + bbbbbb);",
10667             format("fffffffffff(R\"x(\n"
10668                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10669                    ")x\" +   bbbbbb);",
10670                    getGoogleStyleWithColumns(20)));
10671   EXPECT_EQ("fffffffffff(\n"
10672             "    R\"x(\n"
10673             "multiline raw string literal xxxxxxxxxxxxxx\n"
10674             ")x\" +\n"
10675             "    bbbbbb);",
10676             format("fffffffffff(\n"
10677                    " R\"x(\n"
10678                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10679                    ")x\" + bbbbbb);",
10680                    getGoogleStyleWithColumns(20)));
10681   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10682             format("fffffffffff(\n"
10683                    " R\"(single line raw string)\" + bbbbbb);"));
10684 }
10685 
10686 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10687   verifyFormat("string a = \"unterminated;");
10688   EXPECT_EQ("function(\"unterminated,\n"
10689             "         OtherParameter);",
10690             format("function(  \"unterminated,\n"
10691                    "    OtherParameter);"));
10692 }
10693 
10694 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10695   FormatStyle Style = getLLVMStyle();
10696   Style.Standard = FormatStyle::LS_Cpp03;
10697   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10698             format("#define x(_a) printf(\"foo\"_a);", Style));
10699 }
10700 
10701 TEST_F(FormatTest, CppLexVersion) {
10702   FormatStyle Style = getLLVMStyle();
10703   // Formatting of x * y differs if x is a type.
10704   verifyFormat("void foo() { MACRO(a * b); }", Style);
10705   verifyFormat("void foo() { MACRO(int *b); }", Style);
10706 
10707   // LLVM style uses latest lexer.
10708   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10709   Style.Standard = FormatStyle::LS_Cpp17;
10710   // But in c++17, char8_t isn't a keyword.
10711   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10712 }
10713 
10714 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10715 
10716 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10717   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10718             "             \"ddeeefff\");",
10719             format("someFunction(\"aaabbbcccdddeeefff\");",
10720                    getLLVMStyleWithColumns(25)));
10721   EXPECT_EQ("someFunction1234567890(\n"
10722             "    \"aaabbbcccdddeeefff\");",
10723             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10724                    getLLVMStyleWithColumns(26)));
10725   EXPECT_EQ("someFunction1234567890(\n"
10726             "    \"aaabbbcccdddeeeff\"\n"
10727             "    \"f\");",
10728             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10729                    getLLVMStyleWithColumns(25)));
10730   EXPECT_EQ("someFunction1234567890(\n"
10731             "    \"aaabbbcccdddeeeff\"\n"
10732             "    \"f\");",
10733             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10734                    getLLVMStyleWithColumns(24)));
10735   EXPECT_EQ("someFunction(\n"
10736             "    \"aaabbbcc ddde \"\n"
10737             "    \"efff\");",
10738             format("someFunction(\"aaabbbcc ddde efff\");",
10739                    getLLVMStyleWithColumns(25)));
10740   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10741             "             \"ddeeefff\");",
10742             format("someFunction(\"aaabbbccc ddeeefff\");",
10743                    getLLVMStyleWithColumns(25)));
10744   EXPECT_EQ("someFunction1234567890(\n"
10745             "    \"aaabb \"\n"
10746             "    \"cccdddeeefff\");",
10747             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10748                    getLLVMStyleWithColumns(25)));
10749   EXPECT_EQ("#define A          \\\n"
10750             "  string s =       \\\n"
10751             "      \"123456789\"  \\\n"
10752             "      \"0\";         \\\n"
10753             "  int i;",
10754             format("#define A string s = \"1234567890\"; int i;",
10755                    getLLVMStyleWithColumns(20)));
10756   EXPECT_EQ("someFunction(\n"
10757             "    \"aaabbbcc \"\n"
10758             "    \"dddeeefff\");",
10759             format("someFunction(\"aaabbbcc dddeeefff\");",
10760                    getLLVMStyleWithColumns(25)));
10761 }
10762 
10763 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10764   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10765   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10766   EXPECT_EQ("\"test\"\n"
10767             "\"\\n\"",
10768             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10769   EXPECT_EQ("\"tes\\\\\"\n"
10770             "\"n\"",
10771             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10772   EXPECT_EQ("\"\\\\\\\\\"\n"
10773             "\"\\n\"",
10774             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10775   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10776   EXPECT_EQ("\"\\uff01\"\n"
10777             "\"test\"",
10778             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10779   EXPECT_EQ("\"\\Uff01ff02\"",
10780             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10781   EXPECT_EQ("\"\\x000000000001\"\n"
10782             "\"next\"",
10783             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10784   EXPECT_EQ("\"\\x000000000001next\"",
10785             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10786   EXPECT_EQ("\"\\x000000000001\"",
10787             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10788   EXPECT_EQ("\"test\"\n"
10789             "\"\\000000\"\n"
10790             "\"000001\"",
10791             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10792   EXPECT_EQ("\"test\\000\"\n"
10793             "\"00000000\"\n"
10794             "\"1\"",
10795             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10796 }
10797 
10798 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10799   verifyFormat("void f() {\n"
10800                "  return g() {}\n"
10801                "  void h() {}");
10802   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10803                "g();\n"
10804                "}");
10805 }
10806 
10807 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10808   verifyFormat(
10809       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10810 }
10811 
10812 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10813   verifyFormat("class X {\n"
10814                "  void f() {\n"
10815                "  }\n"
10816                "};",
10817                getLLVMStyleWithColumns(12));
10818 }
10819 
10820 TEST_F(FormatTest, ConfigurableIndentWidth) {
10821   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10822   EightIndent.IndentWidth = 8;
10823   EightIndent.ContinuationIndentWidth = 8;
10824   verifyFormat("void f() {\n"
10825                "        someFunction();\n"
10826                "        if (true) {\n"
10827                "                f();\n"
10828                "        }\n"
10829                "}",
10830                EightIndent);
10831   verifyFormat("class X {\n"
10832                "        void f() {\n"
10833                "        }\n"
10834                "};",
10835                EightIndent);
10836   verifyFormat("int x[] = {\n"
10837                "        call(),\n"
10838                "        call()};",
10839                EightIndent);
10840 }
10841 
10842 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10843   verifyFormat("double\n"
10844                "f();",
10845                getLLVMStyleWithColumns(8));
10846 }
10847 
10848 TEST_F(FormatTest, ConfigurableUseOfTab) {
10849   FormatStyle Tab = getLLVMStyleWithColumns(42);
10850   Tab.IndentWidth = 8;
10851   Tab.UseTab = FormatStyle::UT_Always;
10852   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10853 
10854   EXPECT_EQ("if (aaaaaaaa && // q\n"
10855             "    bb)\t\t// w\n"
10856             "\t;",
10857             format("if (aaaaaaaa &&// q\n"
10858                    "bb)// w\n"
10859                    ";",
10860                    Tab));
10861   EXPECT_EQ("if (aaa && bbb) // w\n"
10862             "\t;",
10863             format("if(aaa&&bbb)// w\n"
10864                    ";",
10865                    Tab));
10866 
10867   verifyFormat("class X {\n"
10868                "\tvoid f() {\n"
10869                "\t\tsomeFunction(parameter1,\n"
10870                "\t\t\t     parameter2);\n"
10871                "\t}\n"
10872                "};",
10873                Tab);
10874   verifyFormat("#define A                        \\\n"
10875                "\tvoid f() {               \\\n"
10876                "\t\tsomeFunction(    \\\n"
10877                "\t\t    parameter1,  \\\n"
10878                "\t\t    parameter2); \\\n"
10879                "\t}",
10880                Tab);
10881   verifyFormat("int a;\t      // x\n"
10882                "int bbbbbbbb; // x\n",
10883                Tab);
10884 
10885   Tab.TabWidth = 4;
10886   Tab.IndentWidth = 8;
10887   verifyFormat("class TabWidth4Indent8 {\n"
10888                "\t\tvoid f() {\n"
10889                "\t\t\t\tsomeFunction(parameter1,\n"
10890                "\t\t\t\t\t\t\t parameter2);\n"
10891                "\t\t}\n"
10892                "};",
10893                Tab);
10894 
10895   Tab.TabWidth = 4;
10896   Tab.IndentWidth = 4;
10897   verifyFormat("class TabWidth4Indent4 {\n"
10898                "\tvoid f() {\n"
10899                "\t\tsomeFunction(parameter1,\n"
10900                "\t\t\t\t\t parameter2);\n"
10901                "\t}\n"
10902                "};",
10903                Tab);
10904 
10905   Tab.TabWidth = 8;
10906   Tab.IndentWidth = 4;
10907   verifyFormat("class TabWidth8Indent4 {\n"
10908                "    void f() {\n"
10909                "\tsomeFunction(parameter1,\n"
10910                "\t\t     parameter2);\n"
10911                "    }\n"
10912                "};",
10913                Tab);
10914 
10915   Tab.TabWidth = 8;
10916   Tab.IndentWidth = 8;
10917   EXPECT_EQ("/*\n"
10918             "\t      a\t\tcomment\n"
10919             "\t      in multiple lines\n"
10920             "       */",
10921             format("   /*\t \t \n"
10922                    " \t \t a\t\tcomment\t \t\n"
10923                    " \t \t in multiple lines\t\n"
10924                    " \t  */",
10925                    Tab));
10926 
10927   Tab.UseTab = FormatStyle::UT_ForIndentation;
10928   verifyFormat("{\n"
10929                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10930                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10931                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10932                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10933                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10934                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10935                "};",
10936                Tab);
10937   verifyFormat("enum AA {\n"
10938                "\ta1, // Force multiple lines\n"
10939                "\ta2,\n"
10940                "\ta3\n"
10941                "};",
10942                Tab);
10943   EXPECT_EQ("if (aaaaaaaa && // q\n"
10944             "    bb)         // w\n"
10945             "\t;",
10946             format("if (aaaaaaaa &&// q\n"
10947                    "bb)// w\n"
10948                    ";",
10949                    Tab));
10950   verifyFormat("class X {\n"
10951                "\tvoid f() {\n"
10952                "\t\tsomeFunction(parameter1,\n"
10953                "\t\t             parameter2);\n"
10954                "\t}\n"
10955                "};",
10956                Tab);
10957   verifyFormat("{\n"
10958                "\tQ(\n"
10959                "\t    {\n"
10960                "\t\t    int a;\n"
10961                "\t\t    someFunction(aaaaaaaa,\n"
10962                "\t\t                 bbbbbbb);\n"
10963                "\t    },\n"
10964                "\t    p);\n"
10965                "}",
10966                Tab);
10967   EXPECT_EQ("{\n"
10968             "\t/* aaaa\n"
10969             "\t   bbbb */\n"
10970             "}",
10971             format("{\n"
10972                    "/* aaaa\n"
10973                    "   bbbb */\n"
10974                    "}",
10975                    Tab));
10976   EXPECT_EQ("{\n"
10977             "\t/*\n"
10978             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10979             "\t  bbbbbbbbbbbbb\n"
10980             "\t*/\n"
10981             "}",
10982             format("{\n"
10983                    "/*\n"
10984                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10985                    "*/\n"
10986                    "}",
10987                    Tab));
10988   EXPECT_EQ("{\n"
10989             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10990             "\t// bbbbbbbbbbbbb\n"
10991             "}",
10992             format("{\n"
10993                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10994                    "}",
10995                    Tab));
10996   EXPECT_EQ("{\n"
10997             "\t/*\n"
10998             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10999             "\t  bbbbbbbbbbbbb\n"
11000             "\t*/\n"
11001             "}",
11002             format("{\n"
11003                    "\t/*\n"
11004                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11005                    "\t*/\n"
11006                    "}",
11007                    Tab));
11008   EXPECT_EQ("{\n"
11009             "\t/*\n"
11010             "\n"
11011             "\t*/\n"
11012             "}",
11013             format("{\n"
11014                    "\t/*\n"
11015                    "\n"
11016                    "\t*/\n"
11017                    "}",
11018                    Tab));
11019   EXPECT_EQ("{\n"
11020             "\t/*\n"
11021             " asdf\n"
11022             "\t*/\n"
11023             "}",
11024             format("{\n"
11025                    "\t/*\n"
11026                    " asdf\n"
11027                    "\t*/\n"
11028                    "}",
11029                    Tab));
11030 
11031   Tab.UseTab = FormatStyle::UT_Never;
11032   EXPECT_EQ("/*\n"
11033             "              a\t\tcomment\n"
11034             "              in multiple lines\n"
11035             "       */",
11036             format("   /*\t \t \n"
11037                    " \t \t a\t\tcomment\t \t\n"
11038                    " \t \t in multiple lines\t\n"
11039                    " \t  */",
11040                    Tab));
11041   EXPECT_EQ("/* some\n"
11042             "   comment */",
11043             format(" \t \t /* some\n"
11044                    " \t \t    comment */",
11045                    Tab));
11046   EXPECT_EQ("int a; /* some\n"
11047             "   comment */",
11048             format(" \t \t int a; /* some\n"
11049                    " \t \t    comment */",
11050                    Tab));
11051 
11052   EXPECT_EQ("int a; /* some\n"
11053             "comment */",
11054             format(" \t \t int\ta; /* some\n"
11055                    " \t \t    comment */",
11056                    Tab));
11057   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11058             "    comment */",
11059             format(" \t \t f(\"\t\t\"); /* some\n"
11060                    " \t \t    comment */",
11061                    Tab));
11062   EXPECT_EQ("{\n"
11063             "        /*\n"
11064             "         * Comment\n"
11065             "         */\n"
11066             "        int i;\n"
11067             "}",
11068             format("{\n"
11069                    "\t/*\n"
11070                    "\t * Comment\n"
11071                    "\t */\n"
11072                    "\t int i;\n"
11073                    "}",
11074                    Tab));
11075 
11076   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11077   Tab.TabWidth = 8;
11078   Tab.IndentWidth = 8;
11079   EXPECT_EQ("if (aaaaaaaa && // q\n"
11080             "    bb)         // w\n"
11081             "\t;",
11082             format("if (aaaaaaaa &&// q\n"
11083                    "bb)// w\n"
11084                    ";",
11085                    Tab));
11086   EXPECT_EQ("if (aaa && bbb) // w\n"
11087             "\t;",
11088             format("if(aaa&&bbb)// w\n"
11089                    ";",
11090                    Tab));
11091   verifyFormat("class X {\n"
11092                "\tvoid f() {\n"
11093                "\t\tsomeFunction(parameter1,\n"
11094                "\t\t\t     parameter2);\n"
11095                "\t}\n"
11096                "};",
11097                Tab);
11098   verifyFormat("#define A                        \\\n"
11099                "\tvoid f() {               \\\n"
11100                "\t\tsomeFunction(    \\\n"
11101                "\t\t    parameter1,  \\\n"
11102                "\t\t    parameter2); \\\n"
11103                "\t}",
11104                Tab);
11105   Tab.TabWidth = 4;
11106   Tab.IndentWidth = 8;
11107   verifyFormat("class TabWidth4Indent8 {\n"
11108                "\t\tvoid f() {\n"
11109                "\t\t\t\tsomeFunction(parameter1,\n"
11110                "\t\t\t\t\t\t\t parameter2);\n"
11111                "\t\t}\n"
11112                "};",
11113                Tab);
11114   Tab.TabWidth = 4;
11115   Tab.IndentWidth = 4;
11116   verifyFormat("class TabWidth4Indent4 {\n"
11117                "\tvoid f() {\n"
11118                "\t\tsomeFunction(parameter1,\n"
11119                "\t\t\t\t\t parameter2);\n"
11120                "\t}\n"
11121                "};",
11122                Tab);
11123   Tab.TabWidth = 8;
11124   Tab.IndentWidth = 4;
11125   verifyFormat("class TabWidth8Indent4 {\n"
11126                "    void f() {\n"
11127                "\tsomeFunction(parameter1,\n"
11128                "\t\t     parameter2);\n"
11129                "    }\n"
11130                "};",
11131                Tab);
11132   Tab.TabWidth = 8;
11133   Tab.IndentWidth = 8;
11134   EXPECT_EQ("/*\n"
11135             "\t      a\t\tcomment\n"
11136             "\t      in multiple lines\n"
11137             "       */",
11138             format("   /*\t \t \n"
11139                    " \t \t a\t\tcomment\t \t\n"
11140                    " \t \t in multiple lines\t\n"
11141                    " \t  */",
11142                    Tab));
11143   verifyFormat("{\n"
11144                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11145                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11146                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11147                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11148                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11149                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11150                "};",
11151                Tab);
11152   verifyFormat("enum AA {\n"
11153                "\ta1, // Force multiple lines\n"
11154                "\ta2,\n"
11155                "\ta3\n"
11156                "};",
11157                Tab);
11158   EXPECT_EQ("if (aaaaaaaa && // q\n"
11159             "    bb)         // w\n"
11160             "\t;",
11161             format("if (aaaaaaaa &&// q\n"
11162                    "bb)// w\n"
11163                    ";",
11164                    Tab));
11165   verifyFormat("class X {\n"
11166                "\tvoid f() {\n"
11167                "\t\tsomeFunction(parameter1,\n"
11168                "\t\t\t     parameter2);\n"
11169                "\t}\n"
11170                "};",
11171                Tab);
11172   verifyFormat("{\n"
11173                "\tQ(\n"
11174                "\t    {\n"
11175                "\t\t    int a;\n"
11176                "\t\t    someFunction(aaaaaaaa,\n"
11177                "\t\t\t\t bbbbbbb);\n"
11178                "\t    },\n"
11179                "\t    p);\n"
11180                "}",
11181                Tab);
11182   EXPECT_EQ("{\n"
11183             "\t/* aaaa\n"
11184             "\t   bbbb */\n"
11185             "}",
11186             format("{\n"
11187                    "/* aaaa\n"
11188                    "   bbbb */\n"
11189                    "}",
11190                    Tab));
11191   EXPECT_EQ("{\n"
11192             "\t/*\n"
11193             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11194             "\t  bbbbbbbbbbbbb\n"
11195             "\t*/\n"
11196             "}",
11197             format("{\n"
11198                    "/*\n"
11199                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11200                    "*/\n"
11201                    "}",
11202                    Tab));
11203   EXPECT_EQ("{\n"
11204             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11205             "\t// bbbbbbbbbbbbb\n"
11206             "}",
11207             format("{\n"
11208                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11209                    "}",
11210                    Tab));
11211   EXPECT_EQ("{\n"
11212             "\t/*\n"
11213             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11214             "\t  bbbbbbbbbbbbb\n"
11215             "\t*/\n"
11216             "}",
11217             format("{\n"
11218                    "\t/*\n"
11219                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11220                    "\t*/\n"
11221                    "}",
11222                    Tab));
11223   EXPECT_EQ("{\n"
11224             "\t/*\n"
11225             "\n"
11226             "\t*/\n"
11227             "}",
11228             format("{\n"
11229                    "\t/*\n"
11230                    "\n"
11231                    "\t*/\n"
11232                    "}",
11233                    Tab));
11234   EXPECT_EQ("{\n"
11235             "\t/*\n"
11236             " asdf\n"
11237             "\t*/\n"
11238             "}",
11239             format("{\n"
11240                    "\t/*\n"
11241                    " asdf\n"
11242                    "\t*/\n"
11243                    "}",
11244                    Tab));
11245   EXPECT_EQ("/* some\n"
11246             "   comment */",
11247             format(" \t \t /* some\n"
11248                    " \t \t    comment */",
11249                    Tab));
11250   EXPECT_EQ("int a; /* some\n"
11251             "   comment */",
11252             format(" \t \t int a; /* some\n"
11253                    " \t \t    comment */",
11254                    Tab));
11255   EXPECT_EQ("int a; /* some\n"
11256             "comment */",
11257             format(" \t \t int\ta; /* some\n"
11258                    " \t \t    comment */",
11259                    Tab));
11260   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11261             "    comment */",
11262             format(" \t \t f(\"\t\t\"); /* some\n"
11263                    " \t \t    comment */",
11264                    Tab));
11265   EXPECT_EQ("{\n"
11266             "\t/*\n"
11267             "\t * Comment\n"
11268             "\t */\n"
11269             "\tint i;\n"
11270             "}",
11271             format("{\n"
11272                    "\t/*\n"
11273                    "\t * Comment\n"
11274                    "\t */\n"
11275                    "\t int i;\n"
11276                    "}",
11277                    Tab));
11278   Tab.TabWidth = 2;
11279   Tab.IndentWidth = 2;
11280   EXPECT_EQ("{\n"
11281             "\t/* aaaa\n"
11282             "\t\t bbbb */\n"
11283             "}",
11284             format("{\n"
11285                    "/* aaaa\n"
11286                    "\t bbbb */\n"
11287                    "}",
11288                    Tab));
11289   EXPECT_EQ("{\n"
11290             "\t/*\n"
11291             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11292             "\t\tbbbbbbbbbbbbb\n"
11293             "\t*/\n"
11294             "}",
11295             format("{\n"
11296                    "/*\n"
11297                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11298                    "*/\n"
11299                    "}",
11300                    Tab));
11301   Tab.AlignConsecutiveAssignments = true;
11302   Tab.AlignConsecutiveDeclarations = true;
11303   Tab.TabWidth = 4;
11304   Tab.IndentWidth = 4;
11305   verifyFormat("class Assign {\n"
11306                "\tvoid f() {\n"
11307                "\t\tint         x      = 123;\n"
11308                "\t\tint         random = 4;\n"
11309                "\t\tstd::string alphabet =\n"
11310                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11311                "\t}\n"
11312                "};",
11313                Tab);
11314 
11315   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11316   Tab.TabWidth = 8;
11317   Tab.IndentWidth = 8;
11318   EXPECT_EQ("if (aaaaaaaa && // q\n"
11319             "    bb)         // w\n"
11320             "\t;",
11321             format("if (aaaaaaaa &&// q\n"
11322                    "bb)// w\n"
11323                    ";",
11324                    Tab));
11325   EXPECT_EQ("if (aaa && bbb) // w\n"
11326             "\t;",
11327             format("if(aaa&&bbb)// w\n"
11328                    ";",
11329                    Tab));
11330   verifyFormat("class X {\n"
11331                "\tvoid f() {\n"
11332                "\t\tsomeFunction(parameter1,\n"
11333                "\t\t             parameter2);\n"
11334                "\t}\n"
11335                "};",
11336                Tab);
11337   verifyFormat("#define A                        \\\n"
11338                "\tvoid f() {               \\\n"
11339                "\t\tsomeFunction(    \\\n"
11340                "\t\t    parameter1,  \\\n"
11341                "\t\t    parameter2); \\\n"
11342                "\t}",
11343                Tab);
11344   Tab.TabWidth = 4;
11345   Tab.IndentWidth = 8;
11346   verifyFormat("class TabWidth4Indent8 {\n"
11347                "\t\tvoid f() {\n"
11348                "\t\t\t\tsomeFunction(parameter1,\n"
11349                "\t\t\t\t             parameter2);\n"
11350                "\t\t}\n"
11351                "};",
11352                Tab);
11353   Tab.TabWidth = 4;
11354   Tab.IndentWidth = 4;
11355   verifyFormat("class TabWidth4Indent4 {\n"
11356                "\tvoid f() {\n"
11357                "\t\tsomeFunction(parameter1,\n"
11358                "\t\t             parameter2);\n"
11359                "\t}\n"
11360                "};",
11361                Tab);
11362   Tab.TabWidth = 8;
11363   Tab.IndentWidth = 4;
11364   verifyFormat("class TabWidth8Indent4 {\n"
11365                "    void f() {\n"
11366                "\tsomeFunction(parameter1,\n"
11367                "\t             parameter2);\n"
11368                "    }\n"
11369                "};",
11370                Tab);
11371   Tab.TabWidth = 8;
11372   Tab.IndentWidth = 8;
11373   EXPECT_EQ("/*\n"
11374             "              a\t\tcomment\n"
11375             "              in multiple lines\n"
11376             "       */",
11377             format("   /*\t \t \n"
11378                    " \t \t a\t\tcomment\t \t\n"
11379                    " \t \t in multiple lines\t\n"
11380                    " \t  */",
11381                    Tab));
11382   verifyFormat("{\n"
11383                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11384                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11385                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11386                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11387                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11388                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11389                "};",
11390                Tab);
11391   verifyFormat("enum AA {\n"
11392                "\ta1, // Force multiple lines\n"
11393                "\ta2,\n"
11394                "\ta3\n"
11395                "};",
11396                Tab);
11397   EXPECT_EQ("if (aaaaaaaa && // q\n"
11398             "    bb)         // w\n"
11399             "\t;",
11400             format("if (aaaaaaaa &&// q\n"
11401                    "bb)// w\n"
11402                    ";",
11403                    Tab));
11404   verifyFormat("class X {\n"
11405                "\tvoid f() {\n"
11406                "\t\tsomeFunction(parameter1,\n"
11407                "\t\t             parameter2);\n"
11408                "\t}\n"
11409                "};",
11410                Tab);
11411   verifyFormat("{\n"
11412                "\tQ(\n"
11413                "\t    {\n"
11414                "\t\t    int a;\n"
11415                "\t\t    someFunction(aaaaaaaa,\n"
11416                "\t\t                 bbbbbbb);\n"
11417                "\t    },\n"
11418                "\t    p);\n"
11419                "}",
11420                Tab);
11421   EXPECT_EQ("{\n"
11422             "\t/* aaaa\n"
11423             "\t   bbbb */\n"
11424             "}",
11425             format("{\n"
11426                    "/* aaaa\n"
11427                    "   bbbb */\n"
11428                    "}",
11429                    Tab));
11430   EXPECT_EQ("{\n"
11431             "\t/*\n"
11432             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11433             "\t  bbbbbbbbbbbbb\n"
11434             "\t*/\n"
11435             "}",
11436             format("{\n"
11437                    "/*\n"
11438                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11439                    "*/\n"
11440                    "}",
11441                    Tab));
11442   EXPECT_EQ("{\n"
11443             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11444             "\t// bbbbbbbbbbbbb\n"
11445             "}",
11446             format("{\n"
11447                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11448                    "}",
11449                    Tab));
11450   EXPECT_EQ("{\n"
11451             "\t/*\n"
11452             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11453             "\t  bbbbbbbbbbbbb\n"
11454             "\t*/\n"
11455             "}",
11456             format("{\n"
11457                    "\t/*\n"
11458                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11459                    "\t*/\n"
11460                    "}",
11461                    Tab));
11462   EXPECT_EQ("{\n"
11463             "\t/*\n"
11464             "\n"
11465             "\t*/\n"
11466             "}",
11467             format("{\n"
11468                    "\t/*\n"
11469                    "\n"
11470                    "\t*/\n"
11471                    "}",
11472                    Tab));
11473   EXPECT_EQ("{\n"
11474             "\t/*\n"
11475             " asdf\n"
11476             "\t*/\n"
11477             "}",
11478             format("{\n"
11479                    "\t/*\n"
11480                    " asdf\n"
11481                    "\t*/\n"
11482                    "}",
11483                    Tab));
11484   EXPECT_EQ("/* some\n"
11485             "   comment */",
11486             format(" \t \t /* some\n"
11487                    " \t \t    comment */",
11488                    Tab));
11489   EXPECT_EQ("int a; /* some\n"
11490             "   comment */",
11491             format(" \t \t int a; /* some\n"
11492                    " \t \t    comment */",
11493                    Tab));
11494   EXPECT_EQ("int a; /* some\n"
11495             "comment */",
11496             format(" \t \t int\ta; /* some\n"
11497                    " \t \t    comment */",
11498                    Tab));
11499   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11500             "    comment */",
11501             format(" \t \t f(\"\t\t\"); /* some\n"
11502                    " \t \t    comment */",
11503                    Tab));
11504   EXPECT_EQ("{\n"
11505             "\t/*\n"
11506             "\t * Comment\n"
11507             "\t */\n"
11508             "\tint i;\n"
11509             "}",
11510             format("{\n"
11511                    "\t/*\n"
11512                    "\t * Comment\n"
11513                    "\t */\n"
11514                    "\t int i;\n"
11515                    "}",
11516                    Tab));
11517   Tab.TabWidth = 2;
11518   Tab.IndentWidth = 2;
11519   EXPECT_EQ("{\n"
11520             "\t/* aaaa\n"
11521             "\t   bbbb */\n"
11522             "}",
11523             format("{\n"
11524                    "/* aaaa\n"
11525                    "   bbbb */\n"
11526                    "}",
11527                    Tab));
11528   EXPECT_EQ("{\n"
11529             "\t/*\n"
11530             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11531             "\t  bbbbbbbbbbbbb\n"
11532             "\t*/\n"
11533             "}",
11534             format("{\n"
11535                    "/*\n"
11536                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11537                    "*/\n"
11538                    "}",
11539                    Tab));
11540   Tab.AlignConsecutiveAssignments = true;
11541   Tab.AlignConsecutiveDeclarations = true;
11542   Tab.TabWidth = 4;
11543   Tab.IndentWidth = 4;
11544   verifyFormat("class Assign {\n"
11545                "\tvoid f() {\n"
11546                "\t\tint         x      = 123;\n"
11547                "\t\tint         random = 4;\n"
11548                "\t\tstd::string alphabet =\n"
11549                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11550                "\t}\n"
11551                "};",
11552                Tab);
11553   Tab.AlignOperands = FormatStyle::OAS_Align;
11554   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb +\n"
11555                "                 cccccccccccccccccccc;",
11556                Tab);
11557   // no alignment
11558   verifyFormat("int aaaaaaaaaa =\n"
11559                "\tbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
11560                Tab);
11561   verifyFormat("return aaaaaaaaaaaaaaaa ? 111111111111111\n"
11562                "       : bbbbbbbbbbbbbb ? 222222222222222\n"
11563                "                        : 333333333333333;",
11564                Tab);
11565   Tab.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
11566   Tab.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
11567   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb\n"
11568                "               + cccccccccccccccccccc;",
11569                Tab);
11570 }
11571 
11572 TEST_F(FormatTest, ZeroTabWidth) {
11573   FormatStyle Tab = getLLVMStyleWithColumns(42);
11574   Tab.IndentWidth = 8;
11575   Tab.UseTab = FormatStyle::UT_Never;
11576   Tab.TabWidth = 0;
11577   EXPECT_EQ("void a(){\n"
11578             "    // line starts with '\t'\n"
11579             "};",
11580             format("void a(){\n"
11581                    "\t// line starts with '\t'\n"
11582                    "};",
11583                    Tab));
11584 
11585   EXPECT_EQ("void a(){\n"
11586             "    // line starts with '\t'\n"
11587             "};",
11588             format("void a(){\n"
11589                    "\t\t// line starts with '\t'\n"
11590                    "};",
11591                    Tab));
11592 
11593   Tab.UseTab = FormatStyle::UT_ForIndentation;
11594   EXPECT_EQ("void a(){\n"
11595             "    // line starts with '\t'\n"
11596             "};",
11597             format("void a(){\n"
11598                    "\t// line starts with '\t'\n"
11599                    "};",
11600                    Tab));
11601 
11602   EXPECT_EQ("void a(){\n"
11603             "    // line starts with '\t'\n"
11604             "};",
11605             format("void a(){\n"
11606                    "\t\t// line starts with '\t'\n"
11607                    "};",
11608                    Tab));
11609 
11610   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11611   EXPECT_EQ("void a(){\n"
11612             "    // line starts with '\t'\n"
11613             "};",
11614             format("void a(){\n"
11615                    "\t// line starts with '\t'\n"
11616                    "};",
11617                    Tab));
11618 
11619   EXPECT_EQ("void a(){\n"
11620             "    // line starts with '\t'\n"
11621             "};",
11622             format("void a(){\n"
11623                    "\t\t// line starts with '\t'\n"
11624                    "};",
11625                    Tab));
11626 
11627   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11628   EXPECT_EQ("void a(){\n"
11629             "    // line starts with '\t'\n"
11630             "};",
11631             format("void a(){\n"
11632                    "\t// line starts with '\t'\n"
11633                    "};",
11634                    Tab));
11635 
11636   EXPECT_EQ("void a(){\n"
11637             "    // line starts with '\t'\n"
11638             "};",
11639             format("void a(){\n"
11640                    "\t\t// line starts with '\t'\n"
11641                    "};",
11642                    Tab));
11643 
11644   Tab.UseTab = FormatStyle::UT_Always;
11645   EXPECT_EQ("void a(){\n"
11646             "// line starts with '\t'\n"
11647             "};",
11648             format("void a(){\n"
11649                    "\t// line starts with '\t'\n"
11650                    "};",
11651                    Tab));
11652 
11653   EXPECT_EQ("void a(){\n"
11654             "// line starts with '\t'\n"
11655             "};",
11656             format("void a(){\n"
11657                    "\t\t// line starts with '\t'\n"
11658                    "};",
11659                    Tab));
11660 }
11661 
11662 TEST_F(FormatTest, CalculatesOriginalColumn) {
11663   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11664             "q\"; /* some\n"
11665             "       comment */",
11666             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11667                    "q\"; /* some\n"
11668                    "       comment */",
11669                    getLLVMStyle()));
11670   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11671             "/* some\n"
11672             "   comment */",
11673             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11674                    " /* some\n"
11675                    "    comment */",
11676                    getLLVMStyle()));
11677   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11678             "qqq\n"
11679             "/* some\n"
11680             "   comment */",
11681             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11682                    "qqq\n"
11683                    " /* some\n"
11684                    "    comment */",
11685                    getLLVMStyle()));
11686   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11687             "wwww; /* some\n"
11688             "         comment */",
11689             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11690                    "wwww; /* some\n"
11691                    "         comment */",
11692                    getLLVMStyle()));
11693 }
11694 
11695 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11696   FormatStyle NoSpace = getLLVMStyle();
11697   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11698 
11699   verifyFormat("while(true)\n"
11700                "  continue;",
11701                NoSpace);
11702   verifyFormat("for(;;)\n"
11703                "  continue;",
11704                NoSpace);
11705   verifyFormat("if(true)\n"
11706                "  f();\n"
11707                "else if(true)\n"
11708                "  f();",
11709                NoSpace);
11710   verifyFormat("do {\n"
11711                "  do_something();\n"
11712                "} while(something());",
11713                NoSpace);
11714   verifyFormat("switch(x) {\n"
11715                "default:\n"
11716                "  break;\n"
11717                "}",
11718                NoSpace);
11719   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11720   verifyFormat("size_t x = sizeof(x);", NoSpace);
11721   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11722   verifyFormat("auto f(int x) -> typeof(x);", NoSpace);
11723   verifyFormat("auto f(int x) -> _Atomic(x);", NoSpace);
11724   verifyFormat("auto f(int x) -> __underlying_type(x);", NoSpace);
11725   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11726   verifyFormat("alignas(128) char a[128];", NoSpace);
11727   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11728   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11729   verifyFormat("int f() throw(Deprecated);", NoSpace);
11730   verifyFormat("typedef void (*cb)(int);", NoSpace);
11731   verifyFormat("T A::operator()();", NoSpace);
11732   verifyFormat("X A::operator++(T);", NoSpace);
11733   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11734 
11735   FormatStyle Space = getLLVMStyle();
11736   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11737 
11738   verifyFormat("int f ();", Space);
11739   verifyFormat("void f (int a, T b) {\n"
11740                "  while (true)\n"
11741                "    continue;\n"
11742                "}",
11743                Space);
11744   verifyFormat("if (true)\n"
11745                "  f ();\n"
11746                "else if (true)\n"
11747                "  f ();",
11748                Space);
11749   verifyFormat("do {\n"
11750                "  do_something ();\n"
11751                "} while (something ());",
11752                Space);
11753   verifyFormat("switch (x) {\n"
11754                "default:\n"
11755                "  break;\n"
11756                "}",
11757                Space);
11758   verifyFormat("A::A () : a (1) {}", Space);
11759   verifyFormat("void f () __attribute__ ((asdf));", Space);
11760   verifyFormat("*(&a + 1);\n"
11761                "&((&a)[1]);\n"
11762                "a[(b + c) * d];\n"
11763                "(((a + 1) * 2) + 3) * 4;",
11764                Space);
11765   verifyFormat("#define A(x) x", Space);
11766   verifyFormat("#define A (x) x", Space);
11767   verifyFormat("#if defined(x)\n"
11768                "#endif",
11769                Space);
11770   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11771   verifyFormat("size_t x = sizeof (x);", Space);
11772   verifyFormat("auto f (int x) -> decltype (x);", Space);
11773   verifyFormat("auto f (int x) -> typeof (x);", Space);
11774   verifyFormat("auto f (int x) -> _Atomic (x);", Space);
11775   verifyFormat("auto f (int x) -> __underlying_type (x);", Space);
11776   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11777   verifyFormat("alignas (128) char a[128];", Space);
11778   verifyFormat("size_t x = alignof (MyType);", Space);
11779   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11780   verifyFormat("int f () throw (Deprecated);", Space);
11781   verifyFormat("typedef void (*cb) (int);", Space);
11782   verifyFormat("T A::operator() ();", Space);
11783   verifyFormat("X A::operator++ (T);", Space);
11784   verifyFormat("auto lambda = [] () { return 0; };", Space);
11785   verifyFormat("int x = int (y);", Space);
11786 
11787   FormatStyle SomeSpace = getLLVMStyle();
11788   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11789 
11790   verifyFormat("[]() -> float {}", SomeSpace);
11791   verifyFormat("[] (auto foo) {}", SomeSpace);
11792   verifyFormat("[foo]() -> int {}", SomeSpace);
11793   verifyFormat("int f();", SomeSpace);
11794   verifyFormat("void f (int a, T b) {\n"
11795                "  while (true)\n"
11796                "    continue;\n"
11797                "}",
11798                SomeSpace);
11799   verifyFormat("if (true)\n"
11800                "  f();\n"
11801                "else if (true)\n"
11802                "  f();",
11803                SomeSpace);
11804   verifyFormat("do {\n"
11805                "  do_something();\n"
11806                "} while (something());",
11807                SomeSpace);
11808   verifyFormat("switch (x) {\n"
11809                "default:\n"
11810                "  break;\n"
11811                "}",
11812                SomeSpace);
11813   verifyFormat("A::A() : a (1) {}", SomeSpace);
11814   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11815   verifyFormat("*(&a + 1);\n"
11816                "&((&a)[1]);\n"
11817                "a[(b + c) * d];\n"
11818                "(((a + 1) * 2) + 3) * 4;",
11819                SomeSpace);
11820   verifyFormat("#define A(x) x", SomeSpace);
11821   verifyFormat("#define A (x) x", SomeSpace);
11822   verifyFormat("#if defined(x)\n"
11823                "#endif",
11824                SomeSpace);
11825   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11826   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11827   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11828   verifyFormat("auto f (int x) -> typeof (x);", SomeSpace);
11829   verifyFormat("auto f (int x) -> _Atomic (x);", SomeSpace);
11830   verifyFormat("auto f (int x) -> __underlying_type (x);", SomeSpace);
11831   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11832   verifyFormat("alignas (128) char a[128];", SomeSpace);
11833   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11834   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11835                SomeSpace);
11836   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11837   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11838   verifyFormat("T A::operator()();", SomeSpace);
11839   verifyFormat("X A::operator++ (T);", SomeSpace);
11840   verifyFormat("int x = int (y);", SomeSpace);
11841   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11842 }
11843 
11844 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11845   FormatStyle Spaces = getLLVMStyle();
11846   Spaces.SpaceAfterLogicalNot = true;
11847 
11848   verifyFormat("bool x = ! y", Spaces);
11849   verifyFormat("if (! isFailure())", Spaces);
11850   verifyFormat("if (! (a && b))", Spaces);
11851   verifyFormat("\"Error!\"", Spaces);
11852   verifyFormat("! ! x", Spaces);
11853 }
11854 
11855 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11856   FormatStyle Spaces = getLLVMStyle();
11857 
11858   Spaces.SpacesInParentheses = true;
11859   verifyFormat("do_something( ::globalVar );", Spaces);
11860   verifyFormat("call( x, y, z );", Spaces);
11861   verifyFormat("call();", Spaces);
11862   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11863   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11864                Spaces);
11865   verifyFormat("while ( (bool)1 )\n"
11866                "  continue;",
11867                Spaces);
11868   verifyFormat("for ( ;; )\n"
11869                "  continue;",
11870                Spaces);
11871   verifyFormat("if ( true )\n"
11872                "  f();\n"
11873                "else if ( true )\n"
11874                "  f();",
11875                Spaces);
11876   verifyFormat("do {\n"
11877                "  do_something( (int)i );\n"
11878                "} while ( something() );",
11879                Spaces);
11880   verifyFormat("switch ( x ) {\n"
11881                "default:\n"
11882                "  break;\n"
11883                "}",
11884                Spaces);
11885 
11886   Spaces.SpacesInParentheses = false;
11887   Spaces.SpacesInCStyleCastParentheses = true;
11888   verifyFormat("Type *A = ( Type * )P;", Spaces);
11889   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11890   verifyFormat("x = ( int32 )y;", Spaces);
11891   verifyFormat("int a = ( int )(2.0f);", Spaces);
11892   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11893   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11894   verifyFormat("#define x (( int )-1)", Spaces);
11895 
11896   // Run the first set of tests again with:
11897   Spaces.SpacesInParentheses = false;
11898   Spaces.SpaceInEmptyParentheses = true;
11899   Spaces.SpacesInCStyleCastParentheses = true;
11900   verifyFormat("call(x, y, z);", Spaces);
11901   verifyFormat("call( );", Spaces);
11902   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11903   verifyFormat("while (( bool )1)\n"
11904                "  continue;",
11905                Spaces);
11906   verifyFormat("for (;;)\n"
11907                "  continue;",
11908                Spaces);
11909   verifyFormat("if (true)\n"
11910                "  f( );\n"
11911                "else if (true)\n"
11912                "  f( );",
11913                Spaces);
11914   verifyFormat("do {\n"
11915                "  do_something(( int )i);\n"
11916                "} while (something( ));",
11917                Spaces);
11918   verifyFormat("switch (x) {\n"
11919                "default:\n"
11920                "  break;\n"
11921                "}",
11922                Spaces);
11923 
11924   // Run the first set of tests again with:
11925   Spaces.SpaceAfterCStyleCast = true;
11926   verifyFormat("call(x, y, z);", Spaces);
11927   verifyFormat("call( );", Spaces);
11928   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11929   verifyFormat("while (( bool ) 1)\n"
11930                "  continue;",
11931                Spaces);
11932   verifyFormat("for (;;)\n"
11933                "  continue;",
11934                Spaces);
11935   verifyFormat("if (true)\n"
11936                "  f( );\n"
11937                "else if (true)\n"
11938                "  f( );",
11939                Spaces);
11940   verifyFormat("do {\n"
11941                "  do_something(( int ) i);\n"
11942                "} while (something( ));",
11943                Spaces);
11944   verifyFormat("switch (x) {\n"
11945                "default:\n"
11946                "  break;\n"
11947                "}",
11948                Spaces);
11949 
11950   // Run subset of tests again with:
11951   Spaces.SpacesInCStyleCastParentheses = false;
11952   Spaces.SpaceAfterCStyleCast = true;
11953   verifyFormat("while ((bool) 1)\n"
11954                "  continue;",
11955                Spaces);
11956   verifyFormat("do {\n"
11957                "  do_something((int) i);\n"
11958                "} while (something( ));",
11959                Spaces);
11960 }
11961 
11962 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
11963   verifyFormat("int a[5];");
11964   verifyFormat("a[3] += 42;");
11965 
11966   FormatStyle Spaces = getLLVMStyle();
11967   Spaces.SpacesInSquareBrackets = true;
11968   // Not lambdas.
11969   verifyFormat("int a[ 5 ];", Spaces);
11970   verifyFormat("a[ 3 ] += 42;", Spaces);
11971   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
11972   verifyFormat("double &operator[](int i) { return 0; }\n"
11973                "int i;",
11974                Spaces);
11975   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
11976   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
11977   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
11978   // Lambdas.
11979   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
11980   verifyFormat("return [ i, args... ] {};", Spaces);
11981   verifyFormat("int foo = [ &bar ]() {};", Spaces);
11982   verifyFormat("int foo = [ = ]() {};", Spaces);
11983   verifyFormat("int foo = [ & ]() {};", Spaces);
11984   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
11985   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
11986 }
11987 
11988 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
11989   FormatStyle NoSpaceStyle = getLLVMStyle();
11990   verifyFormat("int a[5];", NoSpaceStyle);
11991   verifyFormat("a[3] += 42;", NoSpaceStyle);
11992 
11993   verifyFormat("int a[1];", NoSpaceStyle);
11994   verifyFormat("int 1 [a];", NoSpaceStyle);
11995   verifyFormat("int a[1][2];", NoSpaceStyle);
11996   verifyFormat("a[7] = 5;", NoSpaceStyle);
11997   verifyFormat("int a = (f())[23];", NoSpaceStyle);
11998   verifyFormat("f([] {})", NoSpaceStyle);
11999 
12000   FormatStyle Space = getLLVMStyle();
12001   Space.SpaceBeforeSquareBrackets = true;
12002   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
12003   verifyFormat("return [i, args...] {};", Space);
12004 
12005   verifyFormat("int a [5];", Space);
12006   verifyFormat("a [3] += 42;", Space);
12007   verifyFormat("constexpr char hello []{\"hello\"};", Space);
12008   verifyFormat("double &operator[](int i) { return 0; }\n"
12009                "int i;",
12010                Space);
12011   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
12012   verifyFormat("int i = a [a][a]->f();", Space);
12013   verifyFormat("int i = (*b) [a]->f();", Space);
12014 
12015   verifyFormat("int a [1];", Space);
12016   verifyFormat("int 1 [a];", Space);
12017   verifyFormat("int a [1][2];", Space);
12018   verifyFormat("a [7] = 5;", Space);
12019   verifyFormat("int a = (f()) [23];", Space);
12020   verifyFormat("f([] {})", Space);
12021 }
12022 
12023 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
12024   verifyFormat("int a = 5;");
12025   verifyFormat("a += 42;");
12026   verifyFormat("a or_eq 8;");
12027 
12028   FormatStyle Spaces = getLLVMStyle();
12029   Spaces.SpaceBeforeAssignmentOperators = false;
12030   verifyFormat("int a= 5;", Spaces);
12031   verifyFormat("a+= 42;", Spaces);
12032   verifyFormat("a or_eq 8;", Spaces);
12033 }
12034 
12035 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
12036   verifyFormat("class Foo : public Bar {};");
12037   verifyFormat("Foo::Foo() : foo(1) {}");
12038   verifyFormat("for (auto a : b) {\n}");
12039   verifyFormat("int x = a ? b : c;");
12040   verifyFormat("{\n"
12041                "label0:\n"
12042                "  int x = 0;\n"
12043                "}");
12044   verifyFormat("switch (x) {\n"
12045                "case 1:\n"
12046                "default:\n"
12047                "}");
12048 
12049   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
12050   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
12051   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
12052   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
12053   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
12054   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
12055   verifyFormat("{\n"
12056                "label1:\n"
12057                "  int x = 0;\n"
12058                "}",
12059                CtorInitializerStyle);
12060   verifyFormat("switch (x) {\n"
12061                "case 1:\n"
12062                "default:\n"
12063                "}",
12064                CtorInitializerStyle);
12065   CtorInitializerStyle.BreakConstructorInitializers =
12066       FormatStyle::BCIS_AfterColon;
12067   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
12068                "    aaaaaaaaaaaaaaaa(1),\n"
12069                "    bbbbbbbbbbbbbbbb(2) {}",
12070                CtorInitializerStyle);
12071   CtorInitializerStyle.BreakConstructorInitializers =
12072       FormatStyle::BCIS_BeforeComma;
12073   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12074                "    : aaaaaaaaaaaaaaaa(1)\n"
12075                "    , bbbbbbbbbbbbbbbb(2) {}",
12076                CtorInitializerStyle);
12077   CtorInitializerStyle.BreakConstructorInitializers =
12078       FormatStyle::BCIS_BeforeColon;
12079   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12080                "    : aaaaaaaaaaaaaaaa(1),\n"
12081                "      bbbbbbbbbbbbbbbb(2) {}",
12082                CtorInitializerStyle);
12083   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
12084   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12085                ": aaaaaaaaaaaaaaaa(1),\n"
12086                "  bbbbbbbbbbbbbbbb(2) {}",
12087                CtorInitializerStyle);
12088 
12089   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
12090   InheritanceStyle.SpaceBeforeInheritanceColon = false;
12091   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
12092   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
12093   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
12094   verifyFormat("int x = a ? b : c;", InheritanceStyle);
12095   verifyFormat("{\n"
12096                "label2:\n"
12097                "  int x = 0;\n"
12098                "}",
12099                InheritanceStyle);
12100   verifyFormat("switch (x) {\n"
12101                "case 1:\n"
12102                "default:\n"
12103                "}",
12104                InheritanceStyle);
12105   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
12106   verifyFormat("class Foooooooooooooooooooooo:\n"
12107                "    public aaaaaaaaaaaaaaaaaa,\n"
12108                "    public bbbbbbbbbbbbbbbbbb {\n"
12109                "}",
12110                InheritanceStyle);
12111   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
12112   verifyFormat("class Foooooooooooooooooooooo\n"
12113                "    : public aaaaaaaaaaaaaaaaaa\n"
12114                "    , public bbbbbbbbbbbbbbbbbb {\n"
12115                "}",
12116                InheritanceStyle);
12117   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
12118   verifyFormat("class Foooooooooooooooooooooo\n"
12119                "    : public aaaaaaaaaaaaaaaaaa,\n"
12120                "      public bbbbbbbbbbbbbbbbbb {\n"
12121                "}",
12122                InheritanceStyle);
12123   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
12124   verifyFormat("class Foooooooooooooooooooooo\n"
12125                ": public aaaaaaaaaaaaaaaaaa,\n"
12126                "  public bbbbbbbbbbbbbbbbbb {}",
12127                InheritanceStyle);
12128 
12129   FormatStyle ForLoopStyle = getLLVMStyle();
12130   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
12131   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
12132   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
12133   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
12134   verifyFormat("int x = a ? b : c;", ForLoopStyle);
12135   verifyFormat("{\n"
12136                "label2:\n"
12137                "  int x = 0;\n"
12138                "}",
12139                ForLoopStyle);
12140   verifyFormat("switch (x) {\n"
12141                "case 1:\n"
12142                "default:\n"
12143                "}",
12144                ForLoopStyle);
12145 
12146   FormatStyle NoSpaceStyle = getLLVMStyle();
12147   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
12148   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
12149   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
12150   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
12151   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
12152   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
12153   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
12154   verifyFormat("{\n"
12155                "label3:\n"
12156                "  int x = 0;\n"
12157                "}",
12158                NoSpaceStyle);
12159   verifyFormat("switch (x) {\n"
12160                "case 1:\n"
12161                "default:\n"
12162                "}",
12163                NoSpaceStyle);
12164 }
12165 
12166 TEST_F(FormatTest, ConfigurableSpaceAroundPointerQualifiers) {
12167   FormatStyle Style = getLLVMStyle();
12168 
12169   Style.PointerAlignment = FormatStyle::PAS_Left;
12170   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
12171   verifyFormat("void* const* x = NULL;", Style);
12172 
12173 #define verifyQualifierSpaces(Code, Pointers, Qualifiers)                      \
12174   do {                                                                         \
12175     Style.PointerAlignment = FormatStyle::Pointers;                            \
12176     Style.SpaceAroundPointerQualifiers = FormatStyle::Qualifiers;              \
12177     verifyFormat(Code, Style);                                                 \
12178   } while (false)
12179 
12180   verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Default);
12181   verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_Default);
12182   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Default);
12183 
12184   verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Before);
12185   verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Before);
12186   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Before);
12187 
12188   verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_After);
12189   verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_After);
12190   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_After);
12191 
12192   verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_Both);
12193   verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Both);
12194   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Both);
12195 
12196 #undef verifyQualifierSpaces
12197 
12198   FormatStyle Spaces = getLLVMStyle();
12199   Spaces.AttributeMacros.push_back("qualified");
12200   Spaces.PointerAlignment = FormatStyle::PAS_Right;
12201   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
12202   verifyFormat("SomeType *volatile *a = NULL;", Spaces);
12203   verifyFormat("SomeType *__attribute__((attr)) *a = NULL;", Spaces);
12204   verifyFormat("std::vector<SomeType *const *> x;", Spaces);
12205   verifyFormat("std::vector<SomeType *qualified *> x;", Spaces);
12206   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12207   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
12208   verifyFormat("SomeType * volatile *a = NULL;", Spaces);
12209   verifyFormat("SomeType * __attribute__((attr)) *a = NULL;", Spaces);
12210   verifyFormat("std::vector<SomeType * const *> x;", Spaces);
12211   verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
12212   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12213 
12214   // Check that SAPQ_Before doesn't result in extra spaces for PAS_Left.
12215   Spaces.PointerAlignment = FormatStyle::PAS_Left;
12216   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
12217   verifyFormat("SomeType* volatile* a = NULL;", Spaces);
12218   verifyFormat("SomeType* __attribute__((attr))* a = NULL;", Spaces);
12219   verifyFormat("std::vector<SomeType* const*> x;", Spaces);
12220   verifyFormat("std::vector<SomeType* qualified*> x;", Spaces);
12221   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12222   // However, setting it to SAPQ_After should add spaces after __attribute, etc.
12223   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
12224   verifyFormat("SomeType* volatile * a = NULL;", Spaces);
12225   verifyFormat("SomeType* __attribute__((attr)) * a = NULL;", Spaces);
12226   verifyFormat("std::vector<SomeType* const *> x;", Spaces);
12227   verifyFormat("std::vector<SomeType* qualified *> x;", Spaces);
12228   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12229 
12230   // PAS_Middle should not have any noticeable changes even for SAPQ_Both
12231   Spaces.PointerAlignment = FormatStyle::PAS_Middle;
12232   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
12233   verifyFormat("SomeType * volatile * a = NULL;", Spaces);
12234   verifyFormat("SomeType * __attribute__((attr)) * a = NULL;", Spaces);
12235   verifyFormat("std::vector<SomeType * const *> x;", Spaces);
12236   verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
12237   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12238 }
12239 
12240 TEST_F(FormatTest, AlignConsecutiveMacros) {
12241   FormatStyle Style = getLLVMStyle();
12242   Style.AlignConsecutiveAssignments = true;
12243   Style.AlignConsecutiveDeclarations = true;
12244   Style.AlignConsecutiveMacros = false;
12245 
12246   verifyFormat("#define a 3\n"
12247                "#define bbbb 4\n"
12248                "#define ccc (5)",
12249                Style);
12250 
12251   verifyFormat("#define f(x) (x * x)\n"
12252                "#define fff(x, y, z) (x * y + z)\n"
12253                "#define ffff(x, y) (x - y)",
12254                Style);
12255 
12256   verifyFormat("#define foo(x, y) (x + y)\n"
12257                "#define bar (5, 6)(2 + 2)",
12258                Style);
12259 
12260   verifyFormat("#define a 3\n"
12261                "#define bbbb 4\n"
12262                "#define ccc (5)\n"
12263                "#define f(x) (x * x)\n"
12264                "#define fff(x, y, z) (x * y + z)\n"
12265                "#define ffff(x, y) (x - y)",
12266                Style);
12267 
12268   Style.AlignConsecutiveMacros = true;
12269   verifyFormat("#define a    3\n"
12270                "#define bbbb 4\n"
12271                "#define ccc  (5)",
12272                Style);
12273 
12274   verifyFormat("#define f(x)         (x * x)\n"
12275                "#define fff(x, y, z) (x * y + z)\n"
12276                "#define ffff(x, y)   (x - y)",
12277                Style);
12278 
12279   verifyFormat("#define foo(x, y) (x + y)\n"
12280                "#define bar       (5, 6)(2 + 2)",
12281                Style);
12282 
12283   verifyFormat("#define a            3\n"
12284                "#define bbbb         4\n"
12285                "#define ccc          (5)\n"
12286                "#define f(x)         (x * x)\n"
12287                "#define fff(x, y, z) (x * y + z)\n"
12288                "#define ffff(x, y)   (x - y)",
12289                Style);
12290 
12291   verifyFormat("#define a         5\n"
12292                "#define foo(x, y) (x + y)\n"
12293                "#define CCC       (6)\n"
12294                "auto lambda = []() {\n"
12295                "  auto  ii = 0;\n"
12296                "  float j  = 0;\n"
12297                "  return 0;\n"
12298                "};\n"
12299                "int   i  = 0;\n"
12300                "float i2 = 0;\n"
12301                "auto  v  = type{\n"
12302                "    i = 1,   //\n"
12303                "    (i = 2), //\n"
12304                "    i = 3    //\n"
12305                "};",
12306                Style);
12307 
12308   Style.AlignConsecutiveMacros = false;
12309   Style.ColumnLimit = 20;
12310 
12311   verifyFormat("#define a          \\\n"
12312                "  \"aabbbbbbbbbbbb\"\n"
12313                "#define D          \\\n"
12314                "  \"aabbbbbbbbbbbb\" \\\n"
12315                "  \"ccddeeeeeeeee\"\n"
12316                "#define B          \\\n"
12317                "  \"QQQQQQQQQQQQQ\"  \\\n"
12318                "  \"FFFFFFFFFFFFF\"  \\\n"
12319                "  \"LLLLLLLL\"\n",
12320                Style);
12321 
12322   Style.AlignConsecutiveMacros = true;
12323   verifyFormat("#define a          \\\n"
12324                "  \"aabbbbbbbbbbbb\"\n"
12325                "#define D          \\\n"
12326                "  \"aabbbbbbbbbbbb\" \\\n"
12327                "  \"ccddeeeeeeeee\"\n"
12328                "#define B          \\\n"
12329                "  \"QQQQQQQQQQQQQ\"  \\\n"
12330                "  \"FFFFFFFFFFFFF\"  \\\n"
12331                "  \"LLLLLLLL\"\n",
12332                Style);
12333 }
12334 
12335 TEST_F(FormatTest, AlignConsecutiveAssignments) {
12336   FormatStyle Alignment = getLLVMStyle();
12337   Alignment.AlignConsecutiveMacros = true;
12338   Alignment.AlignConsecutiveAssignments = false;
12339   verifyFormat("int a = 5;\n"
12340                "int oneTwoThree = 123;",
12341                Alignment);
12342   verifyFormat("int a = 5;\n"
12343                "int oneTwoThree = 123;",
12344                Alignment);
12345 
12346   Alignment.AlignConsecutiveAssignments = true;
12347   verifyFormat("int a           = 5;\n"
12348                "int oneTwoThree = 123;",
12349                Alignment);
12350   verifyFormat("int a           = method();\n"
12351                "int oneTwoThree = 133;",
12352                Alignment);
12353   verifyFormat("a &= 5;\n"
12354                "bcd *= 5;\n"
12355                "ghtyf += 5;\n"
12356                "dvfvdb -= 5;\n"
12357                "a /= 5;\n"
12358                "vdsvsv %= 5;\n"
12359                "sfdbddfbdfbb ^= 5;\n"
12360                "dvsdsv |= 5;\n"
12361                "int dsvvdvsdvvv = 123;",
12362                Alignment);
12363   verifyFormat("int i = 1, j = 10;\n"
12364                "something = 2000;",
12365                Alignment);
12366   verifyFormat("something = 2000;\n"
12367                "int i = 1, j = 10;\n",
12368                Alignment);
12369   verifyFormat("something = 2000;\n"
12370                "another   = 911;\n"
12371                "int i = 1, j = 10;\n"
12372                "oneMore = 1;\n"
12373                "i       = 2;",
12374                Alignment);
12375   verifyFormat("int a   = 5;\n"
12376                "int one = 1;\n"
12377                "method();\n"
12378                "int oneTwoThree = 123;\n"
12379                "int oneTwo      = 12;",
12380                Alignment);
12381   verifyFormat("int oneTwoThree = 123;\n"
12382                "int oneTwo      = 12;\n"
12383                "method();\n",
12384                Alignment);
12385   verifyFormat("int oneTwoThree = 123; // comment\n"
12386                "int oneTwo      = 12;  // comment",
12387                Alignment);
12388 
12389   // Bug 25167
12390   /* Uncomment when fixed
12391     verifyFormat("#if A\n"
12392                  "#else\n"
12393                  "int aaaaaaaa = 12;\n"
12394                  "#endif\n"
12395                  "#if B\n"
12396                  "#else\n"
12397                  "int a = 12;\n"
12398                  "#endif\n",
12399                  Alignment);
12400     verifyFormat("enum foo {\n"
12401                  "#if A\n"
12402                  "#else\n"
12403                  "  aaaaaaaa = 12;\n"
12404                  "#endif\n"
12405                  "#if B\n"
12406                  "#else\n"
12407                  "  a = 12;\n"
12408                  "#endif\n"
12409                  "};\n",
12410                  Alignment);
12411   */
12412 
12413   EXPECT_EQ("int a = 5;\n"
12414             "\n"
12415             "int oneTwoThree = 123;",
12416             format("int a       = 5;\n"
12417                    "\n"
12418                    "int oneTwoThree= 123;",
12419                    Alignment));
12420   EXPECT_EQ("int a   = 5;\n"
12421             "int one = 1;\n"
12422             "\n"
12423             "int oneTwoThree = 123;",
12424             format("int a = 5;\n"
12425                    "int one = 1;\n"
12426                    "\n"
12427                    "int oneTwoThree = 123;",
12428                    Alignment));
12429   EXPECT_EQ("int a   = 5;\n"
12430             "int one = 1;\n"
12431             "\n"
12432             "int oneTwoThree = 123;\n"
12433             "int oneTwo      = 12;",
12434             format("int a = 5;\n"
12435                    "int one = 1;\n"
12436                    "\n"
12437                    "int oneTwoThree = 123;\n"
12438                    "int oneTwo = 12;",
12439                    Alignment));
12440   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12441   verifyFormat("#define A \\\n"
12442                "  int aaaa       = 12; \\\n"
12443                "  int b          = 23; \\\n"
12444                "  int ccc        = 234; \\\n"
12445                "  int dddddddddd = 2345;",
12446                Alignment);
12447   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12448   verifyFormat("#define A               \\\n"
12449                "  int aaaa       = 12;  \\\n"
12450                "  int b          = 23;  \\\n"
12451                "  int ccc        = 234; \\\n"
12452                "  int dddddddddd = 2345;",
12453                Alignment);
12454   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12455   verifyFormat("#define A                                                      "
12456                "                \\\n"
12457                "  int aaaa       = 12;                                         "
12458                "                \\\n"
12459                "  int b          = 23;                                         "
12460                "                \\\n"
12461                "  int ccc        = 234;                                        "
12462                "                \\\n"
12463                "  int dddddddddd = 2345;",
12464                Alignment);
12465   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12466                "k = 4, int l = 5,\n"
12467                "                  int m = 6) {\n"
12468                "  int j      = 10;\n"
12469                "  otherThing = 1;\n"
12470                "}",
12471                Alignment);
12472   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12473                "  int i   = 1;\n"
12474                "  int j   = 2;\n"
12475                "  int big = 10000;\n"
12476                "}",
12477                Alignment);
12478   verifyFormat("class C {\n"
12479                "public:\n"
12480                "  int i            = 1;\n"
12481                "  virtual void f() = 0;\n"
12482                "};",
12483                Alignment);
12484   verifyFormat("int i = 1;\n"
12485                "if (SomeType t = getSomething()) {\n"
12486                "}\n"
12487                "int j   = 2;\n"
12488                "int big = 10000;",
12489                Alignment);
12490   verifyFormat("int j = 7;\n"
12491                "for (int k = 0; k < N; ++k) {\n"
12492                "}\n"
12493                "int j   = 2;\n"
12494                "int big = 10000;\n"
12495                "}",
12496                Alignment);
12497   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12498   verifyFormat("int i = 1;\n"
12499                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12500                "    = someLooooooooooooooooongFunction();\n"
12501                "int j = 2;",
12502                Alignment);
12503   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12504   verifyFormat("int i = 1;\n"
12505                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12506                "    someLooooooooooooooooongFunction();\n"
12507                "int j = 2;",
12508                Alignment);
12509 
12510   verifyFormat("auto lambda = []() {\n"
12511                "  auto i = 0;\n"
12512                "  return 0;\n"
12513                "};\n"
12514                "int i  = 0;\n"
12515                "auto v = type{\n"
12516                "    i = 1,   //\n"
12517                "    (i = 2), //\n"
12518                "    i = 3    //\n"
12519                "};",
12520                Alignment);
12521 
12522   verifyFormat(
12523       "int i      = 1;\n"
12524       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12525       "                          loooooooooooooooooooooongParameterB);\n"
12526       "int j      = 2;",
12527       Alignment);
12528 
12529   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12530                "          typename B   = very_long_type_name_1,\n"
12531                "          typename T_2 = very_long_type_name_2>\n"
12532                "auto foo() {}\n",
12533                Alignment);
12534   verifyFormat("int a, b = 1;\n"
12535                "int c  = 2;\n"
12536                "int dd = 3;\n",
12537                Alignment);
12538   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12539                "float b[1][] = {{3.f}};\n",
12540                Alignment);
12541   verifyFormat("for (int i = 0; i < 1; i++)\n"
12542                "  int x = 1;\n",
12543                Alignment);
12544   verifyFormat("for (i = 0; i < 1; i++)\n"
12545                "  x = 1;\n"
12546                "y = 1;\n",
12547                Alignment);
12548 
12549   Alignment.ReflowComments = true;
12550   Alignment.ColumnLimit = 50;
12551   EXPECT_EQ("int x   = 0;\n"
12552             "int yy  = 1; /// specificlennospace\n"
12553             "int zzz = 2;\n",
12554             format("int x   = 0;\n"
12555                    "int yy  = 1; ///specificlennospace\n"
12556                    "int zzz = 2;\n",
12557                    Alignment));
12558 }
12559 
12560 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12561   FormatStyle Alignment = getLLVMStyle();
12562   Alignment.AlignConsecutiveBitFields = true;
12563   verifyFormat("int const a     : 5;\n"
12564                "int oneTwoThree : 23;",
12565                Alignment);
12566 
12567   // Initializers are allowed starting with c++2a
12568   verifyFormat("int const a     : 5 = 1;\n"
12569                "int oneTwoThree : 23 = 0;",
12570                Alignment);
12571 
12572   Alignment.AlignConsecutiveDeclarations = true;
12573   verifyFormat("int const a           : 5;\n"
12574                "int       oneTwoThree : 23;",
12575                Alignment);
12576 
12577   verifyFormat("int const a           : 5;  // comment\n"
12578                "int       oneTwoThree : 23; // comment",
12579                Alignment);
12580 
12581   verifyFormat("int const a           : 5 = 1;\n"
12582                "int       oneTwoThree : 23 = 0;",
12583                Alignment);
12584 
12585   Alignment.AlignConsecutiveAssignments = true;
12586   verifyFormat("int const a           : 5  = 1;\n"
12587                "int       oneTwoThree : 23 = 0;",
12588                Alignment);
12589   verifyFormat("int const a           : 5  = {1};\n"
12590                "int       oneTwoThree : 23 = 0;",
12591                Alignment);
12592 
12593   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_None;
12594   verifyFormat("int const a          :5;\n"
12595                "int       oneTwoThree:23;",
12596                Alignment);
12597 
12598   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_Before;
12599   verifyFormat("int const a           :5;\n"
12600                "int       oneTwoThree :23;",
12601                Alignment);
12602 
12603   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_After;
12604   verifyFormat("int const a          : 5;\n"
12605                "int       oneTwoThree: 23;",
12606                Alignment);
12607 
12608   // Known limitations: ':' is only recognized as a bitfield colon when
12609   // followed by a number.
12610   /*
12611   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12612                "int a           : 5;",
12613                Alignment);
12614   */
12615 }
12616 
12617 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12618   FormatStyle Alignment = getLLVMStyle();
12619   Alignment.AlignConsecutiveMacros = true;
12620   Alignment.AlignConsecutiveDeclarations = false;
12621   verifyFormat("float const a = 5;\n"
12622                "int oneTwoThree = 123;",
12623                Alignment);
12624   verifyFormat("int a = 5;\n"
12625                "float const oneTwoThree = 123;",
12626                Alignment);
12627 
12628   Alignment.AlignConsecutiveDeclarations = true;
12629   verifyFormat("float const a = 5;\n"
12630                "int         oneTwoThree = 123;",
12631                Alignment);
12632   verifyFormat("int         a = method();\n"
12633                "float const oneTwoThree = 133;",
12634                Alignment);
12635   verifyFormat("int i = 1, j = 10;\n"
12636                "something = 2000;",
12637                Alignment);
12638   verifyFormat("something = 2000;\n"
12639                "int i = 1, j = 10;\n",
12640                Alignment);
12641   verifyFormat("float      something = 2000;\n"
12642                "double     another = 911;\n"
12643                "int        i = 1, j = 10;\n"
12644                "const int *oneMore = 1;\n"
12645                "unsigned   i = 2;",
12646                Alignment);
12647   verifyFormat("float a = 5;\n"
12648                "int   one = 1;\n"
12649                "method();\n"
12650                "const double       oneTwoThree = 123;\n"
12651                "const unsigned int oneTwo = 12;",
12652                Alignment);
12653   verifyFormat("int      oneTwoThree{0}; // comment\n"
12654                "unsigned oneTwo;         // comment",
12655                Alignment);
12656   EXPECT_EQ("float const a = 5;\n"
12657             "\n"
12658             "int oneTwoThree = 123;",
12659             format("float const   a = 5;\n"
12660                    "\n"
12661                    "int           oneTwoThree= 123;",
12662                    Alignment));
12663   EXPECT_EQ("float a = 5;\n"
12664             "int   one = 1;\n"
12665             "\n"
12666             "unsigned oneTwoThree = 123;",
12667             format("float    a = 5;\n"
12668                    "int      one = 1;\n"
12669                    "\n"
12670                    "unsigned oneTwoThree = 123;",
12671                    Alignment));
12672   EXPECT_EQ("float a = 5;\n"
12673             "int   one = 1;\n"
12674             "\n"
12675             "unsigned oneTwoThree = 123;\n"
12676             "int      oneTwo = 12;",
12677             format("float    a = 5;\n"
12678                    "int one = 1;\n"
12679                    "\n"
12680                    "unsigned oneTwoThree = 123;\n"
12681                    "int oneTwo = 12;",
12682                    Alignment));
12683   // Function prototype alignment
12684   verifyFormat("int    a();\n"
12685                "double b();",
12686                Alignment);
12687   verifyFormat("int    a(int x);\n"
12688                "double b();",
12689                Alignment);
12690   unsigned OldColumnLimit = Alignment.ColumnLimit;
12691   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12692   // otherwise the function parameters will be re-flowed onto a single line.
12693   Alignment.ColumnLimit = 0;
12694   EXPECT_EQ("int    a(int   x,\n"
12695             "         float y);\n"
12696             "double b(int    x,\n"
12697             "         double y);",
12698             format("int a(int x,\n"
12699                    " float y);\n"
12700                    "double b(int x,\n"
12701                    " double y);",
12702                    Alignment));
12703   // This ensures that function parameters of function declarations are
12704   // correctly indented when their owning functions are indented.
12705   // The failure case here is for 'double y' to not be indented enough.
12706   EXPECT_EQ("double a(int x);\n"
12707             "int    b(int    y,\n"
12708             "         double z);",
12709             format("double a(int x);\n"
12710                    "int b(int y,\n"
12711                    " double z);",
12712                    Alignment));
12713   // Set ColumnLimit low so that we induce wrapping immediately after
12714   // the function name and opening paren.
12715   Alignment.ColumnLimit = 13;
12716   verifyFormat("int function(\n"
12717                "    int  x,\n"
12718                "    bool y);",
12719                Alignment);
12720   Alignment.ColumnLimit = OldColumnLimit;
12721   // Ensure function pointers don't screw up recursive alignment
12722   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12723                "double b();",
12724                Alignment);
12725   Alignment.AlignConsecutiveAssignments = true;
12726   // Ensure recursive alignment is broken by function braces, so that the
12727   // "a = 1" does not align with subsequent assignments inside the function
12728   // body.
12729   verifyFormat("int func(int a = 1) {\n"
12730                "  int b  = 2;\n"
12731                "  int cc = 3;\n"
12732                "}",
12733                Alignment);
12734   verifyFormat("float      something = 2000;\n"
12735                "double     another   = 911;\n"
12736                "int        i = 1, j = 10;\n"
12737                "const int *oneMore = 1;\n"
12738                "unsigned   i       = 2;",
12739                Alignment);
12740   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12741                "unsigned oneTwo      = 0;   // comment",
12742                Alignment);
12743   // Make sure that scope is correctly tracked, in the absence of braces
12744   verifyFormat("for (int i = 0; i < n; i++)\n"
12745                "  j = i;\n"
12746                "double x = 1;\n",
12747                Alignment);
12748   verifyFormat("if (int i = 0)\n"
12749                "  j = i;\n"
12750                "double x = 1;\n",
12751                Alignment);
12752   // Ensure operator[] and operator() are comprehended
12753   verifyFormat("struct test {\n"
12754                "  long long int foo();\n"
12755                "  int           operator[](int a);\n"
12756                "  double        bar();\n"
12757                "};\n",
12758                Alignment);
12759   verifyFormat("struct test {\n"
12760                "  long long int foo();\n"
12761                "  int           operator()(int a);\n"
12762                "  double        bar();\n"
12763                "};\n",
12764                Alignment);
12765   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12766             "  int const i   = 1;\n"
12767             "  int *     j   = 2;\n"
12768             "  int       big = 10000;\n"
12769             "\n"
12770             "  unsigned oneTwoThree = 123;\n"
12771             "  int      oneTwo      = 12;\n"
12772             "  method();\n"
12773             "  float k  = 2;\n"
12774             "  int   ll = 10000;\n"
12775             "}",
12776             format("void SomeFunction(int parameter= 0) {\n"
12777                    " int const  i= 1;\n"
12778                    "  int *j=2;\n"
12779                    " int big  =  10000;\n"
12780                    "\n"
12781                    "unsigned oneTwoThree  =123;\n"
12782                    "int oneTwo = 12;\n"
12783                    "  method();\n"
12784                    "float k= 2;\n"
12785                    "int ll=10000;\n"
12786                    "}",
12787                    Alignment));
12788   Alignment.AlignConsecutiveAssignments = false;
12789   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12790   verifyFormat("#define A \\\n"
12791                "  int       aaaa = 12; \\\n"
12792                "  float     b = 23; \\\n"
12793                "  const int ccc = 234; \\\n"
12794                "  unsigned  dddddddddd = 2345;",
12795                Alignment);
12796   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12797   verifyFormat("#define A              \\\n"
12798                "  int       aaaa = 12; \\\n"
12799                "  float     b = 23;    \\\n"
12800                "  const int ccc = 234; \\\n"
12801                "  unsigned  dddddddddd = 2345;",
12802                Alignment);
12803   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12804   Alignment.ColumnLimit = 30;
12805   verifyFormat("#define A                    \\\n"
12806                "  int       aaaa = 12;       \\\n"
12807                "  float     b = 23;          \\\n"
12808                "  const int ccc = 234;       \\\n"
12809                "  int       dddddddddd = 2345;",
12810                Alignment);
12811   Alignment.ColumnLimit = 80;
12812   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12813                "k = 4, int l = 5,\n"
12814                "                  int m = 6) {\n"
12815                "  const int j = 10;\n"
12816                "  otherThing = 1;\n"
12817                "}",
12818                Alignment);
12819   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12820                "  int const i = 1;\n"
12821                "  int *     j = 2;\n"
12822                "  int       big = 10000;\n"
12823                "}",
12824                Alignment);
12825   verifyFormat("class C {\n"
12826                "public:\n"
12827                "  int          i = 1;\n"
12828                "  virtual void f() = 0;\n"
12829                "};",
12830                Alignment);
12831   verifyFormat("float i = 1;\n"
12832                "if (SomeType t = getSomething()) {\n"
12833                "}\n"
12834                "const unsigned j = 2;\n"
12835                "int            big = 10000;",
12836                Alignment);
12837   verifyFormat("float j = 7;\n"
12838                "for (int k = 0; k < N; ++k) {\n"
12839                "}\n"
12840                "unsigned j = 2;\n"
12841                "int      big = 10000;\n"
12842                "}",
12843                Alignment);
12844   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12845   verifyFormat("float              i = 1;\n"
12846                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12847                "    = someLooooooooooooooooongFunction();\n"
12848                "int j = 2;",
12849                Alignment);
12850   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12851   verifyFormat("int                i = 1;\n"
12852                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12853                "    someLooooooooooooooooongFunction();\n"
12854                "int j = 2;",
12855                Alignment);
12856 
12857   Alignment.AlignConsecutiveAssignments = true;
12858   verifyFormat("auto lambda = []() {\n"
12859                "  auto  ii = 0;\n"
12860                "  float j  = 0;\n"
12861                "  return 0;\n"
12862                "};\n"
12863                "int   i  = 0;\n"
12864                "float i2 = 0;\n"
12865                "auto  v  = type{\n"
12866                "    i = 1,   //\n"
12867                "    (i = 2), //\n"
12868                "    i = 3    //\n"
12869                "};",
12870                Alignment);
12871   Alignment.AlignConsecutiveAssignments = false;
12872 
12873   verifyFormat(
12874       "int      i = 1;\n"
12875       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12876       "                          loooooooooooooooooooooongParameterB);\n"
12877       "int      j = 2;",
12878       Alignment);
12879 
12880   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12881   // We expect declarations and assignments to align, as long as it doesn't
12882   // exceed the column limit, starting a new alignment sequence whenever it
12883   // happens.
12884   Alignment.AlignConsecutiveAssignments = true;
12885   Alignment.ColumnLimit = 30;
12886   verifyFormat("float    ii              = 1;\n"
12887                "unsigned j               = 2;\n"
12888                "int someVerylongVariable = 1;\n"
12889                "AnotherLongType  ll = 123456;\n"
12890                "VeryVeryLongType k  = 2;\n"
12891                "int              myvar = 1;",
12892                Alignment);
12893   Alignment.ColumnLimit = 80;
12894   Alignment.AlignConsecutiveAssignments = false;
12895 
12896   verifyFormat(
12897       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12898       "          typename LongType, typename B>\n"
12899       "auto foo() {}\n",
12900       Alignment);
12901   verifyFormat("float a, b = 1;\n"
12902                "int   c = 2;\n"
12903                "int   dd = 3;\n",
12904                Alignment);
12905   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12906                "float b[1][] = {{3.f}};\n",
12907                Alignment);
12908   Alignment.AlignConsecutiveAssignments = true;
12909   verifyFormat("float a, b = 1;\n"
12910                "int   c  = 2;\n"
12911                "int   dd = 3;\n",
12912                Alignment);
12913   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12914                "float b[1][] = {{3.f}};\n",
12915                Alignment);
12916   Alignment.AlignConsecutiveAssignments = false;
12917 
12918   Alignment.ColumnLimit = 30;
12919   Alignment.BinPackParameters = false;
12920   verifyFormat("void foo(float     a,\n"
12921                "         float     b,\n"
12922                "         int       c,\n"
12923                "         uint32_t *d) {\n"
12924                "  int *  e = 0;\n"
12925                "  float  f = 0;\n"
12926                "  double g = 0;\n"
12927                "}\n"
12928                "void bar(ino_t     a,\n"
12929                "         int       b,\n"
12930                "         uint32_t *c,\n"
12931                "         bool      d) {}\n",
12932                Alignment);
12933   Alignment.BinPackParameters = true;
12934   Alignment.ColumnLimit = 80;
12935 
12936   // Bug 33507
12937   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12938   verifyFormat(
12939       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12940       "  static const Version verVs2017;\n"
12941       "  return true;\n"
12942       "});\n",
12943       Alignment);
12944   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12945 
12946   // See llvm.org/PR35641
12947   Alignment.AlignConsecutiveDeclarations = true;
12948   verifyFormat("int func() { //\n"
12949                "  int      b;\n"
12950                "  unsigned c;\n"
12951                "}",
12952                Alignment);
12953 
12954   // See PR37175
12955   FormatStyle Style = getMozillaStyle();
12956   Style.AlignConsecutiveDeclarations = true;
12957   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12958             "foo(int a);",
12959             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12960 }
12961 
12962 TEST_F(FormatTest, LinuxBraceBreaking) {
12963   FormatStyle LinuxBraceStyle = getLLVMStyle();
12964   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12965   verifyFormat("namespace a\n"
12966                "{\n"
12967                "class A\n"
12968                "{\n"
12969                "  void f()\n"
12970                "  {\n"
12971                "    if (true) {\n"
12972                "      a();\n"
12973                "      b();\n"
12974                "    } else {\n"
12975                "      a();\n"
12976                "    }\n"
12977                "  }\n"
12978                "  void g() { return; }\n"
12979                "};\n"
12980                "struct B {\n"
12981                "  int x;\n"
12982                "};\n"
12983                "} // namespace a\n",
12984                LinuxBraceStyle);
12985   verifyFormat("enum X {\n"
12986                "  Y = 0,\n"
12987                "}\n",
12988                LinuxBraceStyle);
12989   verifyFormat("struct S {\n"
12990                "  int Type;\n"
12991                "  union {\n"
12992                "    int x;\n"
12993                "    double y;\n"
12994                "  } Value;\n"
12995                "  class C\n"
12996                "  {\n"
12997                "    MyFavoriteType Value;\n"
12998                "  } Class;\n"
12999                "}\n",
13000                LinuxBraceStyle);
13001 }
13002 
13003 TEST_F(FormatTest, MozillaBraceBreaking) {
13004   FormatStyle MozillaBraceStyle = getLLVMStyle();
13005   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
13006   MozillaBraceStyle.FixNamespaceComments = false;
13007   verifyFormat("namespace a {\n"
13008                "class A\n"
13009                "{\n"
13010                "  void f()\n"
13011                "  {\n"
13012                "    if (true) {\n"
13013                "      a();\n"
13014                "      b();\n"
13015                "    }\n"
13016                "  }\n"
13017                "  void g() { return; }\n"
13018                "};\n"
13019                "enum E\n"
13020                "{\n"
13021                "  A,\n"
13022                "  // foo\n"
13023                "  B,\n"
13024                "  C\n"
13025                "};\n"
13026                "struct B\n"
13027                "{\n"
13028                "  int x;\n"
13029                "};\n"
13030                "}\n",
13031                MozillaBraceStyle);
13032   verifyFormat("struct S\n"
13033                "{\n"
13034                "  int Type;\n"
13035                "  union\n"
13036                "  {\n"
13037                "    int x;\n"
13038                "    double y;\n"
13039                "  } Value;\n"
13040                "  class C\n"
13041                "  {\n"
13042                "    MyFavoriteType Value;\n"
13043                "  } Class;\n"
13044                "}\n",
13045                MozillaBraceStyle);
13046 }
13047 
13048 TEST_F(FormatTest, StroustrupBraceBreaking) {
13049   FormatStyle StroustrupBraceStyle = getLLVMStyle();
13050   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
13051   verifyFormat("namespace a {\n"
13052                "class A {\n"
13053                "  void f()\n"
13054                "  {\n"
13055                "    if (true) {\n"
13056                "      a();\n"
13057                "      b();\n"
13058                "    }\n"
13059                "  }\n"
13060                "  void g() { return; }\n"
13061                "};\n"
13062                "struct B {\n"
13063                "  int x;\n"
13064                "};\n"
13065                "} // namespace a\n",
13066                StroustrupBraceStyle);
13067 
13068   verifyFormat("void foo()\n"
13069                "{\n"
13070                "  if (a) {\n"
13071                "    a();\n"
13072                "  }\n"
13073                "  else {\n"
13074                "    b();\n"
13075                "  }\n"
13076                "}\n",
13077                StroustrupBraceStyle);
13078 
13079   verifyFormat("#ifdef _DEBUG\n"
13080                "int foo(int i = 0)\n"
13081                "#else\n"
13082                "int foo(int i = 5)\n"
13083                "#endif\n"
13084                "{\n"
13085                "  return i;\n"
13086                "}",
13087                StroustrupBraceStyle);
13088 
13089   verifyFormat("void foo() {}\n"
13090                "void bar()\n"
13091                "#ifdef _DEBUG\n"
13092                "{\n"
13093                "  foo();\n"
13094                "}\n"
13095                "#else\n"
13096                "{\n"
13097                "}\n"
13098                "#endif",
13099                StroustrupBraceStyle);
13100 
13101   verifyFormat("void foobar() { int i = 5; }\n"
13102                "#ifdef _DEBUG\n"
13103                "void bar() {}\n"
13104                "#else\n"
13105                "void bar() { foobar(); }\n"
13106                "#endif",
13107                StroustrupBraceStyle);
13108 }
13109 
13110 TEST_F(FormatTest, AllmanBraceBreaking) {
13111   FormatStyle AllmanBraceStyle = getLLVMStyle();
13112   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
13113 
13114   EXPECT_EQ("namespace a\n"
13115             "{\n"
13116             "void f();\n"
13117             "void g();\n"
13118             "} // namespace a\n",
13119             format("namespace a\n"
13120                    "{\n"
13121                    "void f();\n"
13122                    "void g();\n"
13123                    "}\n",
13124                    AllmanBraceStyle));
13125 
13126   verifyFormat("namespace a\n"
13127                "{\n"
13128                "class A\n"
13129                "{\n"
13130                "  void f()\n"
13131                "  {\n"
13132                "    if (true)\n"
13133                "    {\n"
13134                "      a();\n"
13135                "      b();\n"
13136                "    }\n"
13137                "  }\n"
13138                "  void g() { return; }\n"
13139                "};\n"
13140                "struct B\n"
13141                "{\n"
13142                "  int x;\n"
13143                "};\n"
13144                "union C\n"
13145                "{\n"
13146                "};\n"
13147                "} // namespace a",
13148                AllmanBraceStyle);
13149 
13150   verifyFormat("void f()\n"
13151                "{\n"
13152                "  if (true)\n"
13153                "  {\n"
13154                "    a();\n"
13155                "  }\n"
13156                "  else if (false)\n"
13157                "  {\n"
13158                "    b();\n"
13159                "  }\n"
13160                "  else\n"
13161                "  {\n"
13162                "    c();\n"
13163                "  }\n"
13164                "}\n",
13165                AllmanBraceStyle);
13166 
13167   verifyFormat("void f()\n"
13168                "{\n"
13169                "  for (int i = 0; i < 10; ++i)\n"
13170                "  {\n"
13171                "    a();\n"
13172                "  }\n"
13173                "  while (false)\n"
13174                "  {\n"
13175                "    b();\n"
13176                "  }\n"
13177                "  do\n"
13178                "  {\n"
13179                "    c();\n"
13180                "  } while (false)\n"
13181                "}\n",
13182                AllmanBraceStyle);
13183 
13184   verifyFormat("void f(int a)\n"
13185                "{\n"
13186                "  switch (a)\n"
13187                "  {\n"
13188                "  case 0:\n"
13189                "    break;\n"
13190                "  case 1:\n"
13191                "  {\n"
13192                "    break;\n"
13193                "  }\n"
13194                "  case 2:\n"
13195                "  {\n"
13196                "  }\n"
13197                "  break;\n"
13198                "  default:\n"
13199                "    break;\n"
13200                "  }\n"
13201                "}\n",
13202                AllmanBraceStyle);
13203 
13204   verifyFormat("enum X\n"
13205                "{\n"
13206                "  Y = 0,\n"
13207                "}\n",
13208                AllmanBraceStyle);
13209   verifyFormat("enum X\n"
13210                "{\n"
13211                "  Y = 0\n"
13212                "}\n",
13213                AllmanBraceStyle);
13214 
13215   verifyFormat("@interface BSApplicationController ()\n"
13216                "{\n"
13217                "@private\n"
13218                "  id _extraIvar;\n"
13219                "}\n"
13220                "@end\n",
13221                AllmanBraceStyle);
13222 
13223   verifyFormat("#ifdef _DEBUG\n"
13224                "int foo(int i = 0)\n"
13225                "#else\n"
13226                "int foo(int i = 5)\n"
13227                "#endif\n"
13228                "{\n"
13229                "  return i;\n"
13230                "}",
13231                AllmanBraceStyle);
13232 
13233   verifyFormat("void foo() {}\n"
13234                "void bar()\n"
13235                "#ifdef _DEBUG\n"
13236                "{\n"
13237                "  foo();\n"
13238                "}\n"
13239                "#else\n"
13240                "{\n"
13241                "}\n"
13242                "#endif",
13243                AllmanBraceStyle);
13244 
13245   verifyFormat("void foobar() { int i = 5; }\n"
13246                "#ifdef _DEBUG\n"
13247                "void bar() {}\n"
13248                "#else\n"
13249                "void bar() { foobar(); }\n"
13250                "#endif",
13251                AllmanBraceStyle);
13252 
13253   // This shouldn't affect ObjC blocks..
13254   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13255                "  // ...\n"
13256                "  int i;\n"
13257                "}];",
13258                AllmanBraceStyle);
13259   verifyFormat("void (^block)(void) = ^{\n"
13260                "  // ...\n"
13261                "  int i;\n"
13262                "};",
13263                AllmanBraceStyle);
13264   // .. or dict literals.
13265   verifyFormat("void f()\n"
13266                "{\n"
13267                "  // ...\n"
13268                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13269                "}",
13270                AllmanBraceStyle);
13271   verifyFormat("void f()\n"
13272                "{\n"
13273                "  // ...\n"
13274                "  [object someMethod:@{a : @\"b\"}];\n"
13275                "}",
13276                AllmanBraceStyle);
13277   verifyFormat("int f()\n"
13278                "{ // comment\n"
13279                "  return 42;\n"
13280                "}",
13281                AllmanBraceStyle);
13282 
13283   AllmanBraceStyle.ColumnLimit = 19;
13284   verifyFormat("void f() { int i; }", AllmanBraceStyle);
13285   AllmanBraceStyle.ColumnLimit = 18;
13286   verifyFormat("void f()\n"
13287                "{\n"
13288                "  int i;\n"
13289                "}",
13290                AllmanBraceStyle);
13291   AllmanBraceStyle.ColumnLimit = 80;
13292 
13293   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
13294   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13295       FormatStyle::SIS_WithoutElse;
13296   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13297   verifyFormat("void f(bool b)\n"
13298                "{\n"
13299                "  if (b)\n"
13300                "  {\n"
13301                "    return;\n"
13302                "  }\n"
13303                "}\n",
13304                BreakBeforeBraceShortIfs);
13305   verifyFormat("void f(bool b)\n"
13306                "{\n"
13307                "  if constexpr (b)\n"
13308                "  {\n"
13309                "    return;\n"
13310                "  }\n"
13311                "}\n",
13312                BreakBeforeBraceShortIfs);
13313   verifyFormat("void f(bool b)\n"
13314                "{\n"
13315                "  if CONSTEXPR (b)\n"
13316                "  {\n"
13317                "    return;\n"
13318                "  }\n"
13319                "}\n",
13320                BreakBeforeBraceShortIfs);
13321   verifyFormat("void f(bool b)\n"
13322                "{\n"
13323                "  if (b) return;\n"
13324                "}\n",
13325                BreakBeforeBraceShortIfs);
13326   verifyFormat("void f(bool b)\n"
13327                "{\n"
13328                "  if constexpr (b) return;\n"
13329                "}\n",
13330                BreakBeforeBraceShortIfs);
13331   verifyFormat("void f(bool b)\n"
13332                "{\n"
13333                "  if CONSTEXPR (b) return;\n"
13334                "}\n",
13335                BreakBeforeBraceShortIfs);
13336   verifyFormat("void f(bool b)\n"
13337                "{\n"
13338                "  while (b)\n"
13339                "  {\n"
13340                "    return;\n"
13341                "  }\n"
13342                "}\n",
13343                BreakBeforeBraceShortIfs);
13344 }
13345 
13346 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
13347   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
13348   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
13349 
13350   // Make a few changes to the style for testing purposes
13351   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
13352       FormatStyle::SFS_Empty;
13353   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
13354   WhitesmithsBraceStyle.ColumnLimit = 0;
13355 
13356   // FIXME: this test case can't decide whether there should be a blank line
13357   // after the ~D() line or not. It adds one if one doesn't exist in the test
13358   // and it removes the line if one exists.
13359   /*
13360   verifyFormat("class A;\n"
13361                "namespace B\n"
13362                "  {\n"
13363                "class C;\n"
13364                "// Comment\n"
13365                "class D\n"
13366                "  {\n"
13367                "public:\n"
13368                "  D();\n"
13369                "  ~D() {}\n"
13370                "private:\n"
13371                "  enum E\n"
13372                "    {\n"
13373                "    F\n"
13374                "    }\n"
13375                "  };\n"
13376                "  } // namespace B\n",
13377                WhitesmithsBraceStyle);
13378   */
13379 
13380   verifyFormat("namespace a\n"
13381                "  {\n"
13382                "class A\n"
13383                "  {\n"
13384                "  void f()\n"
13385                "    {\n"
13386                "    if (true)\n"
13387                "      {\n"
13388                "      a();\n"
13389                "      b();\n"
13390                "      }\n"
13391                "    }\n"
13392                "  void g()\n"
13393                "    {\n"
13394                "    return;\n"
13395                "    }\n"
13396                "  };\n"
13397                "struct B\n"
13398                "  {\n"
13399                "  int x;\n"
13400                "  };\n"
13401                "  } // namespace a",
13402                WhitesmithsBraceStyle);
13403 
13404   verifyFormat("void f()\n"
13405                "  {\n"
13406                "  if (true)\n"
13407                "    {\n"
13408                "    a();\n"
13409                "    }\n"
13410                "  else if (false)\n"
13411                "    {\n"
13412                "    b();\n"
13413                "    }\n"
13414                "  else\n"
13415                "    {\n"
13416                "    c();\n"
13417                "    }\n"
13418                "  }\n",
13419                WhitesmithsBraceStyle);
13420 
13421   verifyFormat("void f()\n"
13422                "  {\n"
13423                "  for (int i = 0; i < 10; ++i)\n"
13424                "    {\n"
13425                "    a();\n"
13426                "    }\n"
13427                "  while (false)\n"
13428                "    {\n"
13429                "    b();\n"
13430                "    }\n"
13431                "  do\n"
13432                "    {\n"
13433                "    c();\n"
13434                "    } while (false)\n"
13435                "  }\n",
13436                WhitesmithsBraceStyle);
13437 
13438   WhitesmithsBraceStyle.IndentCaseBlocks = true;
13439   verifyFormat("void switchTest1(int a)\n"
13440                "  {\n"
13441                "  switch (a)\n"
13442                "    {\n"
13443                "    case 2:\n"
13444                "      {\n"
13445                "      }\n"
13446                "    break;\n"
13447                "    }\n"
13448                "  }\n",
13449                WhitesmithsBraceStyle);
13450 
13451   verifyFormat("void switchTest2(int a)\n"
13452                "  {\n"
13453                "  switch (a)\n"
13454                "    {\n"
13455                "    case 0:\n"
13456                "    break;\n"
13457                "    case 1:\n"
13458                "      {\n"
13459                "      break;\n"
13460                "      }\n"
13461                "    case 2:\n"
13462                "      {\n"
13463                "      }\n"
13464                "    break;\n"
13465                "    default:\n"
13466                "    break;\n"
13467                "    }\n"
13468                "  }\n",
13469                WhitesmithsBraceStyle);
13470 
13471   verifyFormat("void switchTest3(int a)\n"
13472                "  {\n"
13473                "  switch (a)\n"
13474                "    {\n"
13475                "    case 0:\n"
13476                "      {\n"
13477                "      foo(x);\n"
13478                "      }\n"
13479                "    break;\n"
13480                "    default:\n"
13481                "      {\n"
13482                "      foo(1);\n"
13483                "      }\n"
13484                "    break;\n"
13485                "    }\n"
13486                "  }\n",
13487                WhitesmithsBraceStyle);
13488 
13489   WhitesmithsBraceStyle.IndentCaseBlocks = false;
13490 
13491   verifyFormat("void switchTest4(int a)\n"
13492                "  {\n"
13493                "  switch (a)\n"
13494                "    {\n"
13495                "    case 2:\n"
13496                "    {\n"
13497                "    }\n"
13498                "    break;\n"
13499                "    }\n"
13500                "  }\n",
13501                WhitesmithsBraceStyle);
13502 
13503   verifyFormat("void switchTest5(int a)\n"
13504                "  {\n"
13505                "  switch (a)\n"
13506                "    {\n"
13507                "    case 0:\n"
13508                "    break;\n"
13509                "    case 1:\n"
13510                "    {\n"
13511                "    foo();\n"
13512                "    break;\n"
13513                "    }\n"
13514                "    case 2:\n"
13515                "    {\n"
13516                "    }\n"
13517                "    break;\n"
13518                "    default:\n"
13519                "    break;\n"
13520                "    }\n"
13521                "  }\n",
13522                WhitesmithsBraceStyle);
13523 
13524   verifyFormat("void switchTest6(int a)\n"
13525                "  {\n"
13526                "  switch (a)\n"
13527                "    {\n"
13528                "    case 0:\n"
13529                "    {\n"
13530                "    foo(x);\n"
13531                "    }\n"
13532                "    break;\n"
13533                "    default:\n"
13534                "    {\n"
13535                "    foo(1);\n"
13536                "    }\n"
13537                "    break;\n"
13538                "    }\n"
13539                "  }\n",
13540                WhitesmithsBraceStyle);
13541 
13542   verifyFormat("enum X\n"
13543                "  {\n"
13544                "  Y = 0, // testing\n"
13545                "  }\n",
13546                WhitesmithsBraceStyle);
13547 
13548   verifyFormat("enum X\n"
13549                "  {\n"
13550                "  Y = 0\n"
13551                "  }\n",
13552                WhitesmithsBraceStyle);
13553   verifyFormat("enum X\n"
13554                "  {\n"
13555                "  Y = 0,\n"
13556                "  Z = 1\n"
13557                "  };\n",
13558                WhitesmithsBraceStyle);
13559 
13560   verifyFormat("@interface BSApplicationController ()\n"
13561                "  {\n"
13562                "@private\n"
13563                "  id _extraIvar;\n"
13564                "  }\n"
13565                "@end\n",
13566                WhitesmithsBraceStyle);
13567 
13568   verifyFormat("#ifdef _DEBUG\n"
13569                "int foo(int i = 0)\n"
13570                "#else\n"
13571                "int foo(int i = 5)\n"
13572                "#endif\n"
13573                "  {\n"
13574                "  return i;\n"
13575                "  }",
13576                WhitesmithsBraceStyle);
13577 
13578   verifyFormat("void foo() {}\n"
13579                "void bar()\n"
13580                "#ifdef _DEBUG\n"
13581                "  {\n"
13582                "  foo();\n"
13583                "  }\n"
13584                "#else\n"
13585                "  {\n"
13586                "  }\n"
13587                "#endif",
13588                WhitesmithsBraceStyle);
13589 
13590   verifyFormat("void foobar()\n"
13591                "  {\n"
13592                "  int i = 5;\n"
13593                "  }\n"
13594                "#ifdef _DEBUG\n"
13595                "void bar()\n"
13596                "  {\n"
13597                "  }\n"
13598                "#else\n"
13599                "void bar()\n"
13600                "  {\n"
13601                "  foobar();\n"
13602                "  }\n"
13603                "#endif",
13604                WhitesmithsBraceStyle);
13605 
13606   // This shouldn't affect ObjC blocks..
13607   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13608                "  // ...\n"
13609                "  int i;\n"
13610                "}];",
13611                WhitesmithsBraceStyle);
13612   verifyFormat("void (^block)(void) = ^{\n"
13613                "  // ...\n"
13614                "  int i;\n"
13615                "};",
13616                WhitesmithsBraceStyle);
13617   // .. or dict literals.
13618   verifyFormat("void f()\n"
13619                "  {\n"
13620                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13621                "  }",
13622                WhitesmithsBraceStyle);
13623 
13624   verifyFormat("int f()\n"
13625                "  { // comment\n"
13626                "  return 42;\n"
13627                "  }",
13628                WhitesmithsBraceStyle);
13629 
13630   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13631   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13632       FormatStyle::SIS_Always;
13633   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13634   verifyFormat("void f(bool b)\n"
13635                "  {\n"
13636                "  if (b)\n"
13637                "    {\n"
13638                "    return;\n"
13639                "    }\n"
13640                "  }\n",
13641                BreakBeforeBraceShortIfs);
13642   verifyFormat("void f(bool b)\n"
13643                "  {\n"
13644                "  if (b) return;\n"
13645                "  }\n",
13646                BreakBeforeBraceShortIfs);
13647   verifyFormat("void f(bool b)\n"
13648                "  {\n"
13649                "  while (b)\n"
13650                "    {\n"
13651                "    return;\n"
13652                "    }\n"
13653                "  }\n",
13654                BreakBeforeBraceShortIfs);
13655 }
13656 
13657 TEST_F(FormatTest, GNUBraceBreaking) {
13658   FormatStyle GNUBraceStyle = getLLVMStyle();
13659   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13660   verifyFormat("namespace a\n"
13661                "{\n"
13662                "class A\n"
13663                "{\n"
13664                "  void f()\n"
13665                "  {\n"
13666                "    int a;\n"
13667                "    {\n"
13668                "      int b;\n"
13669                "    }\n"
13670                "    if (true)\n"
13671                "      {\n"
13672                "        a();\n"
13673                "        b();\n"
13674                "      }\n"
13675                "  }\n"
13676                "  void g() { return; }\n"
13677                "}\n"
13678                "} // namespace a",
13679                GNUBraceStyle);
13680 
13681   verifyFormat("void f()\n"
13682                "{\n"
13683                "  if (true)\n"
13684                "    {\n"
13685                "      a();\n"
13686                "    }\n"
13687                "  else if (false)\n"
13688                "    {\n"
13689                "      b();\n"
13690                "    }\n"
13691                "  else\n"
13692                "    {\n"
13693                "      c();\n"
13694                "    }\n"
13695                "}\n",
13696                GNUBraceStyle);
13697 
13698   verifyFormat("void f()\n"
13699                "{\n"
13700                "  for (int i = 0; i < 10; ++i)\n"
13701                "    {\n"
13702                "      a();\n"
13703                "    }\n"
13704                "  while (false)\n"
13705                "    {\n"
13706                "      b();\n"
13707                "    }\n"
13708                "  do\n"
13709                "    {\n"
13710                "      c();\n"
13711                "    }\n"
13712                "  while (false);\n"
13713                "}\n",
13714                GNUBraceStyle);
13715 
13716   verifyFormat("void f(int a)\n"
13717                "{\n"
13718                "  switch (a)\n"
13719                "    {\n"
13720                "    case 0:\n"
13721                "      break;\n"
13722                "    case 1:\n"
13723                "      {\n"
13724                "        break;\n"
13725                "      }\n"
13726                "    case 2:\n"
13727                "      {\n"
13728                "      }\n"
13729                "      break;\n"
13730                "    default:\n"
13731                "      break;\n"
13732                "    }\n"
13733                "}\n",
13734                GNUBraceStyle);
13735 
13736   verifyFormat("enum X\n"
13737                "{\n"
13738                "  Y = 0,\n"
13739                "}\n",
13740                GNUBraceStyle);
13741 
13742   verifyFormat("@interface BSApplicationController ()\n"
13743                "{\n"
13744                "@private\n"
13745                "  id _extraIvar;\n"
13746                "}\n"
13747                "@end\n",
13748                GNUBraceStyle);
13749 
13750   verifyFormat("#ifdef _DEBUG\n"
13751                "int foo(int i = 0)\n"
13752                "#else\n"
13753                "int foo(int i = 5)\n"
13754                "#endif\n"
13755                "{\n"
13756                "  return i;\n"
13757                "}",
13758                GNUBraceStyle);
13759 
13760   verifyFormat("void foo() {}\n"
13761                "void bar()\n"
13762                "#ifdef _DEBUG\n"
13763                "{\n"
13764                "  foo();\n"
13765                "}\n"
13766                "#else\n"
13767                "{\n"
13768                "}\n"
13769                "#endif",
13770                GNUBraceStyle);
13771 
13772   verifyFormat("void foobar() { int i = 5; }\n"
13773                "#ifdef _DEBUG\n"
13774                "void bar() {}\n"
13775                "#else\n"
13776                "void bar() { foobar(); }\n"
13777                "#endif",
13778                GNUBraceStyle);
13779 }
13780 
13781 TEST_F(FormatTest, WebKitBraceBreaking) {
13782   FormatStyle WebKitBraceStyle = getLLVMStyle();
13783   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13784   WebKitBraceStyle.FixNamespaceComments = false;
13785   verifyFormat("namespace a {\n"
13786                "class A {\n"
13787                "  void f()\n"
13788                "  {\n"
13789                "    if (true) {\n"
13790                "      a();\n"
13791                "      b();\n"
13792                "    }\n"
13793                "  }\n"
13794                "  void g() { return; }\n"
13795                "};\n"
13796                "enum E {\n"
13797                "  A,\n"
13798                "  // foo\n"
13799                "  B,\n"
13800                "  C\n"
13801                "};\n"
13802                "struct B {\n"
13803                "  int x;\n"
13804                "};\n"
13805                "}\n",
13806                WebKitBraceStyle);
13807   verifyFormat("struct S {\n"
13808                "  int Type;\n"
13809                "  union {\n"
13810                "    int x;\n"
13811                "    double y;\n"
13812                "  } Value;\n"
13813                "  class C {\n"
13814                "    MyFavoriteType Value;\n"
13815                "  } Class;\n"
13816                "};\n",
13817                WebKitBraceStyle);
13818 }
13819 
13820 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13821   verifyFormat("void f() {\n"
13822                "  try {\n"
13823                "  } catch (const Exception &e) {\n"
13824                "  }\n"
13825                "}\n",
13826                getLLVMStyle());
13827 }
13828 
13829 TEST_F(FormatTest, UnderstandsPragmas) {
13830   verifyFormat("#pragma omp reduction(| : var)");
13831   verifyFormat("#pragma omp reduction(+ : var)");
13832 
13833   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13834             "(including parentheses).",
13835             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13836                    "(including parentheses)."));
13837 }
13838 
13839 TEST_F(FormatTest, UnderstandPragmaOption) {
13840   verifyFormat("#pragma option -C -A");
13841 
13842   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13843 }
13844 
13845 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13846   FormatStyle Style = getLLVMStyle();
13847   Style.ColumnLimit = 20;
13848 
13849   // See PR41213
13850   EXPECT_EQ("/*\n"
13851             " *\t9012345\n"
13852             " * /8901\n"
13853             " */",
13854             format("/*\n"
13855                    " *\t9012345 /8901\n"
13856                    " */",
13857                    Style));
13858   EXPECT_EQ("/*\n"
13859             " *345678\n"
13860             " *\t/8901\n"
13861             " */",
13862             format("/*\n"
13863                    " *345678\t/8901\n"
13864                    " */",
13865                    Style));
13866 
13867   verifyFormat("int a; // the\n"
13868                "       // comment",
13869                Style);
13870   EXPECT_EQ("int a; /* first line\n"
13871             "        * second\n"
13872             "        * line third\n"
13873             "        * line\n"
13874             "        */",
13875             format("int a; /* first line\n"
13876                    "        * second\n"
13877                    "        * line third\n"
13878                    "        * line\n"
13879                    "        */",
13880                    Style));
13881   EXPECT_EQ("int a; // first line\n"
13882             "       // second\n"
13883             "       // line third\n"
13884             "       // line",
13885             format("int a; // first line\n"
13886                    "       // second line\n"
13887                    "       // third line",
13888                    Style));
13889 
13890   Style.PenaltyExcessCharacter = 90;
13891   verifyFormat("int a; // the comment", Style);
13892   EXPECT_EQ("int a; // the comment\n"
13893             "       // aaa",
13894             format("int a; // the comment aaa", Style));
13895   EXPECT_EQ("int a; /* first line\n"
13896             "        * second line\n"
13897             "        * third line\n"
13898             "        */",
13899             format("int a; /* first line\n"
13900                    "        * second line\n"
13901                    "        * third line\n"
13902                    "        */",
13903                    Style));
13904   EXPECT_EQ("int a; // first line\n"
13905             "       // second line\n"
13906             "       // third line",
13907             format("int a; // first line\n"
13908                    "       // second line\n"
13909                    "       // third line",
13910                    Style));
13911   // FIXME: Investigate why this is not getting the same layout as the test
13912   // above.
13913   EXPECT_EQ("int a; /* first line\n"
13914             "        * second line\n"
13915             "        * third line\n"
13916             "        */",
13917             format("int a; /* first line second line third line"
13918                    "\n*/",
13919                    Style));
13920 
13921   EXPECT_EQ("// foo bar baz bazfoo\n"
13922             "// foo bar foo bar\n",
13923             format("// foo bar baz bazfoo\n"
13924                    "// foo bar foo           bar\n",
13925                    Style));
13926   EXPECT_EQ("// foo bar baz bazfoo\n"
13927             "// foo bar foo bar\n",
13928             format("// foo bar baz      bazfoo\n"
13929                    "// foo            bar foo bar\n",
13930                    Style));
13931 
13932   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13933   // next one.
13934   EXPECT_EQ("// foo bar baz bazfoo\n"
13935             "// bar foo bar\n",
13936             format("// foo bar baz      bazfoo bar\n"
13937                    "// foo            bar\n",
13938                    Style));
13939 
13940   EXPECT_EQ("// foo bar baz bazfoo\n"
13941             "// foo bar baz bazfoo\n"
13942             "// bar foo bar\n",
13943             format("// foo bar baz      bazfoo\n"
13944                    "// foo bar baz      bazfoo bar\n"
13945                    "// foo bar\n",
13946                    Style));
13947 
13948   EXPECT_EQ("// foo bar baz bazfoo\n"
13949             "// foo bar baz bazfoo\n"
13950             "// bar foo bar\n",
13951             format("// foo bar baz      bazfoo\n"
13952                    "// foo bar baz      bazfoo bar\n"
13953                    "// foo           bar\n",
13954                    Style));
13955 
13956   // Make sure we do not keep protruding characters if strict mode reflow is
13957   // cheaper than keeping protruding characters.
13958   Style.ColumnLimit = 21;
13959   EXPECT_EQ(
13960       "// foo foo foo foo\n"
13961       "// foo foo foo foo\n"
13962       "// foo foo foo foo\n",
13963       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13964 
13965   EXPECT_EQ("int a = /* long block\n"
13966             "           comment */\n"
13967             "    42;",
13968             format("int a = /* long block comment */ 42;", Style));
13969 }
13970 
13971 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13972   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13973   EXPECT_EQ(Styles[0], Styles[i])                                              \
13974       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13975 
13976 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13977   SmallVector<FormatStyle, 3> Styles;
13978   Styles.resize(3);
13979 
13980   Styles[0] = getLLVMStyle();
13981   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13982   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13983   EXPECT_ALL_STYLES_EQUAL(Styles);
13984 
13985   Styles[0] = getGoogleStyle();
13986   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13987   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13988   EXPECT_ALL_STYLES_EQUAL(Styles);
13989 
13990   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13991   EXPECT_TRUE(
13992       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13993   EXPECT_TRUE(
13994       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13995   EXPECT_ALL_STYLES_EQUAL(Styles);
13996 
13997   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13998   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13999   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
14000   EXPECT_ALL_STYLES_EQUAL(Styles);
14001 
14002   Styles[0] = getMozillaStyle();
14003   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
14004   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
14005   EXPECT_ALL_STYLES_EQUAL(Styles);
14006 
14007   Styles[0] = getWebKitStyle();
14008   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
14009   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
14010   EXPECT_ALL_STYLES_EQUAL(Styles);
14011 
14012   Styles[0] = getGNUStyle();
14013   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
14014   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
14015   EXPECT_ALL_STYLES_EQUAL(Styles);
14016 
14017   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
14018 }
14019 
14020 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
14021   SmallVector<FormatStyle, 8> Styles;
14022   Styles.resize(2);
14023 
14024   Styles[0] = getGoogleStyle();
14025   Styles[1] = getLLVMStyle();
14026   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
14027   EXPECT_ALL_STYLES_EQUAL(Styles);
14028 
14029   Styles.resize(5);
14030   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
14031   Styles[1] = getLLVMStyle();
14032   Styles[1].Language = FormatStyle::LK_JavaScript;
14033   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
14034 
14035   Styles[2] = getLLVMStyle();
14036   Styles[2].Language = FormatStyle::LK_JavaScript;
14037   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
14038                                   "BasedOnStyle: Google",
14039                                   &Styles[2])
14040                    .value());
14041 
14042   Styles[3] = getLLVMStyle();
14043   Styles[3].Language = FormatStyle::LK_JavaScript;
14044   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
14045                                   "Language: JavaScript",
14046                                   &Styles[3])
14047                    .value());
14048 
14049   Styles[4] = getLLVMStyle();
14050   Styles[4].Language = FormatStyle::LK_JavaScript;
14051   EXPECT_EQ(0, parseConfiguration("---\n"
14052                                   "BasedOnStyle: LLVM\n"
14053                                   "IndentWidth: 123\n"
14054                                   "---\n"
14055                                   "BasedOnStyle: Google\n"
14056                                   "Language: JavaScript",
14057                                   &Styles[4])
14058                    .value());
14059   EXPECT_ALL_STYLES_EQUAL(Styles);
14060 }
14061 
14062 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
14063   Style.FIELD = false;                                                         \
14064   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
14065   EXPECT_TRUE(Style.FIELD);                                                    \
14066   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
14067   EXPECT_FALSE(Style.FIELD);
14068 
14069 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
14070 
14071 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
14072   Style.STRUCT.FIELD = false;                                                  \
14073   EXPECT_EQ(0,                                                                 \
14074             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
14075                 .value());                                                     \
14076   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
14077   EXPECT_EQ(0,                                                                 \
14078             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
14079                 .value());                                                     \
14080   EXPECT_FALSE(Style.STRUCT.FIELD);
14081 
14082 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
14083   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
14084 
14085 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
14086   EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!";          \
14087   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
14088   EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
14089 
14090 TEST_F(FormatTest, ParsesConfigurationBools) {
14091   FormatStyle Style = {};
14092   Style.Language = FormatStyle::LK_Cpp;
14093   CHECK_PARSE_BOOL(AlignTrailingComments);
14094   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
14095   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
14096   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
14097   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
14098   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
14099   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
14100   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
14101   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
14102   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
14103   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
14104   CHECK_PARSE_BOOL(BinPackArguments);
14105   CHECK_PARSE_BOOL(BinPackParameters);
14106   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
14107   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
14108   CHECK_PARSE_BOOL(BreakStringLiterals);
14109   CHECK_PARSE_BOOL(CompactNamespaces);
14110   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
14111   CHECK_PARSE_BOOL(DeriveLineEnding);
14112   CHECK_PARSE_BOOL(DerivePointerAlignment);
14113   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
14114   CHECK_PARSE_BOOL(DisableFormat);
14115   CHECK_PARSE_BOOL(IndentCaseLabels);
14116   CHECK_PARSE_BOOL(IndentCaseBlocks);
14117   CHECK_PARSE_BOOL(IndentGotoLabels);
14118   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
14119   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
14120   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
14121   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
14122   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
14123   CHECK_PARSE_BOOL(ReflowComments);
14124   CHECK_PARSE_BOOL(SortIncludes);
14125   CHECK_PARSE_BOOL(SortUsingDeclarations);
14126   CHECK_PARSE_BOOL(SpacesInParentheses);
14127   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
14128   CHECK_PARSE_BOOL(SpacesInAngles);
14129   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
14130   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
14131   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
14132   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
14133   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
14134   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
14135   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
14136   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
14137   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
14138   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
14139   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
14140   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
14141   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
14142   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
14143   CHECK_PARSE_BOOL(UseCRLF);
14144 
14145   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
14146   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
14147   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
14148   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
14149   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
14150   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
14151   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
14152   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
14153   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
14154   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
14155   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
14156   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
14157   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
14158   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
14159   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
14160   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
14161   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
14162 }
14163 
14164 #undef CHECK_PARSE_BOOL
14165 
14166 TEST_F(FormatTest, ParsesConfiguration) {
14167   FormatStyle Style = {};
14168   Style.Language = FormatStyle::LK_Cpp;
14169   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
14170   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
14171               ConstructorInitializerIndentWidth, 1234u);
14172   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
14173   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
14174   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
14175   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
14176   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
14177               PenaltyBreakBeforeFirstCallParameter, 1234u);
14178   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
14179               PenaltyBreakTemplateDeclaration, 1234u);
14180   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
14181   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
14182               PenaltyReturnTypeOnItsOwnLine, 1234u);
14183   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
14184               SpacesBeforeTrailingComments, 1234u);
14185   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
14186   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
14187   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
14188 
14189   Style.PointerAlignment = FormatStyle::PAS_Middle;
14190   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
14191               FormatStyle::PAS_Left);
14192   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
14193               FormatStyle::PAS_Right);
14194   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
14195               FormatStyle::PAS_Middle);
14196   // For backward compatibility:
14197   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
14198               FormatStyle::PAS_Left);
14199   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
14200               FormatStyle::PAS_Right);
14201   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
14202               FormatStyle::PAS_Middle);
14203 
14204   Style.Standard = FormatStyle::LS_Auto;
14205   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
14206   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
14207   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
14208   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
14209   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
14210   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
14211   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
14212   // Legacy aliases:
14213   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
14214   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
14215   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
14216   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
14217 
14218   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
14219   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
14220               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
14221   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
14222               FormatStyle::BOS_None);
14223   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
14224               FormatStyle::BOS_All);
14225   // For backward compatibility:
14226   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
14227               FormatStyle::BOS_None);
14228   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
14229               FormatStyle::BOS_All);
14230 
14231   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
14232   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
14233               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14234   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
14235               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
14236   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
14237               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
14238   // For backward compatibility:
14239   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
14240               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14241 
14242   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
14243   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
14244               FormatStyle::BILS_BeforeComma);
14245   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
14246               FormatStyle::BILS_AfterColon);
14247   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
14248               FormatStyle::BILS_BeforeColon);
14249   // For backward compatibility:
14250   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
14251               FormatStyle::BILS_BeforeComma);
14252 
14253   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14254   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
14255               FormatStyle::BAS_Align);
14256   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
14257               FormatStyle::BAS_DontAlign);
14258   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
14259               FormatStyle::BAS_AlwaysBreak);
14260   // For backward compatibility:
14261   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
14262               FormatStyle::BAS_DontAlign);
14263   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
14264               FormatStyle::BAS_Align);
14265 
14266   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
14267   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
14268               FormatStyle::ENAS_DontAlign);
14269   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
14270               FormatStyle::ENAS_Left);
14271   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
14272               FormatStyle::ENAS_Right);
14273   // For backward compatibility:
14274   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
14275               FormatStyle::ENAS_Left);
14276   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
14277               FormatStyle::ENAS_Right);
14278 
14279   Style.AlignOperands = FormatStyle::OAS_Align;
14280   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
14281               FormatStyle::OAS_DontAlign);
14282   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
14283   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
14284               FormatStyle::OAS_AlignAfterOperator);
14285   // For backward compatibility:
14286   CHECK_PARSE("AlignOperands: false", AlignOperands,
14287               FormatStyle::OAS_DontAlign);
14288   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
14289 
14290   Style.UseTab = FormatStyle::UT_ForIndentation;
14291   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
14292   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
14293   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
14294   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
14295               FormatStyle::UT_ForContinuationAndIndentation);
14296   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
14297               FormatStyle::UT_AlignWithSpaces);
14298   // For backward compatibility:
14299   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
14300   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
14301 
14302   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
14303   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
14304               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14305   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
14306               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
14307   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
14308               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14309   // For backward compatibility:
14310   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
14311               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14312   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
14313               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14314 
14315   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
14316   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
14317               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14318   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
14319               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
14320   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
14321               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
14322   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
14323               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14324   // For backward compatibility:
14325   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
14326               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14327   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
14328               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14329 
14330   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Both;
14331   CHECK_PARSE("SpaceAroundPointerQualifiers: Default",
14332               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Default);
14333   CHECK_PARSE("SpaceAroundPointerQualifiers: Before",
14334               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Before);
14335   CHECK_PARSE("SpaceAroundPointerQualifiers: After",
14336               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_After);
14337   CHECK_PARSE("SpaceAroundPointerQualifiers: Both",
14338               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Both);
14339 
14340   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
14341   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
14342               FormatStyle::SBPO_Never);
14343   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
14344               FormatStyle::SBPO_Always);
14345   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
14346               FormatStyle::SBPO_ControlStatements);
14347   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
14348               FormatStyle::SBPO_NonEmptyParentheses);
14349   // For backward compatibility:
14350   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
14351               FormatStyle::SBPO_Never);
14352   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
14353               FormatStyle::SBPO_ControlStatements);
14354 
14355   Style.ColumnLimit = 123;
14356   FormatStyle BaseStyle = getLLVMStyle();
14357   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
14358   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
14359 
14360   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
14361   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
14362               FormatStyle::BS_Attach);
14363   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
14364               FormatStyle::BS_Linux);
14365   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
14366               FormatStyle::BS_Mozilla);
14367   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
14368               FormatStyle::BS_Stroustrup);
14369   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
14370               FormatStyle::BS_Allman);
14371   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
14372               FormatStyle::BS_Whitesmiths);
14373   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
14374   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
14375               FormatStyle::BS_WebKit);
14376   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
14377               FormatStyle::BS_Custom);
14378 
14379   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
14380   CHECK_PARSE("BraceWrapping:\n"
14381               "  AfterControlStatement: MultiLine",
14382               BraceWrapping.AfterControlStatement,
14383               FormatStyle::BWACS_MultiLine);
14384   CHECK_PARSE("BraceWrapping:\n"
14385               "  AfterControlStatement: Always",
14386               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14387   CHECK_PARSE("BraceWrapping:\n"
14388               "  AfterControlStatement: Never",
14389               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14390   // For backward compatibility:
14391   CHECK_PARSE("BraceWrapping:\n"
14392               "  AfterControlStatement: true",
14393               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14394   CHECK_PARSE("BraceWrapping:\n"
14395               "  AfterControlStatement: false",
14396               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14397 
14398   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
14399   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
14400               FormatStyle::RTBS_None);
14401   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
14402               FormatStyle::RTBS_All);
14403   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
14404               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
14405   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
14406               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
14407   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
14408               AlwaysBreakAfterReturnType,
14409               FormatStyle::RTBS_TopLevelDefinitions);
14410 
14411   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
14412   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
14413               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
14414   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
14415               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14416   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
14417               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14418   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
14419               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14420   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
14421               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14422 
14423   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
14424   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
14425               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
14426   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
14427               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
14428   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
14429               AlwaysBreakAfterDefinitionReturnType,
14430               FormatStyle::DRTBS_TopLevel);
14431 
14432   Style.NamespaceIndentation = FormatStyle::NI_All;
14433   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
14434               FormatStyle::NI_None);
14435   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
14436               FormatStyle::NI_Inner);
14437   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
14438               FormatStyle::NI_All);
14439 
14440   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
14441   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
14442               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14443   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
14444               AllowShortIfStatementsOnASingleLine,
14445               FormatStyle::SIS_WithoutElse);
14446   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
14447               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
14448   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
14449               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14450   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
14451               AllowShortIfStatementsOnASingleLine,
14452               FormatStyle::SIS_WithoutElse);
14453 
14454   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
14455   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
14456               FormatStyle::IEBS_AfterExternBlock);
14457   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
14458               FormatStyle::IEBS_Indent);
14459   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
14460               FormatStyle::IEBS_NoIndent);
14461   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
14462               FormatStyle::IEBS_Indent);
14463   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
14464               FormatStyle::IEBS_NoIndent);
14465 
14466   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
14467   CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
14468               FormatStyle::BFCS_Both);
14469   CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
14470               FormatStyle::BFCS_None);
14471   CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
14472               FormatStyle::BFCS_Before);
14473   CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
14474               FormatStyle::BFCS_After);
14475 
14476   Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
14477   CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
14478               FormatStyle::SJSIO_After);
14479   CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
14480               FormatStyle::SJSIO_Before);
14481 
14482   // FIXME: This is required because parsing a configuration simply overwrites
14483   // the first N elements of the list instead of resetting it.
14484   Style.ForEachMacros.clear();
14485   std::vector<std::string> BoostForeach;
14486   BoostForeach.push_back("BOOST_FOREACH");
14487   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
14488   std::vector<std::string> BoostAndQForeach;
14489   BoostAndQForeach.push_back("BOOST_FOREACH");
14490   BoostAndQForeach.push_back("Q_FOREACH");
14491   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
14492               BoostAndQForeach);
14493 
14494   Style.AttributeMacros.clear();
14495   CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
14496               std::vector<std::string>{"__capability"});
14497   CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
14498               std::vector<std::string>({"attr1", "attr2"}));
14499 
14500   Style.StatementMacros.clear();
14501   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
14502               std::vector<std::string>{"QUNUSED"});
14503   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
14504               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
14505 
14506   Style.NamespaceMacros.clear();
14507   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
14508               std::vector<std::string>{"TESTSUITE"});
14509   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
14510               std::vector<std::string>({"TESTSUITE", "SUITE"}));
14511 
14512   Style.WhitespaceSensitiveMacros.clear();
14513   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
14514               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14515   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
14516               WhitespaceSensitiveMacros,
14517               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14518   Style.WhitespaceSensitiveMacros.clear();
14519   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
14520               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14521   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
14522               WhitespaceSensitiveMacros,
14523               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14524 
14525   Style.IncludeStyle.IncludeCategories.clear();
14526   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
14527       {"abc/.*", 2, 0}, {".*", 1, 0}};
14528   CHECK_PARSE("IncludeCategories:\n"
14529               "  - Regex: abc/.*\n"
14530               "    Priority: 2\n"
14531               "  - Regex: .*\n"
14532               "    Priority: 1",
14533               IncludeStyle.IncludeCategories, ExpectedCategories);
14534   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
14535               "abc$");
14536   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
14537               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
14538 
14539   Style.RawStringFormats.clear();
14540   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
14541       {
14542           FormatStyle::LK_TextProto,
14543           {"pb", "proto"},
14544           {"PARSE_TEXT_PROTO"},
14545           /*CanonicalDelimiter=*/"",
14546           "llvm",
14547       },
14548       {
14549           FormatStyle::LK_Cpp,
14550           {"cc", "cpp"},
14551           {"C_CODEBLOCK", "CPPEVAL"},
14552           /*CanonicalDelimiter=*/"cc",
14553           /*BasedOnStyle=*/"",
14554       },
14555   };
14556 
14557   CHECK_PARSE("RawStringFormats:\n"
14558               "  - Language: TextProto\n"
14559               "    Delimiters:\n"
14560               "      - 'pb'\n"
14561               "      - 'proto'\n"
14562               "    EnclosingFunctions:\n"
14563               "      - 'PARSE_TEXT_PROTO'\n"
14564               "    BasedOnStyle: llvm\n"
14565               "  - Language: Cpp\n"
14566               "    Delimiters:\n"
14567               "      - 'cc'\n"
14568               "      - 'cpp'\n"
14569               "    EnclosingFunctions:\n"
14570               "      - 'C_CODEBLOCK'\n"
14571               "      - 'CPPEVAL'\n"
14572               "    CanonicalDelimiter: 'cc'",
14573               RawStringFormats, ExpectedRawStringFormats);
14574 }
14575 
14576 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
14577   FormatStyle Style = {};
14578   Style.Language = FormatStyle::LK_Cpp;
14579   CHECK_PARSE("Language: Cpp\n"
14580               "IndentWidth: 12",
14581               IndentWidth, 12u);
14582   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
14583                                "IndentWidth: 34",
14584                                &Style),
14585             ParseError::Unsuitable);
14586   FormatStyle BinPackedTCS = {};
14587   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
14588   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
14589                                "InsertTrailingCommas: Wrapped",
14590                                &BinPackedTCS),
14591             ParseError::BinPackTrailingCommaConflict);
14592   EXPECT_EQ(12u, Style.IndentWidth);
14593   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14594   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14595 
14596   Style.Language = FormatStyle::LK_JavaScript;
14597   CHECK_PARSE("Language: JavaScript\n"
14598               "IndentWidth: 12",
14599               IndentWidth, 12u);
14600   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14601   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14602                                "IndentWidth: 34",
14603                                &Style),
14604             ParseError::Unsuitable);
14605   EXPECT_EQ(23u, Style.IndentWidth);
14606   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14607   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14608 
14609   CHECK_PARSE("BasedOnStyle: LLVM\n"
14610               "IndentWidth: 67",
14611               IndentWidth, 67u);
14612 
14613   CHECK_PARSE("---\n"
14614               "Language: JavaScript\n"
14615               "IndentWidth: 12\n"
14616               "---\n"
14617               "Language: Cpp\n"
14618               "IndentWidth: 34\n"
14619               "...\n",
14620               IndentWidth, 12u);
14621 
14622   Style.Language = FormatStyle::LK_Cpp;
14623   CHECK_PARSE("---\n"
14624               "Language: JavaScript\n"
14625               "IndentWidth: 12\n"
14626               "---\n"
14627               "Language: Cpp\n"
14628               "IndentWidth: 34\n"
14629               "...\n",
14630               IndentWidth, 34u);
14631   CHECK_PARSE("---\n"
14632               "IndentWidth: 78\n"
14633               "---\n"
14634               "Language: JavaScript\n"
14635               "IndentWidth: 56\n"
14636               "...\n",
14637               IndentWidth, 78u);
14638 
14639   Style.ColumnLimit = 123;
14640   Style.IndentWidth = 234;
14641   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14642   Style.TabWidth = 345;
14643   EXPECT_FALSE(parseConfiguration("---\n"
14644                                   "IndentWidth: 456\n"
14645                                   "BreakBeforeBraces: Allman\n"
14646                                   "---\n"
14647                                   "Language: JavaScript\n"
14648                                   "IndentWidth: 111\n"
14649                                   "TabWidth: 111\n"
14650                                   "---\n"
14651                                   "Language: Cpp\n"
14652                                   "BreakBeforeBraces: Stroustrup\n"
14653                                   "TabWidth: 789\n"
14654                                   "...\n",
14655                                   &Style));
14656   EXPECT_EQ(123u, Style.ColumnLimit);
14657   EXPECT_EQ(456u, Style.IndentWidth);
14658   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14659   EXPECT_EQ(789u, Style.TabWidth);
14660 
14661   EXPECT_EQ(parseConfiguration("---\n"
14662                                "Language: JavaScript\n"
14663                                "IndentWidth: 56\n"
14664                                "---\n"
14665                                "IndentWidth: 78\n"
14666                                "...\n",
14667                                &Style),
14668             ParseError::Error);
14669   EXPECT_EQ(parseConfiguration("---\n"
14670                                "Language: JavaScript\n"
14671                                "IndentWidth: 56\n"
14672                                "---\n"
14673                                "Language: JavaScript\n"
14674                                "IndentWidth: 78\n"
14675                                "...\n",
14676                                &Style),
14677             ParseError::Error);
14678 
14679   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14680 }
14681 
14682 #undef CHECK_PARSE
14683 
14684 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14685   FormatStyle Style = {};
14686   Style.Language = FormatStyle::LK_JavaScript;
14687   Style.BreakBeforeTernaryOperators = true;
14688   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14689   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14690 
14691   Style.BreakBeforeTernaryOperators = true;
14692   EXPECT_EQ(0, parseConfiguration("---\n"
14693                                   "BasedOnStyle: Google\n"
14694                                   "---\n"
14695                                   "Language: JavaScript\n"
14696                                   "IndentWidth: 76\n"
14697                                   "...\n",
14698                                   &Style)
14699                    .value());
14700   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14701   EXPECT_EQ(76u, Style.IndentWidth);
14702   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14703 }
14704 
14705 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14706   FormatStyle Style = getLLVMStyle();
14707   std::string YAML = configurationAsText(Style);
14708   FormatStyle ParsedStyle = {};
14709   ParsedStyle.Language = FormatStyle::LK_Cpp;
14710   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14711   EXPECT_EQ(Style, ParsedStyle);
14712 }
14713 
14714 TEST_F(FormatTest, WorksFor8bitEncodings) {
14715   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14716             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14717             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14718             "\"\xef\xee\xf0\xf3...\"",
14719             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14720                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14721                    "\xef\xee\xf0\xf3...\"",
14722                    getLLVMStyleWithColumns(12)));
14723 }
14724 
14725 TEST_F(FormatTest, HandlesUTF8BOM) {
14726   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14727   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14728             format("\xef\xbb\xbf#include <iostream>"));
14729   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14730             format("\xef\xbb\xbf\n#include <iostream>"));
14731 }
14732 
14733 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14734 #if !defined(_MSC_VER)
14735 
14736 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14737   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14738                getLLVMStyleWithColumns(35));
14739   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14740                getLLVMStyleWithColumns(31));
14741   verifyFormat("// Однажды в студёную зимнюю пору...",
14742                getLLVMStyleWithColumns(36));
14743   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14744   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14745                getLLVMStyleWithColumns(39));
14746   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14747                getLLVMStyleWithColumns(35));
14748 }
14749 
14750 TEST_F(FormatTest, SplitsUTF8Strings) {
14751   // Non-printable characters' width is currently considered to be the length in
14752   // bytes in UTF8. The characters can be displayed in very different manner
14753   // (zero-width, single width with a substitution glyph, expanded to their code
14754   // (e.g. "<8d>"), so there's no single correct way to handle them.
14755   EXPECT_EQ("\"aaaaÄ\"\n"
14756             "\"\xc2\x8d\";",
14757             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14758   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14759             "\"\xc2\x8d\";",
14760             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14761   EXPECT_EQ("\"Однажды, в \"\n"
14762             "\"студёную \"\n"
14763             "\"зимнюю \"\n"
14764             "\"пору,\"",
14765             format("\"Однажды, в студёную зимнюю пору,\"",
14766                    getLLVMStyleWithColumns(13)));
14767   EXPECT_EQ(
14768       "\"一 二 三 \"\n"
14769       "\"四 五六 \"\n"
14770       "\"七 八 九 \"\n"
14771       "\"十\"",
14772       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14773   EXPECT_EQ("\"一\t\"\n"
14774             "\"二 \t\"\n"
14775             "\"三 四 \"\n"
14776             "\"五\t\"\n"
14777             "\"六 \t\"\n"
14778             "\"七 \"\n"
14779             "\"八九十\tqq\"",
14780             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14781                    getLLVMStyleWithColumns(11)));
14782 
14783   // UTF8 character in an escape sequence.
14784   EXPECT_EQ("\"aaaaaa\"\n"
14785             "\"\\\xC2\x8D\"",
14786             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14787 }
14788 
14789 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14790   EXPECT_EQ("const char *sssss =\n"
14791             "    \"一二三四五六七八\\\n"
14792             " 九 十\";",
14793             format("const char *sssss = \"一二三四五六七八\\\n"
14794                    " 九 十\";",
14795                    getLLVMStyleWithColumns(30)));
14796 }
14797 
14798 TEST_F(FormatTest, SplitsUTF8LineComments) {
14799   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14800             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14801   EXPECT_EQ("// Я из лесу\n"
14802             "// вышел; был\n"
14803             "// сильный\n"
14804             "// мороз.",
14805             format("// Я из лесу вышел; был сильный мороз.",
14806                    getLLVMStyleWithColumns(13)));
14807   EXPECT_EQ("// 一二三\n"
14808             "// 四五六七\n"
14809             "// 八  九\n"
14810             "// 十",
14811             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14812 }
14813 
14814 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14815   EXPECT_EQ("/* Гляжу,\n"
14816             " * поднимается\n"
14817             " * медленно в\n"
14818             " * гору\n"
14819             " * Лошадка,\n"
14820             " * везущая\n"
14821             " * хворосту\n"
14822             " * воз. */",
14823             format("/* Гляжу, поднимается медленно в гору\n"
14824                    " * Лошадка, везущая хворосту воз. */",
14825                    getLLVMStyleWithColumns(13)));
14826   EXPECT_EQ(
14827       "/* 一二三\n"
14828       " * 四五六七\n"
14829       " * 八  九\n"
14830       " * 十  */",
14831       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14832   EXPECT_EQ("/* �������� ��������\n"
14833             " * ��������\n"
14834             " * ������-�� */",
14835             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14836 }
14837 
14838 #endif // _MSC_VER
14839 
14840 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14841   FormatStyle Style = getLLVMStyle();
14842 
14843   Style.ConstructorInitializerIndentWidth = 4;
14844   verifyFormat(
14845       "SomeClass::Constructor()\n"
14846       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14847       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14848       Style);
14849 
14850   Style.ConstructorInitializerIndentWidth = 2;
14851   verifyFormat(
14852       "SomeClass::Constructor()\n"
14853       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14854       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14855       Style);
14856 
14857   Style.ConstructorInitializerIndentWidth = 0;
14858   verifyFormat(
14859       "SomeClass::Constructor()\n"
14860       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14861       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14862       Style);
14863   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14864   verifyFormat(
14865       "SomeLongTemplateVariableName<\n"
14866       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14867       Style);
14868   verifyFormat("bool smaller = 1 < "
14869                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14870                "                       "
14871                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14872                Style);
14873 
14874   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14875   verifyFormat("SomeClass::Constructor() :\n"
14876                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14877                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14878                Style);
14879 }
14880 
14881 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14882   FormatStyle Style = getLLVMStyle();
14883   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14884   Style.ConstructorInitializerIndentWidth = 4;
14885   verifyFormat("SomeClass::Constructor()\n"
14886                "    : a(a)\n"
14887                "    , b(b)\n"
14888                "    , c(c) {}",
14889                Style);
14890   verifyFormat("SomeClass::Constructor()\n"
14891                "    : a(a) {}",
14892                Style);
14893 
14894   Style.ColumnLimit = 0;
14895   verifyFormat("SomeClass::Constructor()\n"
14896                "    : a(a) {}",
14897                Style);
14898   verifyFormat("SomeClass::Constructor() noexcept\n"
14899                "    : a(a) {}",
14900                Style);
14901   verifyFormat("SomeClass::Constructor()\n"
14902                "    : a(a)\n"
14903                "    , b(b)\n"
14904                "    , c(c) {}",
14905                Style);
14906   verifyFormat("SomeClass::Constructor()\n"
14907                "    : a(a) {\n"
14908                "  foo();\n"
14909                "  bar();\n"
14910                "}",
14911                Style);
14912 
14913   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14914   verifyFormat("SomeClass::Constructor()\n"
14915                "    : a(a)\n"
14916                "    , b(b)\n"
14917                "    , c(c) {\n}",
14918                Style);
14919   verifyFormat("SomeClass::Constructor()\n"
14920                "    : a(a) {\n}",
14921                Style);
14922 
14923   Style.ColumnLimit = 80;
14924   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14925   Style.ConstructorInitializerIndentWidth = 2;
14926   verifyFormat("SomeClass::Constructor()\n"
14927                "  : a(a)\n"
14928                "  , b(b)\n"
14929                "  , c(c) {}",
14930                Style);
14931 
14932   Style.ConstructorInitializerIndentWidth = 0;
14933   verifyFormat("SomeClass::Constructor()\n"
14934                ": a(a)\n"
14935                ", b(b)\n"
14936                ", c(c) {}",
14937                Style);
14938 
14939   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14940   Style.ConstructorInitializerIndentWidth = 4;
14941   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14942   verifyFormat(
14943       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14944       Style);
14945   verifyFormat(
14946       "SomeClass::Constructor()\n"
14947       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14948       Style);
14949   Style.ConstructorInitializerIndentWidth = 4;
14950   Style.ColumnLimit = 60;
14951   verifyFormat("SomeClass::Constructor()\n"
14952                "    : aaaaaaaa(aaaaaaaa)\n"
14953                "    , aaaaaaaa(aaaaaaaa)\n"
14954                "    , aaaaaaaa(aaaaaaaa) {}",
14955                Style);
14956 }
14957 
14958 TEST_F(FormatTest, Destructors) {
14959   verifyFormat("void F(int &i) { i.~int(); }");
14960   verifyFormat("void F(int &i) { i->~int(); }");
14961 }
14962 
14963 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14964   FormatStyle Style = getWebKitStyle();
14965 
14966   // Don't indent in outer namespaces.
14967   verifyFormat("namespace outer {\n"
14968                "int i;\n"
14969                "namespace inner {\n"
14970                "    int i;\n"
14971                "} // namespace inner\n"
14972                "} // namespace outer\n"
14973                "namespace other_outer {\n"
14974                "int i;\n"
14975                "}",
14976                Style);
14977 
14978   // Don't indent case labels.
14979   verifyFormat("switch (variable) {\n"
14980                "case 1:\n"
14981                "case 2:\n"
14982                "    doSomething();\n"
14983                "    break;\n"
14984                "default:\n"
14985                "    ++variable;\n"
14986                "}",
14987                Style);
14988 
14989   // Wrap before binary operators.
14990   EXPECT_EQ("void f()\n"
14991             "{\n"
14992             "    if (aaaaaaaaaaaaaaaa\n"
14993             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14994             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14995             "        return;\n"
14996             "}",
14997             format("void f() {\n"
14998                    "if (aaaaaaaaaaaaaaaa\n"
14999                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
15000                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
15001                    "return;\n"
15002                    "}",
15003                    Style));
15004 
15005   // Allow functions on a single line.
15006   verifyFormat("void f() { return; }", Style);
15007 
15008   // Allow empty blocks on a single line and insert a space in empty blocks.
15009   EXPECT_EQ("void f() { }", format("void f() {}", Style));
15010   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
15011   // However, don't merge non-empty short loops.
15012   EXPECT_EQ("while (true) {\n"
15013             "    continue;\n"
15014             "}",
15015             format("while (true) { continue; }", Style));
15016 
15017   // Constructor initializers are formatted one per line with the "," on the
15018   // new line.
15019   verifyFormat("Constructor()\n"
15020                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
15021                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
15022                "          aaaaaaaaaaaaaa)\n"
15023                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
15024                "{\n"
15025                "}",
15026                Style);
15027   verifyFormat("SomeClass::Constructor()\n"
15028                "    : a(a)\n"
15029                "{\n"
15030                "}",
15031                Style);
15032   EXPECT_EQ("SomeClass::Constructor()\n"
15033             "    : a(a)\n"
15034             "{\n"
15035             "}",
15036             format("SomeClass::Constructor():a(a){}", Style));
15037   verifyFormat("SomeClass::Constructor()\n"
15038                "    : a(a)\n"
15039                "    , b(b)\n"
15040                "    , c(c)\n"
15041                "{\n"
15042                "}",
15043                Style);
15044   verifyFormat("SomeClass::Constructor()\n"
15045                "    : a(a)\n"
15046                "{\n"
15047                "    foo();\n"
15048                "    bar();\n"
15049                "}",
15050                Style);
15051 
15052   // Access specifiers should be aligned left.
15053   verifyFormat("class C {\n"
15054                "public:\n"
15055                "    int i;\n"
15056                "};",
15057                Style);
15058 
15059   // Do not align comments.
15060   verifyFormat("int a; // Do not\n"
15061                "double b; // align comments.",
15062                Style);
15063 
15064   // Do not align operands.
15065   EXPECT_EQ("ASSERT(aaaa\n"
15066             "    || bbbb);",
15067             format("ASSERT ( aaaa\n||bbbb);", Style));
15068 
15069   // Accept input's line breaks.
15070   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
15071             "    || bbbbbbbbbbbbbbb) {\n"
15072             "    i++;\n"
15073             "}",
15074             format("if (aaaaaaaaaaaaaaa\n"
15075                    "|| bbbbbbbbbbbbbbb) { i++; }",
15076                    Style));
15077   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
15078             "    i++;\n"
15079             "}",
15080             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
15081 
15082   // Don't automatically break all macro definitions (llvm.org/PR17842).
15083   verifyFormat("#define aNumber 10", Style);
15084   // However, generally keep the line breaks that the user authored.
15085   EXPECT_EQ("#define aNumber \\\n"
15086             "    10",
15087             format("#define aNumber \\\n"
15088                    " 10",
15089                    Style));
15090 
15091   // Keep empty and one-element array literals on a single line.
15092   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
15093             "                                  copyItems:YES];",
15094             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
15095                    "copyItems:YES];",
15096                    Style));
15097   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
15098             "                                  copyItems:YES];",
15099             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
15100                    "             copyItems:YES];",
15101                    Style));
15102   // FIXME: This does not seem right, there should be more indentation before
15103   // the array literal's entries. Nested blocks have the same problem.
15104   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
15105             "    @\"a\",\n"
15106             "    @\"a\"\n"
15107             "]\n"
15108             "                                  copyItems:YES];",
15109             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
15110                    "     @\"a\",\n"
15111                    "     @\"a\"\n"
15112                    "     ]\n"
15113                    "       copyItems:YES];",
15114                    Style));
15115   EXPECT_EQ(
15116       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
15117       "                                  copyItems:YES];",
15118       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
15119              "   copyItems:YES];",
15120              Style));
15121 
15122   verifyFormat("[self.a b:c c:d];", Style);
15123   EXPECT_EQ("[self.a b:c\n"
15124             "        c:d];",
15125             format("[self.a b:c\n"
15126                    "c:d];",
15127                    Style));
15128 }
15129 
15130 TEST_F(FormatTest, FormatsLambdas) {
15131   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
15132   verifyFormat(
15133       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
15134   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
15135   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
15136   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
15137   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
15138   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
15139   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
15140   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
15141   verifyFormat("int x = f(*+[] {});");
15142   verifyFormat("void f() {\n"
15143                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
15144                "}\n");
15145   verifyFormat("void f() {\n"
15146                "  other(x.begin(), //\n"
15147                "        x.end(),   //\n"
15148                "        [&](int, int) { return 1; });\n"
15149                "}\n");
15150   verifyFormat("void f() {\n"
15151                "  other.other.other.other.other(\n"
15152                "      x.begin(), x.end(),\n"
15153                "      [something, rather](int, int, int, int, int, int, int) { "
15154                "return 1; });\n"
15155                "}\n");
15156   verifyFormat(
15157       "void f() {\n"
15158       "  other.other.other.other.other(\n"
15159       "      x.begin(), x.end(),\n"
15160       "      [something, rather](int, int, int, int, int, int, int) {\n"
15161       "        //\n"
15162       "      });\n"
15163       "}\n");
15164   verifyFormat("SomeFunction([]() { // A cool function...\n"
15165                "  return 43;\n"
15166                "});");
15167   EXPECT_EQ("SomeFunction([]() {\n"
15168             "#define A a\n"
15169             "  return 43;\n"
15170             "});",
15171             format("SomeFunction([](){\n"
15172                    "#define A a\n"
15173                    "return 43;\n"
15174                    "});"));
15175   verifyFormat("void f() {\n"
15176                "  SomeFunction([](decltype(x), A *a) {});\n"
15177                "  SomeFunction([](typeof(x), A *a) {});\n"
15178                "  SomeFunction([](_Atomic(x), A *a) {});\n"
15179                "  SomeFunction([](__underlying_type(x), A *a) {});\n"
15180                "}");
15181   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15182                "    [](const aaaaaaaaaa &a) { return a; });");
15183   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
15184                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
15185                "});");
15186   verifyFormat("Constructor()\n"
15187                "    : Field([] { // comment\n"
15188                "        int i;\n"
15189                "      }) {}");
15190   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
15191                "  return some_parameter.size();\n"
15192                "};");
15193   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
15194                "    [](const string &s) { return s; };");
15195   verifyFormat("int i = aaaaaa ? 1 //\n"
15196                "               : [] {\n"
15197                "                   return 2; //\n"
15198                "                 }();");
15199   verifyFormat("llvm::errs() << \"number of twos is \"\n"
15200                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
15201                "                  return x == 2; // force break\n"
15202                "                });");
15203   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15204                "    [=](int iiiiiiiiiiii) {\n"
15205                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
15206                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
15207                "    });",
15208                getLLVMStyleWithColumns(60));
15209   verifyFormat("SomeFunction({[&] {\n"
15210                "                // comment\n"
15211                "              },\n"
15212                "              [&] {\n"
15213                "                // comment\n"
15214                "              }});");
15215   verifyFormat("SomeFunction({[&] {\n"
15216                "  // comment\n"
15217                "}});");
15218   verifyFormat(
15219       "virtual aaaaaaaaaaaaaaaa(\n"
15220       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
15221       "    aaaaa aaaaaaaaa);");
15222 
15223   // Lambdas with return types.
15224   verifyFormat("int c = []() -> int { return 2; }();\n");
15225   verifyFormat("int c = []() -> int * { return 2; }();\n");
15226   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
15227   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
15228   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
15229   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
15230   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
15231   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
15232   verifyFormat("[a, a]() -> a<1> {};");
15233   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
15234   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
15235   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
15236   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
15237   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
15238   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
15239   verifyFormat("[]() -> foo<!5> { return {}; };");
15240   verifyFormat("[]() -> foo<~5> { return {}; };");
15241   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
15242   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
15243   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
15244   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
15245   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
15246   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
15247   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
15248   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
15249   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
15250   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
15251   verifyFormat("namespace bar {\n"
15252                "// broken:\n"
15253                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
15254                "} // namespace bar");
15255   verifyFormat("namespace bar {\n"
15256                "// broken:\n"
15257                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
15258                "} // namespace bar");
15259   verifyFormat("namespace bar {\n"
15260                "// broken:\n"
15261                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
15262                "} // namespace bar");
15263   verifyFormat("namespace bar {\n"
15264                "// broken:\n"
15265                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
15266                "} // namespace bar");
15267   verifyFormat("namespace bar {\n"
15268                "// broken:\n"
15269                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
15270                "} // namespace bar");
15271   verifyFormat("namespace bar {\n"
15272                "// broken:\n"
15273                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
15274                "} // namespace bar");
15275   verifyFormat("namespace bar {\n"
15276                "// broken:\n"
15277                "auto foo{[]() -> foo<!5> { return {}; }};\n"
15278                "} // namespace bar");
15279   verifyFormat("namespace bar {\n"
15280                "// broken:\n"
15281                "auto foo{[]() -> foo<~5> { return {}; }};\n"
15282                "} // namespace bar");
15283   verifyFormat("namespace bar {\n"
15284                "// broken:\n"
15285                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
15286                "} // namespace bar");
15287   verifyFormat("namespace bar {\n"
15288                "// broken:\n"
15289                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
15290                "} // namespace bar");
15291   verifyFormat("namespace bar {\n"
15292                "// broken:\n"
15293                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
15294                "} // namespace bar");
15295   verifyFormat("namespace bar {\n"
15296                "// broken:\n"
15297                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
15298                "} // namespace bar");
15299   verifyFormat("namespace bar {\n"
15300                "// broken:\n"
15301                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
15302                "} // namespace bar");
15303   verifyFormat("namespace bar {\n"
15304                "// broken:\n"
15305                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
15306                "} // namespace bar");
15307   verifyFormat("namespace bar {\n"
15308                "// broken:\n"
15309                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
15310                "} // namespace bar");
15311   verifyFormat("namespace bar {\n"
15312                "// broken:\n"
15313                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
15314                "} // namespace bar");
15315   verifyFormat("namespace bar {\n"
15316                "// broken:\n"
15317                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
15318                "} // namespace bar");
15319   verifyFormat("namespace bar {\n"
15320                "// broken:\n"
15321                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
15322                "} // namespace bar");
15323   verifyFormat("[]() -> a<1> {};");
15324   verifyFormat("[]() -> a<1> { ; };");
15325   verifyFormat("[]() -> a<1> { ; }();");
15326   verifyFormat("[a, a]() -> a<true> {};");
15327   verifyFormat("[]() -> a<true> {};");
15328   verifyFormat("[]() -> a<true> { ; };");
15329   verifyFormat("[]() -> a<true> { ; }();");
15330   verifyFormat("[a, a]() -> a<false> {};");
15331   verifyFormat("[]() -> a<false> {};");
15332   verifyFormat("[]() -> a<false> { ; };");
15333   verifyFormat("[]() -> a<false> { ; }();");
15334   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
15335   verifyFormat("namespace bar {\n"
15336                "auto foo{[]() -> foo<false> { ; }};\n"
15337                "} // namespace bar");
15338   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
15339                "                   int j) -> int {\n"
15340                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
15341                "};");
15342   verifyFormat(
15343       "aaaaaaaaaaaaaaaaaaaaaa(\n"
15344       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
15345       "      return aaaaaaaaaaaaaaaaa;\n"
15346       "    });",
15347       getLLVMStyleWithColumns(70));
15348   verifyFormat("[]() //\n"
15349                "    -> int {\n"
15350                "  return 1; //\n"
15351                "};");
15352   verifyFormat("[]() -> Void<T...> {};");
15353   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
15354 
15355   // Lambdas with explicit template argument lists.
15356   verifyFormat(
15357       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
15358 
15359   // Multiple lambdas in the same parentheses change indentation rules. These
15360   // lambdas are forced to start on new lines.
15361   verifyFormat("SomeFunction(\n"
15362                "    []() {\n"
15363                "      //\n"
15364                "    },\n"
15365                "    []() {\n"
15366                "      //\n"
15367                "    });");
15368 
15369   // A lambda passed as arg0 is always pushed to the next line.
15370   verifyFormat("SomeFunction(\n"
15371                "    [this] {\n"
15372                "      //\n"
15373                "    },\n"
15374                "    1);\n");
15375 
15376   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
15377   // the arg0 case above.
15378   auto Style = getGoogleStyle();
15379   Style.BinPackArguments = false;
15380   verifyFormat("SomeFunction(\n"
15381                "    a,\n"
15382                "    [this] {\n"
15383                "      //\n"
15384                "    },\n"
15385                "    b);\n",
15386                Style);
15387   verifyFormat("SomeFunction(\n"
15388                "    a,\n"
15389                "    [this] {\n"
15390                "      //\n"
15391                "    },\n"
15392                "    b);\n");
15393 
15394   // A lambda with a very long line forces arg0 to be pushed out irrespective of
15395   // the BinPackArguments value (as long as the code is wide enough).
15396   verifyFormat(
15397       "something->SomeFunction(\n"
15398       "    a,\n"
15399       "    [this] {\n"
15400       "      "
15401       "D0000000000000000000000000000000000000000000000000000000000001();\n"
15402       "    },\n"
15403       "    b);\n");
15404 
15405   // A multi-line lambda is pulled up as long as the introducer fits on the
15406   // previous line and there are no further args.
15407   verifyFormat("function(1, [this, that] {\n"
15408                "  //\n"
15409                "});\n");
15410   verifyFormat("function([this, that] {\n"
15411                "  //\n"
15412                "});\n");
15413   // FIXME: this format is not ideal and we should consider forcing the first
15414   // arg onto its own line.
15415   verifyFormat("function(a, b, c, //\n"
15416                "         d, [this, that] {\n"
15417                "           //\n"
15418                "         });\n");
15419 
15420   // Multiple lambdas are treated correctly even when there is a short arg0.
15421   verifyFormat("SomeFunction(\n"
15422                "    1,\n"
15423                "    [this] {\n"
15424                "      //\n"
15425                "    },\n"
15426                "    [this] {\n"
15427                "      //\n"
15428                "    },\n"
15429                "    1);\n");
15430 
15431   // More complex introducers.
15432   verifyFormat("return [i, args...] {};");
15433 
15434   // Not lambdas.
15435   verifyFormat("constexpr char hello[]{\"hello\"};");
15436   verifyFormat("double &operator[](int i) { return 0; }\n"
15437                "int i;");
15438   verifyFormat("std::unique_ptr<int[]> foo() {}");
15439   verifyFormat("int i = a[a][a]->f();");
15440   verifyFormat("int i = (*b)[a]->f();");
15441 
15442   // Other corner cases.
15443   verifyFormat("void f() {\n"
15444                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
15445                "  );\n"
15446                "}");
15447 
15448   // Lambdas created through weird macros.
15449   verifyFormat("void f() {\n"
15450                "  MACRO((const AA &a) { return 1; });\n"
15451                "  MACRO((AA &a) { return 1; });\n"
15452                "}");
15453 
15454   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
15455                "      doo_dah();\n"
15456                "      doo_dah();\n"
15457                "    })) {\n"
15458                "}");
15459   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
15460                "                doo_dah();\n"
15461                "                doo_dah();\n"
15462                "              })) {\n"
15463                "}");
15464   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
15465                "                doo_dah();\n"
15466                "                doo_dah();\n"
15467                "              })) {\n"
15468                "}");
15469   verifyFormat("auto lambda = []() {\n"
15470                "  int a = 2\n"
15471                "#if A\n"
15472                "          + 2\n"
15473                "#endif\n"
15474                "      ;\n"
15475                "};");
15476 
15477   // Lambdas with complex multiline introducers.
15478   verifyFormat(
15479       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15480       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
15481       "        -> ::std::unordered_set<\n"
15482       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
15483       "      //\n"
15484       "    });");
15485 
15486   FormatStyle DoNotMerge = getLLVMStyle();
15487   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
15488   verifyFormat("auto c = []() {\n"
15489                "  return b;\n"
15490                "};",
15491                "auto c = []() { return b; };", DoNotMerge);
15492   verifyFormat("auto c = []() {\n"
15493                "};",
15494                " auto c = []() {};", DoNotMerge);
15495 
15496   FormatStyle MergeEmptyOnly = getLLVMStyle();
15497   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
15498   verifyFormat("auto c = []() {\n"
15499                "  return b;\n"
15500                "};",
15501                "auto c = []() {\n"
15502                "  return b;\n"
15503                " };",
15504                MergeEmptyOnly);
15505   verifyFormat("auto c = []() {};",
15506                "auto c = []() {\n"
15507                "};",
15508                MergeEmptyOnly);
15509 
15510   FormatStyle MergeInline = getLLVMStyle();
15511   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
15512   verifyFormat("auto c = []() {\n"
15513                "  return b;\n"
15514                "};",
15515                "auto c = []() { return b; };", MergeInline);
15516   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
15517                MergeInline);
15518   verifyFormat("function([]() { return b; }, a)",
15519                "function([]() { return b; }, a)", MergeInline);
15520   verifyFormat("function(a, []() { return b; })",
15521                "function(a, []() { return b; })", MergeInline);
15522 
15523   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
15524   // AllowShortLambdasOnASingleLine
15525   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15526   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15527   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15528   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15529       FormatStyle::ShortLambdaStyle::SLS_None;
15530   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
15531                "    []()\n"
15532                "    {\n"
15533                "      return 17;\n"
15534                "    });",
15535                LLVMWithBeforeLambdaBody);
15536   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
15537                "    []()\n"
15538                "    {\n"
15539                "    });",
15540                LLVMWithBeforeLambdaBody);
15541   verifyFormat("auto fct_SLS_None = []()\n"
15542                "{\n"
15543                "  return 17;\n"
15544                "};",
15545                LLVMWithBeforeLambdaBody);
15546   verifyFormat("TwoNestedLambdas_SLS_None(\n"
15547                "    []()\n"
15548                "    {\n"
15549                "      return Call(\n"
15550                "          []()\n"
15551                "          {\n"
15552                "            return 17;\n"
15553                "          });\n"
15554                "    });",
15555                LLVMWithBeforeLambdaBody);
15556   verifyFormat("void Fct()\n"
15557                "{\n"
15558                "  return {[]()\n"
15559                "          {\n"
15560                "            return 17;\n"
15561                "          }};\n"
15562                "}",
15563                LLVMWithBeforeLambdaBody);
15564 
15565   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15566       FormatStyle::ShortLambdaStyle::SLS_Empty;
15567   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
15568                "    []()\n"
15569                "    {\n"
15570                "      return 17;\n"
15571                "    });",
15572                LLVMWithBeforeLambdaBody);
15573   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
15574                LLVMWithBeforeLambdaBody);
15575   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
15576                "ongFunctionName_SLS_Empty(\n"
15577                "    []() {});",
15578                LLVMWithBeforeLambdaBody);
15579   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
15580                "                                []()\n"
15581                "                                {\n"
15582                "                                  return 17;\n"
15583                "                                });",
15584                LLVMWithBeforeLambdaBody);
15585   verifyFormat("auto fct_SLS_Empty = []()\n"
15586                "{\n"
15587                "  return 17;\n"
15588                "};",
15589                LLVMWithBeforeLambdaBody);
15590   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
15591                "    []()\n"
15592                "    {\n"
15593                "      return Call([]() {});\n"
15594                "    });",
15595                LLVMWithBeforeLambdaBody);
15596   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15597                "                           []()\n"
15598                "                           {\n"
15599                "                             return Call([]() {});\n"
15600                "                           });",
15601                LLVMWithBeforeLambdaBody);
15602   verifyFormat(
15603       "FctWithLongLineInLambda_SLS_Empty(\n"
15604       "    []()\n"
15605       "    {\n"
15606       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15607       "                               AndShouldNotBeConsiderAsInline,\n"
15608       "                               LambdaBodyMustBeBreak);\n"
15609       "    });",
15610       LLVMWithBeforeLambdaBody);
15611 
15612   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15613       FormatStyle::ShortLambdaStyle::SLS_Inline;
15614   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15615                LLVMWithBeforeLambdaBody);
15616   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15617                LLVMWithBeforeLambdaBody);
15618   verifyFormat("auto fct_SLS_Inline = []()\n"
15619                "{\n"
15620                "  return 17;\n"
15621                "};",
15622                LLVMWithBeforeLambdaBody);
15623   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15624                "17; }); });",
15625                LLVMWithBeforeLambdaBody);
15626   verifyFormat(
15627       "FctWithLongLineInLambda_SLS_Inline(\n"
15628       "    []()\n"
15629       "    {\n"
15630       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15631       "                               AndShouldNotBeConsiderAsInline,\n"
15632       "                               LambdaBodyMustBeBreak);\n"
15633       "    });",
15634       LLVMWithBeforeLambdaBody);
15635   verifyFormat("FctWithMultipleParams_SLS_Inline("
15636                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15637                "                                 []() { return 17; });",
15638                LLVMWithBeforeLambdaBody);
15639   verifyFormat(
15640       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15641       LLVMWithBeforeLambdaBody);
15642 
15643   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15644       FormatStyle::ShortLambdaStyle::SLS_All;
15645   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15646                LLVMWithBeforeLambdaBody);
15647   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15648                LLVMWithBeforeLambdaBody);
15649   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15650                LLVMWithBeforeLambdaBody);
15651   verifyFormat("FctWithOneParam_SLS_All(\n"
15652                "    []()\n"
15653                "    {\n"
15654                "      // A cool function...\n"
15655                "      return 43;\n"
15656                "    });",
15657                LLVMWithBeforeLambdaBody);
15658   verifyFormat("FctWithMultipleParams_SLS_All("
15659                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15660                "                              []() { return 17; });",
15661                LLVMWithBeforeLambdaBody);
15662   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15663                LLVMWithBeforeLambdaBody);
15664   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15665                LLVMWithBeforeLambdaBody);
15666   verifyFormat(
15667       "FctWithLongLineInLambda_SLS_All(\n"
15668       "    []()\n"
15669       "    {\n"
15670       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15671       "                               AndShouldNotBeConsiderAsInline,\n"
15672       "                               LambdaBodyMustBeBreak);\n"
15673       "    });",
15674       LLVMWithBeforeLambdaBody);
15675   verifyFormat(
15676       "auto fct_SLS_All = []()\n"
15677       "{\n"
15678       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15679       "                           AndShouldNotBeConsiderAsInline,\n"
15680       "                           LambdaBodyMustBeBreak);\n"
15681       "};",
15682       LLVMWithBeforeLambdaBody);
15683   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15684   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15685                LLVMWithBeforeLambdaBody);
15686   verifyFormat(
15687       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15688       "                                FirstParam,\n"
15689       "                                SecondParam,\n"
15690       "                                ThirdParam,\n"
15691       "                                FourthParam);",
15692       LLVMWithBeforeLambdaBody);
15693   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15694                "    []() { return "
15695                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15696                "    FirstParam,\n"
15697                "    SecondParam,\n"
15698                "    ThirdParam,\n"
15699                "    FourthParam);",
15700                LLVMWithBeforeLambdaBody);
15701   verifyFormat(
15702       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15703       "                                SecondParam,\n"
15704       "                                ThirdParam,\n"
15705       "                                FourthParam,\n"
15706       "                                []() { return SomeValueNotSoLong; });",
15707       LLVMWithBeforeLambdaBody);
15708   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15709                "    []()\n"
15710                "    {\n"
15711                "      return "
15712                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15713                "eConsiderAsInline;\n"
15714                "    });",
15715                LLVMWithBeforeLambdaBody);
15716   verifyFormat(
15717       "FctWithLongLineInLambda_SLS_All(\n"
15718       "    []()\n"
15719       "    {\n"
15720       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15721       "                               AndShouldNotBeConsiderAsInline,\n"
15722       "                               LambdaBodyMustBeBreak);\n"
15723       "    });",
15724       LLVMWithBeforeLambdaBody);
15725   verifyFormat("FctWithTwoParams_SLS_All(\n"
15726                "    []()\n"
15727                "    {\n"
15728                "      // A cool function...\n"
15729                "      return 43;\n"
15730                "    },\n"
15731                "    87);",
15732                LLVMWithBeforeLambdaBody);
15733   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15734                LLVMWithBeforeLambdaBody);
15735   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15736                LLVMWithBeforeLambdaBody);
15737   verifyFormat(
15738       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15739       LLVMWithBeforeLambdaBody);
15740   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15741                "}); }, x);",
15742                LLVMWithBeforeLambdaBody);
15743   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15744                "    []()\n"
15745                "    {\n"
15746                "      // A cool function...\n"
15747                "      return Call([]() { return 17; });\n"
15748                "    });",
15749                LLVMWithBeforeLambdaBody);
15750   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15751                "    []()\n"
15752                "    {\n"
15753                "      return Call(\n"
15754                "          []()\n"
15755                "          {\n"
15756                "            // A cool function...\n"
15757                "            return 17;\n"
15758                "          });\n"
15759                "    });",
15760                LLVMWithBeforeLambdaBody);
15761 }
15762 
15763 TEST_F(FormatTest, LambdaWithLineComments) {
15764   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15765   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15766   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15767   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15768       FormatStyle::ShortLambdaStyle::SLS_All;
15769 
15770   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15771   verifyFormat("auto k = []() // comment\n"
15772                "{ return; }",
15773                LLVMWithBeforeLambdaBody);
15774   verifyFormat("auto k = []() /* comment */ { return; }",
15775                LLVMWithBeforeLambdaBody);
15776   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15777                LLVMWithBeforeLambdaBody);
15778   verifyFormat("auto k = []() // X\n"
15779                "{ return; }",
15780                LLVMWithBeforeLambdaBody);
15781   verifyFormat(
15782       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15783       "{ return; }",
15784       LLVMWithBeforeLambdaBody);
15785 }
15786 
15787 TEST_F(FormatTest, EmptyLinesInLambdas) {
15788   verifyFormat("auto lambda = []() {\n"
15789                "  x(); //\n"
15790                "};",
15791                "auto lambda = []() {\n"
15792                "\n"
15793                "  x(); //\n"
15794                "\n"
15795                "};");
15796 }
15797 
15798 TEST_F(FormatTest, FormatsBlocks) {
15799   FormatStyle ShortBlocks = getLLVMStyle();
15800   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15801   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15802   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15803   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15804   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15805   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15806   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15807 
15808   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15809   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15810   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15811 
15812   verifyFormat("[operation setCompletionBlock:^{\n"
15813                "  [self onOperationDone];\n"
15814                "}];");
15815   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15816                "  [self onOperationDone];\n"
15817                "}]};");
15818   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15819                "  f();\n"
15820                "}];");
15821   verifyFormat("int a = [operation block:^int(int *i) {\n"
15822                "  return 1;\n"
15823                "}];");
15824   verifyFormat("[myObject doSomethingWith:arg1\n"
15825                "                      aaa:^int(int *a) {\n"
15826                "                        return 1;\n"
15827                "                      }\n"
15828                "                      bbb:f(a * bbbbbbbb)];");
15829 
15830   verifyFormat("[operation setCompletionBlock:^{\n"
15831                "  [self.delegate newDataAvailable];\n"
15832                "}];",
15833                getLLVMStyleWithColumns(60));
15834   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15835                "  NSString *path = [self sessionFilePath];\n"
15836                "  if (path) {\n"
15837                "    // ...\n"
15838                "  }\n"
15839                "});");
15840   verifyFormat("[[SessionService sharedService]\n"
15841                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15842                "      if (window) {\n"
15843                "        [self windowDidLoad:window];\n"
15844                "      } else {\n"
15845                "        [self errorLoadingWindow];\n"
15846                "      }\n"
15847                "    }];");
15848   verifyFormat("void (^largeBlock)(void) = ^{\n"
15849                "  // ...\n"
15850                "};\n",
15851                getLLVMStyleWithColumns(40));
15852   verifyFormat("[[SessionService sharedService]\n"
15853                "    loadWindowWithCompletionBlock: //\n"
15854                "        ^(SessionWindow *window) {\n"
15855                "          if (window) {\n"
15856                "            [self windowDidLoad:window];\n"
15857                "          } else {\n"
15858                "            [self errorLoadingWindow];\n"
15859                "          }\n"
15860                "        }];",
15861                getLLVMStyleWithColumns(60));
15862   verifyFormat("[myObject doSomethingWith:arg1\n"
15863                "    firstBlock:^(Foo *a) {\n"
15864                "      // ...\n"
15865                "      int i;\n"
15866                "    }\n"
15867                "    secondBlock:^(Bar *b) {\n"
15868                "      // ...\n"
15869                "      int i;\n"
15870                "    }\n"
15871                "    thirdBlock:^Foo(Bar *b) {\n"
15872                "      // ...\n"
15873                "      int i;\n"
15874                "    }];");
15875   verifyFormat("[myObject doSomethingWith:arg1\n"
15876                "               firstBlock:-1\n"
15877                "              secondBlock:^(Bar *b) {\n"
15878                "                // ...\n"
15879                "                int i;\n"
15880                "              }];");
15881 
15882   verifyFormat("f(^{\n"
15883                "  @autoreleasepool {\n"
15884                "    if (a) {\n"
15885                "      g();\n"
15886                "    }\n"
15887                "  }\n"
15888                "});");
15889   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15890   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15891                "};");
15892 
15893   FormatStyle FourIndent = getLLVMStyle();
15894   FourIndent.ObjCBlockIndentWidth = 4;
15895   verifyFormat("[operation setCompletionBlock:^{\n"
15896                "    [self onOperationDone];\n"
15897                "}];",
15898                FourIndent);
15899 }
15900 
15901 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15902   FormatStyle ZeroColumn = getLLVMStyle();
15903   ZeroColumn.ColumnLimit = 0;
15904 
15905   verifyFormat("[[SessionService sharedService] "
15906                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15907                "  if (window) {\n"
15908                "    [self windowDidLoad:window];\n"
15909                "  } else {\n"
15910                "    [self errorLoadingWindow];\n"
15911                "  }\n"
15912                "}];",
15913                ZeroColumn);
15914   EXPECT_EQ("[[SessionService sharedService]\n"
15915             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15916             "      if (window) {\n"
15917             "        [self windowDidLoad:window];\n"
15918             "      } else {\n"
15919             "        [self errorLoadingWindow];\n"
15920             "      }\n"
15921             "    }];",
15922             format("[[SessionService sharedService]\n"
15923                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15924                    "                if (window) {\n"
15925                    "    [self windowDidLoad:window];\n"
15926                    "  } else {\n"
15927                    "    [self errorLoadingWindow];\n"
15928                    "  }\n"
15929                    "}];",
15930                    ZeroColumn));
15931   verifyFormat("[myObject doSomethingWith:arg1\n"
15932                "    firstBlock:^(Foo *a) {\n"
15933                "      // ...\n"
15934                "      int i;\n"
15935                "    }\n"
15936                "    secondBlock:^(Bar *b) {\n"
15937                "      // ...\n"
15938                "      int i;\n"
15939                "    }\n"
15940                "    thirdBlock:^Foo(Bar *b) {\n"
15941                "      // ...\n"
15942                "      int i;\n"
15943                "    }];",
15944                ZeroColumn);
15945   verifyFormat("f(^{\n"
15946                "  @autoreleasepool {\n"
15947                "    if (a) {\n"
15948                "      g();\n"
15949                "    }\n"
15950                "  }\n"
15951                "});",
15952                ZeroColumn);
15953   verifyFormat("void (^largeBlock)(void) = ^{\n"
15954                "  // ...\n"
15955                "};",
15956                ZeroColumn);
15957 
15958   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15959   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15960             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15961   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15962   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15963             "  int i;\n"
15964             "};",
15965             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15966 }
15967 
15968 TEST_F(FormatTest, SupportsCRLF) {
15969   EXPECT_EQ("int a;\r\n"
15970             "int b;\r\n"
15971             "int c;\r\n",
15972             format("int a;\r\n"
15973                    "  int b;\r\n"
15974                    "    int c;\r\n",
15975                    getLLVMStyle()));
15976   EXPECT_EQ("int a;\r\n"
15977             "int b;\r\n"
15978             "int c;\r\n",
15979             format("int a;\r\n"
15980                    "  int b;\n"
15981                    "    int c;\r\n",
15982                    getLLVMStyle()));
15983   EXPECT_EQ("int a;\n"
15984             "int b;\n"
15985             "int c;\n",
15986             format("int a;\r\n"
15987                    "  int b;\n"
15988                    "    int c;\n",
15989                    getLLVMStyle()));
15990   EXPECT_EQ("\"aaaaaaa \"\r\n"
15991             "\"bbbbbbb\";\r\n",
15992             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15993   EXPECT_EQ("#define A \\\r\n"
15994             "  b;      \\\r\n"
15995             "  c;      \\\r\n"
15996             "  d;\r\n",
15997             format("#define A \\\r\n"
15998                    "  b; \\\r\n"
15999                    "  c; d; \r\n",
16000                    getGoogleStyle()));
16001 
16002   EXPECT_EQ("/*\r\n"
16003             "multi line block comments\r\n"
16004             "should not introduce\r\n"
16005             "an extra carriage return\r\n"
16006             "*/\r\n",
16007             format("/*\r\n"
16008                    "multi line block comments\r\n"
16009                    "should not introduce\r\n"
16010                    "an extra carriage return\r\n"
16011                    "*/\r\n"));
16012   EXPECT_EQ("/*\r\n"
16013             "\r\n"
16014             "*/",
16015             format("/*\r\n"
16016                    "    \r\r\r\n"
16017                    "*/"));
16018 
16019   FormatStyle style = getLLVMStyle();
16020 
16021   style.DeriveLineEnding = true;
16022   style.UseCRLF = false;
16023   EXPECT_EQ("union FooBarBazQux {\n"
16024             "  int foo;\n"
16025             "  int bar;\n"
16026             "  int baz;\n"
16027             "};",
16028             format("union FooBarBazQux {\r\n"
16029                    "  int foo;\n"
16030                    "  int bar;\r\n"
16031                    "  int baz;\n"
16032                    "};",
16033                    style));
16034   style.UseCRLF = true;
16035   EXPECT_EQ("union FooBarBazQux {\r\n"
16036             "  int foo;\r\n"
16037             "  int bar;\r\n"
16038             "  int baz;\r\n"
16039             "};",
16040             format("union FooBarBazQux {\r\n"
16041                    "  int foo;\n"
16042                    "  int bar;\r\n"
16043                    "  int baz;\n"
16044                    "};",
16045                    style));
16046 
16047   style.DeriveLineEnding = false;
16048   style.UseCRLF = false;
16049   EXPECT_EQ("union FooBarBazQux {\n"
16050             "  int foo;\n"
16051             "  int bar;\n"
16052             "  int baz;\n"
16053             "  int qux;\n"
16054             "};",
16055             format("union FooBarBazQux {\r\n"
16056                    "  int foo;\n"
16057                    "  int bar;\r\n"
16058                    "  int baz;\n"
16059                    "  int qux;\r\n"
16060                    "};",
16061                    style));
16062   style.UseCRLF = true;
16063   EXPECT_EQ("union FooBarBazQux {\r\n"
16064             "  int foo;\r\n"
16065             "  int bar;\r\n"
16066             "  int baz;\r\n"
16067             "  int qux;\r\n"
16068             "};",
16069             format("union FooBarBazQux {\r\n"
16070                    "  int foo;\n"
16071                    "  int bar;\r\n"
16072                    "  int baz;\n"
16073                    "  int qux;\n"
16074                    "};",
16075                    style));
16076 
16077   style.DeriveLineEnding = true;
16078   style.UseCRLF = false;
16079   EXPECT_EQ("union FooBarBazQux {\r\n"
16080             "  int foo;\r\n"
16081             "  int bar;\r\n"
16082             "  int baz;\r\n"
16083             "  int qux;\r\n"
16084             "};",
16085             format("union FooBarBazQux {\r\n"
16086                    "  int foo;\n"
16087                    "  int bar;\r\n"
16088                    "  int baz;\n"
16089                    "  int qux;\r\n"
16090                    "};",
16091                    style));
16092   style.UseCRLF = true;
16093   EXPECT_EQ("union FooBarBazQux {\n"
16094             "  int foo;\n"
16095             "  int bar;\n"
16096             "  int baz;\n"
16097             "  int qux;\n"
16098             "};",
16099             format("union FooBarBazQux {\r\n"
16100                    "  int foo;\n"
16101                    "  int bar;\r\n"
16102                    "  int baz;\n"
16103                    "  int qux;\n"
16104                    "};",
16105                    style));
16106 }
16107 
16108 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
16109   verifyFormat("MY_CLASS(C) {\n"
16110                "  int i;\n"
16111                "  int j;\n"
16112                "};");
16113 }
16114 
16115 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
16116   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
16117   TwoIndent.ContinuationIndentWidth = 2;
16118 
16119   EXPECT_EQ("int i =\n"
16120             "  longFunction(\n"
16121             "    arg);",
16122             format("int i = longFunction(arg);", TwoIndent));
16123 
16124   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
16125   SixIndent.ContinuationIndentWidth = 6;
16126 
16127   EXPECT_EQ("int i =\n"
16128             "      longFunction(\n"
16129             "            arg);",
16130             format("int i = longFunction(arg);", SixIndent));
16131 }
16132 
16133 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
16134   FormatStyle Style = getLLVMStyle();
16135   verifyFormat("int Foo::getter(\n"
16136                "    //\n"
16137                ") const {\n"
16138                "  return foo;\n"
16139                "}",
16140                Style);
16141   verifyFormat("void Foo::setter(\n"
16142                "    //\n"
16143                ") {\n"
16144                "  foo = 1;\n"
16145                "}",
16146                Style);
16147 }
16148 
16149 TEST_F(FormatTest, SpacesInAngles) {
16150   FormatStyle Spaces = getLLVMStyle();
16151   Spaces.SpacesInAngles = true;
16152 
16153   verifyFormat("static_cast< int >(arg);", Spaces);
16154   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
16155   verifyFormat("f< int, float >();", Spaces);
16156   verifyFormat("template <> g() {}", Spaces);
16157   verifyFormat("template < std::vector< int > > f() {}", Spaces);
16158   verifyFormat("std::function< void(int, int) > fct;", Spaces);
16159   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
16160                Spaces);
16161 
16162   Spaces.Standard = FormatStyle::LS_Cpp03;
16163   Spaces.SpacesInAngles = true;
16164   verifyFormat("A< A< int > >();", Spaces);
16165 
16166   Spaces.SpacesInAngles = false;
16167   verifyFormat("A<A<int> >();", Spaces);
16168 
16169   Spaces.Standard = FormatStyle::LS_Cpp11;
16170   Spaces.SpacesInAngles = true;
16171   verifyFormat("A< A< int > >();", Spaces);
16172 
16173   Spaces.SpacesInAngles = false;
16174   verifyFormat("A<A<int>>();", Spaces);
16175 }
16176 
16177 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
16178   FormatStyle Style = getLLVMStyle();
16179   Style.SpaceAfterTemplateKeyword = false;
16180   verifyFormat("template<int> void foo();", Style);
16181 }
16182 
16183 TEST_F(FormatTest, TripleAngleBrackets) {
16184   verifyFormat("f<<<1, 1>>>();");
16185   verifyFormat("f<<<1, 1, 1, s>>>();");
16186   verifyFormat("f<<<a, b, c, d>>>();");
16187   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
16188   verifyFormat("f<param><<<1, 1>>>();");
16189   verifyFormat("f<1><<<1, 1>>>();");
16190   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
16191   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16192                "aaaaaaaaaaa<<<\n    1, 1>>>();");
16193   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
16194                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
16195 }
16196 
16197 TEST_F(FormatTest, MergeLessLessAtEnd) {
16198   verifyFormat("<<");
16199   EXPECT_EQ("< < <", format("\\\n<<<"));
16200   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16201                "aaallvm::outs() <<");
16202   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16203                "aaaallvm::outs()\n    <<");
16204 }
16205 
16206 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
16207   std::string code = "#if A\n"
16208                      "#if B\n"
16209                      "a.\n"
16210                      "#endif\n"
16211                      "    a = 1;\n"
16212                      "#else\n"
16213                      "#endif\n"
16214                      "#if C\n"
16215                      "#else\n"
16216                      "#endif\n";
16217   EXPECT_EQ(code, format(code));
16218 }
16219 
16220 TEST_F(FormatTest, HandleConflictMarkers) {
16221   // Git/SVN conflict markers.
16222   EXPECT_EQ("int a;\n"
16223             "void f() {\n"
16224             "  callme(some(parameter1,\n"
16225             "<<<<<<< text by the vcs\n"
16226             "              parameter2),\n"
16227             "||||||| text by the vcs\n"
16228             "              parameter2),\n"
16229             "         parameter3,\n"
16230             "======= text by the vcs\n"
16231             "              parameter2, parameter3),\n"
16232             ">>>>>>> text by the vcs\n"
16233             "         otherparameter);\n",
16234             format("int a;\n"
16235                    "void f() {\n"
16236                    "  callme(some(parameter1,\n"
16237                    "<<<<<<< text by the vcs\n"
16238                    "  parameter2),\n"
16239                    "||||||| text by the vcs\n"
16240                    "  parameter2),\n"
16241                    "  parameter3,\n"
16242                    "======= text by the vcs\n"
16243                    "  parameter2,\n"
16244                    "  parameter3),\n"
16245                    ">>>>>>> text by the vcs\n"
16246                    "  otherparameter);\n"));
16247 
16248   // Perforce markers.
16249   EXPECT_EQ("void f() {\n"
16250             "  function(\n"
16251             ">>>> text by the vcs\n"
16252             "      parameter,\n"
16253             "==== text by the vcs\n"
16254             "      parameter,\n"
16255             "==== text by the vcs\n"
16256             "      parameter,\n"
16257             "<<<< text by the vcs\n"
16258             "      parameter);\n",
16259             format("void f() {\n"
16260                    "  function(\n"
16261                    ">>>> text by the vcs\n"
16262                    "  parameter,\n"
16263                    "==== text by the vcs\n"
16264                    "  parameter,\n"
16265                    "==== text by the vcs\n"
16266                    "  parameter,\n"
16267                    "<<<< text by the vcs\n"
16268                    "  parameter);\n"));
16269 
16270   EXPECT_EQ("<<<<<<<\n"
16271             "|||||||\n"
16272             "=======\n"
16273             ">>>>>>>",
16274             format("<<<<<<<\n"
16275                    "|||||||\n"
16276                    "=======\n"
16277                    ">>>>>>>"));
16278 
16279   EXPECT_EQ("<<<<<<<\n"
16280             "|||||||\n"
16281             "int i;\n"
16282             "=======\n"
16283             ">>>>>>>",
16284             format("<<<<<<<\n"
16285                    "|||||||\n"
16286                    "int i;\n"
16287                    "=======\n"
16288                    ">>>>>>>"));
16289 
16290   // FIXME: Handle parsing of macros around conflict markers correctly:
16291   EXPECT_EQ("#define Macro \\\n"
16292             "<<<<<<<\n"
16293             "Something \\\n"
16294             "|||||||\n"
16295             "Else \\\n"
16296             "=======\n"
16297             "Other \\\n"
16298             ">>>>>>>\n"
16299             "    End int i;\n",
16300             format("#define Macro \\\n"
16301                    "<<<<<<<\n"
16302                    "  Something \\\n"
16303                    "|||||||\n"
16304                    "  Else \\\n"
16305                    "=======\n"
16306                    "  Other \\\n"
16307                    ">>>>>>>\n"
16308                    "  End\n"
16309                    "int i;\n"));
16310 }
16311 
16312 TEST_F(FormatTest, DisableRegions) {
16313   EXPECT_EQ("int i;\n"
16314             "// clang-format off\n"
16315             "  int j;\n"
16316             "// clang-format on\n"
16317             "int k;",
16318             format(" int  i;\n"
16319                    "   // clang-format off\n"
16320                    "  int j;\n"
16321                    " // clang-format on\n"
16322                    "   int   k;"));
16323   EXPECT_EQ("int i;\n"
16324             "/* clang-format off */\n"
16325             "  int j;\n"
16326             "/* clang-format on */\n"
16327             "int k;",
16328             format(" int  i;\n"
16329                    "   /* clang-format off */\n"
16330                    "  int j;\n"
16331                    " /* clang-format on */\n"
16332                    "   int   k;"));
16333 
16334   // Don't reflow comments within disabled regions.
16335   EXPECT_EQ("// clang-format off\n"
16336             "// long long long long long long line\n"
16337             "/* clang-format on */\n"
16338             "/* long long long\n"
16339             " * long long long\n"
16340             " * line */\n"
16341             "int i;\n"
16342             "/* clang-format off */\n"
16343             "/* long long long long long long line */\n",
16344             format("// clang-format off\n"
16345                    "// long long long long long long line\n"
16346                    "/* clang-format on */\n"
16347                    "/* long long long long long long line */\n"
16348                    "int i;\n"
16349                    "/* clang-format off */\n"
16350                    "/* long long long long long long line */\n",
16351                    getLLVMStyleWithColumns(20)));
16352 }
16353 
16354 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
16355   format("? ) =");
16356   verifyNoCrash("#define a\\\n /**/}");
16357 }
16358 
16359 TEST_F(FormatTest, FormatsTableGenCode) {
16360   FormatStyle Style = getLLVMStyle();
16361   Style.Language = FormatStyle::LK_TableGen;
16362   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
16363 }
16364 
16365 TEST_F(FormatTest, ArrayOfTemplates) {
16366   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
16367             format("auto a = new unique_ptr<int > [ 10];"));
16368 
16369   FormatStyle Spaces = getLLVMStyle();
16370   Spaces.SpacesInSquareBrackets = true;
16371   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
16372             format("auto a = new unique_ptr<int > [10];", Spaces));
16373 }
16374 
16375 TEST_F(FormatTest, ArrayAsTemplateType) {
16376   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
16377             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
16378 
16379   FormatStyle Spaces = getLLVMStyle();
16380   Spaces.SpacesInSquareBrackets = true;
16381   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
16382             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
16383 }
16384 
16385 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
16386 
16387 TEST(FormatStyle, GetStyleWithEmptyFileName) {
16388   llvm::vfs::InMemoryFileSystem FS;
16389   auto Style1 = getStyle("file", "", "Google", "", &FS);
16390   ASSERT_TRUE((bool)Style1);
16391   ASSERT_EQ(*Style1, getGoogleStyle());
16392 }
16393 
16394 TEST(FormatStyle, GetStyleOfFile) {
16395   llvm::vfs::InMemoryFileSystem FS;
16396   // Test 1: format file in the same directory.
16397   ASSERT_TRUE(
16398       FS.addFile("/a/.clang-format", 0,
16399                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
16400   ASSERT_TRUE(
16401       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16402   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
16403   ASSERT_TRUE((bool)Style1);
16404   ASSERT_EQ(*Style1, getLLVMStyle());
16405 
16406   // Test 2.1: fallback to default.
16407   ASSERT_TRUE(
16408       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16409   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
16410   ASSERT_TRUE((bool)Style2);
16411   ASSERT_EQ(*Style2, getMozillaStyle());
16412 
16413   // Test 2.2: no format on 'none' fallback style.
16414   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16415   ASSERT_TRUE((bool)Style2);
16416   ASSERT_EQ(*Style2, getNoStyle());
16417 
16418   // Test 2.3: format if config is found with no based style while fallback is
16419   // 'none'.
16420   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
16421                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
16422   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16423   ASSERT_TRUE((bool)Style2);
16424   ASSERT_EQ(*Style2, getLLVMStyle());
16425 
16426   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
16427   Style2 = getStyle("{}", "a.h", "none", "", &FS);
16428   ASSERT_TRUE((bool)Style2);
16429   ASSERT_EQ(*Style2, getLLVMStyle());
16430 
16431   // Test 3: format file in parent directory.
16432   ASSERT_TRUE(
16433       FS.addFile("/c/.clang-format", 0,
16434                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
16435   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
16436                          llvm::MemoryBuffer::getMemBuffer("int i;")));
16437   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
16438   ASSERT_TRUE((bool)Style3);
16439   ASSERT_EQ(*Style3, getGoogleStyle());
16440 
16441   // Test 4: error on invalid fallback style
16442   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
16443   ASSERT_FALSE((bool)Style4);
16444   llvm::consumeError(Style4.takeError());
16445 
16446   // Test 5: error on invalid yaml on command line
16447   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
16448   ASSERT_FALSE((bool)Style5);
16449   llvm::consumeError(Style5.takeError());
16450 
16451   // Test 6: error on invalid style
16452   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
16453   ASSERT_FALSE((bool)Style6);
16454   llvm::consumeError(Style6.takeError());
16455 
16456   // Test 7: found config file, error on parsing it
16457   ASSERT_TRUE(
16458       FS.addFile("/d/.clang-format", 0,
16459                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
16460                                                   "InvalidKey: InvalidValue")));
16461   ASSERT_TRUE(
16462       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16463   auto Style7a = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
16464   ASSERT_FALSE((bool)Style7a);
16465   llvm::consumeError(Style7a.takeError());
16466 
16467   auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
16468   ASSERT_TRUE((bool)Style7b);
16469 
16470   // Test 8: inferred per-language defaults apply.
16471   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
16472   ASSERT_TRUE((bool)StyleTd);
16473   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
16474 }
16475 
16476 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
16477   // Column limit is 20.
16478   std::string Code = "Type *a =\n"
16479                      "    new Type();\n"
16480                      "g(iiiii, 0, jjjjj,\n"
16481                      "  0, kkkkk, 0, mm);\n"
16482                      "int  bad     = format   ;";
16483   std::string Expected = "auto a = new Type();\n"
16484                          "g(iiiii, nullptr,\n"
16485                          "  jjjjj, nullptr,\n"
16486                          "  kkkkk, nullptr,\n"
16487                          "  mm);\n"
16488                          "int  bad     = format   ;";
16489   FileID ID = Context.createInMemoryFile("format.cpp", Code);
16490   tooling::Replacements Replaces = toReplacements(
16491       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
16492                             "auto "),
16493        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
16494                             "nullptr"),
16495        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
16496                             "nullptr"),
16497        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
16498                             "nullptr")});
16499 
16500   format::FormatStyle Style = format::getLLVMStyle();
16501   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
16502   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16503   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16504       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16505   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16506   EXPECT_TRUE(static_cast<bool>(Result));
16507   EXPECT_EQ(Expected, *Result);
16508 }
16509 
16510 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
16511   std::string Code = "#include \"a.h\"\n"
16512                      "#include \"c.h\"\n"
16513                      "\n"
16514                      "int main() {\n"
16515                      "  return 0;\n"
16516                      "}";
16517   std::string Expected = "#include \"a.h\"\n"
16518                          "#include \"b.h\"\n"
16519                          "#include \"c.h\"\n"
16520                          "\n"
16521                          "int main() {\n"
16522                          "  return 0;\n"
16523                          "}";
16524   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
16525   tooling::Replacements Replaces = toReplacements(
16526       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
16527                             "#include \"b.h\"\n")});
16528 
16529   format::FormatStyle Style = format::getLLVMStyle();
16530   Style.SortIncludes = true;
16531   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16532   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16533       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16534   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16535   EXPECT_TRUE(static_cast<bool>(Result));
16536   EXPECT_EQ(Expected, *Result);
16537 }
16538 
16539 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
16540   EXPECT_EQ("using std::cin;\n"
16541             "using std::cout;",
16542             format("using std::cout;\n"
16543                    "using std::cin;",
16544                    getGoogleStyle()));
16545 }
16546 
16547 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
16548   format::FormatStyle Style = format::getLLVMStyle();
16549   Style.Standard = FormatStyle::LS_Cpp03;
16550   // cpp03 recognize this string as identifier u8 and literal character 'a'
16551   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
16552 }
16553 
16554 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
16555   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
16556   // all modes, including C++11, C++14 and C++17
16557   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
16558 }
16559 
16560 TEST_F(FormatTest, DoNotFormatLikelyXml) {
16561   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
16562   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
16563 }
16564 
16565 TEST_F(FormatTest, StructuredBindings) {
16566   // Structured bindings is a C++17 feature.
16567   // all modes, including C++11, C++14 and C++17
16568   verifyFormat("auto [a, b] = f();");
16569   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
16570   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
16571   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
16572   EXPECT_EQ("auto const volatile [a, b] = f();",
16573             format("auto  const   volatile[a, b] = f();"));
16574   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
16575   EXPECT_EQ("auto &[a, b, c] = f();",
16576             format("auto   &[  a  ,  b,c   ] = f();"));
16577   EXPECT_EQ("auto &&[a, b, c] = f();",
16578             format("auto   &&[  a  ,  b,c   ] = f();"));
16579   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
16580   EXPECT_EQ("auto const volatile &&[a, b] = f();",
16581             format("auto  const  volatile  &&[a, b] = f();"));
16582   EXPECT_EQ("auto const &&[a, b] = f();",
16583             format("auto  const   &&  [a, b] = f();"));
16584   EXPECT_EQ("const auto &[a, b] = f();",
16585             format("const  auto  &  [a, b] = f();"));
16586   EXPECT_EQ("const auto volatile &&[a, b] = f();",
16587             format("const  auto   volatile  &&[a, b] = f();"));
16588   EXPECT_EQ("volatile const auto &&[a, b] = f();",
16589             format("volatile  const  auto   &&[a, b] = f();"));
16590   EXPECT_EQ("const auto &&[a, b] = f();",
16591             format("const  auto  &&  [a, b] = f();"));
16592 
16593   // Make sure we don't mistake structured bindings for lambdas.
16594   FormatStyle PointerMiddle = getLLVMStyle();
16595   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16596   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16597   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16598   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16599   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16600   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16601   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16602   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16603   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16604   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16605   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16606   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16607   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16608 
16609   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16610             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16611   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16612             format("for (const auto   &   [a, b] : some_range) {\n}"));
16613   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16614             format("for (const auto[a, b] : some_range) {\n}"));
16615   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16616   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16617   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16618   EXPECT_EQ("auto const &[x, y](expr);",
16619             format("auto  const  &  [x,y]  (expr);"));
16620   EXPECT_EQ("auto const &&[x, y](expr);",
16621             format("auto  const  &&  [x,y]  (expr);"));
16622   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16623   EXPECT_EQ("auto const &[x, y]{expr};",
16624             format("auto  const  &  [x,y]  {expr};"));
16625   EXPECT_EQ("auto const &&[x, y]{expr};",
16626             format("auto  const  &&  [x,y]  {expr};"));
16627 
16628   format::FormatStyle Spaces = format::getLLVMStyle();
16629   Spaces.SpacesInSquareBrackets = true;
16630   verifyFormat("auto [ a, b ] = f();", Spaces);
16631   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16632   verifyFormat("auto &[ a, b ] = f();", Spaces);
16633   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16634   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16635 }
16636 
16637 TEST_F(FormatTest, FileAndCode) {
16638   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16639   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16640   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16641   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16642   EXPECT_EQ(FormatStyle::LK_ObjC,
16643             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16644   EXPECT_EQ(
16645       FormatStyle::LK_ObjC,
16646       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16647   EXPECT_EQ(FormatStyle::LK_ObjC,
16648             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16649   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16650   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16651   EXPECT_EQ(FormatStyle::LK_ObjC,
16652             guessLanguage("foo", "@interface Foo\n@end\n"));
16653   EXPECT_EQ(FormatStyle::LK_ObjC,
16654             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16655   EXPECT_EQ(
16656       FormatStyle::LK_ObjC,
16657       guessLanguage("foo.h",
16658                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16659   EXPECT_EQ(
16660       FormatStyle::LK_Cpp,
16661       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16662 }
16663 
16664 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16665   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16666   EXPECT_EQ(FormatStyle::LK_ObjC,
16667             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16668   EXPECT_EQ(FormatStyle::LK_Cpp,
16669             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16670   EXPECT_EQ(
16671       FormatStyle::LK_Cpp,
16672       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16673   EXPECT_EQ(FormatStyle::LK_ObjC,
16674             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16675   EXPECT_EQ(FormatStyle::LK_Cpp,
16676             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16677   EXPECT_EQ(FormatStyle::LK_ObjC,
16678             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16679   EXPECT_EQ(FormatStyle::LK_Cpp,
16680             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16681   EXPECT_EQ(FormatStyle::LK_Cpp,
16682             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16683   EXPECT_EQ(FormatStyle::LK_ObjC,
16684             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16685   EXPECT_EQ(FormatStyle::LK_Cpp,
16686             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16687   EXPECT_EQ(
16688       FormatStyle::LK_Cpp,
16689       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16690   EXPECT_EQ(
16691       FormatStyle::LK_Cpp,
16692       guessLanguage("foo.h",
16693                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16694   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16695 }
16696 
16697 TEST_F(FormatTest, GuessLanguageWithCaret) {
16698   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16699   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16700   EXPECT_EQ(FormatStyle::LK_ObjC,
16701             guessLanguage("foo.h", "int(^)(char, float);"));
16702   EXPECT_EQ(FormatStyle::LK_ObjC,
16703             guessLanguage("foo.h", "int(^foo)(char, float);"));
16704   EXPECT_EQ(FormatStyle::LK_ObjC,
16705             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16706   EXPECT_EQ(FormatStyle::LK_ObjC,
16707             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16708   EXPECT_EQ(
16709       FormatStyle::LK_ObjC,
16710       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16711 }
16712 
16713 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16714   // ASM symbolic names are identifiers that must be surrounded by [] without
16715   // space in between:
16716   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16717 
16718   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16719   verifyFormat(R"(//
16720 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16721 )");
16722 
16723   // A list of several ASM symbolic names.
16724   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16725 
16726   // ASM symbolic names in inline ASM with inputs and outputs.
16727   verifyFormat(R"(//
16728 asm("cmoveq %1, %2, %[result]"
16729     : [result] "=r"(result)
16730     : "r"(test), "r"(new), "[result]"(old));
16731 )");
16732 
16733   // ASM symbolic names in inline ASM with no outputs.
16734   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16735 }
16736 
16737 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
16738   EXPECT_EQ(FormatStyle::LK_Cpp,
16739             guessLanguage("foo.h", "void f() {\n"
16740                                    "  asm (\"mov %[e], %[d]\"\n"
16741                                    "     : [d] \"=rm\" (d)\n"
16742                                    "       [e] \"rm\" (*e));\n"
16743                                    "}"));
16744   EXPECT_EQ(FormatStyle::LK_Cpp,
16745             guessLanguage("foo.h", "void f() {\n"
16746                                    "  _asm (\"mov %[e], %[d]\"\n"
16747                                    "     : [d] \"=rm\" (d)\n"
16748                                    "       [e] \"rm\" (*e));\n"
16749                                    "}"));
16750   EXPECT_EQ(FormatStyle::LK_Cpp,
16751             guessLanguage("foo.h", "void f() {\n"
16752                                    "  __asm (\"mov %[e], %[d]\"\n"
16753                                    "     : [d] \"=rm\" (d)\n"
16754                                    "       [e] \"rm\" (*e));\n"
16755                                    "}"));
16756   EXPECT_EQ(FormatStyle::LK_Cpp,
16757             guessLanguage("foo.h", "void f() {\n"
16758                                    "  __asm__ (\"mov %[e], %[d]\"\n"
16759                                    "     : [d] \"=rm\" (d)\n"
16760                                    "       [e] \"rm\" (*e));\n"
16761                                    "}"));
16762   EXPECT_EQ(FormatStyle::LK_Cpp,
16763             guessLanguage("foo.h", "void f() {\n"
16764                                    "  asm (\"mov %[e], %[d]\"\n"
16765                                    "     : [d] \"=rm\" (d),\n"
16766                                    "       [e] \"rm\" (*e));\n"
16767                                    "}"));
16768   EXPECT_EQ(FormatStyle::LK_Cpp,
16769             guessLanguage("foo.h", "void f() {\n"
16770                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16771                                    "     : [d] \"=rm\" (d)\n"
16772                                    "       [e] \"rm\" (*e));\n"
16773                                    "}"));
16774 }
16775 
16776 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16777   EXPECT_EQ(FormatStyle::LK_Cpp,
16778             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16779   EXPECT_EQ(FormatStyle::LK_ObjC,
16780             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16781   EXPECT_EQ(
16782       FormatStyle::LK_Cpp,
16783       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16784   EXPECT_EQ(
16785       FormatStyle::LK_ObjC,
16786       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16787 }
16788 
16789 TEST_F(FormatTest, TypenameMacros) {
16790   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16791 
16792   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16793   FormatStyle Google = getGoogleStyleWithColumns(0);
16794   Google.TypenameMacros = TypenameMacros;
16795   verifyFormat("struct foo {\n"
16796                "  int bar;\n"
16797                "  TAILQ_ENTRY(a) bleh;\n"
16798                "};",
16799                Google);
16800 
16801   FormatStyle Macros = getLLVMStyle();
16802   Macros.TypenameMacros = TypenameMacros;
16803 
16804   verifyFormat("STACK_OF(int) a;", Macros);
16805   verifyFormat("STACK_OF(int) *a;", Macros);
16806   verifyFormat("STACK_OF(int const *) *a;", Macros);
16807   verifyFormat("STACK_OF(int *const) *a;", Macros);
16808   verifyFormat("STACK_OF(int, string) a;", Macros);
16809   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16810   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16811   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16812   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16813   verifyFormat("vector<LIST(uint64_t) *attr> x;", Macros);
16814   verifyFormat("vector<LIST(uint64_t) *const> f(LIST(uint64_t) *arg);", Macros);
16815 
16816   Macros.PointerAlignment = FormatStyle::PAS_Left;
16817   verifyFormat("STACK_OF(int)* a;", Macros);
16818   verifyFormat("STACK_OF(int*)* a;", Macros);
16819   verifyFormat("x = (STACK_OF(uint64_t))*a;", Macros);
16820   verifyFormat("x = (STACK_OF(uint64_t))&a;", Macros);
16821   verifyFormat("vector<STACK_OF(uint64_t)* attr> x;", Macros);
16822 }
16823 
16824 TEST_F(FormatTest, AtomicQualifier) {
16825   // Check that we treate _Atomic as a type and not a function call
16826   FormatStyle Google = getGoogleStyleWithColumns(0);
16827   verifyFormat("struct foo {\n"
16828                "  int a1;\n"
16829                "  _Atomic(a) a2;\n"
16830                "  _Atomic(_Atomic(int) *const) a3;\n"
16831                "};",
16832                Google);
16833   verifyFormat("_Atomic(uint64_t) a;");
16834   verifyFormat("_Atomic(uint64_t) *a;");
16835   verifyFormat("_Atomic(uint64_t const *) *a;");
16836   verifyFormat("_Atomic(uint64_t *const) *a;");
16837   verifyFormat("_Atomic(const uint64_t *) *a;");
16838   verifyFormat("_Atomic(uint64_t) a;");
16839   verifyFormat("_Atomic(_Atomic(uint64_t)) a;");
16840   verifyFormat("_Atomic(_Atomic(uint64_t)) a, b;");
16841   verifyFormat("for (_Atomic(uint64_t) *a = NULL; a;) {\n}");
16842   verifyFormat("_Atomic(uint64_t) f(_Atomic(uint64_t) *arg);");
16843 
16844   verifyFormat("_Atomic(uint64_t) *s(InitValue);");
16845   verifyFormat("_Atomic(uint64_t) *s{InitValue};");
16846   FormatStyle Style = getLLVMStyle();
16847   Style.PointerAlignment = FormatStyle::PAS_Left;
16848   verifyFormat("_Atomic(uint64_t)* s(InitValue);", Style);
16849   verifyFormat("_Atomic(uint64_t)* s{InitValue};", Style);
16850   verifyFormat("_Atomic(int)* a;", Style);
16851   verifyFormat("_Atomic(int*)* a;", Style);
16852   verifyFormat("vector<_Atomic(uint64_t)* attr> x;", Style);
16853 
16854   Style.SpacesInCStyleCastParentheses = true;
16855   Style.SpacesInParentheses = false;
16856   verifyFormat("x = ( _Atomic(uint64_t) )*a;", Style);
16857   Style.SpacesInCStyleCastParentheses = false;
16858   Style.SpacesInParentheses = true;
16859   verifyFormat("x = (_Atomic( uint64_t ))*a;", Style);
16860   verifyFormat("x = (_Atomic( uint64_t ))&a;", Style);
16861 }
16862 
16863 TEST_F(FormatTest, AmbersandInLamda) {
16864   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16865   FormatStyle AlignStyle = getLLVMStyle();
16866   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16867   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16868   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16869   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16870 }
16871 
16872 TEST_F(FormatTest, SpacesInConditionalStatement) {
16873   FormatStyle Spaces = getLLVMStyle();
16874   Spaces.SpacesInConditionalStatement = true;
16875   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16876   verifyFormat("if ( !a )\n  return;", Spaces);
16877   verifyFormat("if ( a )\n  return;", Spaces);
16878   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16879   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16880   verifyFormat("while ( a )\n  return;", Spaces);
16881   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16882   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16883   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16884   // Check that space on the left of "::" is inserted as expected at beginning
16885   // of condition.
16886   verifyFormat("while ( ::func() )\n  return;", Spaces);
16887 }
16888 
16889 TEST_F(FormatTest, AlternativeOperators) {
16890   // Test case for ensuring alternate operators are not
16891   // combined with their right most neighbour.
16892   verifyFormat("int a and b;");
16893   verifyFormat("int a and_eq b;");
16894   verifyFormat("int a bitand b;");
16895   verifyFormat("int a bitor b;");
16896   verifyFormat("int a compl b;");
16897   verifyFormat("int a not b;");
16898   verifyFormat("int a not_eq b;");
16899   verifyFormat("int a or b;");
16900   verifyFormat("int a xor b;");
16901   verifyFormat("int a xor_eq b;");
16902   verifyFormat("return this not_eq bitand other;");
16903   verifyFormat("bool operator not_eq(const X bitand other)");
16904 
16905   verifyFormat("int a and 5;");
16906   verifyFormat("int a and_eq 5;");
16907   verifyFormat("int a bitand 5;");
16908   verifyFormat("int a bitor 5;");
16909   verifyFormat("int a compl 5;");
16910   verifyFormat("int a not 5;");
16911   verifyFormat("int a not_eq 5;");
16912   verifyFormat("int a or 5;");
16913   verifyFormat("int a xor 5;");
16914   verifyFormat("int a xor_eq 5;");
16915 
16916   verifyFormat("int a compl(5);");
16917   verifyFormat("int a not(5);");
16918 
16919   /* FIXME handle alternate tokens
16920    * https://en.cppreference.com/w/cpp/language/operator_alternative
16921   // alternative tokens
16922   verifyFormat("compl foo();");     //  ~foo();
16923   verifyFormat("foo() <%%>;");      // foo();
16924   verifyFormat("void foo() <%%>;"); // void foo(){}
16925   verifyFormat("int a <:1:>;");     // int a[1];[
16926   verifyFormat("%:define ABC abc"); // #define ABC abc
16927   verifyFormat("%:%:");             // ##
16928   */
16929 }
16930 
16931 TEST_F(FormatTest, STLWhileNotDefineChed) {
16932   verifyFormat("#if defined(while)\n"
16933                "#define while EMIT WARNING C4005\n"
16934                "#endif // while");
16935 }
16936 
16937 TEST_F(FormatTest, OperatorSpacing) {
16938   FormatStyle Style = getLLVMStyle();
16939   Style.PointerAlignment = FormatStyle::PAS_Right;
16940   verifyFormat("Foo::operator*();", Style);
16941   verifyFormat("Foo::operator void *();", Style);
16942   verifyFormat("Foo::operator void **();", Style);
16943   verifyFormat("Foo::operator void *&();", Style);
16944   verifyFormat("Foo::operator void *&&();", Style);
16945   verifyFormat("Foo::operator()(void *);", Style);
16946   verifyFormat("Foo::operator*(void *);", Style);
16947   verifyFormat("Foo::operator*();", Style);
16948   verifyFormat("Foo::operator**();", Style);
16949   verifyFormat("Foo::operator&();", Style);
16950   verifyFormat("Foo::operator<int> *();", Style);
16951   verifyFormat("Foo::operator<Foo> *();", Style);
16952   verifyFormat("Foo::operator<int> **();", Style);
16953   verifyFormat("Foo::operator<Foo> **();", Style);
16954   verifyFormat("Foo::operator<int> &();", Style);
16955   verifyFormat("Foo::operator<Foo> &();", Style);
16956   verifyFormat("Foo::operator<int> &&();", Style);
16957   verifyFormat("Foo::operator<Foo> &&();", Style);
16958   verifyFormat("Foo::operator<int> *&();", Style);
16959   verifyFormat("Foo::operator<Foo> *&();", Style);
16960   verifyFormat("Foo::operator<int> *&&();", Style);
16961   verifyFormat("Foo::operator<Foo> *&&();", Style);
16962   verifyFormat("operator*(int (*)(), class Foo);", Style);
16963 
16964   verifyFormat("Foo::operator&();", Style);
16965   verifyFormat("Foo::operator void &();", Style);
16966   verifyFormat("Foo::operator()(void &);", Style);
16967   verifyFormat("Foo::operator&(void &);", Style);
16968   verifyFormat("Foo::operator&();", Style);
16969   verifyFormat("operator&(int (&)(), class Foo);", Style);
16970 
16971   verifyFormat("Foo::operator&&();", Style);
16972   verifyFormat("Foo::operator**();", Style);
16973   verifyFormat("Foo::operator void &&();", Style);
16974   verifyFormat("Foo::operator()(void &&);", Style);
16975   verifyFormat("Foo::operator&&(void &&);", Style);
16976   verifyFormat("Foo::operator&&();", Style);
16977   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16978   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16979   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16980                Style);
16981   verifyFormat("operator void **()", Style);
16982   verifyFormat("operator const FooRight<Object> &()", Style);
16983   verifyFormat("operator const FooRight<Object> *()", Style);
16984   verifyFormat("operator const FooRight<Object> **()", Style);
16985   verifyFormat("operator const FooRight<Object> *&()", Style);
16986   verifyFormat("operator const FooRight<Object> *&&()", Style);
16987 
16988   Style.PointerAlignment = FormatStyle::PAS_Left;
16989   verifyFormat("Foo::operator*();", Style);
16990   verifyFormat("Foo::operator**();", Style);
16991   verifyFormat("Foo::operator void*();", Style);
16992   verifyFormat("Foo::operator void**();", Style);
16993   verifyFormat("Foo::operator void*&();", Style);
16994   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16995   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16996   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16997   verifyFormat("Foo::operator()(void*);", Style);
16998   verifyFormat("Foo::operator*(void*);", Style);
16999   verifyFormat("Foo::operator*();", Style);
17000   verifyFormat("Foo::operator<int>*();", Style);
17001   verifyFormat("Foo::operator<Foo>*();", Style);
17002   verifyFormat("Foo::operator<int>**();", Style);
17003   verifyFormat("Foo::operator<Foo>**();", Style);
17004   verifyFormat("Foo::operator<Foo>*&();", Style);
17005   verifyFormat("Foo::operator<int>&();", Style);
17006   verifyFormat("Foo::operator<Foo>&();", Style);
17007   verifyFormat("Foo::operator<int>&&();", Style);
17008   verifyFormat("Foo::operator<Foo>&&();", Style);
17009   verifyFormat("Foo::operator<int>*&();", Style);
17010   verifyFormat("Foo::operator<Foo>*&();", Style);
17011   verifyFormat("operator*(int (*)(), class Foo);", Style);
17012 
17013   verifyFormat("Foo::operator&();", Style);
17014   verifyFormat("Foo::operator void&();", Style);
17015   verifyFormat("Foo::operator/*comment*/ void&();", Style);
17016   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
17017   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
17018   verifyFormat("Foo::operator()(void&);", Style);
17019   verifyFormat("Foo::operator&(void&);", Style);
17020   verifyFormat("Foo::operator&();", Style);
17021   verifyFormat("operator&(int (&)(), class Foo);", Style);
17022 
17023   verifyFormat("Foo::operator&&();", Style);
17024   verifyFormat("Foo::operator void&&();", Style);
17025   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
17026   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
17027   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
17028   verifyFormat("Foo::operator()(void&&);", Style);
17029   verifyFormat("Foo::operator&&(void&&);", Style);
17030   verifyFormat("Foo::operator&&();", Style);
17031   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
17032   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
17033   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
17034                Style);
17035   verifyFormat("operator void**()", Style);
17036   verifyFormat("operator const FooLeft<Object>&()", Style);
17037   verifyFormat("operator const FooLeft<Object>*()", Style);
17038   verifyFormat("operator const FooLeft<Object>**()", Style);
17039   verifyFormat("operator const FooLeft<Object>*&()", Style);
17040   verifyFormat("operator const FooLeft<Object>*&&()", Style);
17041 
17042   // PR45107
17043   verifyFormat("operator Vector<String>&();", Style);
17044   verifyFormat("operator const Vector<String>&();", Style);
17045   verifyFormat("operator foo::Bar*();", Style);
17046   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
17047   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
17048                Style);
17049 
17050   Style.PointerAlignment = FormatStyle::PAS_Middle;
17051   verifyFormat("Foo::operator*();", Style);
17052   verifyFormat("Foo::operator void *();", Style);
17053   verifyFormat("Foo::operator()(void *);", Style);
17054   verifyFormat("Foo::operator*(void *);", Style);
17055   verifyFormat("Foo::operator*();", Style);
17056   verifyFormat("operator*(int (*)(), class Foo);", Style);
17057 
17058   verifyFormat("Foo::operator&();", Style);
17059   verifyFormat("Foo::operator void &();", Style);
17060   verifyFormat("Foo::operator()(void &);", Style);
17061   verifyFormat("Foo::operator&(void &);", Style);
17062   verifyFormat("Foo::operator&();", Style);
17063   verifyFormat("operator&(int (&)(), class Foo);", Style);
17064 
17065   verifyFormat("Foo::operator&&();", Style);
17066   verifyFormat("Foo::operator void &&();", Style);
17067   verifyFormat("Foo::operator()(void &&);", Style);
17068   verifyFormat("Foo::operator&&(void &&);", Style);
17069   verifyFormat("Foo::operator&&();", Style);
17070   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
17071 }
17072 
17073 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
17074   FormatStyle Style = getLLVMStyle();
17075   // PR46157
17076   verifyFormat("foo(operator+, -42);", Style);
17077   verifyFormat("foo(operator++, -42);", Style);
17078   verifyFormat("foo(operator--, -42);", Style);
17079   verifyFormat("foo(-42, operator--);", Style);
17080   verifyFormat("foo(-42, operator, );", Style);
17081   verifyFormat("foo(operator, , -42);", Style);
17082 }
17083 
17084 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
17085   FormatStyle Style = getLLVMStyle();
17086   Style.WhitespaceSensitiveMacros.push_back("FOO");
17087 
17088   // Don't use the helpers here, since 'mess up' will change the whitespace
17089   // and these are all whitespace sensitive by definition
17090   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
17091             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
17092   EXPECT_EQ(
17093       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
17094       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
17095   EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
17096             format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
17097   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
17098             "       Still=Intentional);",
17099             format("FOO(String-ized&Messy+But,: :\n"
17100                    "       Still=Intentional);",
17101                    Style));
17102   Style.AlignConsecutiveAssignments = true;
17103   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
17104             "       Still=Intentional);",
17105             format("FOO(String-ized=&Messy+But,: :\n"
17106                    "       Still=Intentional);",
17107                    Style));
17108 
17109   Style.ColumnLimit = 21;
17110   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
17111             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
17112 }
17113 
17114 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
17115   // These tests are not in NamespaceFixer because that doesn't
17116   // test its interaction with line wrapping
17117   FormatStyle Style = getLLVMStyle();
17118   Style.ColumnLimit = 80;
17119   verifyFormat("namespace {\n"
17120                "int i;\n"
17121                "int j;\n"
17122                "} // namespace",
17123                Style);
17124 
17125   verifyFormat("namespace AAA {\n"
17126                "int i;\n"
17127                "int j;\n"
17128                "} // namespace AAA",
17129                Style);
17130 
17131   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
17132             "int i;\n"
17133             "int j;\n"
17134             "} // namespace Averyveryveryverylongnamespace",
17135             format("namespace Averyveryveryverylongnamespace {\n"
17136                    "int i;\n"
17137                    "int j;\n"
17138                    "}",
17139                    Style));
17140 
17141   EXPECT_EQ(
17142       "namespace "
17143       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
17144       "    went::mad::now {\n"
17145       "int i;\n"
17146       "int j;\n"
17147       "} // namespace\n"
17148       "  // "
17149       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
17150       "went::mad::now",
17151       format("namespace "
17152              "would::it::save::you::a::lot::of::time::if_::i::"
17153              "just::gave::up::and_::went::mad::now {\n"
17154              "int i;\n"
17155              "int j;\n"
17156              "}",
17157              Style));
17158 
17159   // This used to duplicate the comment again and again on subsequent runs
17160   EXPECT_EQ(
17161       "namespace "
17162       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
17163       "    went::mad::now {\n"
17164       "int i;\n"
17165       "int j;\n"
17166       "} // namespace\n"
17167       "  // "
17168       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
17169       "went::mad::now",
17170       format("namespace "
17171              "would::it::save::you::a::lot::of::time::if_::i::"
17172              "just::gave::up::and_::went::mad::now {\n"
17173              "int i;\n"
17174              "int j;\n"
17175              "} // namespace\n"
17176              "  // "
17177              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
17178              "and_::went::mad::now",
17179              Style));
17180 }
17181 
17182 TEST_F(FormatTest, LikelyUnlikely) {
17183   FormatStyle Style = getLLVMStyle();
17184 
17185   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17186                "  return 29;\n"
17187                "}",
17188                Style);
17189 
17190   verifyFormat("if (argc > 5) [[likely]] {\n"
17191                "  return 29;\n"
17192                "}",
17193                Style);
17194 
17195   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17196                "  return 29;\n"
17197                "} else [[likely]] {\n"
17198                "  return 42;\n"
17199                "}\n",
17200                Style);
17201 
17202   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17203                "  return 29;\n"
17204                "} else if (argc > 10) [[likely]] {\n"
17205                "  return 99;\n"
17206                "} else {\n"
17207                "  return 42;\n"
17208                "}\n",
17209                Style);
17210 
17211   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
17212                "  return 29;\n"
17213                "}",
17214                Style);
17215 }
17216 
17217 TEST_F(FormatTest, LLVMDefaultStyle) {
17218   FormatStyle Style = getLLVMStyle();
17219   verifyFormat("extern \"C\" {\n"
17220                "int foo();\n"
17221                "}",
17222                Style);
17223 }
17224 TEST_F(FormatTest, GNUDefaultStyle) {
17225   FormatStyle Style = getGNUStyle();
17226   verifyFormat("extern \"C\"\n"
17227                "{\n"
17228                "  int foo ();\n"
17229                "}",
17230                Style);
17231 }
17232 TEST_F(FormatTest, MozillaDefaultStyle) {
17233   FormatStyle Style = getMozillaStyle();
17234   verifyFormat("extern \"C\"\n"
17235                "{\n"
17236                "  int foo();\n"
17237                "}",
17238                Style);
17239 }
17240 TEST_F(FormatTest, GoogleDefaultStyle) {
17241   FormatStyle Style = getGoogleStyle();
17242   verifyFormat("extern \"C\" {\n"
17243                "int foo();\n"
17244                "}",
17245                Style);
17246 }
17247 TEST_F(FormatTest, ChromiumDefaultStyle) {
17248   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
17249   verifyFormat("extern \"C\" {\n"
17250                "int foo();\n"
17251                "}",
17252                Style);
17253 }
17254 TEST_F(FormatTest, MicrosoftDefaultStyle) {
17255   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
17256   verifyFormat("extern \"C\"\n"
17257                "{\n"
17258                "    int foo();\n"
17259                "}",
17260                Style);
17261 }
17262 TEST_F(FormatTest, WebKitDefaultStyle) {
17263   FormatStyle Style = getWebKitStyle();
17264   verifyFormat("extern \"C\" {\n"
17265                "int foo();\n"
17266                "}",
17267                Style);
17268 }
17269 } // namespace
17270 } // namespace format
17271 } // namespace clang
17272