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, BreakConstructorInitializersAfterColon) {
4996   FormatStyle Style = getLLVMStyle();
4997   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4998 
4999   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
5000   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
5001                getStyleWithColumns(Style, 45));
5002   verifyFormat("Constructor() :\n"
5003                "    Initializer(FitsOnTheLine) {}",
5004                getStyleWithColumns(Style, 44));
5005   verifyFormat("Constructor() :\n"
5006                "    Initializer(FitsOnTheLine) {}",
5007                getStyleWithColumns(Style, 43));
5008 
5009   verifyFormat("template <typename T>\n"
5010                "Constructor() : Initializer(FitsOnTheLine) {}",
5011                getStyleWithColumns(Style, 50));
5012   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5013   verifyFormat(
5014       "SomeClass::Constructor() :\n"
5015       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5016       Style);
5017 
5018   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
5019   verifyFormat(
5020       "SomeClass::Constructor() :\n"
5021       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5022       Style);
5023 
5024   verifyFormat(
5025       "SomeClass::Constructor() :\n"
5026       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5027       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5028       Style);
5029   verifyFormat(
5030       "SomeClass::Constructor() :\n"
5031       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5032       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5033       Style);
5034   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5035                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
5036                "    aaaaaaaaaa(aaaaaa) {}",
5037                Style);
5038 
5039   verifyFormat("Constructor() :\n"
5040                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5041                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5042                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5043                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
5044                Style);
5045 
5046   verifyFormat("Constructor() :\n"
5047                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5048                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5049                Style);
5050 
5051   verifyFormat("Constructor(int Parameter = 0) :\n"
5052                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
5053                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
5054                Style);
5055   verifyFormat("Constructor() :\n"
5056                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
5057                "}",
5058                getStyleWithColumns(Style, 60));
5059   verifyFormat("Constructor() :\n"
5060                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5061                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
5062                Style);
5063 
5064   // Here a line could be saved by splitting the second initializer onto two
5065   // lines, but that is not desirable.
5066   verifyFormat("Constructor() :\n"
5067                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
5068                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
5069                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5070                Style);
5071 
5072   FormatStyle OnePerLine = Style;
5073   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5074   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
5075   verifyFormat("SomeClass::Constructor() :\n"
5076                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5077                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5078                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5079                OnePerLine);
5080   verifyFormat("SomeClass::Constructor() :\n"
5081                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
5082                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5083                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5084                OnePerLine);
5085   verifyFormat("MyClass::MyClass(int var) :\n"
5086                "    some_var_(var),            // 4 space indent\n"
5087                "    some_other_var_(var + 1) { // lined up\n"
5088                "}",
5089                OnePerLine);
5090   verifyFormat("Constructor() :\n"
5091                "    aaaaa(aaaaaa),\n"
5092                "    aaaaa(aaaaaa),\n"
5093                "    aaaaa(aaaaaa),\n"
5094                "    aaaaa(aaaaaa),\n"
5095                "    aaaaa(aaaaaa) {}",
5096                OnePerLine);
5097   verifyFormat("Constructor() :\n"
5098                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5099                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
5100                OnePerLine);
5101   OnePerLine.BinPackParameters = false;
5102   verifyFormat("Constructor() :\n"
5103                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5104                "        aaaaaaaaaaa().aaa(),\n"
5105                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5106                OnePerLine);
5107   OnePerLine.ColumnLimit = 60;
5108   verifyFormat("Constructor() :\n"
5109                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
5110                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
5111                OnePerLine);
5112 
5113   EXPECT_EQ("Constructor() :\n"
5114             "    // Comment forcing unwanted break.\n"
5115             "    aaaa(aaaa) {}",
5116             format("Constructor() :\n"
5117                    "    // Comment forcing unwanted break.\n"
5118                    "    aaaa(aaaa) {}",
5119                    Style));
5120 
5121   Style.ColumnLimit = 0;
5122   verifyFormat("SomeClass::Constructor() :\n"
5123                "    a(a) {}",
5124                Style);
5125   verifyFormat("SomeClass::Constructor() noexcept :\n"
5126                "    a(a) {}",
5127                Style);
5128   verifyFormat("SomeClass::Constructor() :\n"
5129                "    a(a), b(b), c(c) {}",
5130                Style);
5131   verifyFormat("SomeClass::Constructor() :\n"
5132                "    a(a) {\n"
5133                "  foo();\n"
5134                "  bar();\n"
5135                "}",
5136                Style);
5137 
5138   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5139   verifyFormat("SomeClass::Constructor() :\n"
5140                "    a(a), b(b), c(c) {\n"
5141                "}",
5142                Style);
5143   verifyFormat("SomeClass::Constructor() :\n"
5144                "    a(a) {\n"
5145                "}",
5146                Style);
5147 
5148   Style.ColumnLimit = 80;
5149   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5150   Style.ConstructorInitializerIndentWidth = 2;
5151   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5152   verifyFormat("SomeClass::Constructor() :\n"
5153                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5154                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5155                Style);
5156 
5157   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5158   // well
5159   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5160   verifyFormat(
5161       "class SomeClass\n"
5162       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5163       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5164       Style);
5165   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5166   verifyFormat(
5167       "class SomeClass\n"
5168       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5169       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5170       Style);
5171   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5172   verifyFormat(
5173       "class SomeClass :\n"
5174       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5175       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5176       Style);
5177 }
5178 
5179 #ifndef EXPENSIVE_CHECKS
5180 // Expensive checks enables libstdc++ checking which includes validating the
5181 // state of ranges used in std::priority_queue - this blows out the
5182 // runtime/scalability of the function and makes this test unacceptably slow.
5183 TEST_F(FormatTest, MemoizationTests) {
5184   // This breaks if the memoization lookup does not take \c Indent and
5185   // \c LastSpace into account.
5186   verifyFormat(
5187       "extern CFRunLoopTimerRef\n"
5188       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5189       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
5190       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
5191       "                     CFRunLoopTimerContext *context) {}");
5192 
5193   // Deep nesting somewhat works around our memoization.
5194   verifyFormat(
5195       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5196       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5197       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5198       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5199       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
5200       getLLVMStyleWithColumns(65));
5201   verifyFormat(
5202       "aaaaa(\n"
5203       "    aaaaa,\n"
5204       "    aaaaa(\n"
5205       "        aaaaa,\n"
5206       "        aaaaa(\n"
5207       "            aaaaa,\n"
5208       "            aaaaa(\n"
5209       "                aaaaa,\n"
5210       "                aaaaa(\n"
5211       "                    aaaaa,\n"
5212       "                    aaaaa(\n"
5213       "                        aaaaa,\n"
5214       "                        aaaaa(\n"
5215       "                            aaaaa,\n"
5216       "                            aaaaa(\n"
5217       "                                aaaaa,\n"
5218       "                                aaaaa(\n"
5219       "                                    aaaaa,\n"
5220       "                                    aaaaa(\n"
5221       "                                        aaaaa,\n"
5222       "                                        aaaaa(\n"
5223       "                                            aaaaa,\n"
5224       "                                            aaaaa(\n"
5225       "                                                aaaaa,\n"
5226       "                                                aaaaa))))))))))));",
5227       getLLVMStyleWithColumns(65));
5228   verifyFormat(
5229       "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"
5230       "                                  a),\n"
5231       "                                a),\n"
5232       "                              a),\n"
5233       "                            a),\n"
5234       "                          a),\n"
5235       "                        a),\n"
5236       "                      a),\n"
5237       "                    a),\n"
5238       "                  a),\n"
5239       "                a),\n"
5240       "              a),\n"
5241       "            a),\n"
5242       "          a),\n"
5243       "        a),\n"
5244       "      a),\n"
5245       "    a),\n"
5246       "  a)",
5247       getLLVMStyleWithColumns(65));
5248 
5249   // This test takes VERY long when memoization is broken.
5250   FormatStyle OnePerLine = getLLVMStyle();
5251   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5252   OnePerLine.BinPackParameters = false;
5253   std::string input = "Constructor()\n"
5254                       "    : aaaa(a,\n";
5255   for (unsigned i = 0, e = 80; i != e; ++i) {
5256     input += "           a,\n";
5257   }
5258   input += "           a) {}";
5259   verifyFormat(input, OnePerLine);
5260 }
5261 #endif
5262 
5263 TEST_F(FormatTest, BreaksAsHighAsPossible) {
5264   verifyFormat(
5265       "void f() {\n"
5266       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5267       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5268       "    f();\n"
5269       "}");
5270   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5271                "    Intervals[i - 1].getRange().getLast()) {\n}");
5272 }
5273 
5274 TEST_F(FormatTest, BreaksFunctionDeclarations) {
5275   // Principially, we break function declarations in a certain order:
5276   // 1) break amongst arguments.
5277   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5278                "                              Cccccccccccccc cccccccccccccc);");
5279   verifyFormat("template <class TemplateIt>\n"
5280                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5281                "                            TemplateIt *stop) {}");
5282 
5283   // 2) break after return type.
5284   verifyFormat(
5285       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5286       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5287       getGoogleStyle());
5288 
5289   // 3) break after (.
5290   verifyFormat(
5291       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5292       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5293       getGoogleStyle());
5294 
5295   // 4) break before after nested name specifiers.
5296   verifyFormat(
5297       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5298       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5299       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5300       getGoogleStyle());
5301 
5302   // However, there are exceptions, if a sufficient amount of lines can be
5303   // saved.
5304   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5305   // more adjusting.
5306   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5307                "                                  Cccccccccccccc cccccccccc,\n"
5308                "                                  Cccccccccccccc cccccccccc,\n"
5309                "                                  Cccccccccccccc cccccccccc,\n"
5310                "                                  Cccccccccccccc cccccccccc);");
5311   verifyFormat(
5312       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5313       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5314       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5315       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5316       getGoogleStyle());
5317   verifyFormat(
5318       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5319       "                                          Cccccccccccccc cccccccccc,\n"
5320       "                                          Cccccccccccccc cccccccccc,\n"
5321       "                                          Cccccccccccccc cccccccccc,\n"
5322       "                                          Cccccccccccccc cccccccccc,\n"
5323       "                                          Cccccccccccccc cccccccccc,\n"
5324       "                                          Cccccccccccccc cccccccccc);");
5325   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5326                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5327                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5328                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5329                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5330 
5331   // Break after multi-line parameters.
5332   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5333                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5334                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5335                "    bbbb bbbb);");
5336   verifyFormat("void SomeLoooooooooooongFunction(\n"
5337                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5338                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5339                "    int bbbbbbbbbbbbb);");
5340 
5341   // Treat overloaded operators like other functions.
5342   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5343                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5344   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5345                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5346   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5347                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5348   verifyGoogleFormat(
5349       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5350       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5351   verifyGoogleFormat(
5352       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5353       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5354   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5355                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5356   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5357                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5358   verifyGoogleFormat(
5359       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5360       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5361       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5362   verifyGoogleFormat("template <typename T>\n"
5363                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5364                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5365                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5366 
5367   FormatStyle Style = getLLVMStyle();
5368   Style.PointerAlignment = FormatStyle::PAS_Left;
5369   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5370                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5371                Style);
5372   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5373                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5374                Style);
5375 }
5376 
5377 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5378   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5379   // Prefer keeping `::` followed by `operator` together.
5380   EXPECT_EQ("const aaaa::bbbbbbb &\n"
5381             "ccccccccc::operator++() {\n"
5382             "  stuff();\n"
5383             "}",
5384             format("const aaaa::bbbbbbb\n"
5385                    "&ccccccccc::operator++() { stuff(); }",
5386                    getLLVMStyleWithColumns(40)));
5387 }
5388 
5389 TEST_F(FormatTest, TrailingReturnType) {
5390   verifyFormat("auto foo() -> int;\n");
5391   // correct trailing return type spacing
5392   verifyFormat("auto operator->() -> int;\n");
5393   verifyFormat("auto operator++(int) -> int;\n");
5394 
5395   verifyFormat("struct S {\n"
5396                "  auto bar() const -> int;\n"
5397                "};");
5398   verifyFormat("template <size_t Order, typename T>\n"
5399                "auto load_img(const std::string &filename)\n"
5400                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
5401   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5402                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5403   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5404   verifyFormat("template <typename T>\n"
5405                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5406                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5407 
5408   // Not trailing return types.
5409   verifyFormat("void f() { auto a = b->c(); }");
5410 }
5411 
5412 TEST_F(FormatTest, DeductionGuides) {
5413   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5414   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5415   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5416   verifyFormat(
5417       "template <class... T>\n"
5418       "array(T &&...t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5419   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5420   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5421   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5422   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5423   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5424   verifyFormat("template <class T> x() -> x<1>;");
5425   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5426 
5427   // Ensure not deduction guides.
5428   verifyFormat("c()->f<int>();");
5429   verifyFormat("x()->foo<1>;");
5430   verifyFormat("x = p->foo<3>();");
5431   verifyFormat("x()->x<1>();");
5432   verifyFormat("x()->x<1>;");
5433 }
5434 
5435 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5436   // Avoid breaking before trailing 'const' or other trailing annotations, if
5437   // they are not function-like.
5438   FormatStyle Style = getGoogleStyle();
5439   Style.ColumnLimit = 47;
5440   verifyFormat("void someLongFunction(\n"
5441                "    int someLoooooooooooooongParameter) const {\n}",
5442                getLLVMStyleWithColumns(47));
5443   verifyFormat("LoooooongReturnType\n"
5444                "someLoooooooongFunction() const {}",
5445                getLLVMStyleWithColumns(47));
5446   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5447                "    const {}",
5448                Style);
5449   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5450                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5451   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5452                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5453   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5454                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5455   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5456                "                   aaaaaaaaaaa aaaaa) const override;");
5457   verifyGoogleFormat(
5458       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5459       "    const override;");
5460 
5461   // Even if the first parameter has to be wrapped.
5462   verifyFormat("void someLongFunction(\n"
5463                "    int someLongParameter) const {}",
5464                getLLVMStyleWithColumns(46));
5465   verifyFormat("void someLongFunction(\n"
5466                "    int someLongParameter) const {}",
5467                Style);
5468   verifyFormat("void someLongFunction(\n"
5469                "    int someLongParameter) override {}",
5470                Style);
5471   verifyFormat("void someLongFunction(\n"
5472                "    int someLongParameter) OVERRIDE {}",
5473                Style);
5474   verifyFormat("void someLongFunction(\n"
5475                "    int someLongParameter) final {}",
5476                Style);
5477   verifyFormat("void someLongFunction(\n"
5478                "    int someLongParameter) FINAL {}",
5479                Style);
5480   verifyFormat("void someLongFunction(\n"
5481                "    int parameter) const override {}",
5482                Style);
5483 
5484   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5485   verifyFormat("void someLongFunction(\n"
5486                "    int someLongParameter) const\n"
5487                "{\n"
5488                "}",
5489                Style);
5490 
5491   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5492   verifyFormat("void someLongFunction(\n"
5493                "    int someLongParameter) const\n"
5494                "  {\n"
5495                "  }",
5496                Style);
5497 
5498   // Unless these are unknown annotations.
5499   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5500                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5501                "    LONG_AND_UGLY_ANNOTATION;");
5502 
5503   // Breaking before function-like trailing annotations is fine to keep them
5504   // close to their arguments.
5505   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5506                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5507   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5508                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5509   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5510                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5511   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5512                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5513   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5514 
5515   verifyFormat(
5516       "void aaaaaaaaaaaaaaaaaa()\n"
5517       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5518       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5519   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5520                "    __attribute__((unused));");
5521   verifyGoogleFormat(
5522       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5523       "    GUARDED_BY(aaaaaaaaaaaa);");
5524   verifyGoogleFormat(
5525       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5526       "    GUARDED_BY(aaaaaaaaaaaa);");
5527   verifyGoogleFormat(
5528       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5529       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5530   verifyGoogleFormat(
5531       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5532       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5533 }
5534 
5535 TEST_F(FormatTest, FunctionAnnotations) {
5536   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5537                "int OldFunction(const string &parameter) {}");
5538   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5539                "string OldFunction(const string &parameter) {}");
5540   verifyFormat("template <typename T>\n"
5541                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5542                "string OldFunction(const string &parameter) {}");
5543 
5544   // Not function annotations.
5545   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5546                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5547   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5548                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5549   verifyFormat("MACRO(abc).function() // wrap\n"
5550                "    << abc;");
5551   verifyFormat("MACRO(abc)->function() // wrap\n"
5552                "    << abc;");
5553   verifyFormat("MACRO(abc)::function() // wrap\n"
5554                "    << abc;");
5555 }
5556 
5557 TEST_F(FormatTest, BreaksDesireably) {
5558   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5559                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5560                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5561   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5562                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5563                "}");
5564 
5565   verifyFormat(
5566       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5567       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5568 
5569   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5570                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5571                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5572 
5573   verifyFormat(
5574       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5575       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5576       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5577       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5578       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5579 
5580   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5581                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5582 
5583   verifyFormat(
5584       "void f() {\n"
5585       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5586       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5587       "}");
5588   verifyFormat(
5589       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5590       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5591   verifyFormat(
5592       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5593       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5594   verifyFormat(
5595       "aaaaaa(aaa,\n"
5596       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5597       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5598       "       aaaa);");
5599   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5600                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5601                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5602 
5603   // Indent consistently independent of call expression and unary operator.
5604   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5605                "    dddddddddddddddddddddddddddddd));");
5606   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5607                "    dddddddddddddddddddddddddddddd));");
5608   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5609                "    dddddddddddddddddddddddddddddd));");
5610 
5611   // This test case breaks on an incorrect memoization, i.e. an optimization not
5612   // taking into account the StopAt value.
5613   verifyFormat(
5614       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5615       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5616       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5617       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5618 
5619   verifyFormat("{\n  {\n    {\n"
5620                "      Annotation.SpaceRequiredBefore =\n"
5621                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5622                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5623                "    }\n  }\n}");
5624 
5625   // Break on an outer level if there was a break on an inner level.
5626   EXPECT_EQ("f(g(h(a, // comment\n"
5627             "      b, c),\n"
5628             "    d, e),\n"
5629             "  x, y);",
5630             format("f(g(h(a, // comment\n"
5631                    "    b, c), d, e), x, y);"));
5632 
5633   // Prefer breaking similar line breaks.
5634   verifyFormat(
5635       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5636       "                             NSTrackingMouseEnteredAndExited |\n"
5637       "                             NSTrackingActiveAlways;");
5638 }
5639 
5640 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5641   FormatStyle NoBinPacking = getGoogleStyle();
5642   NoBinPacking.BinPackParameters = false;
5643   NoBinPacking.BinPackArguments = true;
5644   verifyFormat("void f() {\n"
5645                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5646                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5647                "}",
5648                NoBinPacking);
5649   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5650                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5651                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5652                NoBinPacking);
5653 
5654   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5655   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5656                "                        vector<int> bbbbbbbbbbbbbbb);",
5657                NoBinPacking);
5658   // FIXME: This behavior difference is probably not wanted. However, currently
5659   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5660   // template arguments from BreakBeforeParameter being set because of the
5661   // one-per-line formatting.
5662   verifyFormat(
5663       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5664       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5665       NoBinPacking);
5666   verifyFormat(
5667       "void fffffffffff(\n"
5668       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5669       "        aaaaaaaaaa);");
5670 }
5671 
5672 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5673   FormatStyle NoBinPacking = getGoogleStyle();
5674   NoBinPacking.BinPackParameters = false;
5675   NoBinPacking.BinPackArguments = false;
5676   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5677                "  aaaaaaaaaaaaaaaaaaaa,\n"
5678                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5679                NoBinPacking);
5680   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5681                "        aaaaaaaaaaaaa,\n"
5682                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5683                NoBinPacking);
5684   verifyFormat(
5685       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5686       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5687       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5688       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5689       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5690       NoBinPacking);
5691   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5692                "    .aaaaaaaaaaaaaaaaaa();",
5693                NoBinPacking);
5694   verifyFormat("void f() {\n"
5695                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5696                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5697                "}",
5698                NoBinPacking);
5699 
5700   verifyFormat(
5701       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5702       "             aaaaaaaaaaaa,\n"
5703       "             aaaaaaaaaaaa);",
5704       NoBinPacking);
5705   verifyFormat(
5706       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5707       "                               ddddddddddddddddddddddddddddd),\n"
5708       "             test);",
5709       NoBinPacking);
5710 
5711   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5712                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5713                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5714                "    aaaaaaaaaaaaaaaaaa;",
5715                NoBinPacking);
5716   verifyFormat("a(\"a\"\n"
5717                "  \"a\",\n"
5718                "  a);");
5719 
5720   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5721   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5722                "                aaaaaaaaa,\n"
5723                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5724                NoBinPacking);
5725   verifyFormat(
5726       "void f() {\n"
5727       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5728       "      .aaaaaaa();\n"
5729       "}",
5730       NoBinPacking);
5731   verifyFormat(
5732       "template <class SomeType, class SomeOtherType>\n"
5733       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5734       NoBinPacking);
5735 }
5736 
5737 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5738   FormatStyle Style = getLLVMStyleWithColumns(15);
5739   Style.ExperimentalAutoDetectBinPacking = true;
5740   EXPECT_EQ("aaa(aaaa,\n"
5741             "    aaaa,\n"
5742             "    aaaa);\n"
5743             "aaa(aaaa,\n"
5744             "    aaaa,\n"
5745             "    aaaa);",
5746             format("aaa(aaaa,\n" // one-per-line
5747                    "  aaaa,\n"
5748                    "    aaaa  );\n"
5749                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5750                    Style));
5751   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5752             "    aaaa);\n"
5753             "aaa(aaaa, aaaa,\n"
5754             "    aaaa);",
5755             format("aaa(aaaa,  aaaa,\n" // bin-packed
5756                    "    aaaa  );\n"
5757                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5758                    Style));
5759 }
5760 
5761 TEST_F(FormatTest, FormatsBuilderPattern) {
5762   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5763                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5764                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5765                "    .StartsWith(\".init\", ORDER_INIT)\n"
5766                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5767                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5768                "    .Default(ORDER_TEXT);\n");
5769 
5770   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5771                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5772   verifyFormat("aaaaaaa->aaaaaaa\n"
5773                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5774                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5775                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5776   verifyFormat(
5777       "aaaaaaa->aaaaaaa\n"
5778       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5779       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5780   verifyFormat(
5781       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5782       "    aaaaaaaaaaaaaa);");
5783   verifyFormat(
5784       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5785       "    aaaaaa->aaaaaaaaaaaa()\n"
5786       "        ->aaaaaaaaaaaaaaaa(\n"
5787       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5788       "        ->aaaaaaaaaaaaaaaaa();");
5789   verifyGoogleFormat(
5790       "void f() {\n"
5791       "  someo->Add((new util::filetools::Handler(dir))\n"
5792       "                 ->OnEvent1(NewPermanentCallback(\n"
5793       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5794       "                 ->OnEvent2(NewPermanentCallback(\n"
5795       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5796       "                 ->OnEvent3(NewPermanentCallback(\n"
5797       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5798       "                 ->OnEvent5(NewPermanentCallback(\n"
5799       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5800       "                 ->OnEvent6(NewPermanentCallback(\n"
5801       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5802       "}");
5803 
5804   verifyFormat(
5805       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5806   verifyFormat("aaaaaaaaaaaaaaa()\n"
5807                "    .aaaaaaaaaaaaaaa()\n"
5808                "    .aaaaaaaaaaaaaaa()\n"
5809                "    .aaaaaaaaaaaaaaa()\n"
5810                "    .aaaaaaaaaaaaaaa();");
5811   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5812                "    .aaaaaaaaaaaaaaa()\n"
5813                "    .aaaaaaaaaaaaaaa()\n"
5814                "    .aaaaaaaaaaaaaaa();");
5815   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5816                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5817                "    .aaaaaaaaaaaaaaa();");
5818   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5819                "    ->aaaaaaaaaaaaaae(0)\n"
5820                "    ->aaaaaaaaaaaaaaa();");
5821 
5822   // Don't linewrap after very short segments.
5823   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5824                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5825                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5826   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5827                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5828                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5829   verifyFormat("aaa()\n"
5830                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5831                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5832                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5833 
5834   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5835                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5836                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5837   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5838                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5839                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5840 
5841   // Prefer not to break after empty parentheses.
5842   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5843                "    First->LastNewlineOffset);");
5844 
5845   // Prefer not to create "hanging" indents.
5846   verifyFormat(
5847       "return !soooooooooooooome_map\n"
5848       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5849       "            .second;");
5850   verifyFormat(
5851       "return aaaaaaaaaaaaaaaa\n"
5852       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5853       "    .aaaa(aaaaaaaaaaaaaa);");
5854   // No hanging indent here.
5855   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5856                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5857   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5858                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5859   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5860                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5861                getLLVMStyleWithColumns(60));
5862   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5863                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5864                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5865                getLLVMStyleWithColumns(59));
5866   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5867                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5868                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5869 
5870   // Dont break if only closing statements before member call
5871   verifyFormat("test() {\n"
5872                "  ([]() -> {\n"
5873                "    int b = 32;\n"
5874                "    return 3;\n"
5875                "  }).foo();\n"
5876                "}");
5877   verifyFormat("test() {\n"
5878                "  (\n"
5879                "      []() -> {\n"
5880                "        int b = 32;\n"
5881                "        return 3;\n"
5882                "      },\n"
5883                "      foo, bar)\n"
5884                "      .foo();\n"
5885                "}");
5886   verifyFormat("test() {\n"
5887                "  ([]() -> {\n"
5888                "    int b = 32;\n"
5889                "    return 3;\n"
5890                "  })\n"
5891                "      .foo()\n"
5892                "      .bar();\n"
5893                "}");
5894   verifyFormat("test() {\n"
5895                "  ([]() -> {\n"
5896                "    int b = 32;\n"
5897                "    return 3;\n"
5898                "  })\n"
5899                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5900                "           \"bbbb\");\n"
5901                "}",
5902                getLLVMStyleWithColumns(30));
5903 }
5904 
5905 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5906   verifyFormat(
5907       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5908       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5909   verifyFormat(
5910       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5911       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5912 
5913   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5914                "    ccccccccccccccccccccccccc) {\n}");
5915   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5916                "    ccccccccccccccccccccccccc) {\n}");
5917 
5918   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5919                "    ccccccccccccccccccccccccc) {\n}");
5920   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5921                "    ccccccccccccccccccccccccc) {\n}");
5922 
5923   verifyFormat(
5924       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
5925       "    ccccccccccccccccccccccccc) {\n}");
5926   verifyFormat(
5927       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
5928       "    ccccccccccccccccccccccccc) {\n}");
5929 
5930   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
5931                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
5932                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
5933                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5934   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
5935                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
5936                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
5937                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
5938 
5939   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
5940                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
5941                "    aaaaaaaaaaaaaaa != aa) {\n}");
5942   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
5943                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
5944                "    aaaaaaaaaaaaaaa != aa) {\n}");
5945 }
5946 
5947 TEST_F(FormatTest, BreaksAfterAssignments) {
5948   verifyFormat(
5949       "unsigned Cost =\n"
5950       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
5951       "                        SI->getPointerAddressSpaceee());\n");
5952   verifyFormat(
5953       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
5954       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
5955 
5956   verifyFormat(
5957       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
5958       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
5959   verifyFormat("unsigned OriginalStartColumn =\n"
5960                "    SourceMgr.getSpellingColumnNumber(\n"
5961                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
5962                "    1;");
5963 }
5964 
5965 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
5966   FormatStyle Style = getLLVMStyle();
5967   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5968                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
5969                Style);
5970 
5971   Style.PenaltyBreakAssignment = 20;
5972   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5973                "                                 cccccccccccccccccccccccccc;",
5974                Style);
5975 }
5976 
5977 TEST_F(FormatTest, AlignsAfterAssignments) {
5978   verifyFormat(
5979       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5980       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
5981   verifyFormat(
5982       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5983       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
5984   verifyFormat(
5985       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5986       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
5987   verifyFormat(
5988       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5989       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
5990   verifyFormat(
5991       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5992       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
5993       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
5994 }
5995 
5996 TEST_F(FormatTest, AlignsAfterReturn) {
5997   verifyFormat(
5998       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5999       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
6000   verifyFormat(
6001       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6002       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
6003   verifyFormat(
6004       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
6005       "       aaaaaaaaaaaaaaaaaaaaaa();");
6006   verifyFormat(
6007       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
6008       "        aaaaaaaaaaaaaaaaaaaaaa());");
6009   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6010                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6011   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6012                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
6013                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6014   verifyFormat("return\n"
6015                "    // true if code is one of a or b.\n"
6016                "    code == a || code == b;");
6017 }
6018 
6019 TEST_F(FormatTest, AlignsAfterOpenBracket) {
6020   verifyFormat(
6021       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
6022       "                                                aaaaaaaaa aaaaaaa) {}");
6023   verifyFormat(
6024       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
6025       "                                               aaaaaaaaaaa aaaaaaaaa);");
6026   verifyFormat(
6027       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6028       "                                             aaaaaaaaaaaaaaaaaaaaa));");
6029   FormatStyle Style = getLLVMStyle();
6030   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6031   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6032                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
6033                Style);
6034   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6035                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
6036                Style);
6037   verifyFormat("SomeLongVariableName->someFunction(\n"
6038                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
6039                Style);
6040   verifyFormat(
6041       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
6042       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6043       Style);
6044   verifyFormat(
6045       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
6046       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6047       Style);
6048   verifyFormat(
6049       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6050       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6051       Style);
6052 
6053   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
6054                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
6055                "        b));",
6056                Style);
6057 
6058   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6059   Style.BinPackArguments = false;
6060   Style.BinPackParameters = false;
6061   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6062                "    aaaaaaaaaaa aaaaaaaa,\n"
6063                "    aaaaaaaaa aaaaaaa,\n"
6064                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6065                Style);
6066   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6067                "    aaaaaaaaaaa aaaaaaaaa,\n"
6068                "    aaaaaaaaaaa aaaaaaaaa,\n"
6069                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6070                Style);
6071   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
6072                "    aaaaaaaaaaaaaaa,\n"
6073                "    aaaaaaaaaaaaaaaaaaaaa,\n"
6074                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6075                Style);
6076   verifyFormat(
6077       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
6078       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6079       Style);
6080   verifyFormat(
6081       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
6082       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6083       Style);
6084   verifyFormat(
6085       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6086       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6087       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
6088       "    aaaaaaaaaaaaaaaa);",
6089       Style);
6090   verifyFormat(
6091       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6092       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6093       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
6094       "    aaaaaaaaaaaaaaaa);",
6095       Style);
6096 }
6097 
6098 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
6099   FormatStyle Style = getLLVMStyleWithColumns(40);
6100   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6101                "          bbbbbbbbbbbbbbbbbbbbbb);",
6102                Style);
6103   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6104   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6105   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6106                "          bbbbbbbbbbbbbbbbbbbbbb);",
6107                Style);
6108   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6109   Style.AlignOperands = FormatStyle::OAS_Align;
6110   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6111                "          bbbbbbbbbbbbbbbbbbbbbb);",
6112                Style);
6113   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6114   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6115   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6116                "    bbbbbbbbbbbbbbbbbbbbbb);",
6117                Style);
6118 }
6119 
6120 TEST_F(FormatTest, BreaksConditionalExpressions) {
6121   verifyFormat(
6122       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6123       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6124       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6125   verifyFormat(
6126       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6127       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6128       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6129   verifyFormat(
6130       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6131       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6132   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6133                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6134                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6135   verifyFormat(
6136       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6137       "                                                    : aaaaaaaaaaaaa);");
6138   verifyFormat(
6139       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6140       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6141       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6142       "                   aaaaaaaaaaaaa);");
6143   verifyFormat(
6144       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6145       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6146       "                   aaaaaaaaaaaaa);");
6147   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6148                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6149                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6150                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6151                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6152   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6153                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6154                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6155                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6156                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6157                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6158                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6159   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6160                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6161                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6162                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6163                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6164   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6165                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6166                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6167   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6168                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6169                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6170                "        : aaaaaaaaaaaaaaaa;");
6171   verifyFormat(
6172       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6173       "    ? aaaaaaaaaaaaaaa\n"
6174       "    : aaaaaaaaaaaaaaa;");
6175   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6176                "          aaaaaaaaa\n"
6177                "      ? b\n"
6178                "      : c);");
6179   verifyFormat("return aaaa == bbbb\n"
6180                "           // comment\n"
6181                "           ? aaaa\n"
6182                "           : bbbb;");
6183   verifyFormat("unsigned Indent =\n"
6184                "    format(TheLine.First,\n"
6185                "           IndentForLevel[TheLine.Level] >= 0\n"
6186                "               ? IndentForLevel[TheLine.Level]\n"
6187                "               : TheLine * 2,\n"
6188                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6189                getLLVMStyleWithColumns(60));
6190   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6191                "                  ? aaaaaaaaaaaaaaa\n"
6192                "                  : bbbbbbbbbbbbbbb //\n"
6193                "                        ? ccccccccccccccc\n"
6194                "                        : ddddddddddddddd;");
6195   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6196                "                  ? aaaaaaaaaaaaaaa\n"
6197                "                  : (bbbbbbbbbbbbbbb //\n"
6198                "                         ? ccccccccccccccc\n"
6199                "                         : ddddddddddddddd);");
6200   verifyFormat(
6201       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6202       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6203       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
6204       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
6205       "                                      : aaaaaaaaaa;");
6206   verifyFormat(
6207       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6208       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
6209       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6210 
6211   FormatStyle NoBinPacking = getLLVMStyle();
6212   NoBinPacking.BinPackArguments = false;
6213   verifyFormat(
6214       "void f() {\n"
6215       "  g(aaa,\n"
6216       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6217       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6218       "        ? aaaaaaaaaaaaaaa\n"
6219       "        : aaaaaaaaaaaaaaa);\n"
6220       "}",
6221       NoBinPacking);
6222   verifyFormat(
6223       "void f() {\n"
6224       "  g(aaa,\n"
6225       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6226       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6227       "        ?: aaaaaaaaaaaaaaa);\n"
6228       "}",
6229       NoBinPacking);
6230 
6231   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6232                "             // comment.\n"
6233                "             ccccccccccccccccccccccccccccccccccccccc\n"
6234                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6235                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6236 
6237   // Assignments in conditional expressions. Apparently not uncommon :-(.
6238   verifyFormat("return a != b\n"
6239                "           // comment\n"
6240                "           ? a = b\n"
6241                "           : a = b;");
6242   verifyFormat("return a != b\n"
6243                "           // comment\n"
6244                "           ? a = a != b\n"
6245                "                     // comment\n"
6246                "                     ? a = b\n"
6247                "                     : a\n"
6248                "           : a;\n");
6249   verifyFormat("return a != b\n"
6250                "           // comment\n"
6251                "           ? a\n"
6252                "           : a = a != b\n"
6253                "                     // comment\n"
6254                "                     ? a = b\n"
6255                "                     : a;");
6256 
6257   // Chained conditionals
6258   FormatStyle Style = getLLVMStyle();
6259   Style.ColumnLimit = 70;
6260   Style.AlignOperands = FormatStyle::OAS_Align;
6261   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6262                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6263                "                        : 3333333333333333;",
6264                Style);
6265   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6266                "       : bbbbbbbbbb     ? 2222222222222222\n"
6267                "                        : 3333333333333333;",
6268                Style);
6269   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
6270                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6271                "                          : 3333333333333333;",
6272                Style);
6273   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6274                "       : bbbbbbbbbbbbbb ? 222222\n"
6275                "                        : 333333;",
6276                Style);
6277   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6278                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6279                "       : cccccccccccccc ? 3333333333333333\n"
6280                "                        : 4444444444444444;",
6281                Style);
6282   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6283                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6284                "                        : 3333333333333333;",
6285                Style);
6286   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6287                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6288                "                        : (aaa ? bbb : ccc);",
6289                Style);
6290   verifyFormat(
6291       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6292       "                                             : cccccccccccccccccc)\n"
6293       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6294       "                        : 3333333333333333;",
6295       Style);
6296   verifyFormat(
6297       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6298       "                                             : cccccccccccccccccc)\n"
6299       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6300       "                        : 3333333333333333;",
6301       Style);
6302   verifyFormat(
6303       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6304       "                                             : dddddddddddddddddd)\n"
6305       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6306       "                        : 3333333333333333;",
6307       Style);
6308   verifyFormat(
6309       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6310       "                                             : dddddddddddddddddd)\n"
6311       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6312       "                        : 3333333333333333;",
6313       Style);
6314   verifyFormat(
6315       "return aaaaaaaaa        ? 1111111111111111\n"
6316       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6317       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6318       "                                             : dddddddddddddddddd)\n",
6319       Style);
6320   verifyFormat(
6321       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6322       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6323       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6324       "                                             : cccccccccccccccccc);",
6325       Style);
6326   verifyFormat(
6327       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6328       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6329       "                                             : eeeeeeeeeeeeeeeeee)\n"
6330       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6331       "                        : 3333333333333333;",
6332       Style);
6333   verifyFormat(
6334       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
6335       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6336       "                                             : eeeeeeeeeeeeeeeeee)\n"
6337       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6338       "                        : 3333333333333333;",
6339       Style);
6340   verifyFormat(
6341       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6342       "                           : cccccccccccc    ? dddddddddddddddddd\n"
6343       "                                             : eeeeeeeeeeeeeeeeee)\n"
6344       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6345       "                        : 3333333333333333;",
6346       Style);
6347   verifyFormat(
6348       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6349       "                                             : cccccccccccccccccc\n"
6350       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6351       "                        : 3333333333333333;",
6352       Style);
6353   verifyFormat(
6354       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6355       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
6356       "                                             : eeeeeeeeeeeeeeeeee\n"
6357       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6358       "                        : 3333333333333333;",
6359       Style);
6360   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6361                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
6362                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
6363                "                                   : eeeeeeeeeeeeeeeeee)\n"
6364                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6365                "                             : 3333333333333333;",
6366                Style);
6367   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6368                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6369                "             : cccccccccccccccc ? dddddddddddddddddd\n"
6370                "                                : eeeeeeeeeeeeeeeeee\n"
6371                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6372                "                                 : 3333333333333333;",
6373                Style);
6374 
6375   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6376   Style.BreakBeforeTernaryOperators = false;
6377   // FIXME: Aligning the question marks is weird given DontAlign.
6378   // Consider disabling this alignment in this case. Also check whether this
6379   // will render the adjustment from https://reviews.llvm.org/D82199
6380   // unnecessary.
6381   verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
6382                "    bbbb                ? cccccccccccccccccc :\n"
6383                "                          ddddd;\n",
6384                Style);
6385 }
6386 
6387 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6388   FormatStyle Style = getLLVMStyle();
6389   Style.BreakBeforeTernaryOperators = false;
6390   Style.ColumnLimit = 70;
6391   verifyFormat(
6392       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6393       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6394       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6395       Style);
6396   verifyFormat(
6397       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6398       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6399       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6400       Style);
6401   verifyFormat(
6402       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6403       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6404       Style);
6405   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6406                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6407                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6408                Style);
6409   verifyFormat(
6410       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6411       "                                                      aaaaaaaaaaaaa);",
6412       Style);
6413   verifyFormat(
6414       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6415       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6416       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6417       "                   aaaaaaaaaaaaa);",
6418       Style);
6419   verifyFormat(
6420       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6421       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6422       "                   aaaaaaaaaaaaa);",
6423       Style);
6424   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6425                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6426                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6427                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6428                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6429                Style);
6430   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6431                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6432                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6433                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6434                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6435                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6436                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6437                Style);
6438   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6439                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6440                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6441                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6442                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6443                Style);
6444   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6445                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6446                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6447                Style);
6448   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6449                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6450                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6451                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6452                Style);
6453   verifyFormat(
6454       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6455       "    aaaaaaaaaaaaaaa :\n"
6456       "    aaaaaaaaaaaaaaa;",
6457       Style);
6458   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6459                "          aaaaaaaaa ?\n"
6460                "      b :\n"
6461                "      c);",
6462                Style);
6463   verifyFormat("unsigned Indent =\n"
6464                "    format(TheLine.First,\n"
6465                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
6466                "               IndentForLevel[TheLine.Level] :\n"
6467                "               TheLine * 2,\n"
6468                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6469                Style);
6470   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6471                "                  aaaaaaaaaaaaaaa :\n"
6472                "                  bbbbbbbbbbbbbbb ? //\n"
6473                "                      ccccccccccccccc :\n"
6474                "                      ddddddddddddddd;",
6475                Style);
6476   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6477                "                  aaaaaaaaaaaaaaa :\n"
6478                "                  (bbbbbbbbbbbbbbb ? //\n"
6479                "                       ccccccccccccccc :\n"
6480                "                       ddddddddddddddd);",
6481                Style);
6482   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6483                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6484                "            ccccccccccccccccccccccccccc;",
6485                Style);
6486   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6487                "           aaaaa :\n"
6488                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
6489                Style);
6490 
6491   // Chained conditionals
6492   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6493                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6494                "                          3333333333333333;",
6495                Style);
6496   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6497                "       bbbbbbbbbb       ? 2222222222222222 :\n"
6498                "                          3333333333333333;",
6499                Style);
6500   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
6501                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6502                "                          3333333333333333;",
6503                Style);
6504   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6505                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
6506                "                          333333;",
6507                Style);
6508   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6509                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6510                "       cccccccccccccccc ? 3333333333333333 :\n"
6511                "                          4444444444444444;",
6512                Style);
6513   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6514                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6515                "                          3333333333333333;",
6516                Style);
6517   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6518                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6519                "                          (aaa ? bbb : ccc);",
6520                Style);
6521   verifyFormat(
6522       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6523       "                                               cccccccccccccccccc) :\n"
6524       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6525       "                          3333333333333333;",
6526       Style);
6527   verifyFormat(
6528       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6529       "                                               cccccccccccccccccc) :\n"
6530       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6531       "                          3333333333333333;",
6532       Style);
6533   verifyFormat(
6534       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6535       "                                               dddddddddddddddddd) :\n"
6536       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6537       "                          3333333333333333;",
6538       Style);
6539   verifyFormat(
6540       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6541       "                                               dddddddddddddddddd) :\n"
6542       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6543       "                          3333333333333333;",
6544       Style);
6545   verifyFormat(
6546       "return aaaaaaaaa        ? 1111111111111111 :\n"
6547       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6548       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6549       "                                               dddddddddddddddddd)\n",
6550       Style);
6551   verifyFormat(
6552       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6553       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6554       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6555       "                                               cccccccccccccccccc);",
6556       Style);
6557   verifyFormat(
6558       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6559       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6560       "                                               eeeeeeeeeeeeeeeeee) :\n"
6561       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6562       "                          3333333333333333;",
6563       Style);
6564   verifyFormat(
6565       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6566       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
6567       "                                               eeeeeeeeeeeeeeeeee) :\n"
6568       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6569       "                          3333333333333333;",
6570       Style);
6571   verifyFormat(
6572       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
6573       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6574       "                                               eeeeeeeeeeeeeeeeee) :\n"
6575       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6576       "                          3333333333333333;",
6577       Style);
6578   verifyFormat(
6579       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6580       "                                               cccccccccccccccccc :\n"
6581       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6582       "                          3333333333333333;",
6583       Style);
6584   verifyFormat(
6585       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6586       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
6587       "                                               eeeeeeeeeeeeeeeeee :\n"
6588       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6589       "                          3333333333333333;",
6590       Style);
6591   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6592                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6593                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
6594                "                                 eeeeeeeeeeeeeeeeee) :\n"
6595                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6596                "                               3333333333333333;",
6597                Style);
6598   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6599                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6600                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
6601                "                                  eeeeeeeeeeeeeeeeee :\n"
6602                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6603                "                               3333333333333333;",
6604                Style);
6605 }
6606 
6607 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6608   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6609                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6610   verifyFormat("bool a = true, b = false;");
6611 
6612   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6613                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6614                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6615                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6616   verifyFormat(
6617       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6618       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6619       "     d = e && f;");
6620   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6621                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6622   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6623                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6624   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6625                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6626 
6627   FormatStyle Style = getGoogleStyle();
6628   Style.PointerAlignment = FormatStyle::PAS_Left;
6629   Style.DerivePointerAlignment = false;
6630   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6631                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6632                "    *b = bbbbbbbbbbbbbbbbbbb;",
6633                Style);
6634   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6635                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6636                Style);
6637   verifyFormat("vector<int*> a, b;", Style);
6638   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6639 }
6640 
6641 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6642   verifyFormat("arr[foo ? bar : baz];");
6643   verifyFormat("f()[foo ? bar : baz];");
6644   verifyFormat("(a + b)[foo ? bar : baz];");
6645   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6646 }
6647 
6648 TEST_F(FormatTest, AlignsStringLiterals) {
6649   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6650                "                                      \"short literal\");");
6651   verifyFormat(
6652       "looooooooooooooooooooooooongFunction(\n"
6653       "    \"short literal\"\n"
6654       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6655   verifyFormat("someFunction(\"Always break between multi-line\"\n"
6656                "             \" string literals\",\n"
6657                "             and, other, parameters);");
6658   EXPECT_EQ("fun + \"1243\" /* comment */\n"
6659             "      \"5678\";",
6660             format("fun + \"1243\" /* comment */\n"
6661                    "    \"5678\";",
6662                    getLLVMStyleWithColumns(28)));
6663   EXPECT_EQ(
6664       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6665       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6666       "         \"aaaaaaaaaaaaaaaa\";",
6667       format("aaaaaa ="
6668              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6669              "aaaaaaaaaaaaaaaaaaaaa\" "
6670              "\"aaaaaaaaaaaaaaaa\";"));
6671   verifyFormat("a = a + \"a\"\n"
6672                "        \"a\"\n"
6673                "        \"a\";");
6674   verifyFormat("f(\"a\", \"b\"\n"
6675                "       \"c\");");
6676 
6677   verifyFormat(
6678       "#define LL_FORMAT \"ll\"\n"
6679       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6680       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6681 
6682   verifyFormat("#define A(X)          \\\n"
6683                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
6684                "  \"ccccc\"",
6685                getLLVMStyleWithColumns(23));
6686   verifyFormat("#define A \"def\"\n"
6687                "f(\"abc\" A \"ghi\"\n"
6688                "  \"jkl\");");
6689 
6690   verifyFormat("f(L\"a\"\n"
6691                "  L\"b\");");
6692   verifyFormat("#define A(X)            \\\n"
6693                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6694                "  L\"ccccc\"",
6695                getLLVMStyleWithColumns(25));
6696 
6697   verifyFormat("f(@\"a\"\n"
6698                "  @\"b\");");
6699   verifyFormat("NSString s = @\"a\"\n"
6700                "             @\"b\"\n"
6701                "             @\"c\";");
6702   verifyFormat("NSString s = @\"a\"\n"
6703                "              \"b\"\n"
6704                "              \"c\";");
6705 }
6706 
6707 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6708   FormatStyle Style = getLLVMStyle();
6709   // No declarations or definitions should be moved to own line.
6710   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6711   verifyFormat("class A {\n"
6712                "  int f() { return 1; }\n"
6713                "  int g();\n"
6714                "};\n"
6715                "int f() { return 1; }\n"
6716                "int g();\n",
6717                Style);
6718 
6719   // All declarations and definitions should have the return type moved to its
6720   // own line.
6721   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6722   Style.TypenameMacros = {"LIST"};
6723   verifyFormat("SomeType\n"
6724                "funcdecl(LIST(uint64_t));",
6725                Style);
6726   verifyFormat("class E {\n"
6727                "  int\n"
6728                "  f() {\n"
6729                "    return 1;\n"
6730                "  }\n"
6731                "  int\n"
6732                "  g();\n"
6733                "};\n"
6734                "int\n"
6735                "f() {\n"
6736                "  return 1;\n"
6737                "}\n"
6738                "int\n"
6739                "g();\n",
6740                Style);
6741 
6742   // Top-level definitions, and no kinds of declarations should have the
6743   // return type moved to its own line.
6744   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6745   verifyFormat("class B {\n"
6746                "  int f() { return 1; }\n"
6747                "  int g();\n"
6748                "};\n"
6749                "int\n"
6750                "f() {\n"
6751                "  return 1;\n"
6752                "}\n"
6753                "int g();\n",
6754                Style);
6755 
6756   // Top-level definitions and declarations should have the return type moved
6757   // to its own line.
6758   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6759   verifyFormat("class C {\n"
6760                "  int f() { return 1; }\n"
6761                "  int g();\n"
6762                "};\n"
6763                "int\n"
6764                "f() {\n"
6765                "  return 1;\n"
6766                "}\n"
6767                "int\n"
6768                "g();\n",
6769                Style);
6770 
6771   // All definitions should have the return type moved to its own line, but no
6772   // kinds of declarations.
6773   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6774   verifyFormat("class D {\n"
6775                "  int\n"
6776                "  f() {\n"
6777                "    return 1;\n"
6778                "  }\n"
6779                "  int g();\n"
6780                "};\n"
6781                "int\n"
6782                "f() {\n"
6783                "  return 1;\n"
6784                "}\n"
6785                "int g();\n",
6786                Style);
6787   verifyFormat("const char *\n"
6788                "f(void) {\n" // Break here.
6789                "  return \"\";\n"
6790                "}\n"
6791                "const char *bar(void);\n", // No break here.
6792                Style);
6793   verifyFormat("template <class T>\n"
6794                "T *\n"
6795                "f(T &c) {\n" // Break here.
6796                "  return NULL;\n"
6797                "}\n"
6798                "template <class T> T *f(T &c);\n", // No break here.
6799                Style);
6800   verifyFormat("class C {\n"
6801                "  int\n"
6802                "  operator+() {\n"
6803                "    return 1;\n"
6804                "  }\n"
6805                "  int\n"
6806                "  operator()() {\n"
6807                "    return 1;\n"
6808                "  }\n"
6809                "};\n",
6810                Style);
6811   verifyFormat("void\n"
6812                "A::operator()() {}\n"
6813                "void\n"
6814                "A::operator>>() {}\n"
6815                "void\n"
6816                "A::operator+() {}\n"
6817                "void\n"
6818                "A::operator*() {}\n"
6819                "void\n"
6820                "A::operator->() {}\n"
6821                "void\n"
6822                "A::operator void *() {}\n"
6823                "void\n"
6824                "A::operator void &() {}\n"
6825                "void\n"
6826                "A::operator void &&() {}\n"
6827                "void\n"
6828                "A::operator char *() {}\n"
6829                "void\n"
6830                "A::operator[]() {}\n"
6831                "void\n"
6832                "A::operator!() {}\n"
6833                "void\n"
6834                "A::operator**() {}\n"
6835                "void\n"
6836                "A::operator<Foo> *() {}\n"
6837                "void\n"
6838                "A::operator<Foo> **() {}\n"
6839                "void\n"
6840                "A::operator<Foo> &() {}\n"
6841                "void\n"
6842                "A::operator void **() {}\n",
6843                Style);
6844   verifyFormat("constexpr auto\n"
6845                "operator()() const -> reference {}\n"
6846                "constexpr auto\n"
6847                "operator>>() const -> reference {}\n"
6848                "constexpr auto\n"
6849                "operator+() const -> reference {}\n"
6850                "constexpr auto\n"
6851                "operator*() const -> reference {}\n"
6852                "constexpr auto\n"
6853                "operator->() const -> reference {}\n"
6854                "constexpr auto\n"
6855                "operator++() const -> reference {}\n"
6856                "constexpr auto\n"
6857                "operator void *() const -> reference {}\n"
6858                "constexpr auto\n"
6859                "operator void **() const -> reference {}\n"
6860                "constexpr auto\n"
6861                "operator void *() const -> reference {}\n"
6862                "constexpr auto\n"
6863                "operator void &() const -> reference {}\n"
6864                "constexpr auto\n"
6865                "operator void &&() const -> reference {}\n"
6866                "constexpr auto\n"
6867                "operator char *() const -> reference {}\n"
6868                "constexpr auto\n"
6869                "operator!() const -> reference {}\n"
6870                "constexpr auto\n"
6871                "operator[]() const -> reference {}\n",
6872                Style);
6873   verifyFormat("void *operator new(std::size_t s);", // No break here.
6874                Style);
6875   verifyFormat("void *\n"
6876                "operator new(std::size_t s) {}",
6877                Style);
6878   verifyFormat("void *\n"
6879                "operator delete[](void *ptr) {}",
6880                Style);
6881   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6882   verifyFormat("const char *\n"
6883                "f(void)\n" // Break here.
6884                "{\n"
6885                "  return \"\";\n"
6886                "}\n"
6887                "const char *bar(void);\n", // No break here.
6888                Style);
6889   verifyFormat("template <class T>\n"
6890                "T *\n"     // Problem here: no line break
6891                "f(T &c)\n" // Break here.
6892                "{\n"
6893                "  return NULL;\n"
6894                "}\n"
6895                "template <class T> T *f(T &c);\n", // No break here.
6896                Style);
6897   verifyFormat("int\n"
6898                "foo(A<bool> a)\n"
6899                "{\n"
6900                "  return a;\n"
6901                "}\n",
6902                Style);
6903   verifyFormat("int\n"
6904                "foo(A<8> a)\n"
6905                "{\n"
6906                "  return a;\n"
6907                "}\n",
6908                Style);
6909   verifyFormat("int\n"
6910                "foo(A<B<bool>, 8> a)\n"
6911                "{\n"
6912                "  return a;\n"
6913                "}\n",
6914                Style);
6915   verifyFormat("int\n"
6916                "foo(A<B<8>, bool> a)\n"
6917                "{\n"
6918                "  return a;\n"
6919                "}\n",
6920                Style);
6921   verifyFormat("int\n"
6922                "foo(A<B<bool>, bool> a)\n"
6923                "{\n"
6924                "  return a;\n"
6925                "}\n",
6926                Style);
6927   verifyFormat("int\n"
6928                "foo(A<B<8>, 8> a)\n"
6929                "{\n"
6930                "  return a;\n"
6931                "}\n",
6932                Style);
6933 
6934   Style = getGNUStyle();
6935 
6936   // Test for comments at the end of function declarations.
6937   verifyFormat("void\n"
6938                "foo (int a, /*abc*/ int b) // def\n"
6939                "{\n"
6940                "}\n",
6941                Style);
6942 
6943   verifyFormat("void\n"
6944                "foo (int a, /* abc */ int b) /* def */\n"
6945                "{\n"
6946                "}\n",
6947                Style);
6948 
6949   // Definitions that should not break after return type
6950   verifyFormat("void foo (int a, int b); // def\n", Style);
6951   verifyFormat("void foo (int a, int b); /* def */\n", Style);
6952   verifyFormat("void foo (int a, int b);\n", Style);
6953 }
6954 
6955 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
6956   FormatStyle NoBreak = getLLVMStyle();
6957   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
6958   FormatStyle Break = getLLVMStyle();
6959   Break.AlwaysBreakBeforeMultilineStrings = true;
6960   verifyFormat("aaaa = \"bbbb\"\n"
6961                "       \"cccc\";",
6962                NoBreak);
6963   verifyFormat("aaaa =\n"
6964                "    \"bbbb\"\n"
6965                "    \"cccc\";",
6966                Break);
6967   verifyFormat("aaaa(\"bbbb\"\n"
6968                "     \"cccc\");",
6969                NoBreak);
6970   verifyFormat("aaaa(\n"
6971                "    \"bbbb\"\n"
6972                "    \"cccc\");",
6973                Break);
6974   verifyFormat("aaaa(qqq, \"bbbb\"\n"
6975                "          \"cccc\");",
6976                NoBreak);
6977   verifyFormat("aaaa(qqq,\n"
6978                "     \"bbbb\"\n"
6979                "     \"cccc\");",
6980                Break);
6981   verifyFormat("aaaa(qqq,\n"
6982                "     L\"bbbb\"\n"
6983                "     L\"cccc\");",
6984                Break);
6985   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
6986                "                      \"bbbb\"));",
6987                Break);
6988   verifyFormat("string s = someFunction(\n"
6989                "    \"abc\"\n"
6990                "    \"abc\");",
6991                Break);
6992 
6993   // As we break before unary operators, breaking right after them is bad.
6994   verifyFormat("string foo = abc ? \"x\"\n"
6995                "                   \"blah blah blah blah blah blah\"\n"
6996                "                 : \"y\";",
6997                Break);
6998 
6999   // Don't break if there is no column gain.
7000   verifyFormat("f(\"aaaa\"\n"
7001                "  \"bbbb\");",
7002                Break);
7003 
7004   // Treat literals with escaped newlines like multi-line string literals.
7005   EXPECT_EQ("x = \"a\\\n"
7006             "b\\\n"
7007             "c\";",
7008             format("x = \"a\\\n"
7009                    "b\\\n"
7010                    "c\";",
7011                    NoBreak));
7012   EXPECT_EQ("xxxx =\n"
7013             "    \"a\\\n"
7014             "b\\\n"
7015             "c\";",
7016             format("xxxx = \"a\\\n"
7017                    "b\\\n"
7018                    "c\";",
7019                    Break));
7020 
7021   EXPECT_EQ("NSString *const kString =\n"
7022             "    @\"aaaa\"\n"
7023             "    @\"bbbb\";",
7024             format("NSString *const kString = @\"aaaa\"\n"
7025                    "@\"bbbb\";",
7026                    Break));
7027 
7028   Break.ColumnLimit = 0;
7029   verifyFormat("const char *hello = \"hello llvm\";", Break);
7030 }
7031 
7032 TEST_F(FormatTest, AlignsPipes) {
7033   verifyFormat(
7034       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7035       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7036       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7037   verifyFormat(
7038       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
7039       "                     << aaaaaaaaaaaaaaaaaaaa;");
7040   verifyFormat(
7041       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7042       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7043   verifyFormat(
7044       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7045       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7046   verifyFormat(
7047       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
7048       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
7049       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
7050   verifyFormat(
7051       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7052       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7053       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7054   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7055                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7056                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7057                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7058   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
7059                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
7060   verifyFormat(
7061       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7062       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7063   verifyFormat(
7064       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
7065       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
7066 
7067   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
7068                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
7069   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7070                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7071                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
7072                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
7073   verifyFormat("LOG_IF(aaa == //\n"
7074                "       bbb)\n"
7075                "    << a << b;");
7076 
7077   // But sometimes, breaking before the first "<<" is desirable.
7078   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7079                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
7080   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
7081                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7082                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7083   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
7084                "    << BEF << IsTemplate << Description << E->getType();");
7085   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7086                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7087                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7088   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7089                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7090                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7091                "    << aaa;");
7092 
7093   verifyFormat(
7094       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7095       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7096 
7097   // Incomplete string literal.
7098   EXPECT_EQ("llvm::errs() << \"\n"
7099             "             << a;",
7100             format("llvm::errs() << \"\n<<a;"));
7101 
7102   verifyFormat("void f() {\n"
7103                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
7104                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
7105                "}");
7106 
7107   // Handle 'endl'.
7108   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
7109                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7110   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7111 
7112   // Handle '\n'.
7113   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
7114                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7115   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
7116                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
7117   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
7118                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
7119   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7120 }
7121 
7122 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
7123   verifyFormat("return out << \"somepacket = {\\n\"\n"
7124                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
7125                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
7126                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
7127                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
7128                "           << \"}\";");
7129 
7130   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7131                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7132                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7133   verifyFormat(
7134       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7135       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7136       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7137       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7138       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7139   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7140                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7141   verifyFormat(
7142       "void f() {\n"
7143       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7144       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7145       "}");
7146 
7147   // Breaking before the first "<<" is generally not desirable.
7148   verifyFormat(
7149       "llvm::errs()\n"
7150       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7151       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7152       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7153       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7154       getLLVMStyleWithColumns(70));
7155   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7156                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7157                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7158                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7159                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7160                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7161                getLLVMStyleWithColumns(70));
7162 
7163   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7164                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7165                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7166   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7167                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7168                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7169   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7170                "           (aaaa + aaaa);",
7171                getLLVMStyleWithColumns(40));
7172   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7173                "                  (aaaaaaa + aaaaa));",
7174                getLLVMStyleWithColumns(40));
7175   verifyFormat(
7176       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7177       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7178       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
7179 }
7180 
7181 TEST_F(FormatTest, UnderstandsEquals) {
7182   verifyFormat(
7183       "aaaaaaaaaaaaaaaaa =\n"
7184       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7185   verifyFormat(
7186       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7187       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7188   verifyFormat(
7189       "if (a) {\n"
7190       "  f();\n"
7191       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7192       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7193       "}");
7194 
7195   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7196                "        100000000 + 10000000) {\n}");
7197 }
7198 
7199 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7200   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7201                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
7202 
7203   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7204                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
7205 
7206   verifyFormat(
7207       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7208       "                                                          Parameter2);");
7209 
7210   verifyFormat(
7211       "ShortObject->shortFunction(\n"
7212       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7213       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7214 
7215   verifyFormat("loooooooooooooongFunction(\n"
7216                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
7217 
7218   verifyFormat(
7219       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7220       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7221 
7222   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7223                "    .WillRepeatedly(Return(SomeValue));");
7224   verifyFormat("void f() {\n"
7225                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7226                "      .Times(2)\n"
7227                "      .WillRepeatedly(Return(SomeValue));\n"
7228                "}");
7229   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7230                "    ccccccccccccccccccccccc);");
7231   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7232                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7233                "          .aaaaa(aaaaa),\n"
7234                "      aaaaaaaaaaaaaaaaaaaaa);");
7235   verifyFormat("void f() {\n"
7236                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7237                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7238                "}");
7239   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7240                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7241                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7242                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7243                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7244   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7245                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7246                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7247                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7248                "}");
7249 
7250   // Here, it is not necessary to wrap at "." or "->".
7251   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7252                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7253   verifyFormat(
7254       "aaaaaaaaaaa->aaaaaaaaa(\n"
7255       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7256       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7257 
7258   verifyFormat(
7259       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7260       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7261   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7262                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7263   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7264                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7265 
7266   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7267                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7268                "    .a();");
7269 
7270   FormatStyle NoBinPacking = getLLVMStyle();
7271   NoBinPacking.BinPackParameters = false;
7272   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7273                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7274                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7275                "                         aaaaaaaaaaaaaaaaaaa,\n"
7276                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7277                NoBinPacking);
7278 
7279   // If there is a subsequent call, change to hanging indentation.
7280   verifyFormat(
7281       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7282       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7283       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7284   verifyFormat(
7285       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7286       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7287   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7288                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7289                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7290   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7291                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7292                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7293 }
7294 
7295 TEST_F(FormatTest, WrapsTemplateDeclarations) {
7296   verifyFormat("template <typename T>\n"
7297                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7298   verifyFormat("template <typename T>\n"
7299                "// T should be one of {A, B}.\n"
7300                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7301   verifyFormat(
7302       "template <typename T>\n"
7303       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7304   verifyFormat("template <typename T>\n"
7305                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7306                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7307   verifyFormat(
7308       "template <typename T>\n"
7309       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7310       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
7311   verifyFormat(
7312       "template <typename T>\n"
7313       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7314       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7315       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7316   verifyFormat("template <typename T>\n"
7317                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7318                "    int aaaaaaaaaaaaaaaaaaaaaa);");
7319   verifyFormat(
7320       "template <typename T1, typename T2 = char, typename T3 = char,\n"
7321       "          typename T4 = char>\n"
7322       "void f();");
7323   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7324                "          template <typename> class cccccccccccccccccccccc,\n"
7325                "          typename ddddddddddddd>\n"
7326                "class C {};");
7327   verifyFormat(
7328       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7329       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7330 
7331   verifyFormat("void f() {\n"
7332                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7333                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7334                "}");
7335 
7336   verifyFormat("template <typename T> class C {};");
7337   verifyFormat("template <typename T> void f();");
7338   verifyFormat("template <typename T> void f() {}");
7339   verifyFormat(
7340       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7341       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7342       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7343       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7344       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7345       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7346       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
7347       getLLVMStyleWithColumns(72));
7348   EXPECT_EQ("static_cast<A< //\n"
7349             "    B> *>(\n"
7350             "\n"
7351             ");",
7352             format("static_cast<A<//\n"
7353                    "    B>*>(\n"
7354                    "\n"
7355                    "    );"));
7356   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7357                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7358 
7359   FormatStyle AlwaysBreak = getLLVMStyle();
7360   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7361   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7362   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7363   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7364   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7365                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7366                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
7367   verifyFormat("template <template <typename> class Fooooooo,\n"
7368                "          template <typename> class Baaaaaaar>\n"
7369                "struct C {};",
7370                AlwaysBreak);
7371   verifyFormat("template <typename T> // T can be A, B or C.\n"
7372                "struct C {};",
7373                AlwaysBreak);
7374   verifyFormat("template <enum E> class A {\n"
7375                "public:\n"
7376                "  E *f();\n"
7377                "};");
7378 
7379   FormatStyle NeverBreak = getLLVMStyle();
7380   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7381   verifyFormat("template <typename T> class C {};", NeverBreak);
7382   verifyFormat("template <typename T> void f();", NeverBreak);
7383   verifyFormat("template <typename T> void f() {}", NeverBreak);
7384   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7385                "bbbbbbbbbbbbbbbbbbbb) {}",
7386                NeverBreak);
7387   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7388                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7389                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
7390                NeverBreak);
7391   verifyFormat("template <template <typename> class Fooooooo,\n"
7392                "          template <typename> class Baaaaaaar>\n"
7393                "struct C {};",
7394                NeverBreak);
7395   verifyFormat("template <typename T> // T can be A, B or C.\n"
7396                "struct C {};",
7397                NeverBreak);
7398   verifyFormat("template <enum E> class A {\n"
7399                "public:\n"
7400                "  E *f();\n"
7401                "};",
7402                NeverBreak);
7403   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7404   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7405                "bbbbbbbbbbbbbbbbbbbb) {}",
7406                NeverBreak);
7407 }
7408 
7409 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7410   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7411   Style.ColumnLimit = 60;
7412   EXPECT_EQ("// Baseline - no comments.\n"
7413             "template <\n"
7414             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7415             "void f() {}",
7416             format("// Baseline - no comments.\n"
7417                    "template <\n"
7418                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7419                    "void f() {}",
7420                    Style));
7421 
7422   EXPECT_EQ("template <\n"
7423             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7424             "void f() {}",
7425             format("template <\n"
7426                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7427                    "void f() {}",
7428                    Style));
7429 
7430   EXPECT_EQ(
7431       "template <\n"
7432       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7433       "void f() {}",
7434       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
7435              "void f() {}",
7436              Style));
7437 
7438   EXPECT_EQ(
7439       "template <\n"
7440       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7441       "                                               // multiline\n"
7442       "void f() {}",
7443       format("template <\n"
7444              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7445              "                                              // multiline\n"
7446              "void f() {}",
7447              Style));
7448 
7449   EXPECT_EQ(
7450       "template <typename aaaaaaaaaa<\n"
7451       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
7452       "void f() {}",
7453       format(
7454           "template <\n"
7455           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7456           "void f() {}",
7457           Style));
7458 }
7459 
7460 TEST_F(FormatTest, WrapsTemplateParameters) {
7461   FormatStyle Style = getLLVMStyle();
7462   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7463   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7464   verifyFormat(
7465       "template <typename... a> struct q {};\n"
7466       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7467       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7468       "    y;",
7469       Style);
7470   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7471   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7472   verifyFormat(
7473       "template <typename... a> struct r {};\n"
7474       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7475       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7476       "    y;",
7477       Style);
7478   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7479   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7480   verifyFormat("template <typename... a> struct s {};\n"
7481                "extern s<\n"
7482                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7483                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7484                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7485                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7486                "    y;",
7487                Style);
7488   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7489   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7490   verifyFormat("template <typename... a> struct t {};\n"
7491                "extern t<\n"
7492                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7493                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7494                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7495                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7496                "    y;",
7497                Style);
7498 }
7499 
7500 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7501   verifyFormat(
7502       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7503       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7504   verifyFormat(
7505       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7506       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7507       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7508 
7509   // FIXME: Should we have the extra indent after the second break?
7510   verifyFormat(
7511       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7512       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7513       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7514 
7515   verifyFormat(
7516       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7517       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
7518 
7519   // Breaking at nested name specifiers is generally not desirable.
7520   verifyFormat(
7521       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7522       "    aaaaaaaaaaaaaaaaaaaaaaa);");
7523 
7524   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7525                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7526                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7527                "                   aaaaaaaaaaaaaaaaaaaaa);",
7528                getLLVMStyleWithColumns(74));
7529 
7530   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7531                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7532                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7533 }
7534 
7535 TEST_F(FormatTest, UnderstandsTemplateParameters) {
7536   verifyFormat("A<int> a;");
7537   verifyFormat("A<A<A<int>>> a;");
7538   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7539   verifyFormat("bool x = a < 1 || 2 > a;");
7540   verifyFormat("bool x = 5 < f<int>();");
7541   verifyFormat("bool x = f<int>() > 5;");
7542   verifyFormat("bool x = 5 < a<int>::x;");
7543   verifyFormat("bool x = a < 4 ? a > 2 : false;");
7544   verifyFormat("bool x = f() ? a < 2 : a > 2;");
7545 
7546   verifyGoogleFormat("A<A<int>> a;");
7547   verifyGoogleFormat("A<A<A<int>>> a;");
7548   verifyGoogleFormat("A<A<A<A<int>>>> a;");
7549   verifyGoogleFormat("A<A<int> > a;");
7550   verifyGoogleFormat("A<A<A<int> > > a;");
7551   verifyGoogleFormat("A<A<A<A<int> > > > a;");
7552   verifyGoogleFormat("A<::A<int>> a;");
7553   verifyGoogleFormat("A<::A> a;");
7554   verifyGoogleFormat("A< ::A> a;");
7555   verifyGoogleFormat("A< ::A<int> > a;");
7556   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7557   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7558   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7559   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7560   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7561             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7562 
7563   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7564 
7565   // template closer followed by a token that starts with > or =
7566   verifyFormat("bool b = a<1> > 1;");
7567   verifyFormat("bool b = a<1> >= 1;");
7568   verifyFormat("int i = a<1> >> 1;");
7569   FormatStyle Style = getLLVMStyle();
7570   Style.SpaceBeforeAssignmentOperators = false;
7571   verifyFormat("bool b= a<1> == 1;", Style);
7572   verifyFormat("a<int> = 1;", Style);
7573   verifyFormat("a<int> >>= 1;", Style);
7574 
7575   verifyFormat("test >> a >> b;");
7576   verifyFormat("test << a >> b;");
7577 
7578   verifyFormat("f<int>();");
7579   verifyFormat("template <typename T> void f() {}");
7580   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7581   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7582                "sizeof(char)>::type>;");
7583   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7584   verifyFormat("f(a.operator()<A>());");
7585   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7586                "      .template operator()<A>());",
7587                getLLVMStyleWithColumns(35));
7588 
7589   // Not template parameters.
7590   verifyFormat("return a < b && c > d;");
7591   verifyFormat("void f() {\n"
7592                "  while (a < b && c > d) {\n"
7593                "  }\n"
7594                "}");
7595   verifyFormat("template <typename... Types>\n"
7596                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7597 
7598   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7599                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7600                getLLVMStyleWithColumns(60));
7601   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7602   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7603   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7604   verifyFormat("some_templated_type<decltype([](int i) { return i; })>");
7605 }
7606 
7607 TEST_F(FormatTest, UnderstandsShiftOperators) {
7608   verifyFormat("if (i < x >> 1)");
7609   verifyFormat("while (i < x >> 1)");
7610   verifyFormat("for (unsigned i = 0; i < i; ++i, v = v >> 1)");
7611   verifyFormat("for (unsigned i = 0; i < x >> 1; ++i, v = v >> 1)");
7612   verifyFormat(
7613       "for (std::vector<int>::iterator i = 0; i < x >> 1; ++i, v = v >> 1)");
7614   verifyFormat("Foo.call<Bar<Function>>()");
7615   verifyFormat("if (Foo.call<Bar<Function>>() == 0)");
7616   verifyFormat("for (std::vector<std::pair<int>>::iterator i = 0; i < x >> 1; "
7617                "++i, v = v >> 1)");
7618   verifyFormat("if (w<u<v<x>>, 1>::t)");
7619 }
7620 
7621 TEST_F(FormatTest, BitshiftOperatorWidth) {
7622   EXPECT_EQ("int a = 1 << 2; /* foo\n"
7623             "                   bar */",
7624             format("int    a=1<<2;  /* foo\n"
7625                    "                   bar */"));
7626 
7627   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7628             "                     bar */",
7629             format("int  b  =256>>1 ;  /* foo\n"
7630                    "                      bar */"));
7631 }
7632 
7633 TEST_F(FormatTest, UnderstandsBinaryOperators) {
7634   verifyFormat("COMPARE(a, ==, b);");
7635   verifyFormat("auto s = sizeof...(Ts) - 1;");
7636 }
7637 
7638 TEST_F(FormatTest, UnderstandsPointersToMembers) {
7639   verifyFormat("int A::*x;");
7640   verifyFormat("int (S::*func)(void *);");
7641   verifyFormat("void f() { int (S::*func)(void *); }");
7642   verifyFormat("typedef bool *(Class::*Member)() const;");
7643   verifyFormat("void f() {\n"
7644                "  (a->*f)();\n"
7645                "  a->*x;\n"
7646                "  (a.*f)();\n"
7647                "  ((*a).*f)();\n"
7648                "  a.*x;\n"
7649                "}");
7650   verifyFormat("void f() {\n"
7651                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7652                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7653                "}");
7654   verifyFormat(
7655       "(aaaaaaaaaa->*bbbbbbb)(\n"
7656       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7657   FormatStyle Style = getLLVMStyle();
7658   Style.PointerAlignment = FormatStyle::PAS_Left;
7659   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7660 }
7661 
7662 TEST_F(FormatTest, UnderstandsUnaryOperators) {
7663   verifyFormat("int a = -2;");
7664   verifyFormat("f(-1, -2, -3);");
7665   verifyFormat("a[-1] = 5;");
7666   verifyFormat("int a = 5 + -2;");
7667   verifyFormat("if (i == -1) {\n}");
7668   verifyFormat("if (i != -1) {\n}");
7669   verifyFormat("if (i > -1) {\n}");
7670   verifyFormat("if (i < -1) {\n}");
7671   verifyFormat("++(a->f());");
7672   verifyFormat("--(a->f());");
7673   verifyFormat("(a->f())++;");
7674   verifyFormat("a[42]++;");
7675   verifyFormat("if (!(a->f())) {\n}");
7676   verifyFormat("if (!+i) {\n}");
7677   verifyFormat("~&a;");
7678 
7679   verifyFormat("a-- > b;");
7680   verifyFormat("b ? -a : c;");
7681   verifyFormat("n * sizeof char16;");
7682   verifyFormat("n * alignof char16;", getGoogleStyle());
7683   verifyFormat("sizeof(char);");
7684   verifyFormat("alignof(char);", getGoogleStyle());
7685 
7686   verifyFormat("return -1;");
7687   verifyFormat("throw -1;");
7688   verifyFormat("switch (a) {\n"
7689                "case -1:\n"
7690                "  break;\n"
7691                "}");
7692   verifyFormat("#define X -1");
7693   verifyFormat("#define X -kConstant");
7694 
7695   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7696   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7697 
7698   verifyFormat("int a = /* confusing comment */ -1;");
7699   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7700   verifyFormat("int a = i /* confusing comment */++;");
7701 
7702   verifyFormat("co_yield -1;");
7703   verifyFormat("co_return -1;");
7704 }
7705 
7706 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7707   verifyFormat("if (!aaaaaaaaaa( // break\n"
7708                "        aaaaa)) {\n"
7709                "}");
7710   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7711                "    aaaaa));");
7712   verifyFormat("*aaa = aaaaaaa( // break\n"
7713                "    bbbbbb);");
7714 }
7715 
7716 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7717   verifyFormat("bool operator<();");
7718   verifyFormat("bool operator>();");
7719   verifyFormat("bool operator=();");
7720   verifyFormat("bool operator==();");
7721   verifyFormat("bool operator!=();");
7722   verifyFormat("int operator+();");
7723   verifyFormat("int operator++();");
7724   verifyFormat("int operator++(int) volatile noexcept;");
7725   verifyFormat("bool operator,();");
7726   verifyFormat("bool operator();");
7727   verifyFormat("bool operator()();");
7728   verifyFormat("bool operator[]();");
7729   verifyFormat("operator bool();");
7730   verifyFormat("operator int();");
7731   verifyFormat("operator void *();");
7732   verifyFormat("operator SomeType<int>();");
7733   verifyFormat("operator SomeType<int, int>();");
7734   verifyFormat("operator SomeType<SomeType<int>>();");
7735   verifyFormat("void *operator new(std::size_t size);");
7736   verifyFormat("void *operator new[](std::size_t size);");
7737   verifyFormat("void operator delete(void *ptr);");
7738   verifyFormat("void operator delete[](void *ptr);");
7739   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7740                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7741   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7742                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7743 
7744   verifyFormat(
7745       "ostream &operator<<(ostream &OutputStream,\n"
7746       "                    SomeReallyLongType WithSomeReallyLongValue);");
7747   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7748                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7749                "  return left.group < right.group;\n"
7750                "}");
7751   verifyFormat("SomeType &operator=(const SomeType &S);");
7752   verifyFormat("f.template operator()<int>();");
7753 
7754   verifyGoogleFormat("operator void*();");
7755   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7756   verifyGoogleFormat("operator ::A();");
7757 
7758   verifyFormat("using A::operator+;");
7759   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7760                "int i;");
7761 }
7762 
7763 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7764   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7765   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7766   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7767   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7768   verifyFormat("Deleted &operator=(const Deleted &) &;");
7769   verifyFormat("Deleted &operator=(const Deleted &) &&;");
7770   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7771   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7772   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7773   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7774   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7775   verifyFormat("void Fn(T const &) const &;");
7776   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7777   verifyFormat("template <typename T>\n"
7778                "void F(T) && = delete;",
7779                getGoogleStyle());
7780 
7781   FormatStyle AlignLeft = getLLVMStyle();
7782   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7783   verifyFormat("void A::b() && {}", AlignLeft);
7784   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7785   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7786                AlignLeft);
7787   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7788   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7789   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7790   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7791   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7792   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7793   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7794   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7795 
7796   FormatStyle Spaces = getLLVMStyle();
7797   Spaces.SpacesInCStyleCastParentheses = true;
7798   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7799   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7800   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7801   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7802 
7803   Spaces.SpacesInCStyleCastParentheses = false;
7804   Spaces.SpacesInParentheses = true;
7805   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7806   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7807                Spaces);
7808   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7809   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7810 
7811   FormatStyle BreakTemplate = getLLVMStyle();
7812   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7813 
7814   verifyFormat("struct f {\n"
7815                "  template <class T>\n"
7816                "  int &foo(const std::string &str) &noexcept {}\n"
7817                "};",
7818                BreakTemplate);
7819 
7820   verifyFormat("struct f {\n"
7821                "  template <class T>\n"
7822                "  int &foo(const std::string &str) &&noexcept {}\n"
7823                "};",
7824                BreakTemplate);
7825 
7826   verifyFormat("struct f {\n"
7827                "  template <class T>\n"
7828                "  int &foo(const std::string &str) const &noexcept {}\n"
7829                "};",
7830                BreakTemplate);
7831 
7832   verifyFormat("struct f {\n"
7833                "  template <class T>\n"
7834                "  int &foo(const std::string &str) const &noexcept {}\n"
7835                "};",
7836                BreakTemplate);
7837 
7838   verifyFormat("struct f {\n"
7839                "  template <class T>\n"
7840                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
7841                "};",
7842                BreakTemplate);
7843 
7844   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7845   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7846       FormatStyle::BTDS_Yes;
7847   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7848 
7849   verifyFormat("struct f {\n"
7850                "  template <class T>\n"
7851                "  int& foo(const std::string& str) & noexcept {}\n"
7852                "};",
7853                AlignLeftBreakTemplate);
7854 
7855   verifyFormat("struct f {\n"
7856                "  template <class T>\n"
7857                "  int& foo(const std::string& str) && noexcept {}\n"
7858                "};",
7859                AlignLeftBreakTemplate);
7860 
7861   verifyFormat("struct f {\n"
7862                "  template <class T>\n"
7863                "  int& foo(const std::string& str) const& noexcept {}\n"
7864                "};",
7865                AlignLeftBreakTemplate);
7866 
7867   verifyFormat("struct f {\n"
7868                "  template <class T>\n"
7869                "  int& foo(const std::string& str) const&& noexcept {}\n"
7870                "};",
7871                AlignLeftBreakTemplate);
7872 
7873   verifyFormat("struct f {\n"
7874                "  template <class T>\n"
7875                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7876                "};",
7877                AlignLeftBreakTemplate);
7878 
7879   // The `&` in `Type&` should not be confused with a trailing `&` of
7880   // DEPRECATED(reason) member function.
7881   verifyFormat("struct f {\n"
7882                "  template <class T>\n"
7883                "  DEPRECATED(reason)\n"
7884                "  Type &foo(arguments) {}\n"
7885                "};",
7886                BreakTemplate);
7887 
7888   verifyFormat("struct f {\n"
7889                "  template <class T>\n"
7890                "  DEPRECATED(reason)\n"
7891                "  Type& foo(arguments) {}\n"
7892                "};",
7893                AlignLeftBreakTemplate);
7894 
7895   verifyFormat("void (*foopt)(int) = &func;");
7896 }
7897 
7898 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7899   verifyFormat("void f() {\n"
7900                "  A *a = new A;\n"
7901                "  A *a = new (placement) A;\n"
7902                "  delete a;\n"
7903                "  delete (A *)a;\n"
7904                "}");
7905   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7906                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7907   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7908                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7909                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7910   verifyFormat("delete[] h->p;");
7911 }
7912 
7913 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
7914   verifyFormat("int *f(int *a) {}");
7915   verifyFormat("int main(int argc, char **argv) {}");
7916   verifyFormat("Test::Test(int b) : a(b * b) {}");
7917   verifyIndependentOfContext("f(a, *a);");
7918   verifyFormat("void g() { f(*a); }");
7919   verifyIndependentOfContext("int a = b * 10;");
7920   verifyIndependentOfContext("int a = 10 * b;");
7921   verifyIndependentOfContext("int a = b * c;");
7922   verifyIndependentOfContext("int a += b * c;");
7923   verifyIndependentOfContext("int a -= b * c;");
7924   verifyIndependentOfContext("int a *= b * c;");
7925   verifyIndependentOfContext("int a /= b * c;");
7926   verifyIndependentOfContext("int a = *b;");
7927   verifyIndependentOfContext("int a = *b * c;");
7928   verifyIndependentOfContext("int a = b * *c;");
7929   verifyIndependentOfContext("int a = b * (10);");
7930   verifyIndependentOfContext("S << b * (10);");
7931   verifyIndependentOfContext("return 10 * b;");
7932   verifyIndependentOfContext("return *b * *c;");
7933   verifyIndependentOfContext("return a & ~b;");
7934   verifyIndependentOfContext("f(b ? *c : *d);");
7935   verifyIndependentOfContext("int a = b ? *c : *d;");
7936   verifyIndependentOfContext("*b = a;");
7937   verifyIndependentOfContext("a * ~b;");
7938   verifyIndependentOfContext("a * !b;");
7939   verifyIndependentOfContext("a * +b;");
7940   verifyIndependentOfContext("a * -b;");
7941   verifyIndependentOfContext("a * ++b;");
7942   verifyIndependentOfContext("a * --b;");
7943   verifyIndependentOfContext("a[4] * b;");
7944   verifyIndependentOfContext("a[a * a] = 1;");
7945   verifyIndependentOfContext("f() * b;");
7946   verifyIndependentOfContext("a * [self dostuff];");
7947   verifyIndependentOfContext("int x = a * (a + b);");
7948   verifyIndependentOfContext("(a *)(a + b);");
7949   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
7950   verifyIndependentOfContext("int *pa = (int *)&a;");
7951   verifyIndependentOfContext("return sizeof(int **);");
7952   verifyIndependentOfContext("return sizeof(int ******);");
7953   verifyIndependentOfContext("return (int **&)a;");
7954   verifyIndependentOfContext("f((*PointerToArray)[10]);");
7955   verifyFormat("void f(Type (*parameter)[10]) {}");
7956   verifyFormat("void f(Type (&parameter)[10]) {}");
7957   verifyGoogleFormat("return sizeof(int**);");
7958   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
7959   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
7960   verifyFormat("auto a = [](int **&, int ***) {};");
7961   verifyFormat("auto PointerBinding = [](const char *S) {};");
7962   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
7963   verifyFormat("[](const decltype(*a) &value) {}");
7964   verifyFormat("[](const typeof(*a) &value) {}");
7965   verifyFormat("[](const _Atomic(a *) &value) {}");
7966   verifyFormat("[](const __underlying_type(a) &value) {}");
7967   verifyFormat("decltype(a * b) F();");
7968   verifyFormat("typeof(a * b) F();");
7969   verifyFormat("#define MACRO() [](A *a) { return 1; }");
7970   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
7971   verifyIndependentOfContext("typedef void (*f)(int *a);");
7972   verifyIndependentOfContext("int i{a * b};");
7973   verifyIndependentOfContext("aaa && aaa->f();");
7974   verifyIndependentOfContext("int x = ~*p;");
7975   verifyFormat("Constructor() : a(a), area(width * height) {}");
7976   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
7977   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
7978   verifyFormat("void f() { f(a, c * d); }");
7979   verifyFormat("void f() { f(new a(), c * d); }");
7980   verifyFormat("void f(const MyOverride &override);");
7981   verifyFormat("void f(const MyFinal &final);");
7982   verifyIndependentOfContext("bool a = f() && override.f();");
7983   verifyIndependentOfContext("bool a = f() && final.f();");
7984 
7985   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
7986 
7987   verifyIndependentOfContext("A<int *> a;");
7988   verifyIndependentOfContext("A<int **> a;");
7989   verifyIndependentOfContext("A<int *, int *> a;");
7990   verifyIndependentOfContext("A<int *[]> a;");
7991   verifyIndependentOfContext(
7992       "const char *const p = reinterpret_cast<const char *const>(q);");
7993   verifyIndependentOfContext("A<int **, int **> a;");
7994   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
7995   verifyFormat("for (char **a = b; *a; ++a) {\n}");
7996   verifyFormat("for (; a && b;) {\n}");
7997   verifyFormat("bool foo = true && [] { return false; }();");
7998 
7999   verifyFormat(
8000       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8001       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8002 
8003   verifyGoogleFormat("int const* a = &b;");
8004   verifyGoogleFormat("**outparam = 1;");
8005   verifyGoogleFormat("*outparam = a * b;");
8006   verifyGoogleFormat("int main(int argc, char** argv) {}");
8007   verifyGoogleFormat("A<int*> a;");
8008   verifyGoogleFormat("A<int**> a;");
8009   verifyGoogleFormat("A<int*, int*> a;");
8010   verifyGoogleFormat("A<int**, int**> a;");
8011   verifyGoogleFormat("f(b ? *c : *d);");
8012   verifyGoogleFormat("int a = b ? *c : *d;");
8013   verifyGoogleFormat("Type* t = **x;");
8014   verifyGoogleFormat("Type* t = *++*x;");
8015   verifyGoogleFormat("*++*x;");
8016   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
8017   verifyGoogleFormat("Type* t = x++ * y;");
8018   verifyGoogleFormat(
8019       "const char* const p = reinterpret_cast<const char* const>(q);");
8020   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
8021   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
8022   verifyGoogleFormat("template <typename T>\n"
8023                      "void f(int i = 0, SomeType** temps = NULL);");
8024 
8025   FormatStyle Left = getLLVMStyle();
8026   Left.PointerAlignment = FormatStyle::PAS_Left;
8027   verifyFormat("x = *a(x) = *a(y);", Left);
8028   verifyFormat("for (;; *a = b) {\n}", Left);
8029   verifyFormat("return *this += 1;", Left);
8030   verifyFormat("throw *x;", Left);
8031   verifyFormat("delete *x;", Left);
8032   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
8033   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
8034   verifyFormat("[](const typeof(*a)* ptr) {}", Left);
8035   verifyFormat("[](const _Atomic(a*)* ptr) {}", Left);
8036   verifyFormat("[](const __underlying_type(a)* ptr) {}", Left);
8037   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
8038   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
8039   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
8040   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
8041 
8042   verifyIndependentOfContext("a = *(x + y);");
8043   verifyIndependentOfContext("a = &(x + y);");
8044   verifyIndependentOfContext("*(x + y).call();");
8045   verifyIndependentOfContext("&(x + y)->call();");
8046   verifyFormat("void f() { &(*I).first; }");
8047 
8048   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
8049   verifyFormat(
8050       "int *MyValues = {\n"
8051       "    *A, // Operator detection might be confused by the '{'\n"
8052       "    *BB // Operator detection might be confused by previous comment\n"
8053       "};");
8054 
8055   verifyIndependentOfContext("if (int *a = &b)");
8056   verifyIndependentOfContext("if (int &a = *b)");
8057   verifyIndependentOfContext("if (a & b[i])");
8058   verifyIndependentOfContext("if constexpr (a & b[i])");
8059   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
8060   verifyIndependentOfContext("if (a * (b * c))");
8061   verifyIndependentOfContext("if constexpr (a * (b * c))");
8062   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
8063   verifyIndependentOfContext("if (a::b::c::d & b[i])");
8064   verifyIndependentOfContext("if (*b[i])");
8065   verifyIndependentOfContext("if (int *a = (&b))");
8066   verifyIndependentOfContext("while (int *a = &b)");
8067   verifyIndependentOfContext("while (a * (b * c))");
8068   verifyIndependentOfContext("size = sizeof *a;");
8069   verifyIndependentOfContext("if (a && (b = c))");
8070   verifyFormat("void f() {\n"
8071                "  for (const int &v : Values) {\n"
8072                "  }\n"
8073                "}");
8074   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
8075   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
8076   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
8077 
8078   verifyFormat("#define A (!a * b)");
8079   verifyFormat("#define MACRO     \\\n"
8080                "  int *i = a * b; \\\n"
8081                "  void f(a *b);",
8082                getLLVMStyleWithColumns(19));
8083 
8084   verifyIndependentOfContext("A = new SomeType *[Length];");
8085   verifyIndependentOfContext("A = new SomeType *[Length]();");
8086   verifyIndependentOfContext("T **t = new T *;");
8087   verifyIndependentOfContext("T **t = new T *();");
8088   verifyGoogleFormat("A = new SomeType*[Length]();");
8089   verifyGoogleFormat("A = new SomeType*[Length];");
8090   verifyGoogleFormat("T** t = new T*;");
8091   verifyGoogleFormat("T** t = new T*();");
8092 
8093   verifyFormat("STATIC_ASSERT((a & b) == 0);");
8094   verifyFormat("STATIC_ASSERT(0 == (a & b));");
8095   verifyFormat("template <bool a, bool b> "
8096                "typename t::if<x && y>::type f() {}");
8097   verifyFormat("template <int *y> f() {}");
8098   verifyFormat("vector<int *> v;");
8099   verifyFormat("vector<int *const> v;");
8100   verifyFormat("vector<int *const **const *> v;");
8101   verifyFormat("vector<int *volatile> v;");
8102   verifyFormat("vector<a *_Nonnull> v;");
8103   verifyFormat("vector<a *_Nullable> v;");
8104   verifyFormat("vector<a *_Null_unspecified> v;");
8105   verifyFormat("vector<a *__ptr32> v;");
8106   verifyFormat("vector<a *__ptr64> v;");
8107   verifyFormat("vector<a *__capability> v;");
8108   FormatStyle TypeMacros = getLLVMStyle();
8109   TypeMacros.TypenameMacros = {"LIST"};
8110   verifyFormat("vector<LIST(uint64_t)> v;", TypeMacros);
8111   verifyFormat("vector<LIST(uint64_t) *> v;", TypeMacros);
8112   verifyFormat("vector<LIST(uint64_t) **> v;", TypeMacros);
8113   verifyFormat("vector<LIST(uint64_t) *attr> v;", TypeMacros);
8114   verifyFormat("vector<A(uint64_t) * attr> v;", TypeMacros); // multiplication
8115 
8116   FormatStyle CustomQualifier = getLLVMStyle();
8117   // Add indentifers that should not be parsed as a qualifier by default.
8118   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8119   CustomQualifier.AttributeMacros.push_back("_My_qualifier");
8120   CustomQualifier.AttributeMacros.push_back("my_other_qualifier");
8121   verifyFormat("vector<a * __my_qualifier> parse_as_multiply;");
8122   verifyFormat("vector<a *__my_qualifier> v;", CustomQualifier);
8123   verifyFormat("vector<a * _My_qualifier> parse_as_multiply;");
8124   verifyFormat("vector<a *_My_qualifier> v;", CustomQualifier);
8125   verifyFormat("vector<a * my_other_qualifier> parse_as_multiply;");
8126   verifyFormat("vector<a *my_other_qualifier> v;", CustomQualifier);
8127   verifyFormat("vector<a * _NotAQualifier> v;");
8128   verifyFormat("vector<a * __not_a_qualifier> v;");
8129   verifyFormat("vector<a * b> v;");
8130   verifyFormat("foo<b && false>();");
8131   verifyFormat("foo<b & 1>();");
8132   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
8133   verifyFormat("typeof(*::std::declval<const T &>()) void F();");
8134   verifyFormat("_Atomic(*::std::declval<const T &>()) void F();");
8135   verifyFormat("__underlying_type(*::std::declval<const T &>()) void F();");
8136   verifyFormat(
8137       "template <class T, class = typename std::enable_if<\n"
8138       "                       std::is_integral<T>::value &&\n"
8139       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
8140       "void F();",
8141       getLLVMStyleWithColumns(70));
8142   verifyFormat("template <class T,\n"
8143                "          class = typename std::enable_if<\n"
8144                "              std::is_integral<T>::value &&\n"
8145                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
8146                "          class U>\n"
8147                "void F();",
8148                getLLVMStyleWithColumns(70));
8149   verifyFormat(
8150       "template <class T,\n"
8151       "          class = typename ::std::enable_if<\n"
8152       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
8153       "void F();",
8154       getGoogleStyleWithColumns(68));
8155 
8156   verifyIndependentOfContext("MACRO(int *i);");
8157   verifyIndependentOfContext("MACRO(auto *a);");
8158   verifyIndependentOfContext("MACRO(const A *a);");
8159   verifyIndependentOfContext("MACRO(_Atomic(A) *a);");
8160   verifyIndependentOfContext("MACRO(decltype(A) *a);");
8161   verifyIndependentOfContext("MACRO(typeof(A) *a);");
8162   verifyIndependentOfContext("MACRO(__underlying_type(A) *a);");
8163   verifyIndependentOfContext("MACRO(A *const a);");
8164   verifyIndependentOfContext("MACRO(A *restrict a);");
8165   verifyIndependentOfContext("MACRO(A *__restrict__ a);");
8166   verifyIndependentOfContext("MACRO(A *__restrict a);");
8167   verifyIndependentOfContext("MACRO(A *volatile a);");
8168   verifyIndependentOfContext("MACRO(A *__volatile a);");
8169   verifyIndependentOfContext("MACRO(A *__volatile__ a);");
8170   verifyIndependentOfContext("MACRO(A *_Nonnull a);");
8171   verifyIndependentOfContext("MACRO(A *_Nullable a);");
8172   verifyIndependentOfContext("MACRO(A *_Null_unspecified a);");
8173   verifyIndependentOfContext("MACRO(A *__attribute__((foo)) a);");
8174   verifyIndependentOfContext("MACRO(A *__attribute((foo)) a);");
8175   verifyIndependentOfContext("MACRO(A *[[clang::attr]] a);");
8176   verifyIndependentOfContext("MACRO(A *[[clang::attr(\"foo\")]] a);");
8177   verifyIndependentOfContext("MACRO(A *__ptr32 a);");
8178   verifyIndependentOfContext("MACRO(A *__ptr64 a);");
8179   verifyIndependentOfContext("MACRO(A *__capability);");
8180   verifyIndependentOfContext("MACRO(A &__capability);");
8181   verifyFormat("MACRO(A *__my_qualifier);");               // type declaration
8182   verifyFormat("void f() { MACRO(A * __my_qualifier); }"); // multiplication
8183   // If we add __my_qualifier to AttributeMacros it should always be parsed as
8184   // a type declaration:
8185   verifyFormat("MACRO(A *__my_qualifier);", CustomQualifier);
8186   verifyFormat("void f() { MACRO(A *__my_qualifier); }", CustomQualifier);
8187   // Also check that TypenameMacros prevents parsing it as multiplication:
8188   verifyIndependentOfContext("MACRO(LIST(uint64_t) * a);"); // multiplication
8189   verifyIndependentOfContext("MACRO(LIST(uint64_t) *a);", TypeMacros); // type
8190 
8191   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
8192   verifyFormat("void f() { f(float{1}, a * a); }");
8193   // FIXME: Is there a way to make this work?
8194   // verifyIndependentOfContext("MACRO(A *a);");
8195   verifyFormat("MACRO(A &B);");
8196   verifyFormat("MACRO(A *B);");
8197   verifyFormat("void f() { MACRO(A * B); }");
8198   verifyFormat("void f() { MACRO(A & B); }");
8199 
8200   verifyFormat("DatumHandle const *operator->() const { return input_; }");
8201   verifyFormat("return options != nullptr && operator==(*options);");
8202 
8203   EXPECT_EQ("#define OP(x)                                    \\\n"
8204             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
8205             "    return s << a.DebugString();                 \\\n"
8206             "  }",
8207             format("#define OP(x) \\\n"
8208                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
8209                    "    return s << a.DebugString(); \\\n"
8210                    "  }",
8211                    getLLVMStyleWithColumns(50)));
8212 
8213   // FIXME: We cannot handle this case yet; we might be able to figure out that
8214   // foo<x> d > v; doesn't make sense.
8215   verifyFormat("foo<a<b && c> d> v;");
8216 
8217   FormatStyle PointerMiddle = getLLVMStyle();
8218   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8219   verifyFormat("delete *x;", PointerMiddle);
8220   verifyFormat("int * x;", PointerMiddle);
8221   verifyFormat("int *[] x;", PointerMiddle);
8222   verifyFormat("template <int * y> f() {}", PointerMiddle);
8223   verifyFormat("int * f(int * a) {}", PointerMiddle);
8224   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8225   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8226   verifyFormat("A<int *> a;", PointerMiddle);
8227   verifyFormat("A<int **> a;", PointerMiddle);
8228   verifyFormat("A<int *, int *> a;", PointerMiddle);
8229   verifyFormat("A<int *[]> a;", PointerMiddle);
8230   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8231   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8232   verifyFormat("T ** t = new T *;", PointerMiddle);
8233 
8234   // Member function reference qualifiers aren't binary operators.
8235   verifyFormat("string // break\n"
8236                "operator()() & {}");
8237   verifyFormat("string // break\n"
8238                "operator()() && {}");
8239   verifyGoogleFormat("template <typename T>\n"
8240                      "auto x() & -> int {}");
8241 }
8242 
8243 TEST_F(FormatTest, UnderstandsAttributes) {
8244   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8245   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8246                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8247   FormatStyle AfterType = getLLVMStyle();
8248   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
8249   verifyFormat("__attribute__((nodebug)) void\n"
8250                "foo() {}\n",
8251                AfterType);
8252   verifyFormat("__unused void\n"
8253                "foo() {}",
8254                AfterType);
8255 
8256   FormatStyle CustomAttrs = getLLVMStyle();
8257   CustomAttrs.AttributeMacros.push_back("__unused");
8258   CustomAttrs.AttributeMacros.push_back("__attr1");
8259   CustomAttrs.AttributeMacros.push_back("__attr2");
8260   CustomAttrs.AttributeMacros.push_back("no_underscore_attr");
8261   verifyFormat("vector<SomeType *__attribute((foo))> v;");
8262   verifyFormat("vector<SomeType *__attribute__((foo))> v;");
8263   verifyFormat("vector<SomeType * __not_attribute__((foo))> v;");
8264   // Check that it is parsed as a multiplication without AttributeMacros and
8265   // as a pointer qualifier when we add __attr1/__attr2 to AttributeMacros.
8266   verifyFormat("vector<SomeType * __attr1> v;");
8267   verifyFormat("vector<SomeType __attr1 *> v;");
8268   verifyFormat("vector<SomeType __attr1 *const> v;");
8269   verifyFormat("vector<SomeType __attr1 * __attr2> v;");
8270   verifyFormat("vector<SomeType *__attr1> v;", CustomAttrs);
8271   verifyFormat("vector<SomeType *__attr2> v;", CustomAttrs);
8272   verifyFormat("vector<SomeType *no_underscore_attr> v;", CustomAttrs);
8273   verifyFormat("vector<SomeType __attr1 *> v;", CustomAttrs);
8274   verifyFormat("vector<SomeType __attr1 *const> v;", CustomAttrs);
8275   verifyFormat("vector<SomeType __attr1 *__attr2> v;", CustomAttrs);
8276   verifyFormat("vector<SomeType __attr1 *no_underscore_attr> v;", CustomAttrs);
8277 
8278   // Check that these are not parsed as function declarations:
8279   CustomAttrs.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8280   CustomAttrs.BreakBeforeBraces = FormatStyle::BS_Allman;
8281   verifyFormat("SomeType s(InitValue);", CustomAttrs);
8282   verifyFormat("SomeType s{InitValue};", CustomAttrs);
8283   verifyFormat("SomeType *__unused s(InitValue);", CustomAttrs);
8284   verifyFormat("SomeType *__unused s{InitValue};", CustomAttrs);
8285   verifyFormat("SomeType s __unused(InitValue);", CustomAttrs);
8286   verifyFormat("SomeType s __unused{InitValue};", CustomAttrs);
8287   verifyFormat("SomeType *__capability s(InitValue);", CustomAttrs);
8288   verifyFormat("SomeType *__capability s{InitValue};", CustomAttrs);
8289 }
8290 
8291 TEST_F(FormatTest, UnderstandsPointerQualifiersInCast) {
8292   // Check that qualifiers on pointers don't break parsing of casts.
8293   verifyFormat("x = (foo *const)*v;");
8294   verifyFormat("x = (foo *volatile)*v;");
8295   verifyFormat("x = (foo *restrict)*v;");
8296   verifyFormat("x = (foo *__attribute__((foo)))*v;");
8297   verifyFormat("x = (foo *_Nonnull)*v;");
8298   verifyFormat("x = (foo *_Nullable)*v;");
8299   verifyFormat("x = (foo *_Null_unspecified)*v;");
8300   verifyFormat("x = (foo *_Nonnull)*v;");
8301   verifyFormat("x = (foo *[[clang::attr]])*v;");
8302   verifyFormat("x = (foo *[[clang::attr(\"foo\")]])*v;");
8303   verifyFormat("x = (foo *__ptr32)*v;");
8304   verifyFormat("x = (foo *__ptr64)*v;");
8305   verifyFormat("x = (foo *__capability)*v;");
8306 
8307   // Check that we handle multiple trailing qualifiers and skip them all to
8308   // determine that the expression is a cast to a pointer type.
8309   FormatStyle LongPointerRight = getLLVMStyleWithColumns(999);
8310   FormatStyle LongPointerLeft = getLLVMStyleWithColumns(999);
8311   LongPointerLeft.PointerAlignment = FormatStyle::PAS_Left;
8312   StringRef AllQualifiers =
8313       "const volatile restrict __attribute__((foo)) _Nonnull _Null_unspecified "
8314       "_Nonnull [[clang::attr]] __ptr32 __ptr64 __capability";
8315   verifyFormat(("x = (foo *" + AllQualifiers + ")*v;").str(), LongPointerRight);
8316   verifyFormat(("x = (foo* " + AllQualifiers + ")*v;").str(), LongPointerLeft);
8317 
8318   // Also check that address-of is not parsed as a binary bitwise-and:
8319   verifyFormat("x = (foo *const)&v;");
8320   verifyFormat(("x = (foo *" + AllQualifiers + ")&v;").str(), LongPointerRight);
8321   verifyFormat(("x = (foo* " + AllQualifiers + ")&v;").str(), LongPointerLeft);
8322 
8323   // Check custom qualifiers:
8324   FormatStyle CustomQualifier = getLLVMStyleWithColumns(999);
8325   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8326   verifyFormat("x = (foo * __my_qualifier) * v;"); // not parsed as qualifier.
8327   verifyFormat("x = (foo *__my_qualifier)*v;", CustomQualifier);
8328   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)*v;").str(),
8329                CustomQualifier);
8330   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)&v;").str(),
8331                CustomQualifier);
8332 
8333   // Check that unknown identifiers result in binary operator parsing:
8334   verifyFormat("x = (foo * __unknown_qualifier) * v;");
8335   verifyFormat("x = (foo * __unknown_qualifier) & v;");
8336 }
8337 
8338 TEST_F(FormatTest, UnderstandsSquareAttributes) {
8339   verifyFormat("SomeType s [[unused]] (InitValue);");
8340   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8341   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8342   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8343   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8344   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8345                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8346   verifyFormat("[[nodiscard]] bool f() { return false; }");
8347   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
8348   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
8349   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
8350 
8351   // Make sure we do not mistake attributes for array subscripts.
8352   verifyFormat("int a() {}\n"
8353                "[[unused]] int b() {}\n");
8354   verifyFormat("NSArray *arr;\n"
8355                "arr[[Foo() bar]];");
8356 
8357   // On the other hand, we still need to correctly find array subscripts.
8358   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8359 
8360   // Make sure that we do not mistake Objective-C method inside array literals
8361   // as attributes, even if those method names are also keywords.
8362   verifyFormat("@[ [foo bar] ];");
8363   verifyFormat("@[ [NSArray class] ];");
8364   verifyFormat("@[ [foo enum] ];");
8365 
8366   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8367 
8368   // Make sure we do not parse attributes as lambda introducers.
8369   FormatStyle MultiLineFunctions = getLLVMStyle();
8370   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8371   verifyFormat("[[unused]] int b() {\n"
8372                "  return 42;\n"
8373                "}\n",
8374                MultiLineFunctions);
8375 }
8376 
8377 TEST_F(FormatTest, AttributeClass) {
8378   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8379   verifyFormat("class S {\n"
8380                "  S(S&&) = default;\n"
8381                "};",
8382                Style);
8383   verifyFormat("class [[nodiscard]] S {\n"
8384                "  S(S&&) = default;\n"
8385                "};",
8386                Style);
8387   verifyFormat("class __attribute((maybeunused)) S {\n"
8388                "  S(S&&) = default;\n"
8389                "};",
8390                Style);
8391   verifyFormat("struct S {\n"
8392                "  S(S&&) = default;\n"
8393                "};",
8394                Style);
8395   verifyFormat("struct [[nodiscard]] S {\n"
8396                "  S(S&&) = default;\n"
8397                "};",
8398                Style);
8399 }
8400 
8401 TEST_F(FormatTest, AttributesAfterMacro) {
8402   FormatStyle Style = getLLVMStyle();
8403   verifyFormat("MACRO;\n"
8404                "__attribute__((maybe_unused)) int foo() {\n"
8405                "  //...\n"
8406                "}");
8407 
8408   verifyFormat("MACRO;\n"
8409                "[[nodiscard]] int foo() {\n"
8410                "  //...\n"
8411                "}");
8412 
8413   EXPECT_EQ("MACRO\n\n"
8414             "__attribute__((maybe_unused)) int foo() {\n"
8415             "  //...\n"
8416             "}",
8417             format("MACRO\n\n"
8418                    "__attribute__((maybe_unused)) int foo() {\n"
8419                    "  //...\n"
8420                    "}"));
8421 
8422   EXPECT_EQ("MACRO\n\n"
8423             "[[nodiscard]] int foo() {\n"
8424             "  //...\n"
8425             "}",
8426             format("MACRO\n\n"
8427                    "[[nodiscard]] int foo() {\n"
8428                    "  //...\n"
8429                    "}"));
8430 }
8431 
8432 TEST_F(FormatTest, AttributePenaltyBreaking) {
8433   FormatStyle Style = getLLVMStyle();
8434   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8435                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8436                Style);
8437   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8438                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8439                Style);
8440   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8441                "shared_ptr<ALongTypeName> &C d) {\n}",
8442                Style);
8443 }
8444 
8445 TEST_F(FormatTest, UnderstandsEllipsis) {
8446   FormatStyle Style = getLLVMStyle();
8447   verifyFormat("int printf(const char *fmt, ...);");
8448   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8449   verifyFormat("template <class... Ts> void Foo(Ts *...ts) {}");
8450 
8451   verifyFormat("template <int *...PP> a;", Style);
8452 
8453   Style.PointerAlignment = FormatStyle::PAS_Left;
8454   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", Style);
8455 
8456   verifyFormat("template <int*... PP> a;", Style);
8457 
8458   Style.PointerAlignment = FormatStyle::PAS_Middle;
8459   verifyFormat("template <int *... PP> a;", Style);
8460 }
8461 
8462 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8463   EXPECT_EQ("int *a;\n"
8464             "int *a;\n"
8465             "int *a;",
8466             format("int *a;\n"
8467                    "int* a;\n"
8468                    "int *a;",
8469                    getGoogleStyle()));
8470   EXPECT_EQ("int* a;\n"
8471             "int* a;\n"
8472             "int* a;",
8473             format("int* a;\n"
8474                    "int* a;\n"
8475                    "int *a;",
8476                    getGoogleStyle()));
8477   EXPECT_EQ("int *a;\n"
8478             "int *a;\n"
8479             "int *a;",
8480             format("int *a;\n"
8481                    "int * a;\n"
8482                    "int *  a;",
8483                    getGoogleStyle()));
8484   EXPECT_EQ("auto x = [] {\n"
8485             "  int *a;\n"
8486             "  int *a;\n"
8487             "  int *a;\n"
8488             "};",
8489             format("auto x=[]{int *a;\n"
8490                    "int * a;\n"
8491                    "int *  a;};",
8492                    getGoogleStyle()));
8493 }
8494 
8495 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8496   verifyFormat("int f(int &&a) {}");
8497   verifyFormat("int f(int a, char &&b) {}");
8498   verifyFormat("void f() { int &&a = b; }");
8499   verifyGoogleFormat("int f(int a, char&& b) {}");
8500   verifyGoogleFormat("void f() { int&& a = b; }");
8501 
8502   verifyIndependentOfContext("A<int &&> a;");
8503   verifyIndependentOfContext("A<int &&, int &&> a;");
8504   verifyGoogleFormat("A<int&&> a;");
8505   verifyGoogleFormat("A<int&&, int&&> a;");
8506 
8507   // Not rvalue references:
8508   verifyFormat("template <bool B, bool C> class A {\n"
8509                "  static_assert(B && C, \"Something is wrong\");\n"
8510                "};");
8511   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8512   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8513   verifyFormat("#define A(a, b) (a && b)");
8514 }
8515 
8516 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8517   verifyFormat("void f() {\n"
8518                "  x[aaaaaaaaa -\n"
8519                "    b] = 23;\n"
8520                "}",
8521                getLLVMStyleWithColumns(15));
8522 }
8523 
8524 TEST_F(FormatTest, FormatsCasts) {
8525   verifyFormat("Type *A = static_cast<Type *>(P);");
8526   verifyFormat("Type *A = (Type *)P;");
8527   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8528   verifyFormat("int a = (int)(2.0f);");
8529   verifyFormat("int a = (int)2.0f;");
8530   verifyFormat("x[(int32)y];");
8531   verifyFormat("x = (int32)y;");
8532   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8533   verifyFormat("int a = (int)*b;");
8534   verifyFormat("int a = (int)2.0f;");
8535   verifyFormat("int a = (int)~0;");
8536   verifyFormat("int a = (int)++a;");
8537   verifyFormat("int a = (int)sizeof(int);");
8538   verifyFormat("int a = (int)+2;");
8539   verifyFormat("my_int a = (my_int)2.0f;");
8540   verifyFormat("my_int a = (my_int)sizeof(int);");
8541   verifyFormat("return (my_int)aaa;");
8542   verifyFormat("#define x ((int)-1)");
8543   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8544   verifyFormat("#define p(q) ((int *)&q)");
8545   verifyFormat("fn(a)(b) + 1;");
8546 
8547   verifyFormat("void f() { my_int a = (my_int)*b; }");
8548   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8549   verifyFormat("my_int a = (my_int)~0;");
8550   verifyFormat("my_int a = (my_int)++a;");
8551   verifyFormat("my_int a = (my_int)-2;");
8552   verifyFormat("my_int a = (my_int)1;");
8553   verifyFormat("my_int a = (my_int *)1;");
8554   verifyFormat("my_int a = (const my_int)-1;");
8555   verifyFormat("my_int a = (const my_int *)-1;");
8556   verifyFormat("my_int a = (my_int)(my_int)-1;");
8557   verifyFormat("my_int a = (ns::my_int)-2;");
8558   verifyFormat("case (my_int)ONE:");
8559   verifyFormat("auto x = (X)this;");
8560   // Casts in Obj-C style calls used to not be recognized as such.
8561   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8562 
8563   // FIXME: single value wrapped with paren will be treated as cast.
8564   verifyFormat("void f(int i = (kValue)*kMask) {}");
8565 
8566   verifyFormat("{ (void)F; }");
8567 
8568   // Don't break after a cast's
8569   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8570                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8571                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8572 
8573   // These are not casts.
8574   verifyFormat("void f(int *) {}");
8575   verifyFormat("f(foo)->b;");
8576   verifyFormat("f(foo).b;");
8577   verifyFormat("f(foo)(b);");
8578   verifyFormat("f(foo)[b];");
8579   verifyFormat("[](foo) { return 4; }(bar);");
8580   verifyFormat("(*funptr)(foo)[4];");
8581   verifyFormat("funptrs[4](foo)[4];");
8582   verifyFormat("void f(int *);");
8583   verifyFormat("void f(int *) = 0;");
8584   verifyFormat("void f(SmallVector<int>) {}");
8585   verifyFormat("void f(SmallVector<int>);");
8586   verifyFormat("void f(SmallVector<int>) = 0;");
8587   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8588   verifyFormat("int a = sizeof(int) * b;");
8589   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8590   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8591   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8592   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8593 
8594   // These are not casts, but at some point were confused with casts.
8595   verifyFormat("virtual void foo(int *) override;");
8596   verifyFormat("virtual void foo(char &) const;");
8597   verifyFormat("virtual void foo(int *a, char *) const;");
8598   verifyFormat("int a = sizeof(int *) + b;");
8599   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8600   verifyFormat("bool b = f(g<int>) && c;");
8601   verifyFormat("typedef void (*f)(int i) func;");
8602   verifyFormat("void operator++(int) noexcept;");
8603   verifyFormat("void operator++(int &) noexcept;");
8604   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8605                "&) noexcept;");
8606   verifyFormat(
8607       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8608   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8609   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8610   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8611   verifyFormat("void operator delete(foo &) noexcept;");
8612   verifyFormat("void operator delete(foo) noexcept;");
8613   verifyFormat("void operator delete(int) noexcept;");
8614   verifyFormat("void operator delete(int &) noexcept;");
8615   verifyFormat("void operator delete(int &) volatile noexcept;");
8616   verifyFormat("void operator delete(int &) const");
8617   verifyFormat("void operator delete(int &) = default");
8618   verifyFormat("void operator delete(int &) = delete");
8619   verifyFormat("void operator delete(int &) [[noreturn]]");
8620   verifyFormat("void operator delete(int &) throw();");
8621   verifyFormat("void operator delete(int &) throw(int);");
8622   verifyFormat("auto operator delete(int &) -> int;");
8623   verifyFormat("auto operator delete(int &) override");
8624   verifyFormat("auto operator delete(int &) final");
8625 
8626   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8627                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8628   // FIXME: The indentation here is not ideal.
8629   verifyFormat(
8630       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8631       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8632       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8633 }
8634 
8635 TEST_F(FormatTest, FormatsFunctionTypes) {
8636   verifyFormat("A<bool()> a;");
8637   verifyFormat("A<SomeType()> a;");
8638   verifyFormat("A<void (*)(int, std::string)> a;");
8639   verifyFormat("A<void *(int)>;");
8640   verifyFormat("void *(*a)(int *, SomeType *);");
8641   verifyFormat("int (*func)(void *);");
8642   verifyFormat("void f() { int (*func)(void *); }");
8643   verifyFormat("template <class CallbackClass>\n"
8644                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8645 
8646   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8647   verifyGoogleFormat("void* (*a)(int);");
8648   verifyGoogleFormat(
8649       "template <class CallbackClass>\n"
8650       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8651 
8652   // Other constructs can look somewhat like function types:
8653   verifyFormat("A<sizeof(*x)> a;");
8654   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8655   verifyFormat("some_var = function(*some_pointer_var)[0];");
8656   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8657   verifyFormat("int x = f(&h)();");
8658   verifyFormat("returnsFunction(&param1, &param2)(param);");
8659   verifyFormat("std::function<\n"
8660                "    LooooooooooongTemplatedType<\n"
8661                "        SomeType>*(\n"
8662                "        LooooooooooooooooongType type)>\n"
8663                "    function;",
8664                getGoogleStyleWithColumns(40));
8665 }
8666 
8667 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8668   verifyFormat("A (*foo_)[6];");
8669   verifyFormat("vector<int> (*foo_)[6];");
8670 }
8671 
8672 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8673   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8674                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8675   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8676                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8677   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8678                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8679 
8680   // Different ways of ()-initializiation.
8681   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8682                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8683   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8684                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8685   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8686                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8687   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8688                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8689 
8690   // Lambdas should not confuse the variable declaration heuristic.
8691   verifyFormat("LooooooooooooooooongType\n"
8692                "    variable(nullptr, [](A *a) {});",
8693                getLLVMStyleWithColumns(40));
8694 }
8695 
8696 TEST_F(FormatTest, BreaksLongDeclarations) {
8697   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8698                "    AnotherNameForTheLongType;");
8699   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8700                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8701   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8702                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8703   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8704                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8705   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8706                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8707   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8708                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8709   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8710                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8711   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8712                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8713   verifyFormat("typeof(LoooooooooooooooooooooooooooooooooooooooooongName)\n"
8714                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8715   verifyFormat("_Atomic(LooooooooooooooooooooooooooooooooooooooooongName)\n"
8716                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8717   verifyFormat("__underlying_type(LooooooooooooooooooooooooooooooongName)\n"
8718                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8719   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8720                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8721   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8722                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8723   FormatStyle Indented = getLLVMStyle();
8724   Indented.IndentWrappedFunctionNames = true;
8725   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8726                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8727                Indented);
8728   verifyFormat(
8729       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8730       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8731       Indented);
8732   verifyFormat(
8733       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8734       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8735       Indented);
8736   verifyFormat(
8737       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8738       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8739       Indented);
8740 
8741   // FIXME: Without the comment, this breaks after "(".
8742   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8743                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8744                getGoogleStyle());
8745 
8746   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8747                "                  int LoooooooooooooooooooongParam2) {}");
8748   verifyFormat(
8749       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8750       "                                   SourceLocation L, IdentifierIn *II,\n"
8751       "                                   Type *T) {}");
8752   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8753                "ReallyReaaallyLongFunctionName(\n"
8754                "    const std::string &SomeParameter,\n"
8755                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8756                "        &ReallyReallyLongParameterName,\n"
8757                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8758                "        &AnotherLongParameterName) {}");
8759   verifyFormat("template <typename A>\n"
8760                "SomeLoooooooooooooooooooooongType<\n"
8761                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8762                "Function() {}");
8763 
8764   verifyGoogleFormat(
8765       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8766       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8767   verifyGoogleFormat(
8768       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8769       "                                   SourceLocation L) {}");
8770   verifyGoogleFormat(
8771       "some_namespace::LongReturnType\n"
8772       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8773       "    int first_long_parameter, int second_parameter) {}");
8774 
8775   verifyGoogleFormat("template <typename T>\n"
8776                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8777                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8778   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8779                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8780 
8781   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8782                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8783                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8784   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8785                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8786                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8787   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8788                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8789                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8790                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8791 
8792   verifyFormat("template <typename T> // Templates on own line.\n"
8793                "static int            // Some comment.\n"
8794                "MyFunction(int a);",
8795                getLLVMStyle());
8796 }
8797 
8798 TEST_F(FormatTest, FormatsArrays) {
8799   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8800                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8801   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8802                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8803   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8804                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8805   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8806                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8807   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8808                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8809   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8810                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8811                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8812   verifyFormat(
8813       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8814       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8815       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8816   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8817                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8818 
8819   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8820                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8821   verifyFormat(
8822       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8823       "                                  .aaaaaaa[0]\n"
8824       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8825   verifyFormat("a[::b::c];");
8826 
8827   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8828 
8829   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8830   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8831 }
8832 
8833 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8834   verifyFormat("(a)->b();");
8835   verifyFormat("--a;");
8836 }
8837 
8838 TEST_F(FormatTest, HandlesIncludeDirectives) {
8839   verifyFormat("#include <string>\n"
8840                "#include <a/b/c.h>\n"
8841                "#include \"a/b/string\"\n"
8842                "#include \"string.h\"\n"
8843                "#include \"string.h\"\n"
8844                "#include <a-a>\n"
8845                "#include < path with space >\n"
8846                "#include_next <test.h>"
8847                "#include \"abc.h\" // this is included for ABC\n"
8848                "#include \"some long include\" // with a comment\n"
8849                "#include \"some very long include path\"\n"
8850                "#include <some/very/long/include/path>\n",
8851                getLLVMStyleWithColumns(35));
8852   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8853   EXPECT_EQ("#include <a>", format("#include<a>"));
8854 
8855   verifyFormat("#import <string>");
8856   verifyFormat("#import <a/b/c.h>");
8857   verifyFormat("#import \"a/b/string\"");
8858   verifyFormat("#import \"string.h\"");
8859   verifyFormat("#import \"string.h\"");
8860   verifyFormat("#if __has_include(<strstream>)\n"
8861                "#include <strstream>\n"
8862                "#endif");
8863 
8864   verifyFormat("#define MY_IMPORT <a/b>");
8865 
8866   verifyFormat("#if __has_include(<a/b>)");
8867   verifyFormat("#if __has_include_next(<a/b>)");
8868   verifyFormat("#define F __has_include(<a/b>)");
8869   verifyFormat("#define F __has_include_next(<a/b>)");
8870 
8871   // Protocol buffer definition or missing "#".
8872   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8873                getLLVMStyleWithColumns(30));
8874 
8875   FormatStyle Style = getLLVMStyle();
8876   Style.AlwaysBreakBeforeMultilineStrings = true;
8877   Style.ColumnLimit = 0;
8878   verifyFormat("#import \"abc.h\"", Style);
8879 
8880   // But 'import' might also be a regular C++ namespace.
8881   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8882                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8883 }
8884 
8885 //===----------------------------------------------------------------------===//
8886 // Error recovery tests.
8887 //===----------------------------------------------------------------------===//
8888 
8889 TEST_F(FormatTest, IncompleteParameterLists) {
8890   FormatStyle NoBinPacking = getLLVMStyle();
8891   NoBinPacking.BinPackParameters = false;
8892   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8893                "                        double *min_x,\n"
8894                "                        double *max_x,\n"
8895                "                        double *min_y,\n"
8896                "                        double *max_y,\n"
8897                "                        double *min_z,\n"
8898                "                        double *max_z, ) {}",
8899                NoBinPacking);
8900 }
8901 
8902 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8903   verifyFormat("void f() { return; }\n42");
8904   verifyFormat("void f() {\n"
8905                "  if (0)\n"
8906                "    return;\n"
8907                "}\n"
8908                "42");
8909   verifyFormat("void f() { return }\n42");
8910   verifyFormat("void f() {\n"
8911                "  if (0)\n"
8912                "    return\n"
8913                "}\n"
8914                "42");
8915 }
8916 
8917 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
8918   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
8919   EXPECT_EQ("void f() {\n"
8920             "  if (a)\n"
8921             "    return\n"
8922             "}",
8923             format("void  f  (  )  {  if  ( a )  return  }"));
8924   EXPECT_EQ("namespace N {\n"
8925             "void f()\n"
8926             "}",
8927             format("namespace  N  {  void f()  }"));
8928   EXPECT_EQ("namespace N {\n"
8929             "void f() {}\n"
8930             "void g()\n"
8931             "} // namespace N",
8932             format("namespace N  { void f( ) { } void g( ) }"));
8933 }
8934 
8935 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
8936   verifyFormat("int aaaaaaaa =\n"
8937                "    // Overlylongcomment\n"
8938                "    b;",
8939                getLLVMStyleWithColumns(20));
8940   verifyFormat("function(\n"
8941                "    ShortArgument,\n"
8942                "    LoooooooooooongArgument);\n",
8943                getLLVMStyleWithColumns(20));
8944 }
8945 
8946 TEST_F(FormatTest, IncorrectAccessSpecifier) {
8947   verifyFormat("public:");
8948   verifyFormat("class A {\n"
8949                "public\n"
8950                "  void f() {}\n"
8951                "};");
8952   verifyFormat("public\n"
8953                "int qwerty;");
8954   verifyFormat("public\n"
8955                "B {}");
8956   verifyFormat("public\n"
8957                "{}");
8958   verifyFormat("public\n"
8959                "B { int x; }");
8960 }
8961 
8962 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
8963   verifyFormat("{");
8964   verifyFormat("#})");
8965   verifyNoCrash("(/**/[:!] ?[).");
8966 }
8967 
8968 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
8969   // Found by oss-fuzz:
8970   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
8971   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
8972   Style.ColumnLimit = 60;
8973   verifyNoCrash(
8974       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
8975       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
8976       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
8977       Style);
8978 }
8979 
8980 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
8981   verifyFormat("do {\n}");
8982   verifyFormat("do {\n}\n"
8983                "f();");
8984   verifyFormat("do {\n}\n"
8985                "wheeee(fun);");
8986   verifyFormat("do {\n"
8987                "  f();\n"
8988                "}");
8989 }
8990 
8991 TEST_F(FormatTest, IncorrectCodeMissingParens) {
8992   verifyFormat("if {\n  foo;\n  foo();\n}");
8993   verifyFormat("switch {\n  foo;\n  foo();\n}");
8994   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
8995   verifyFormat("while {\n  foo;\n  foo();\n}");
8996   verifyFormat("do {\n  foo;\n  foo();\n} while;");
8997 }
8998 
8999 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
9000   verifyIncompleteFormat("namespace {\n"
9001                          "class Foo { Foo (\n"
9002                          "};\n"
9003                          "} // namespace");
9004 }
9005 
9006 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
9007   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
9008   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
9009   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
9010   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
9011 
9012   EXPECT_EQ("{\n"
9013             "  {\n"
9014             "    breakme(\n"
9015             "        qwe);\n"
9016             "  }\n",
9017             format("{\n"
9018                    "    {\n"
9019                    " breakme(qwe);\n"
9020                    "}\n",
9021                    getLLVMStyleWithColumns(10)));
9022 }
9023 
9024 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
9025   verifyFormat("int x = {\n"
9026                "    avariable,\n"
9027                "    b(alongervariable)};",
9028                getLLVMStyleWithColumns(25));
9029 }
9030 
9031 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
9032   verifyFormat("return (a)(b){1, 2, 3};");
9033 }
9034 
9035 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
9036   verifyFormat("vector<int> x{1, 2, 3, 4};");
9037   verifyFormat("vector<int> x{\n"
9038                "    1,\n"
9039                "    2,\n"
9040                "    3,\n"
9041                "    4,\n"
9042                "};");
9043   verifyFormat("vector<T> x{{}, {}, {}, {}};");
9044   verifyFormat("f({1, 2});");
9045   verifyFormat("auto v = Foo{-1};");
9046   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
9047   verifyFormat("Class::Class : member{1, 2, 3} {}");
9048   verifyFormat("new vector<int>{1, 2, 3};");
9049   verifyFormat("new int[3]{1, 2, 3};");
9050   verifyFormat("new int{1};");
9051   verifyFormat("return {arg1, arg2};");
9052   verifyFormat("return {arg1, SomeType{parameter}};");
9053   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
9054   verifyFormat("new T{arg1, arg2};");
9055   verifyFormat("f(MyMap[{composite, key}]);");
9056   verifyFormat("class Class {\n"
9057                "  T member = {arg1, arg2};\n"
9058                "};");
9059   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
9060   verifyFormat("const struct A a = {.a = 1, .b = 2};");
9061   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
9062   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
9063   verifyFormat("int a = std::is_integral<int>{} + 0;");
9064 
9065   verifyFormat("int foo(int i) { return fo1{}(i); }");
9066   verifyFormat("int foo(int i) { return fo1{}(i); }");
9067   verifyFormat("auto i = decltype(x){};");
9068   verifyFormat("auto i = typeof(x){};");
9069   verifyFormat("auto i = _Atomic(x){};");
9070   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
9071   verifyFormat("Node n{1, Node{1000}, //\n"
9072                "       2};");
9073   verifyFormat("Aaaa aaaaaaa{\n"
9074                "    {\n"
9075                "        aaaa,\n"
9076                "    },\n"
9077                "};");
9078   verifyFormat("class C : public D {\n"
9079                "  SomeClass SC{2};\n"
9080                "};");
9081   verifyFormat("class C : public A {\n"
9082                "  class D : public B {\n"
9083                "    void f() { int i{2}; }\n"
9084                "  };\n"
9085                "};");
9086   verifyFormat("#define A {a, a},");
9087 
9088   // Avoid breaking between equal sign and opening brace
9089   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
9090   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
9091   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
9092                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
9093                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
9094                "     {\"ccccccccccccccccccccc\", 2}};",
9095                AvoidBreakingFirstArgument);
9096 
9097   // Binpacking only if there is no trailing comma
9098   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
9099                "                      cccccccccc, dddddddddd};",
9100                getLLVMStyleWithColumns(50));
9101   verifyFormat("const Aaaaaa aaaaa = {\n"
9102                "    aaaaaaaaaaa,\n"
9103                "    bbbbbbbbbbb,\n"
9104                "    ccccccccccc,\n"
9105                "    ddddddddddd,\n"
9106                "};",
9107                getLLVMStyleWithColumns(50));
9108 
9109   // Cases where distinguising braced lists and blocks is hard.
9110   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
9111   verifyFormat("void f() {\n"
9112                "  return; // comment\n"
9113                "}\n"
9114                "SomeType t;");
9115   verifyFormat("void f() {\n"
9116                "  if (a) {\n"
9117                "    f();\n"
9118                "  }\n"
9119                "}\n"
9120                "SomeType t;");
9121 
9122   // In combination with BinPackArguments = false.
9123   FormatStyle NoBinPacking = getLLVMStyle();
9124   NoBinPacking.BinPackArguments = false;
9125   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
9126                "                      bbbbb,\n"
9127                "                      ccccc,\n"
9128                "                      ddddd,\n"
9129                "                      eeeee,\n"
9130                "                      ffffff,\n"
9131                "                      ggggg,\n"
9132                "                      hhhhhh,\n"
9133                "                      iiiiii,\n"
9134                "                      jjjjjj,\n"
9135                "                      kkkkkk};",
9136                NoBinPacking);
9137   verifyFormat("const Aaaaaa aaaaa = {\n"
9138                "    aaaaa,\n"
9139                "    bbbbb,\n"
9140                "    ccccc,\n"
9141                "    ddddd,\n"
9142                "    eeeee,\n"
9143                "    ffffff,\n"
9144                "    ggggg,\n"
9145                "    hhhhhh,\n"
9146                "    iiiiii,\n"
9147                "    jjjjjj,\n"
9148                "    kkkkkk,\n"
9149                "};",
9150                NoBinPacking);
9151   verifyFormat(
9152       "const Aaaaaa aaaaa = {\n"
9153       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
9154       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
9155       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
9156       "};",
9157       NoBinPacking);
9158 
9159   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
9160   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
9161             "    CDDDP83848_BMCR_REGISTER,\n"
9162             "    CDDDP83848_BMSR_REGISTER,\n"
9163             "    CDDDP83848_RBR_REGISTER};",
9164             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
9165                    "                                CDDDP83848_BMSR_REGISTER,\n"
9166                    "                                CDDDP83848_RBR_REGISTER};",
9167                    NoBinPacking));
9168 
9169   // FIXME: The alignment of these trailing comments might be bad. Then again,
9170   // this might be utterly useless in real code.
9171   verifyFormat("Constructor::Constructor()\n"
9172                "    : some_value{         //\n"
9173                "                 aaaaaaa, //\n"
9174                "                 bbbbbbb} {}");
9175 
9176   // In braced lists, the first comment is always assumed to belong to the
9177   // first element. Thus, it can be moved to the next or previous line as
9178   // appropriate.
9179   EXPECT_EQ("function({// First element:\n"
9180             "          1,\n"
9181             "          // Second element:\n"
9182             "          2});",
9183             format("function({\n"
9184                    "    // First element:\n"
9185                    "    1,\n"
9186                    "    // Second element:\n"
9187                    "    2});"));
9188   EXPECT_EQ("std::vector<int> MyNumbers{\n"
9189             "    // First element:\n"
9190             "    1,\n"
9191             "    // Second element:\n"
9192             "    2};",
9193             format("std::vector<int> MyNumbers{// First element:\n"
9194                    "                           1,\n"
9195                    "                           // Second element:\n"
9196                    "                           2};",
9197                    getLLVMStyleWithColumns(30)));
9198   // A trailing comma should still lead to an enforced line break and no
9199   // binpacking.
9200   EXPECT_EQ("vector<int> SomeVector = {\n"
9201             "    // aaa\n"
9202             "    1,\n"
9203             "    2,\n"
9204             "};",
9205             format("vector<int> SomeVector = { // aaa\n"
9206                    "    1, 2, };"));
9207 
9208   // C++11 brace initializer list l-braces should not be treated any differently
9209   // when breaking before lambda bodies is enabled
9210   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
9211   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
9212   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
9213   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
9214   verifyFormat(
9215       "std::runtime_error{\n"
9216       "    \"Long string which will force a break onto the next line...\"};",
9217       BreakBeforeLambdaBody);
9218 
9219   FormatStyle ExtraSpaces = getLLVMStyle();
9220   ExtraSpaces.Cpp11BracedListStyle = false;
9221   ExtraSpaces.ColumnLimit = 75;
9222   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
9223   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
9224   verifyFormat("f({ 1, 2 });", ExtraSpaces);
9225   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
9226   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
9227   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
9228   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
9229   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
9230   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
9231   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
9232   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
9233   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
9234   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
9235   verifyFormat("class Class {\n"
9236                "  T member = { arg1, arg2 };\n"
9237                "};",
9238                ExtraSpaces);
9239   verifyFormat(
9240       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9241       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
9242       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
9243       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
9244       ExtraSpaces);
9245   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
9246   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
9247                ExtraSpaces);
9248   verifyFormat(
9249       "someFunction(OtherParam,\n"
9250       "             BracedList{ // comment 1 (Forcing interesting break)\n"
9251       "                         param1, param2,\n"
9252       "                         // comment 2\n"
9253       "                         param3, param4 });",
9254       ExtraSpaces);
9255   verifyFormat(
9256       "std::this_thread::sleep_for(\n"
9257       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
9258       ExtraSpaces);
9259   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
9260                "    aaaaaaa,\n"
9261                "    aaaaaaaaaa,\n"
9262                "    aaaaa,\n"
9263                "    aaaaaaaaaaaaaaa,\n"
9264                "    aaa,\n"
9265                "    aaaaaaaaaa,\n"
9266                "    a,\n"
9267                "    aaaaaaaaaaaaaaaaaaaaa,\n"
9268                "    aaaaaaaaaaaa,\n"
9269                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
9270                "    aaaaaaa,\n"
9271                "    a};");
9272   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
9273   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
9274   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
9275 
9276   // Avoid breaking between initializer/equal sign and opening brace
9277   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
9278   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
9279                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9280                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9281                "  { \"ccccccccccccccccccccc\", 2 }\n"
9282                "};",
9283                ExtraSpaces);
9284   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
9285                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9286                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9287                "  { \"ccccccccccccccccccccc\", 2 }\n"
9288                "};",
9289                ExtraSpaces);
9290 
9291   FormatStyle SpaceBeforeBrace = getLLVMStyle();
9292   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9293   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9294   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9295 
9296   FormatStyle SpaceBetweenBraces = getLLVMStyle();
9297   SpaceBetweenBraces.SpacesInAngles = true;
9298   SpaceBetweenBraces.SpacesInParentheses = true;
9299   SpaceBetweenBraces.SpacesInSquareBrackets = true;
9300   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9301   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9302   verifyFormat("vector< int > x{ // comment 1\n"
9303                "                 1, 2, 3, 4 };",
9304                SpaceBetweenBraces);
9305   SpaceBetweenBraces.ColumnLimit = 20;
9306   EXPECT_EQ("vector< int > x{\n"
9307             "    1, 2, 3, 4 };",
9308             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9309   SpaceBetweenBraces.ColumnLimit = 24;
9310   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9311             "                 3, 4 };",
9312             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9313   EXPECT_EQ("vector< int > x{\n"
9314             "    1,\n"
9315             "    2,\n"
9316             "    3,\n"
9317             "    4,\n"
9318             "};",
9319             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9320   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9321   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9322   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9323 }
9324 
9325 TEST_F(FormatTest, FormatSpacesInAngles) {
9326   FormatStyle SpaceInAngles = getLLVMStyle();
9327   SpaceInAngles.SpacesInAngles = true;
9328   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9329   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9330   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9331 
9332   SpaceInAngles.SpacesInAngles = false;
9333   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9334   verifyFormat("vector<int> x5;", SpaceInAngles);
9335   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9336   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9337 }
9338 
9339 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9340   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9341                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9342                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9343                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9344                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9345                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9346   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9347                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9348                "                 1, 22, 333, 4444, 55555, //\n"
9349                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9350                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9351   verifyFormat(
9352       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9353       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9354       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9355       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9356       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9357       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9358       "                 7777777};");
9359   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9360                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9361                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9362   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9363                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9364                "    // Separating comment.\n"
9365                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9366   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9367                "    // Leading comment\n"
9368                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9369                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9370   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9371                "                 1, 1, 1, 1};",
9372                getLLVMStyleWithColumns(39));
9373   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9374                "                 1, 1, 1, 1};",
9375                getLLVMStyleWithColumns(38));
9376   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9377                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9378                getLLVMStyleWithColumns(43));
9379   verifyFormat(
9380       "static unsigned SomeValues[10][3] = {\n"
9381       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9382       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9383   verifyFormat("static auto fields = new vector<string>{\n"
9384                "    \"aaaaaaaaaaaaa\",\n"
9385                "    \"aaaaaaaaaaaaa\",\n"
9386                "    \"aaaaaaaaaaaa\",\n"
9387                "    \"aaaaaaaaaaaaaa\",\n"
9388                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9389                "    \"aaaaaaaaaaaa\",\n"
9390                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9391                "};");
9392   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9393   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9394                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9395                "                 3, cccccccccccccccccccccc};",
9396                getLLVMStyleWithColumns(60));
9397 
9398   // Trailing commas.
9399   verifyFormat("vector<int> x = {\n"
9400                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9401                "};",
9402                getLLVMStyleWithColumns(39));
9403   verifyFormat("vector<int> x = {\n"
9404                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9405                "};",
9406                getLLVMStyleWithColumns(39));
9407   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9408                "                 1, 1, 1, 1,\n"
9409                "                 /**/ /**/};",
9410                getLLVMStyleWithColumns(39));
9411 
9412   // Trailing comment in the first line.
9413   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9414                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9415                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9416                "    11111111,   22222222,   333333333,   44444444};");
9417   // Trailing comment in the last line.
9418   verifyFormat("int aaaaa[] = {\n"
9419                "    1, 2, 3, // comment\n"
9420                "    4, 5, 6  // comment\n"
9421                "};");
9422 
9423   // With nested lists, we should either format one item per line or all nested
9424   // lists one on line.
9425   // FIXME: For some nested lists, we can do better.
9426   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9427                "        {aaaaaaaaaaaaaaaaaaa},\n"
9428                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9429                "        {aaaaaaaaaaaaaaaaa}};",
9430                getLLVMStyleWithColumns(60));
9431   verifyFormat(
9432       "SomeStruct my_struct_array = {\n"
9433       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9434       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9435       "    {aaa, aaa},\n"
9436       "    {aaa, aaa},\n"
9437       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9438       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9439       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9440 
9441   // No column layout should be used here.
9442   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9443                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9444 
9445   verifyNoCrash("a<,");
9446 
9447   // No braced initializer here.
9448   verifyFormat("void f() {\n"
9449                "  struct Dummy {};\n"
9450                "  f(v);\n"
9451                "}");
9452 
9453   // Long lists should be formatted in columns even if they are nested.
9454   verifyFormat(
9455       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9456       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9457       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9458       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9459       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9460       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9461 
9462   // Allow "single-column" layout even if that violates the column limit. There
9463   // isn't going to be a better way.
9464   verifyFormat("std::vector<int> a = {\n"
9465                "    aaaaaaaa,\n"
9466                "    aaaaaaaa,\n"
9467                "    aaaaaaaa,\n"
9468                "    aaaaaaaa,\n"
9469                "    aaaaaaaaaa,\n"
9470                "    aaaaaaaa,\n"
9471                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9472                getLLVMStyleWithColumns(30));
9473   verifyFormat("vector<int> aaaa = {\n"
9474                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9475                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9476                "    aaaaaa.aaaaaaa,\n"
9477                "    aaaaaa.aaaaaaa,\n"
9478                "    aaaaaa.aaaaaaa,\n"
9479                "    aaaaaa.aaaaaaa,\n"
9480                "};");
9481 
9482   // Don't create hanging lists.
9483   verifyFormat("someFunction(Param, {List1, List2,\n"
9484                "                     List3});",
9485                getLLVMStyleWithColumns(35));
9486   verifyFormat("someFunction(Param, Param,\n"
9487                "             {List1, List2,\n"
9488                "              List3});",
9489                getLLVMStyleWithColumns(35));
9490   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9491                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9492 }
9493 
9494 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9495   FormatStyle DoNotMerge = getLLVMStyle();
9496   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9497 
9498   verifyFormat("void f() { return 42; }");
9499   verifyFormat("void f() {\n"
9500                "  return 42;\n"
9501                "}",
9502                DoNotMerge);
9503   verifyFormat("void f() {\n"
9504                "  // Comment\n"
9505                "}");
9506   verifyFormat("{\n"
9507                "#error {\n"
9508                "  int a;\n"
9509                "}");
9510   verifyFormat("{\n"
9511                "  int a;\n"
9512                "#error {\n"
9513                "}");
9514   verifyFormat("void f() {} // comment");
9515   verifyFormat("void f() { int a; } // comment");
9516   verifyFormat("void f() {\n"
9517                "} // comment",
9518                DoNotMerge);
9519   verifyFormat("void f() {\n"
9520                "  int a;\n"
9521                "} // comment",
9522                DoNotMerge);
9523   verifyFormat("void f() {\n"
9524                "} // comment",
9525                getLLVMStyleWithColumns(15));
9526 
9527   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9528   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9529 
9530   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9531   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9532   verifyFormat("class C {\n"
9533                "  C()\n"
9534                "      : iiiiiiii(nullptr),\n"
9535                "        kkkkkkk(nullptr),\n"
9536                "        mmmmmmm(nullptr),\n"
9537                "        nnnnnnn(nullptr) {}\n"
9538                "};",
9539                getGoogleStyle());
9540 
9541   FormatStyle NoColumnLimit = getLLVMStyle();
9542   NoColumnLimit.ColumnLimit = 0;
9543   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9544   EXPECT_EQ("class C {\n"
9545             "  A() : b(0) {}\n"
9546             "};",
9547             format("class C{A():b(0){}};", NoColumnLimit));
9548   EXPECT_EQ("A()\n"
9549             "    : b(0) {\n"
9550             "}",
9551             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9552 
9553   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9554   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9555       FormatStyle::SFS_None;
9556   EXPECT_EQ("A()\n"
9557             "    : b(0) {\n"
9558             "}",
9559             format("A():b(0){}", DoNotMergeNoColumnLimit));
9560   EXPECT_EQ("A()\n"
9561             "    : b(0) {\n"
9562             "}",
9563             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9564 
9565   verifyFormat("#define A          \\\n"
9566                "  void f() {       \\\n"
9567                "    int i;         \\\n"
9568                "  }",
9569                getLLVMStyleWithColumns(20));
9570   verifyFormat("#define A           \\\n"
9571                "  void f() { int i; }",
9572                getLLVMStyleWithColumns(21));
9573   verifyFormat("#define A            \\\n"
9574                "  void f() {         \\\n"
9575                "    int i;           \\\n"
9576                "  }                  \\\n"
9577                "  int j;",
9578                getLLVMStyleWithColumns(22));
9579   verifyFormat("#define A             \\\n"
9580                "  void f() { int i; } \\\n"
9581                "  int j;",
9582                getLLVMStyleWithColumns(23));
9583 }
9584 
9585 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9586   FormatStyle MergeEmptyOnly = getLLVMStyle();
9587   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9588   verifyFormat("class C {\n"
9589                "  int f() {}\n"
9590                "};",
9591                MergeEmptyOnly);
9592   verifyFormat("class C {\n"
9593                "  int f() {\n"
9594                "    return 42;\n"
9595                "  }\n"
9596                "};",
9597                MergeEmptyOnly);
9598   verifyFormat("int f() {}", MergeEmptyOnly);
9599   verifyFormat("int f() {\n"
9600                "  return 42;\n"
9601                "}",
9602                MergeEmptyOnly);
9603 
9604   // Also verify behavior when BraceWrapping.AfterFunction = true
9605   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9606   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9607   verifyFormat("int f() {}", MergeEmptyOnly);
9608   verifyFormat("class C {\n"
9609                "  int f() {}\n"
9610                "};",
9611                MergeEmptyOnly);
9612 }
9613 
9614 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9615   FormatStyle MergeInlineOnly = getLLVMStyle();
9616   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9617   verifyFormat("class C {\n"
9618                "  int f() { return 42; }\n"
9619                "};",
9620                MergeInlineOnly);
9621   verifyFormat("int f() {\n"
9622                "  return 42;\n"
9623                "}",
9624                MergeInlineOnly);
9625 
9626   // SFS_Inline implies SFS_Empty
9627   verifyFormat("class C {\n"
9628                "  int f() {}\n"
9629                "};",
9630                MergeInlineOnly);
9631   verifyFormat("int f() {}", MergeInlineOnly);
9632 
9633   // Also verify behavior when BraceWrapping.AfterFunction = true
9634   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9635   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9636   verifyFormat("class C {\n"
9637                "  int f() { return 42; }\n"
9638                "};",
9639                MergeInlineOnly);
9640   verifyFormat("int f()\n"
9641                "{\n"
9642                "  return 42;\n"
9643                "}",
9644                MergeInlineOnly);
9645 
9646   // SFS_Inline implies SFS_Empty
9647   verifyFormat("int f() {}", MergeInlineOnly);
9648   verifyFormat("class C {\n"
9649                "  int f() {}\n"
9650                "};",
9651                MergeInlineOnly);
9652 }
9653 
9654 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9655   FormatStyle MergeInlineOnly = getLLVMStyle();
9656   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9657       FormatStyle::SFS_InlineOnly;
9658   verifyFormat("class C {\n"
9659                "  int f() { return 42; }\n"
9660                "};",
9661                MergeInlineOnly);
9662   verifyFormat("int f() {\n"
9663                "  return 42;\n"
9664                "}",
9665                MergeInlineOnly);
9666 
9667   // SFS_InlineOnly does not imply SFS_Empty
9668   verifyFormat("class C {\n"
9669                "  int f() {}\n"
9670                "};",
9671                MergeInlineOnly);
9672   verifyFormat("int f() {\n"
9673                "}",
9674                MergeInlineOnly);
9675 
9676   // Also verify behavior when BraceWrapping.AfterFunction = true
9677   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9678   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9679   verifyFormat("class C {\n"
9680                "  int f() { return 42; }\n"
9681                "};",
9682                MergeInlineOnly);
9683   verifyFormat("int f()\n"
9684                "{\n"
9685                "  return 42;\n"
9686                "}",
9687                MergeInlineOnly);
9688 
9689   // SFS_InlineOnly does not imply SFS_Empty
9690   verifyFormat("int f()\n"
9691                "{\n"
9692                "}",
9693                MergeInlineOnly);
9694   verifyFormat("class C {\n"
9695                "  int f() {}\n"
9696                "};",
9697                MergeInlineOnly);
9698 }
9699 
9700 TEST_F(FormatTest, SplitEmptyFunction) {
9701   FormatStyle Style = getLLVMStyle();
9702   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9703   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9704   Style.BraceWrapping.AfterFunction = true;
9705   Style.BraceWrapping.SplitEmptyFunction = false;
9706   Style.ColumnLimit = 40;
9707 
9708   verifyFormat("int f()\n"
9709                "{}",
9710                Style);
9711   verifyFormat("int f()\n"
9712                "{\n"
9713                "  return 42;\n"
9714                "}",
9715                Style);
9716   verifyFormat("int f()\n"
9717                "{\n"
9718                "  // some comment\n"
9719                "}",
9720                Style);
9721 
9722   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9723   verifyFormat("int f() {}", Style);
9724   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9725                "{}",
9726                Style);
9727   verifyFormat("int f()\n"
9728                "{\n"
9729                "  return 0;\n"
9730                "}",
9731                Style);
9732 
9733   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9734   verifyFormat("class Foo {\n"
9735                "  int f() {}\n"
9736                "};\n",
9737                Style);
9738   verifyFormat("class Foo {\n"
9739                "  int f() { return 0; }\n"
9740                "};\n",
9741                Style);
9742   verifyFormat("class Foo {\n"
9743                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9744                "  {}\n"
9745                "};\n",
9746                Style);
9747   verifyFormat("class Foo {\n"
9748                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9749                "  {\n"
9750                "    return 0;\n"
9751                "  }\n"
9752                "};\n",
9753                Style);
9754 
9755   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9756   verifyFormat("int f() {}", Style);
9757   verifyFormat("int f() { return 0; }", Style);
9758   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9759                "{}",
9760                Style);
9761   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9762                "{\n"
9763                "  return 0;\n"
9764                "}",
9765                Style);
9766 }
9767 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9768   FormatStyle Style = getLLVMStyle();
9769   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9770   verifyFormat("#ifdef A\n"
9771                "int f() {}\n"
9772                "#else\n"
9773                "int g() {}\n"
9774                "#endif",
9775                Style);
9776 }
9777 
9778 TEST_F(FormatTest, SplitEmptyClass) {
9779   FormatStyle Style = getLLVMStyle();
9780   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9781   Style.BraceWrapping.AfterClass = true;
9782   Style.BraceWrapping.SplitEmptyRecord = false;
9783 
9784   verifyFormat("class Foo\n"
9785                "{};",
9786                Style);
9787   verifyFormat("/* something */ class Foo\n"
9788                "{};",
9789                Style);
9790   verifyFormat("template <typename X> class Foo\n"
9791                "{};",
9792                Style);
9793   verifyFormat("class Foo\n"
9794                "{\n"
9795                "  Foo();\n"
9796                "};",
9797                Style);
9798   verifyFormat("typedef class Foo\n"
9799                "{\n"
9800                "} Foo_t;",
9801                Style);
9802 }
9803 
9804 TEST_F(FormatTest, SplitEmptyStruct) {
9805   FormatStyle Style = getLLVMStyle();
9806   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9807   Style.BraceWrapping.AfterStruct = true;
9808   Style.BraceWrapping.SplitEmptyRecord = false;
9809 
9810   verifyFormat("struct Foo\n"
9811                "{};",
9812                Style);
9813   verifyFormat("/* something */ struct Foo\n"
9814                "{};",
9815                Style);
9816   verifyFormat("template <typename X> struct Foo\n"
9817                "{};",
9818                Style);
9819   verifyFormat("struct Foo\n"
9820                "{\n"
9821                "  Foo();\n"
9822                "};",
9823                Style);
9824   verifyFormat("typedef struct Foo\n"
9825                "{\n"
9826                "} Foo_t;",
9827                Style);
9828   // typedef struct Bar {} Bar_t;
9829 }
9830 
9831 TEST_F(FormatTest, SplitEmptyUnion) {
9832   FormatStyle Style = getLLVMStyle();
9833   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9834   Style.BraceWrapping.AfterUnion = true;
9835   Style.BraceWrapping.SplitEmptyRecord = false;
9836 
9837   verifyFormat("union Foo\n"
9838                "{};",
9839                Style);
9840   verifyFormat("/* something */ union Foo\n"
9841                "{};",
9842                Style);
9843   verifyFormat("union Foo\n"
9844                "{\n"
9845                "  A,\n"
9846                "};",
9847                Style);
9848   verifyFormat("typedef union Foo\n"
9849                "{\n"
9850                "} Foo_t;",
9851                Style);
9852 }
9853 
9854 TEST_F(FormatTest, SplitEmptyNamespace) {
9855   FormatStyle Style = getLLVMStyle();
9856   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9857   Style.BraceWrapping.AfterNamespace = true;
9858   Style.BraceWrapping.SplitEmptyNamespace = false;
9859 
9860   verifyFormat("namespace Foo\n"
9861                "{};",
9862                Style);
9863   verifyFormat("/* something */ namespace Foo\n"
9864                "{};",
9865                Style);
9866   verifyFormat("inline namespace Foo\n"
9867                "{};",
9868                Style);
9869   verifyFormat("/* something */ inline namespace Foo\n"
9870                "{};",
9871                Style);
9872   verifyFormat("export namespace Foo\n"
9873                "{};",
9874                Style);
9875   verifyFormat("namespace Foo\n"
9876                "{\n"
9877                "void Bar();\n"
9878                "};",
9879                Style);
9880 }
9881 
9882 TEST_F(FormatTest, NeverMergeShortRecords) {
9883   FormatStyle Style = getLLVMStyle();
9884 
9885   verifyFormat("class Foo {\n"
9886                "  Foo();\n"
9887                "};",
9888                Style);
9889   verifyFormat("typedef class Foo {\n"
9890                "  Foo();\n"
9891                "} Foo_t;",
9892                Style);
9893   verifyFormat("struct Foo {\n"
9894                "  Foo();\n"
9895                "};",
9896                Style);
9897   verifyFormat("typedef struct Foo {\n"
9898                "  Foo();\n"
9899                "} Foo_t;",
9900                Style);
9901   verifyFormat("union Foo {\n"
9902                "  A,\n"
9903                "};",
9904                Style);
9905   verifyFormat("typedef union Foo {\n"
9906                "  A,\n"
9907                "} Foo_t;",
9908                Style);
9909   verifyFormat("namespace Foo {\n"
9910                "void Bar();\n"
9911                "};",
9912                Style);
9913 
9914   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9915   Style.BraceWrapping.AfterClass = true;
9916   Style.BraceWrapping.AfterStruct = true;
9917   Style.BraceWrapping.AfterUnion = true;
9918   Style.BraceWrapping.AfterNamespace = true;
9919   verifyFormat("class Foo\n"
9920                "{\n"
9921                "  Foo();\n"
9922                "};",
9923                Style);
9924   verifyFormat("typedef class Foo\n"
9925                "{\n"
9926                "  Foo();\n"
9927                "} Foo_t;",
9928                Style);
9929   verifyFormat("struct Foo\n"
9930                "{\n"
9931                "  Foo();\n"
9932                "};",
9933                Style);
9934   verifyFormat("typedef struct Foo\n"
9935                "{\n"
9936                "  Foo();\n"
9937                "} Foo_t;",
9938                Style);
9939   verifyFormat("union Foo\n"
9940                "{\n"
9941                "  A,\n"
9942                "};",
9943                Style);
9944   verifyFormat("typedef union Foo\n"
9945                "{\n"
9946                "  A,\n"
9947                "} Foo_t;",
9948                Style);
9949   verifyFormat("namespace Foo\n"
9950                "{\n"
9951                "void Bar();\n"
9952                "};",
9953                Style);
9954 }
9955 
9956 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
9957   // Elaborate type variable declarations.
9958   verifyFormat("struct foo a = {bar};\nint n;");
9959   verifyFormat("class foo a = {bar};\nint n;");
9960   verifyFormat("union foo a = {bar};\nint n;");
9961 
9962   // Elaborate types inside function definitions.
9963   verifyFormat("struct foo f() {}\nint n;");
9964   verifyFormat("class foo f() {}\nint n;");
9965   verifyFormat("union foo f() {}\nint n;");
9966 
9967   // Templates.
9968   verifyFormat("template <class X> void f() {}\nint n;");
9969   verifyFormat("template <struct X> void f() {}\nint n;");
9970   verifyFormat("template <union X> void f() {}\nint n;");
9971 
9972   // Actual definitions...
9973   verifyFormat("struct {\n} n;");
9974   verifyFormat(
9975       "template <template <class T, class Y>, class Z> class X {\n} n;");
9976   verifyFormat("union Z {\n  int n;\n} x;");
9977   verifyFormat("class MACRO Z {\n} n;");
9978   verifyFormat("class MACRO(X) Z {\n} n;");
9979   verifyFormat("class __attribute__(X) Z {\n} n;");
9980   verifyFormat("class __declspec(X) Z {\n} n;");
9981   verifyFormat("class A##B##C {\n} n;");
9982   verifyFormat("class alignas(16) Z {\n} n;");
9983   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
9984   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
9985 
9986   // Redefinition from nested context:
9987   verifyFormat("class A::B::C {\n} n;");
9988 
9989   // Template definitions.
9990   verifyFormat(
9991       "template <typename F>\n"
9992       "Matcher(const Matcher<F> &Other,\n"
9993       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
9994       "                             !is_same<F, T>::value>::type * = 0)\n"
9995       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
9996 
9997   // FIXME: This is still incorrectly handled at the formatter side.
9998   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
9999   verifyFormat("int i = SomeFunction(a<b, a> b);");
10000 
10001   // FIXME:
10002   // This now gets parsed incorrectly as class definition.
10003   // verifyFormat("class A<int> f() {\n}\nint n;");
10004 
10005   // Elaborate types where incorrectly parsing the structural element would
10006   // break the indent.
10007   verifyFormat("if (true)\n"
10008                "  class X x;\n"
10009                "else\n"
10010                "  f();\n");
10011 
10012   // This is simply incomplete. Formatting is not important, but must not crash.
10013   verifyFormat("class A:");
10014 }
10015 
10016 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
10017   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
10018             format("#error Leave     all         white!!!!! space* alone!\n"));
10019   EXPECT_EQ(
10020       "#warning Leave     all         white!!!!! space* alone!\n",
10021       format("#warning Leave     all         white!!!!! space* alone!\n"));
10022   EXPECT_EQ("#error 1", format("  #  error   1"));
10023   EXPECT_EQ("#warning 1", format("  #  warning 1"));
10024 }
10025 
10026 TEST_F(FormatTest, FormatHashIfExpressions) {
10027   verifyFormat("#if AAAA && BBBB");
10028   verifyFormat("#if (AAAA && BBBB)");
10029   verifyFormat("#elif (AAAA && BBBB)");
10030   // FIXME: Come up with a better indentation for #elif.
10031   verifyFormat(
10032       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
10033       "    defined(BBBBBBBB)\n"
10034       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
10035       "    defined(BBBBBBBB)\n"
10036       "#endif",
10037       getLLVMStyleWithColumns(65));
10038 }
10039 
10040 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
10041   FormatStyle AllowsMergedIf = getGoogleStyle();
10042   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
10043       FormatStyle::SIS_WithoutElse;
10044   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
10045   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
10046   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
10047   EXPECT_EQ("if (true) return 42;",
10048             format("if (true)\nreturn 42;", AllowsMergedIf));
10049   FormatStyle ShortMergedIf = AllowsMergedIf;
10050   ShortMergedIf.ColumnLimit = 25;
10051   verifyFormat("#define A \\\n"
10052                "  if (true) return 42;",
10053                ShortMergedIf);
10054   verifyFormat("#define A \\\n"
10055                "  f();    \\\n"
10056                "  if (true)\n"
10057                "#define B",
10058                ShortMergedIf);
10059   verifyFormat("#define A \\\n"
10060                "  f();    \\\n"
10061                "  if (true)\n"
10062                "g();",
10063                ShortMergedIf);
10064   verifyFormat("{\n"
10065                "#ifdef A\n"
10066                "  // Comment\n"
10067                "  if (true) continue;\n"
10068                "#endif\n"
10069                "  // Comment\n"
10070                "  if (true) continue;\n"
10071                "}",
10072                ShortMergedIf);
10073   ShortMergedIf.ColumnLimit = 33;
10074   verifyFormat("#define A \\\n"
10075                "  if constexpr (true) return 42;",
10076                ShortMergedIf);
10077   verifyFormat("#define A \\\n"
10078                "  if CONSTEXPR (true) return 42;",
10079                ShortMergedIf);
10080   ShortMergedIf.ColumnLimit = 29;
10081   verifyFormat("#define A                   \\\n"
10082                "  if (aaaaaaaaaa) return 1; \\\n"
10083                "  return 2;",
10084                ShortMergedIf);
10085   ShortMergedIf.ColumnLimit = 28;
10086   verifyFormat("#define A         \\\n"
10087                "  if (aaaaaaaaaa) \\\n"
10088                "    return 1;     \\\n"
10089                "  return 2;",
10090                ShortMergedIf);
10091   verifyFormat("#define A                \\\n"
10092                "  if constexpr (aaaaaaa) \\\n"
10093                "    return 1;            \\\n"
10094                "  return 2;",
10095                ShortMergedIf);
10096   verifyFormat("#define A                \\\n"
10097                "  if CONSTEXPR (aaaaaaa) \\\n"
10098                "    return 1;            \\\n"
10099                "  return 2;",
10100                ShortMergedIf);
10101 }
10102 
10103 TEST_F(FormatTest, FormatStarDependingOnContext) {
10104   verifyFormat("void f(int *a);");
10105   verifyFormat("void f() { f(fint * b); }");
10106   verifyFormat("class A {\n  void f(int *a);\n};");
10107   verifyFormat("class A {\n  int *a;\n};");
10108   verifyFormat("namespace a {\n"
10109                "namespace b {\n"
10110                "class A {\n"
10111                "  void f() {}\n"
10112                "  int *a;\n"
10113                "};\n"
10114                "} // namespace b\n"
10115                "} // namespace a");
10116 }
10117 
10118 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
10119   verifyFormat("while");
10120   verifyFormat("operator");
10121 }
10122 
10123 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
10124   // This code would be painfully slow to format if we didn't skip it.
10125   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
10126                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10127                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10128                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10129                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10130                    "A(1, 1)\n"
10131                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
10132                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10133                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10134                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10135                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10136                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10137                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10138                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10139                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10140                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
10141   // Deeply nested part is untouched, rest is formatted.
10142   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
10143             format(std::string("int    i;\n") + Code + "int    j;\n",
10144                    getLLVMStyle(), SC_ExpectIncomplete));
10145 }
10146 
10147 //===----------------------------------------------------------------------===//
10148 // Objective-C tests.
10149 //===----------------------------------------------------------------------===//
10150 
10151 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
10152   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
10153   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
10154             format("-(NSUInteger)indexOfObject:(id)anObject;"));
10155   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
10156   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
10157   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
10158             format("-(NSInteger)Method3:(id)anObject;"));
10159   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
10160             format("-(NSInteger)Method4:(id)anObject;"));
10161   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
10162             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
10163   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
10164             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
10165   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10166             "forAllCells:(BOOL)flag;",
10167             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10168                    "forAllCells:(BOOL)flag;"));
10169 
10170   // Very long objectiveC method declaration.
10171   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
10172                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
10173   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
10174                "                    inRange:(NSRange)range\n"
10175                "                   outRange:(NSRange)out_range\n"
10176                "                  outRange1:(NSRange)out_range1\n"
10177                "                  outRange2:(NSRange)out_range2\n"
10178                "                  outRange3:(NSRange)out_range3\n"
10179                "                  outRange4:(NSRange)out_range4\n"
10180                "                  outRange5:(NSRange)out_range5\n"
10181                "                  outRange6:(NSRange)out_range6\n"
10182                "                  outRange7:(NSRange)out_range7\n"
10183                "                  outRange8:(NSRange)out_range8\n"
10184                "                  outRange9:(NSRange)out_range9;");
10185 
10186   // When the function name has to be wrapped.
10187   FormatStyle Style = getLLVMStyle();
10188   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
10189   // and always indents instead.
10190   Style.IndentWrappedFunctionNames = false;
10191   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10192                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
10193                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
10194                "}",
10195                Style);
10196   Style.IndentWrappedFunctionNames = true;
10197   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10198                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
10199                "               anotherName:(NSString)dddddddddddddd {\n"
10200                "}",
10201                Style);
10202 
10203   verifyFormat("- (int)sum:(vector<int>)numbers;");
10204   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
10205   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
10206   // protocol lists (but not for template classes):
10207   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
10208 
10209   verifyFormat("- (int (*)())foo:(int (*)())f;");
10210   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
10211 
10212   // If there's no return type (very rare in practice!), LLVM and Google style
10213   // agree.
10214   verifyFormat("- foo;");
10215   verifyFormat("- foo:(int)f;");
10216   verifyGoogleFormat("- foo:(int)foo;");
10217 }
10218 
10219 TEST_F(FormatTest, BreaksStringLiterals) {
10220   EXPECT_EQ("\"some text \"\n"
10221             "\"other\";",
10222             format("\"some text other\";", getLLVMStyleWithColumns(12)));
10223   EXPECT_EQ("\"some text \"\n"
10224             "\"other\";",
10225             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
10226   EXPECT_EQ(
10227       "#define A  \\\n"
10228       "  \"some \"  \\\n"
10229       "  \"text \"  \\\n"
10230       "  \"other\";",
10231       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
10232   EXPECT_EQ(
10233       "#define A  \\\n"
10234       "  \"so \"    \\\n"
10235       "  \"text \"  \\\n"
10236       "  \"other\";",
10237       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
10238 
10239   EXPECT_EQ("\"some text\"",
10240             format("\"some text\"", getLLVMStyleWithColumns(1)));
10241   EXPECT_EQ("\"some text\"",
10242             format("\"some text\"", getLLVMStyleWithColumns(11)));
10243   EXPECT_EQ("\"some \"\n"
10244             "\"text\"",
10245             format("\"some text\"", getLLVMStyleWithColumns(10)));
10246   EXPECT_EQ("\"some \"\n"
10247             "\"text\"",
10248             format("\"some text\"", getLLVMStyleWithColumns(7)));
10249   EXPECT_EQ("\"some\"\n"
10250             "\" tex\"\n"
10251             "\"t\"",
10252             format("\"some text\"", getLLVMStyleWithColumns(6)));
10253   EXPECT_EQ("\"some\"\n"
10254             "\" tex\"\n"
10255             "\" and\"",
10256             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
10257   EXPECT_EQ("\"some\"\n"
10258             "\"/tex\"\n"
10259             "\"/and\"",
10260             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
10261 
10262   EXPECT_EQ("variable =\n"
10263             "    \"long string \"\n"
10264             "    \"literal\";",
10265             format("variable = \"long string literal\";",
10266                    getLLVMStyleWithColumns(20)));
10267 
10268   EXPECT_EQ("variable = f(\n"
10269             "    \"long string \"\n"
10270             "    \"literal\",\n"
10271             "    short,\n"
10272             "    loooooooooooooooooooong);",
10273             format("variable = f(\"long string literal\", short, "
10274                    "loooooooooooooooooooong);",
10275                    getLLVMStyleWithColumns(20)));
10276 
10277   EXPECT_EQ(
10278       "f(g(\"long string \"\n"
10279       "    \"literal\"),\n"
10280       "  b);",
10281       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
10282   EXPECT_EQ("f(g(\"long string \"\n"
10283             "    \"literal\",\n"
10284             "    a),\n"
10285             "  b);",
10286             format("f(g(\"long string literal\", a), b);",
10287                    getLLVMStyleWithColumns(20)));
10288   EXPECT_EQ(
10289       "f(\"one two\".split(\n"
10290       "    variable));",
10291       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10292   EXPECT_EQ("f(\"one two three four five six \"\n"
10293             "  \"seven\".split(\n"
10294             "      really_looooong_variable));",
10295             format("f(\"one two three four five six seven\"."
10296                    "split(really_looooong_variable));",
10297                    getLLVMStyleWithColumns(33)));
10298 
10299   EXPECT_EQ("f(\"some \"\n"
10300             "  \"text\",\n"
10301             "  other);",
10302             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10303 
10304   // Only break as a last resort.
10305   verifyFormat(
10306       "aaaaaaaaaaaaaaaaaaaa(\n"
10307       "    aaaaaaaaaaaaaaaaaaaa,\n"
10308       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10309 
10310   EXPECT_EQ("\"splitmea\"\n"
10311             "\"trandomp\"\n"
10312             "\"oint\"",
10313             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10314 
10315   EXPECT_EQ("\"split/\"\n"
10316             "\"pathat/\"\n"
10317             "\"slashes\"",
10318             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10319 
10320   EXPECT_EQ("\"split/\"\n"
10321             "\"pathat/\"\n"
10322             "\"slashes\"",
10323             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10324   EXPECT_EQ("\"split at \"\n"
10325             "\"spaces/at/\"\n"
10326             "\"slashes.at.any$\"\n"
10327             "\"non-alphanumeric%\"\n"
10328             "\"1111111111characte\"\n"
10329             "\"rs\"",
10330             format("\"split at "
10331                    "spaces/at/"
10332                    "slashes.at."
10333                    "any$non-"
10334                    "alphanumeric%"
10335                    "1111111111characte"
10336                    "rs\"",
10337                    getLLVMStyleWithColumns(20)));
10338 
10339   // Verify that splitting the strings understands
10340   // Style::AlwaysBreakBeforeMultilineStrings.
10341   EXPECT_EQ("aaaaaaaaaaaa(\n"
10342             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10343             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10344             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10345                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10346                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10347                    getGoogleStyle()));
10348   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10349             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10350             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10351                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10352                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10353                    getGoogleStyle()));
10354   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10355             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10356             format("llvm::outs() << "
10357                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10358                    "aaaaaaaaaaaaaaaaaaa\";"));
10359   EXPECT_EQ("ffff(\n"
10360             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10361             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10362             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10363                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10364                    getGoogleStyle()));
10365 
10366   FormatStyle Style = getLLVMStyleWithColumns(12);
10367   Style.BreakStringLiterals = false;
10368   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10369 
10370   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10371   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10372   EXPECT_EQ("#define A \\\n"
10373             "  \"some \" \\\n"
10374             "  \"text \" \\\n"
10375             "  \"other\";",
10376             format("#define A \"some text other\";", AlignLeft));
10377 }
10378 
10379 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10380   EXPECT_EQ("C a = \"some more \"\n"
10381             "      \"text\";",
10382             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10383 }
10384 
10385 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10386   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10387   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10388   EXPECT_EQ("int i = a(b());",
10389             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10390 }
10391 
10392 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10393   EXPECT_EQ(
10394       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10395       "(\n"
10396       "    \"x\t\");",
10397       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10398              "aaaaaaa("
10399              "\"x\t\");"));
10400 }
10401 
10402 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10403   EXPECT_EQ(
10404       "u8\"utf8 string \"\n"
10405       "u8\"literal\";",
10406       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10407   EXPECT_EQ(
10408       "u\"utf16 string \"\n"
10409       "u\"literal\";",
10410       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10411   EXPECT_EQ(
10412       "U\"utf32 string \"\n"
10413       "U\"literal\";",
10414       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10415   EXPECT_EQ("L\"wide string \"\n"
10416             "L\"literal\";",
10417             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10418   EXPECT_EQ("@\"NSString \"\n"
10419             "@\"literal\";",
10420             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10421   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10422 
10423   // This input makes clang-format try to split the incomplete unicode escape
10424   // sequence, which used to lead to a crasher.
10425   verifyNoCrash(
10426       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10427       getLLVMStyleWithColumns(60));
10428 }
10429 
10430 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10431   FormatStyle Style = getGoogleStyleWithColumns(15);
10432   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10433   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10434   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10435   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10436   EXPECT_EQ("u8R\"x(raw literal)x\";",
10437             format("u8R\"x(raw literal)x\";", Style));
10438 }
10439 
10440 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10441   FormatStyle Style = getLLVMStyleWithColumns(20);
10442   EXPECT_EQ(
10443       "_T(\"aaaaaaaaaaaaaa\")\n"
10444       "_T(\"aaaaaaaaaaaaaa\")\n"
10445       "_T(\"aaaaaaaaaaaa\")",
10446       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10447   EXPECT_EQ("f(x,\n"
10448             "  _T(\"aaaaaaaaaaaa\")\n"
10449             "  _T(\"aaa\"),\n"
10450             "  z);",
10451             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10452 
10453   // FIXME: Handle embedded spaces in one iteration.
10454   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10455   //            "_T(\"aaaaaaaaaaaaa\")\n"
10456   //            "_T(\"aaaaaaaaaaaaa\")\n"
10457   //            "_T(\"a\")",
10458   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10459   //                   getLLVMStyleWithColumns(20)));
10460   EXPECT_EQ(
10461       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10462       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10463   EXPECT_EQ("f(\n"
10464             "#if !TEST\n"
10465             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10466             "#endif\n"
10467             ");",
10468             format("f(\n"
10469                    "#if !TEST\n"
10470                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10471                    "#endif\n"
10472                    ");"));
10473   EXPECT_EQ("f(\n"
10474             "\n"
10475             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10476             format("f(\n"
10477                    "\n"
10478                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10479 }
10480 
10481 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10482   // In a function call with two operands, the second can be broken with no line
10483   // break before it.
10484   EXPECT_EQ(
10485       "func(a, \"long long \"\n"
10486       "        \"long long\");",
10487       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10488   // In a function call with three operands, the second must be broken with a
10489   // line break before it.
10490   EXPECT_EQ("func(a,\n"
10491             "     \"long long long \"\n"
10492             "     \"long\",\n"
10493             "     c);",
10494             format("func(a, \"long long long long\", c);",
10495                    getLLVMStyleWithColumns(24)));
10496   // In a function call with three operands, the third must be broken with a
10497   // line break before it.
10498   EXPECT_EQ("func(a, b,\n"
10499             "     \"long long long \"\n"
10500             "     \"long\");",
10501             format("func(a, b, \"long long long long\");",
10502                    getLLVMStyleWithColumns(24)));
10503   // In a function call with three operands, both the second and the third must
10504   // be broken with a line break before them.
10505   EXPECT_EQ("func(a,\n"
10506             "     \"long long long \"\n"
10507             "     \"long\",\n"
10508             "     \"long long long \"\n"
10509             "     \"long\");",
10510             format("func(a, \"long long long long\", \"long long long long\");",
10511                    getLLVMStyleWithColumns(24)));
10512   // In a chain of << with two operands, the second can be broken with no line
10513   // break before it.
10514   EXPECT_EQ("a << \"line line \"\n"
10515             "     \"line\";",
10516             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10517   // In a chain of << with three operands, the second can be broken with no line
10518   // break before it.
10519   EXPECT_EQ(
10520       "abcde << \"line \"\n"
10521       "         \"line line\"\n"
10522       "      << c;",
10523       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10524   // In a chain of << with three operands, the third must be broken with a line
10525   // break before it.
10526   EXPECT_EQ(
10527       "a << b\n"
10528       "  << \"line line \"\n"
10529       "     \"line\";",
10530       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10531   // In a chain of << with three operands, the second can be broken with no line
10532   // break before it and the third must be broken with a line break before it.
10533   EXPECT_EQ("abcd << \"line line \"\n"
10534             "        \"line\"\n"
10535             "     << \"line line \"\n"
10536             "        \"line\";",
10537             format("abcd << \"line line line\" << \"line line line\";",
10538                    getLLVMStyleWithColumns(20)));
10539   // In a chain of binary operators with two operands, the second can be broken
10540   // with no line break before it.
10541   EXPECT_EQ(
10542       "abcd + \"line line \"\n"
10543       "       \"line line\";",
10544       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10545   // In a chain of binary operators with three operands, the second must be
10546   // broken with a line break before it.
10547   EXPECT_EQ("abcd +\n"
10548             "    \"line line \"\n"
10549             "    \"line line\" +\n"
10550             "    e;",
10551             format("abcd + \"line line line line\" + e;",
10552                    getLLVMStyleWithColumns(20)));
10553   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10554   // the first must be broken with a line break before it.
10555   FormatStyle Style = getLLVMStyleWithColumns(25);
10556   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10557   EXPECT_EQ("someFunction(\n"
10558             "    \"long long long \"\n"
10559             "    \"long\",\n"
10560             "    a);",
10561             format("someFunction(\"long long long long\", a);", Style));
10562 }
10563 
10564 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10565   EXPECT_EQ(
10566       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10567       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10568       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10569       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10570              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10571              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10572 }
10573 
10574 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10575   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10576             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10577   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10578             "multiline raw string literal xxxxxxxxxxxxxx\n"
10579             ")x\",\n"
10580             "              a),\n"
10581             "            b);",
10582             format("fffffffffff(g(R\"x(\n"
10583                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10584                    ")x\", a), b);",
10585                    getGoogleStyleWithColumns(20)));
10586   EXPECT_EQ("fffffffffff(\n"
10587             "    g(R\"x(qqq\n"
10588             "multiline raw string literal xxxxxxxxxxxxxx\n"
10589             ")x\",\n"
10590             "      a),\n"
10591             "    b);",
10592             format("fffffffffff(g(R\"x(qqq\n"
10593                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10594                    ")x\", a), b);",
10595                    getGoogleStyleWithColumns(20)));
10596 
10597   EXPECT_EQ("fffffffffff(R\"x(\n"
10598             "multiline raw string literal xxxxxxxxxxxxxx\n"
10599             ")x\");",
10600             format("fffffffffff(R\"x(\n"
10601                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10602                    ")x\");",
10603                    getGoogleStyleWithColumns(20)));
10604   EXPECT_EQ("fffffffffff(R\"x(\n"
10605             "multiline raw string literal xxxxxxxxxxxxxx\n"
10606             ")x\" + bbbbbb);",
10607             format("fffffffffff(R\"x(\n"
10608                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10609                    ")x\" +   bbbbbb);",
10610                    getGoogleStyleWithColumns(20)));
10611   EXPECT_EQ("fffffffffff(\n"
10612             "    R\"x(\n"
10613             "multiline raw string literal xxxxxxxxxxxxxx\n"
10614             ")x\" +\n"
10615             "    bbbbbb);",
10616             format("fffffffffff(\n"
10617                    " R\"x(\n"
10618                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10619                    ")x\" + bbbbbb);",
10620                    getGoogleStyleWithColumns(20)));
10621   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10622             format("fffffffffff(\n"
10623                    " R\"(single line raw string)\" + bbbbbb);"));
10624 }
10625 
10626 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10627   verifyFormat("string a = \"unterminated;");
10628   EXPECT_EQ("function(\"unterminated,\n"
10629             "         OtherParameter);",
10630             format("function(  \"unterminated,\n"
10631                    "    OtherParameter);"));
10632 }
10633 
10634 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10635   FormatStyle Style = getLLVMStyle();
10636   Style.Standard = FormatStyle::LS_Cpp03;
10637   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10638             format("#define x(_a) printf(\"foo\"_a);", Style));
10639 }
10640 
10641 TEST_F(FormatTest, CppLexVersion) {
10642   FormatStyle Style = getLLVMStyle();
10643   // Formatting of x * y differs if x is a type.
10644   verifyFormat("void foo() { MACRO(a * b); }", Style);
10645   verifyFormat("void foo() { MACRO(int *b); }", Style);
10646 
10647   // LLVM style uses latest lexer.
10648   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10649   Style.Standard = FormatStyle::LS_Cpp17;
10650   // But in c++17, char8_t isn't a keyword.
10651   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10652 }
10653 
10654 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10655 
10656 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10657   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10658             "             \"ddeeefff\");",
10659             format("someFunction(\"aaabbbcccdddeeefff\");",
10660                    getLLVMStyleWithColumns(25)));
10661   EXPECT_EQ("someFunction1234567890(\n"
10662             "    \"aaabbbcccdddeeefff\");",
10663             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10664                    getLLVMStyleWithColumns(26)));
10665   EXPECT_EQ("someFunction1234567890(\n"
10666             "    \"aaabbbcccdddeeeff\"\n"
10667             "    \"f\");",
10668             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10669                    getLLVMStyleWithColumns(25)));
10670   EXPECT_EQ("someFunction1234567890(\n"
10671             "    \"aaabbbcccdddeeeff\"\n"
10672             "    \"f\");",
10673             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10674                    getLLVMStyleWithColumns(24)));
10675   EXPECT_EQ("someFunction(\n"
10676             "    \"aaabbbcc ddde \"\n"
10677             "    \"efff\");",
10678             format("someFunction(\"aaabbbcc ddde efff\");",
10679                    getLLVMStyleWithColumns(25)));
10680   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10681             "             \"ddeeefff\");",
10682             format("someFunction(\"aaabbbccc ddeeefff\");",
10683                    getLLVMStyleWithColumns(25)));
10684   EXPECT_EQ("someFunction1234567890(\n"
10685             "    \"aaabb \"\n"
10686             "    \"cccdddeeefff\");",
10687             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10688                    getLLVMStyleWithColumns(25)));
10689   EXPECT_EQ("#define A          \\\n"
10690             "  string s =       \\\n"
10691             "      \"123456789\"  \\\n"
10692             "      \"0\";         \\\n"
10693             "  int i;",
10694             format("#define A string s = \"1234567890\"; int i;",
10695                    getLLVMStyleWithColumns(20)));
10696   EXPECT_EQ("someFunction(\n"
10697             "    \"aaabbbcc \"\n"
10698             "    \"dddeeefff\");",
10699             format("someFunction(\"aaabbbcc dddeeefff\");",
10700                    getLLVMStyleWithColumns(25)));
10701 }
10702 
10703 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10704   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10705   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10706   EXPECT_EQ("\"test\"\n"
10707             "\"\\n\"",
10708             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10709   EXPECT_EQ("\"tes\\\\\"\n"
10710             "\"n\"",
10711             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10712   EXPECT_EQ("\"\\\\\\\\\"\n"
10713             "\"\\n\"",
10714             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10715   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10716   EXPECT_EQ("\"\\uff01\"\n"
10717             "\"test\"",
10718             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10719   EXPECT_EQ("\"\\Uff01ff02\"",
10720             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10721   EXPECT_EQ("\"\\x000000000001\"\n"
10722             "\"next\"",
10723             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10724   EXPECT_EQ("\"\\x000000000001next\"",
10725             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10726   EXPECT_EQ("\"\\x000000000001\"",
10727             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10728   EXPECT_EQ("\"test\"\n"
10729             "\"\\000000\"\n"
10730             "\"000001\"",
10731             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10732   EXPECT_EQ("\"test\\000\"\n"
10733             "\"00000000\"\n"
10734             "\"1\"",
10735             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10736 }
10737 
10738 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10739   verifyFormat("void f() {\n"
10740                "  return g() {}\n"
10741                "  void h() {}");
10742   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10743                "g();\n"
10744                "}");
10745 }
10746 
10747 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10748   verifyFormat(
10749       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10750 }
10751 
10752 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10753   verifyFormat("class X {\n"
10754                "  void f() {\n"
10755                "  }\n"
10756                "};",
10757                getLLVMStyleWithColumns(12));
10758 }
10759 
10760 TEST_F(FormatTest, ConfigurableIndentWidth) {
10761   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10762   EightIndent.IndentWidth = 8;
10763   EightIndent.ContinuationIndentWidth = 8;
10764   verifyFormat("void f() {\n"
10765                "        someFunction();\n"
10766                "        if (true) {\n"
10767                "                f();\n"
10768                "        }\n"
10769                "}",
10770                EightIndent);
10771   verifyFormat("class X {\n"
10772                "        void f() {\n"
10773                "        }\n"
10774                "};",
10775                EightIndent);
10776   verifyFormat("int x[] = {\n"
10777                "        call(),\n"
10778                "        call()};",
10779                EightIndent);
10780 }
10781 
10782 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10783   verifyFormat("double\n"
10784                "f();",
10785                getLLVMStyleWithColumns(8));
10786 }
10787 
10788 TEST_F(FormatTest, ConfigurableUseOfTab) {
10789   FormatStyle Tab = getLLVMStyleWithColumns(42);
10790   Tab.IndentWidth = 8;
10791   Tab.UseTab = FormatStyle::UT_Always;
10792   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10793 
10794   EXPECT_EQ("if (aaaaaaaa && // q\n"
10795             "    bb)\t\t// w\n"
10796             "\t;",
10797             format("if (aaaaaaaa &&// q\n"
10798                    "bb)// w\n"
10799                    ";",
10800                    Tab));
10801   EXPECT_EQ("if (aaa && bbb) // w\n"
10802             "\t;",
10803             format("if(aaa&&bbb)// w\n"
10804                    ";",
10805                    Tab));
10806 
10807   verifyFormat("class X {\n"
10808                "\tvoid f() {\n"
10809                "\t\tsomeFunction(parameter1,\n"
10810                "\t\t\t     parameter2);\n"
10811                "\t}\n"
10812                "};",
10813                Tab);
10814   verifyFormat("#define A                        \\\n"
10815                "\tvoid f() {               \\\n"
10816                "\t\tsomeFunction(    \\\n"
10817                "\t\t    parameter1,  \\\n"
10818                "\t\t    parameter2); \\\n"
10819                "\t}",
10820                Tab);
10821   verifyFormat("int a;\t      // x\n"
10822                "int bbbbbbbb; // x\n",
10823                Tab);
10824 
10825   Tab.TabWidth = 4;
10826   Tab.IndentWidth = 8;
10827   verifyFormat("class TabWidth4Indent8 {\n"
10828                "\t\tvoid f() {\n"
10829                "\t\t\t\tsomeFunction(parameter1,\n"
10830                "\t\t\t\t\t\t\t parameter2);\n"
10831                "\t\t}\n"
10832                "};",
10833                Tab);
10834 
10835   Tab.TabWidth = 4;
10836   Tab.IndentWidth = 4;
10837   verifyFormat("class TabWidth4Indent4 {\n"
10838                "\tvoid f() {\n"
10839                "\t\tsomeFunction(parameter1,\n"
10840                "\t\t\t\t\t parameter2);\n"
10841                "\t}\n"
10842                "};",
10843                Tab);
10844 
10845   Tab.TabWidth = 8;
10846   Tab.IndentWidth = 4;
10847   verifyFormat("class TabWidth8Indent4 {\n"
10848                "    void f() {\n"
10849                "\tsomeFunction(parameter1,\n"
10850                "\t\t     parameter2);\n"
10851                "    }\n"
10852                "};",
10853                Tab);
10854 
10855   Tab.TabWidth = 8;
10856   Tab.IndentWidth = 8;
10857   EXPECT_EQ("/*\n"
10858             "\t      a\t\tcomment\n"
10859             "\t      in multiple lines\n"
10860             "       */",
10861             format("   /*\t \t \n"
10862                    " \t \t a\t\tcomment\t \t\n"
10863                    " \t \t in multiple lines\t\n"
10864                    " \t  */",
10865                    Tab));
10866 
10867   Tab.UseTab = FormatStyle::UT_ForIndentation;
10868   verifyFormat("{\n"
10869                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10870                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10871                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10872                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10873                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10874                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
10875                "};",
10876                Tab);
10877   verifyFormat("enum AA {\n"
10878                "\ta1, // Force multiple lines\n"
10879                "\ta2,\n"
10880                "\ta3\n"
10881                "};",
10882                Tab);
10883   EXPECT_EQ("if (aaaaaaaa && // q\n"
10884             "    bb)         // w\n"
10885             "\t;",
10886             format("if (aaaaaaaa &&// q\n"
10887                    "bb)// w\n"
10888                    ";",
10889                    Tab));
10890   verifyFormat("class X {\n"
10891                "\tvoid f() {\n"
10892                "\t\tsomeFunction(parameter1,\n"
10893                "\t\t             parameter2);\n"
10894                "\t}\n"
10895                "};",
10896                Tab);
10897   verifyFormat("{\n"
10898                "\tQ(\n"
10899                "\t    {\n"
10900                "\t\t    int a;\n"
10901                "\t\t    someFunction(aaaaaaaa,\n"
10902                "\t\t                 bbbbbbb);\n"
10903                "\t    },\n"
10904                "\t    p);\n"
10905                "}",
10906                Tab);
10907   EXPECT_EQ("{\n"
10908             "\t/* aaaa\n"
10909             "\t   bbbb */\n"
10910             "}",
10911             format("{\n"
10912                    "/* aaaa\n"
10913                    "   bbbb */\n"
10914                    "}",
10915                    Tab));
10916   EXPECT_EQ("{\n"
10917             "\t/*\n"
10918             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10919             "\t  bbbbbbbbbbbbb\n"
10920             "\t*/\n"
10921             "}",
10922             format("{\n"
10923                    "/*\n"
10924                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10925                    "*/\n"
10926                    "}",
10927                    Tab));
10928   EXPECT_EQ("{\n"
10929             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10930             "\t// bbbbbbbbbbbbb\n"
10931             "}",
10932             format("{\n"
10933                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10934                    "}",
10935                    Tab));
10936   EXPECT_EQ("{\n"
10937             "\t/*\n"
10938             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10939             "\t  bbbbbbbbbbbbb\n"
10940             "\t*/\n"
10941             "}",
10942             format("{\n"
10943                    "\t/*\n"
10944                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
10945                    "\t*/\n"
10946                    "}",
10947                    Tab));
10948   EXPECT_EQ("{\n"
10949             "\t/*\n"
10950             "\n"
10951             "\t*/\n"
10952             "}",
10953             format("{\n"
10954                    "\t/*\n"
10955                    "\n"
10956                    "\t*/\n"
10957                    "}",
10958                    Tab));
10959   EXPECT_EQ("{\n"
10960             "\t/*\n"
10961             " asdf\n"
10962             "\t*/\n"
10963             "}",
10964             format("{\n"
10965                    "\t/*\n"
10966                    " asdf\n"
10967                    "\t*/\n"
10968                    "}",
10969                    Tab));
10970 
10971   Tab.UseTab = FormatStyle::UT_Never;
10972   EXPECT_EQ("/*\n"
10973             "              a\t\tcomment\n"
10974             "              in multiple lines\n"
10975             "       */",
10976             format("   /*\t \t \n"
10977                    " \t \t a\t\tcomment\t \t\n"
10978                    " \t \t in multiple lines\t\n"
10979                    " \t  */",
10980                    Tab));
10981   EXPECT_EQ("/* some\n"
10982             "   comment */",
10983             format(" \t \t /* some\n"
10984                    " \t \t    comment */",
10985                    Tab));
10986   EXPECT_EQ("int a; /* some\n"
10987             "   comment */",
10988             format(" \t \t int a; /* some\n"
10989                    " \t \t    comment */",
10990                    Tab));
10991 
10992   EXPECT_EQ("int a; /* some\n"
10993             "comment */",
10994             format(" \t \t int\ta; /* some\n"
10995                    " \t \t    comment */",
10996                    Tab));
10997   EXPECT_EQ("f(\"\t\t\"); /* some\n"
10998             "    comment */",
10999             format(" \t \t f(\"\t\t\"); /* some\n"
11000                    " \t \t    comment */",
11001                    Tab));
11002   EXPECT_EQ("{\n"
11003             "        /*\n"
11004             "         * Comment\n"
11005             "         */\n"
11006             "        int i;\n"
11007             "}",
11008             format("{\n"
11009                    "\t/*\n"
11010                    "\t * Comment\n"
11011                    "\t */\n"
11012                    "\t int i;\n"
11013                    "}",
11014                    Tab));
11015 
11016   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11017   Tab.TabWidth = 8;
11018   Tab.IndentWidth = 8;
11019   EXPECT_EQ("if (aaaaaaaa && // q\n"
11020             "    bb)         // w\n"
11021             "\t;",
11022             format("if (aaaaaaaa &&// q\n"
11023                    "bb)// w\n"
11024                    ";",
11025                    Tab));
11026   EXPECT_EQ("if (aaa && bbb) // w\n"
11027             "\t;",
11028             format("if(aaa&&bbb)// w\n"
11029                    ";",
11030                    Tab));
11031   verifyFormat("class X {\n"
11032                "\tvoid f() {\n"
11033                "\t\tsomeFunction(parameter1,\n"
11034                "\t\t\t     parameter2);\n"
11035                "\t}\n"
11036                "};",
11037                Tab);
11038   verifyFormat("#define A                        \\\n"
11039                "\tvoid f() {               \\\n"
11040                "\t\tsomeFunction(    \\\n"
11041                "\t\t    parameter1,  \\\n"
11042                "\t\t    parameter2); \\\n"
11043                "\t}",
11044                Tab);
11045   Tab.TabWidth = 4;
11046   Tab.IndentWidth = 8;
11047   verifyFormat("class TabWidth4Indent8 {\n"
11048                "\t\tvoid f() {\n"
11049                "\t\t\t\tsomeFunction(parameter1,\n"
11050                "\t\t\t\t\t\t\t parameter2);\n"
11051                "\t\t}\n"
11052                "};",
11053                Tab);
11054   Tab.TabWidth = 4;
11055   Tab.IndentWidth = 4;
11056   verifyFormat("class TabWidth4Indent4 {\n"
11057                "\tvoid f() {\n"
11058                "\t\tsomeFunction(parameter1,\n"
11059                "\t\t\t\t\t parameter2);\n"
11060                "\t}\n"
11061                "};",
11062                Tab);
11063   Tab.TabWidth = 8;
11064   Tab.IndentWidth = 4;
11065   verifyFormat("class TabWidth8Indent4 {\n"
11066                "    void f() {\n"
11067                "\tsomeFunction(parameter1,\n"
11068                "\t\t     parameter2);\n"
11069                "    }\n"
11070                "};",
11071                Tab);
11072   Tab.TabWidth = 8;
11073   Tab.IndentWidth = 8;
11074   EXPECT_EQ("/*\n"
11075             "\t      a\t\tcomment\n"
11076             "\t      in multiple lines\n"
11077             "       */",
11078             format("   /*\t \t \n"
11079                    " \t \t a\t\tcomment\t \t\n"
11080                    " \t \t in multiple lines\t\n"
11081                    " \t  */",
11082                    Tab));
11083   verifyFormat("{\n"
11084                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11085                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11086                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11087                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11088                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11089                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11090                "};",
11091                Tab);
11092   verifyFormat("enum AA {\n"
11093                "\ta1, // Force multiple lines\n"
11094                "\ta2,\n"
11095                "\ta3\n"
11096                "};",
11097                Tab);
11098   EXPECT_EQ("if (aaaaaaaa && // q\n"
11099             "    bb)         // w\n"
11100             "\t;",
11101             format("if (aaaaaaaa &&// q\n"
11102                    "bb)// w\n"
11103                    ";",
11104                    Tab));
11105   verifyFormat("class X {\n"
11106                "\tvoid f() {\n"
11107                "\t\tsomeFunction(parameter1,\n"
11108                "\t\t\t     parameter2);\n"
11109                "\t}\n"
11110                "};",
11111                Tab);
11112   verifyFormat("{\n"
11113                "\tQ(\n"
11114                "\t    {\n"
11115                "\t\t    int a;\n"
11116                "\t\t    someFunction(aaaaaaaa,\n"
11117                "\t\t\t\t bbbbbbb);\n"
11118                "\t    },\n"
11119                "\t    p);\n"
11120                "}",
11121                Tab);
11122   EXPECT_EQ("{\n"
11123             "\t/* aaaa\n"
11124             "\t   bbbb */\n"
11125             "}",
11126             format("{\n"
11127                    "/* aaaa\n"
11128                    "   bbbb */\n"
11129                    "}",
11130                    Tab));
11131   EXPECT_EQ("{\n"
11132             "\t/*\n"
11133             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11134             "\t  bbbbbbbbbbbbb\n"
11135             "\t*/\n"
11136             "}",
11137             format("{\n"
11138                    "/*\n"
11139                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11140                    "*/\n"
11141                    "}",
11142                    Tab));
11143   EXPECT_EQ("{\n"
11144             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11145             "\t// bbbbbbbbbbbbb\n"
11146             "}",
11147             format("{\n"
11148                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11149                    "}",
11150                    Tab));
11151   EXPECT_EQ("{\n"
11152             "\t/*\n"
11153             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11154             "\t  bbbbbbbbbbbbb\n"
11155             "\t*/\n"
11156             "}",
11157             format("{\n"
11158                    "\t/*\n"
11159                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11160                    "\t*/\n"
11161                    "}",
11162                    Tab));
11163   EXPECT_EQ("{\n"
11164             "\t/*\n"
11165             "\n"
11166             "\t*/\n"
11167             "}",
11168             format("{\n"
11169                    "\t/*\n"
11170                    "\n"
11171                    "\t*/\n"
11172                    "}",
11173                    Tab));
11174   EXPECT_EQ("{\n"
11175             "\t/*\n"
11176             " asdf\n"
11177             "\t*/\n"
11178             "}",
11179             format("{\n"
11180                    "\t/*\n"
11181                    " asdf\n"
11182                    "\t*/\n"
11183                    "}",
11184                    Tab));
11185   EXPECT_EQ("/* some\n"
11186             "   comment */",
11187             format(" \t \t /* some\n"
11188                    " \t \t    comment */",
11189                    Tab));
11190   EXPECT_EQ("int a; /* some\n"
11191             "   comment */",
11192             format(" \t \t int a; /* some\n"
11193                    " \t \t    comment */",
11194                    Tab));
11195   EXPECT_EQ("int a; /* some\n"
11196             "comment */",
11197             format(" \t \t int\ta; /* some\n"
11198                    " \t \t    comment */",
11199                    Tab));
11200   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11201             "    comment */",
11202             format(" \t \t f(\"\t\t\"); /* some\n"
11203                    " \t \t    comment */",
11204                    Tab));
11205   EXPECT_EQ("{\n"
11206             "\t/*\n"
11207             "\t * Comment\n"
11208             "\t */\n"
11209             "\tint i;\n"
11210             "}",
11211             format("{\n"
11212                    "\t/*\n"
11213                    "\t * Comment\n"
11214                    "\t */\n"
11215                    "\t int i;\n"
11216                    "}",
11217                    Tab));
11218   Tab.TabWidth = 2;
11219   Tab.IndentWidth = 2;
11220   EXPECT_EQ("{\n"
11221             "\t/* aaaa\n"
11222             "\t\t bbbb */\n"
11223             "}",
11224             format("{\n"
11225                    "/* aaaa\n"
11226                    "\t bbbb */\n"
11227                    "}",
11228                    Tab));
11229   EXPECT_EQ("{\n"
11230             "\t/*\n"
11231             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11232             "\t\tbbbbbbbbbbbbb\n"
11233             "\t*/\n"
11234             "}",
11235             format("{\n"
11236                    "/*\n"
11237                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11238                    "*/\n"
11239                    "}",
11240                    Tab));
11241   Tab.AlignConsecutiveAssignments = true;
11242   Tab.AlignConsecutiveDeclarations = true;
11243   Tab.TabWidth = 4;
11244   Tab.IndentWidth = 4;
11245   verifyFormat("class Assign {\n"
11246                "\tvoid f() {\n"
11247                "\t\tint         x      = 123;\n"
11248                "\t\tint         random = 4;\n"
11249                "\t\tstd::string alphabet =\n"
11250                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11251                "\t}\n"
11252                "};",
11253                Tab);
11254 
11255   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11256   Tab.TabWidth = 8;
11257   Tab.IndentWidth = 8;
11258   EXPECT_EQ("if (aaaaaaaa && // q\n"
11259             "    bb)         // w\n"
11260             "\t;",
11261             format("if (aaaaaaaa &&// q\n"
11262                    "bb)// w\n"
11263                    ";",
11264                    Tab));
11265   EXPECT_EQ("if (aaa && bbb) // w\n"
11266             "\t;",
11267             format("if(aaa&&bbb)// w\n"
11268                    ";",
11269                    Tab));
11270   verifyFormat("class X {\n"
11271                "\tvoid f() {\n"
11272                "\t\tsomeFunction(parameter1,\n"
11273                "\t\t             parameter2);\n"
11274                "\t}\n"
11275                "};",
11276                Tab);
11277   verifyFormat("#define A                        \\\n"
11278                "\tvoid f() {               \\\n"
11279                "\t\tsomeFunction(    \\\n"
11280                "\t\t    parameter1,  \\\n"
11281                "\t\t    parameter2); \\\n"
11282                "\t}",
11283                Tab);
11284   Tab.TabWidth = 4;
11285   Tab.IndentWidth = 8;
11286   verifyFormat("class TabWidth4Indent8 {\n"
11287                "\t\tvoid f() {\n"
11288                "\t\t\t\tsomeFunction(parameter1,\n"
11289                "\t\t\t\t             parameter2);\n"
11290                "\t\t}\n"
11291                "};",
11292                Tab);
11293   Tab.TabWidth = 4;
11294   Tab.IndentWidth = 4;
11295   verifyFormat("class TabWidth4Indent4 {\n"
11296                "\tvoid f() {\n"
11297                "\t\tsomeFunction(parameter1,\n"
11298                "\t\t             parameter2);\n"
11299                "\t}\n"
11300                "};",
11301                Tab);
11302   Tab.TabWidth = 8;
11303   Tab.IndentWidth = 4;
11304   verifyFormat("class TabWidth8Indent4 {\n"
11305                "    void f() {\n"
11306                "\tsomeFunction(parameter1,\n"
11307                "\t             parameter2);\n"
11308                "    }\n"
11309                "};",
11310                Tab);
11311   Tab.TabWidth = 8;
11312   Tab.IndentWidth = 8;
11313   EXPECT_EQ("/*\n"
11314             "              a\t\tcomment\n"
11315             "              in multiple lines\n"
11316             "       */",
11317             format("   /*\t \t \n"
11318                    " \t \t a\t\tcomment\t \t\n"
11319                    " \t \t in multiple lines\t\n"
11320                    " \t  */",
11321                    Tab));
11322   verifyFormat("{\n"
11323                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11324                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11325                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11326                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11327                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11328                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11329                "};",
11330                Tab);
11331   verifyFormat("enum AA {\n"
11332                "\ta1, // Force multiple lines\n"
11333                "\ta2,\n"
11334                "\ta3\n"
11335                "};",
11336                Tab);
11337   EXPECT_EQ("if (aaaaaaaa && // q\n"
11338             "    bb)         // w\n"
11339             "\t;",
11340             format("if (aaaaaaaa &&// q\n"
11341                    "bb)// w\n"
11342                    ";",
11343                    Tab));
11344   verifyFormat("class X {\n"
11345                "\tvoid f() {\n"
11346                "\t\tsomeFunction(parameter1,\n"
11347                "\t\t             parameter2);\n"
11348                "\t}\n"
11349                "};",
11350                Tab);
11351   verifyFormat("{\n"
11352                "\tQ(\n"
11353                "\t    {\n"
11354                "\t\t    int a;\n"
11355                "\t\t    someFunction(aaaaaaaa,\n"
11356                "\t\t                 bbbbbbb);\n"
11357                "\t    },\n"
11358                "\t    p);\n"
11359                "}",
11360                Tab);
11361   EXPECT_EQ("{\n"
11362             "\t/* aaaa\n"
11363             "\t   bbbb */\n"
11364             "}",
11365             format("{\n"
11366                    "/* aaaa\n"
11367                    "   bbbb */\n"
11368                    "}",
11369                    Tab));
11370   EXPECT_EQ("{\n"
11371             "\t/*\n"
11372             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11373             "\t  bbbbbbbbbbbbb\n"
11374             "\t*/\n"
11375             "}",
11376             format("{\n"
11377                    "/*\n"
11378                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11379                    "*/\n"
11380                    "}",
11381                    Tab));
11382   EXPECT_EQ("{\n"
11383             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11384             "\t// bbbbbbbbbbbbb\n"
11385             "}",
11386             format("{\n"
11387                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11388                    "}",
11389                    Tab));
11390   EXPECT_EQ("{\n"
11391             "\t/*\n"
11392             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11393             "\t  bbbbbbbbbbbbb\n"
11394             "\t*/\n"
11395             "}",
11396             format("{\n"
11397                    "\t/*\n"
11398                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11399                    "\t*/\n"
11400                    "}",
11401                    Tab));
11402   EXPECT_EQ("{\n"
11403             "\t/*\n"
11404             "\n"
11405             "\t*/\n"
11406             "}",
11407             format("{\n"
11408                    "\t/*\n"
11409                    "\n"
11410                    "\t*/\n"
11411                    "}",
11412                    Tab));
11413   EXPECT_EQ("{\n"
11414             "\t/*\n"
11415             " asdf\n"
11416             "\t*/\n"
11417             "}",
11418             format("{\n"
11419                    "\t/*\n"
11420                    " asdf\n"
11421                    "\t*/\n"
11422                    "}",
11423                    Tab));
11424   EXPECT_EQ("/* some\n"
11425             "   comment */",
11426             format(" \t \t /* some\n"
11427                    " \t \t    comment */",
11428                    Tab));
11429   EXPECT_EQ("int a; /* some\n"
11430             "   comment */",
11431             format(" \t \t int a; /* some\n"
11432                    " \t \t    comment */",
11433                    Tab));
11434   EXPECT_EQ("int a; /* some\n"
11435             "comment */",
11436             format(" \t \t int\ta; /* some\n"
11437                    " \t \t    comment */",
11438                    Tab));
11439   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11440             "    comment */",
11441             format(" \t \t f(\"\t\t\"); /* some\n"
11442                    " \t \t    comment */",
11443                    Tab));
11444   EXPECT_EQ("{\n"
11445             "\t/*\n"
11446             "\t * Comment\n"
11447             "\t */\n"
11448             "\tint i;\n"
11449             "}",
11450             format("{\n"
11451                    "\t/*\n"
11452                    "\t * Comment\n"
11453                    "\t */\n"
11454                    "\t int i;\n"
11455                    "}",
11456                    Tab));
11457   Tab.TabWidth = 2;
11458   Tab.IndentWidth = 2;
11459   EXPECT_EQ("{\n"
11460             "\t/* aaaa\n"
11461             "\t   bbbb */\n"
11462             "}",
11463             format("{\n"
11464                    "/* aaaa\n"
11465                    "   bbbb */\n"
11466                    "}",
11467                    Tab));
11468   EXPECT_EQ("{\n"
11469             "\t/*\n"
11470             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11471             "\t  bbbbbbbbbbbbb\n"
11472             "\t*/\n"
11473             "}",
11474             format("{\n"
11475                    "/*\n"
11476                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11477                    "*/\n"
11478                    "}",
11479                    Tab));
11480   Tab.AlignConsecutiveAssignments = true;
11481   Tab.AlignConsecutiveDeclarations = true;
11482   Tab.TabWidth = 4;
11483   Tab.IndentWidth = 4;
11484   verifyFormat("class Assign {\n"
11485                "\tvoid f() {\n"
11486                "\t\tint         x      = 123;\n"
11487                "\t\tint         random = 4;\n"
11488                "\t\tstd::string alphabet =\n"
11489                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11490                "\t}\n"
11491                "};",
11492                Tab);
11493   Tab.AlignOperands = FormatStyle::OAS_Align;
11494   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb +\n"
11495                "                 cccccccccccccccccccc;",
11496                Tab);
11497   // no alignment
11498   verifyFormat("int aaaaaaaaaa =\n"
11499                "\tbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
11500                Tab);
11501   verifyFormat("return aaaaaaaaaaaaaaaa ? 111111111111111\n"
11502                "       : bbbbbbbbbbbbbb ? 222222222222222\n"
11503                "                        : 333333333333333;",
11504                Tab);
11505   Tab.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
11506   Tab.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
11507   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb\n"
11508                "               + cccccccccccccccccccc;",
11509                Tab);
11510 }
11511 
11512 TEST_F(FormatTest, ZeroTabWidth) {
11513   FormatStyle Tab = getLLVMStyleWithColumns(42);
11514   Tab.IndentWidth = 8;
11515   Tab.UseTab = FormatStyle::UT_Never;
11516   Tab.TabWidth = 0;
11517   EXPECT_EQ("void a(){\n"
11518             "    // line starts with '\t'\n"
11519             "};",
11520             format("void a(){\n"
11521                    "\t// line starts with '\t'\n"
11522                    "};",
11523                    Tab));
11524 
11525   EXPECT_EQ("void a(){\n"
11526             "    // line starts with '\t'\n"
11527             "};",
11528             format("void a(){\n"
11529                    "\t\t// line starts with '\t'\n"
11530                    "};",
11531                    Tab));
11532 
11533   Tab.UseTab = FormatStyle::UT_ForIndentation;
11534   EXPECT_EQ("void a(){\n"
11535             "    // line starts with '\t'\n"
11536             "};",
11537             format("void a(){\n"
11538                    "\t// line starts with '\t'\n"
11539                    "};",
11540                    Tab));
11541 
11542   EXPECT_EQ("void a(){\n"
11543             "    // line starts with '\t'\n"
11544             "};",
11545             format("void a(){\n"
11546                    "\t\t// line starts with '\t'\n"
11547                    "};",
11548                    Tab));
11549 
11550   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11551   EXPECT_EQ("void a(){\n"
11552             "    // line starts with '\t'\n"
11553             "};",
11554             format("void a(){\n"
11555                    "\t// line starts with '\t'\n"
11556                    "};",
11557                    Tab));
11558 
11559   EXPECT_EQ("void a(){\n"
11560             "    // line starts with '\t'\n"
11561             "};",
11562             format("void a(){\n"
11563                    "\t\t// line starts with '\t'\n"
11564                    "};",
11565                    Tab));
11566 
11567   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11568   EXPECT_EQ("void a(){\n"
11569             "    // line starts with '\t'\n"
11570             "};",
11571             format("void a(){\n"
11572                    "\t// line starts with '\t'\n"
11573                    "};",
11574                    Tab));
11575 
11576   EXPECT_EQ("void a(){\n"
11577             "    // line starts with '\t'\n"
11578             "};",
11579             format("void a(){\n"
11580                    "\t\t// line starts with '\t'\n"
11581                    "};",
11582                    Tab));
11583 
11584   Tab.UseTab = FormatStyle::UT_Always;
11585   EXPECT_EQ("void a(){\n"
11586             "// line starts with '\t'\n"
11587             "};",
11588             format("void a(){\n"
11589                    "\t// line starts with '\t'\n"
11590                    "};",
11591                    Tab));
11592 
11593   EXPECT_EQ("void a(){\n"
11594             "// line starts with '\t'\n"
11595             "};",
11596             format("void a(){\n"
11597                    "\t\t// line starts with '\t'\n"
11598                    "};",
11599                    Tab));
11600 }
11601 
11602 TEST_F(FormatTest, CalculatesOriginalColumn) {
11603   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11604             "q\"; /* some\n"
11605             "       comment */",
11606             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11607                    "q\"; /* some\n"
11608                    "       comment */",
11609                    getLLVMStyle()));
11610   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11611             "/* some\n"
11612             "   comment */",
11613             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11614                    " /* some\n"
11615                    "    comment */",
11616                    getLLVMStyle()));
11617   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11618             "qqq\n"
11619             "/* some\n"
11620             "   comment */",
11621             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11622                    "qqq\n"
11623                    " /* some\n"
11624                    "    comment */",
11625                    getLLVMStyle()));
11626   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11627             "wwww; /* some\n"
11628             "         comment */",
11629             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11630                    "wwww; /* some\n"
11631                    "         comment */",
11632                    getLLVMStyle()));
11633 }
11634 
11635 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11636   FormatStyle NoSpace = getLLVMStyle();
11637   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11638 
11639   verifyFormat("while(true)\n"
11640                "  continue;",
11641                NoSpace);
11642   verifyFormat("for(;;)\n"
11643                "  continue;",
11644                NoSpace);
11645   verifyFormat("if(true)\n"
11646                "  f();\n"
11647                "else if(true)\n"
11648                "  f();",
11649                NoSpace);
11650   verifyFormat("do {\n"
11651                "  do_something();\n"
11652                "} while(something());",
11653                NoSpace);
11654   verifyFormat("switch(x) {\n"
11655                "default:\n"
11656                "  break;\n"
11657                "}",
11658                NoSpace);
11659   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11660   verifyFormat("size_t x = sizeof(x);", NoSpace);
11661   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11662   verifyFormat("auto f(int x) -> typeof(x);", NoSpace);
11663   verifyFormat("auto f(int x) -> _Atomic(x);", NoSpace);
11664   verifyFormat("auto f(int x) -> __underlying_type(x);", NoSpace);
11665   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11666   verifyFormat("alignas(128) char a[128];", NoSpace);
11667   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11668   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11669   verifyFormat("int f() throw(Deprecated);", NoSpace);
11670   verifyFormat("typedef void (*cb)(int);", NoSpace);
11671   verifyFormat("T A::operator()();", NoSpace);
11672   verifyFormat("X A::operator++(T);", NoSpace);
11673   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11674 
11675   FormatStyle Space = getLLVMStyle();
11676   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11677 
11678   verifyFormat("int f ();", Space);
11679   verifyFormat("void f (int a, T b) {\n"
11680                "  while (true)\n"
11681                "    continue;\n"
11682                "}",
11683                Space);
11684   verifyFormat("if (true)\n"
11685                "  f ();\n"
11686                "else if (true)\n"
11687                "  f ();",
11688                Space);
11689   verifyFormat("do {\n"
11690                "  do_something ();\n"
11691                "} while (something ());",
11692                Space);
11693   verifyFormat("switch (x) {\n"
11694                "default:\n"
11695                "  break;\n"
11696                "}",
11697                Space);
11698   verifyFormat("A::A () : a (1) {}", Space);
11699   verifyFormat("void f () __attribute__ ((asdf));", Space);
11700   verifyFormat("*(&a + 1);\n"
11701                "&((&a)[1]);\n"
11702                "a[(b + c) * d];\n"
11703                "(((a + 1) * 2) + 3) * 4;",
11704                Space);
11705   verifyFormat("#define A(x) x", Space);
11706   verifyFormat("#define A (x) x", Space);
11707   verifyFormat("#if defined(x)\n"
11708                "#endif",
11709                Space);
11710   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11711   verifyFormat("size_t x = sizeof (x);", Space);
11712   verifyFormat("auto f (int x) -> decltype (x);", Space);
11713   verifyFormat("auto f (int x) -> typeof (x);", Space);
11714   verifyFormat("auto f (int x) -> _Atomic (x);", Space);
11715   verifyFormat("auto f (int x) -> __underlying_type (x);", Space);
11716   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11717   verifyFormat("alignas (128) char a[128];", Space);
11718   verifyFormat("size_t x = alignof (MyType);", Space);
11719   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11720   verifyFormat("int f () throw (Deprecated);", Space);
11721   verifyFormat("typedef void (*cb) (int);", Space);
11722   verifyFormat("T A::operator() ();", Space);
11723   verifyFormat("X A::operator++ (T);", Space);
11724   verifyFormat("auto lambda = [] () { return 0; };", Space);
11725   verifyFormat("int x = int (y);", Space);
11726 
11727   FormatStyle SomeSpace = getLLVMStyle();
11728   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11729 
11730   verifyFormat("[]() -> float {}", SomeSpace);
11731   verifyFormat("[] (auto foo) {}", SomeSpace);
11732   verifyFormat("[foo]() -> int {}", SomeSpace);
11733   verifyFormat("int f();", SomeSpace);
11734   verifyFormat("void f (int a, T b) {\n"
11735                "  while (true)\n"
11736                "    continue;\n"
11737                "}",
11738                SomeSpace);
11739   verifyFormat("if (true)\n"
11740                "  f();\n"
11741                "else if (true)\n"
11742                "  f();",
11743                SomeSpace);
11744   verifyFormat("do {\n"
11745                "  do_something();\n"
11746                "} while (something());",
11747                SomeSpace);
11748   verifyFormat("switch (x) {\n"
11749                "default:\n"
11750                "  break;\n"
11751                "}",
11752                SomeSpace);
11753   verifyFormat("A::A() : a (1) {}", SomeSpace);
11754   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11755   verifyFormat("*(&a + 1);\n"
11756                "&((&a)[1]);\n"
11757                "a[(b + c) * d];\n"
11758                "(((a + 1) * 2) + 3) * 4;",
11759                SomeSpace);
11760   verifyFormat("#define A(x) x", SomeSpace);
11761   verifyFormat("#define A (x) x", SomeSpace);
11762   verifyFormat("#if defined(x)\n"
11763                "#endif",
11764                SomeSpace);
11765   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11766   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11767   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11768   verifyFormat("auto f (int x) -> typeof (x);", SomeSpace);
11769   verifyFormat("auto f (int x) -> _Atomic (x);", SomeSpace);
11770   verifyFormat("auto f (int x) -> __underlying_type (x);", SomeSpace);
11771   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11772   verifyFormat("alignas (128) char a[128];", SomeSpace);
11773   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11774   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11775                SomeSpace);
11776   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11777   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11778   verifyFormat("T A::operator()();", SomeSpace);
11779   verifyFormat("X A::operator++ (T);", SomeSpace);
11780   verifyFormat("int x = int (y);", SomeSpace);
11781   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11782 }
11783 
11784 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11785   FormatStyle Spaces = getLLVMStyle();
11786   Spaces.SpaceAfterLogicalNot = true;
11787 
11788   verifyFormat("bool x = ! y", Spaces);
11789   verifyFormat("if (! isFailure())", Spaces);
11790   verifyFormat("if (! (a && b))", Spaces);
11791   verifyFormat("\"Error!\"", Spaces);
11792   verifyFormat("! ! x", Spaces);
11793 }
11794 
11795 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11796   FormatStyle Spaces = getLLVMStyle();
11797 
11798   Spaces.SpacesInParentheses = true;
11799   verifyFormat("do_something( ::globalVar );", Spaces);
11800   verifyFormat("call( x, y, z );", Spaces);
11801   verifyFormat("call();", Spaces);
11802   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11803   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11804                Spaces);
11805   verifyFormat("while ( (bool)1 )\n"
11806                "  continue;",
11807                Spaces);
11808   verifyFormat("for ( ;; )\n"
11809                "  continue;",
11810                Spaces);
11811   verifyFormat("if ( true )\n"
11812                "  f();\n"
11813                "else if ( true )\n"
11814                "  f();",
11815                Spaces);
11816   verifyFormat("do {\n"
11817                "  do_something( (int)i );\n"
11818                "} while ( something() );",
11819                Spaces);
11820   verifyFormat("switch ( x ) {\n"
11821                "default:\n"
11822                "  break;\n"
11823                "}",
11824                Spaces);
11825 
11826   Spaces.SpacesInParentheses = false;
11827   Spaces.SpacesInCStyleCastParentheses = true;
11828   verifyFormat("Type *A = ( Type * )P;", Spaces);
11829   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11830   verifyFormat("x = ( int32 )y;", Spaces);
11831   verifyFormat("int a = ( int )(2.0f);", Spaces);
11832   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11833   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11834   verifyFormat("#define x (( int )-1)", Spaces);
11835 
11836   // Run the first set of tests again with:
11837   Spaces.SpacesInParentheses = false;
11838   Spaces.SpaceInEmptyParentheses = true;
11839   Spaces.SpacesInCStyleCastParentheses = true;
11840   verifyFormat("call(x, y, z);", Spaces);
11841   verifyFormat("call( );", Spaces);
11842   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11843   verifyFormat("while (( bool )1)\n"
11844                "  continue;",
11845                Spaces);
11846   verifyFormat("for (;;)\n"
11847                "  continue;",
11848                Spaces);
11849   verifyFormat("if (true)\n"
11850                "  f( );\n"
11851                "else if (true)\n"
11852                "  f( );",
11853                Spaces);
11854   verifyFormat("do {\n"
11855                "  do_something(( int )i);\n"
11856                "} while (something( ));",
11857                Spaces);
11858   verifyFormat("switch (x) {\n"
11859                "default:\n"
11860                "  break;\n"
11861                "}",
11862                Spaces);
11863 
11864   // Run the first set of tests again with:
11865   Spaces.SpaceAfterCStyleCast = true;
11866   verifyFormat("call(x, y, z);", Spaces);
11867   verifyFormat("call( );", Spaces);
11868   verifyFormat("std::function<void(int, int)> callback;", Spaces);
11869   verifyFormat("while (( bool ) 1)\n"
11870                "  continue;",
11871                Spaces);
11872   verifyFormat("for (;;)\n"
11873                "  continue;",
11874                Spaces);
11875   verifyFormat("if (true)\n"
11876                "  f( );\n"
11877                "else if (true)\n"
11878                "  f( );",
11879                Spaces);
11880   verifyFormat("do {\n"
11881                "  do_something(( int ) i);\n"
11882                "} while (something( ));",
11883                Spaces);
11884   verifyFormat("switch (x) {\n"
11885                "default:\n"
11886                "  break;\n"
11887                "}",
11888                Spaces);
11889 
11890   // Run subset of tests again with:
11891   Spaces.SpacesInCStyleCastParentheses = false;
11892   Spaces.SpaceAfterCStyleCast = true;
11893   verifyFormat("while ((bool) 1)\n"
11894                "  continue;",
11895                Spaces);
11896   verifyFormat("do {\n"
11897                "  do_something((int) i);\n"
11898                "} while (something( ));",
11899                Spaces);
11900 }
11901 
11902 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
11903   verifyFormat("int a[5];");
11904   verifyFormat("a[3] += 42;");
11905 
11906   FormatStyle Spaces = getLLVMStyle();
11907   Spaces.SpacesInSquareBrackets = true;
11908   // Not lambdas.
11909   verifyFormat("int a[ 5 ];", Spaces);
11910   verifyFormat("a[ 3 ] += 42;", Spaces);
11911   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
11912   verifyFormat("double &operator[](int i) { return 0; }\n"
11913                "int i;",
11914                Spaces);
11915   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
11916   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
11917   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
11918   // Lambdas.
11919   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
11920   verifyFormat("return [ i, args... ] {};", Spaces);
11921   verifyFormat("int foo = [ &bar ]() {};", Spaces);
11922   verifyFormat("int foo = [ = ]() {};", Spaces);
11923   verifyFormat("int foo = [ & ]() {};", Spaces);
11924   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
11925   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
11926 }
11927 
11928 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
11929   FormatStyle NoSpaceStyle = getLLVMStyle();
11930   verifyFormat("int a[5];", NoSpaceStyle);
11931   verifyFormat("a[3] += 42;", NoSpaceStyle);
11932 
11933   verifyFormat("int a[1];", NoSpaceStyle);
11934   verifyFormat("int 1 [a];", NoSpaceStyle);
11935   verifyFormat("int a[1][2];", NoSpaceStyle);
11936   verifyFormat("a[7] = 5;", NoSpaceStyle);
11937   verifyFormat("int a = (f())[23];", NoSpaceStyle);
11938   verifyFormat("f([] {})", NoSpaceStyle);
11939 
11940   FormatStyle Space = getLLVMStyle();
11941   Space.SpaceBeforeSquareBrackets = true;
11942   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
11943   verifyFormat("return [i, args...] {};", Space);
11944 
11945   verifyFormat("int a [5];", Space);
11946   verifyFormat("a [3] += 42;", Space);
11947   verifyFormat("constexpr char hello []{\"hello\"};", Space);
11948   verifyFormat("double &operator[](int i) { return 0; }\n"
11949                "int i;",
11950                Space);
11951   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
11952   verifyFormat("int i = a [a][a]->f();", Space);
11953   verifyFormat("int i = (*b) [a]->f();", Space);
11954 
11955   verifyFormat("int a [1];", Space);
11956   verifyFormat("int 1 [a];", Space);
11957   verifyFormat("int a [1][2];", Space);
11958   verifyFormat("a [7] = 5;", Space);
11959   verifyFormat("int a = (f()) [23];", Space);
11960   verifyFormat("f([] {})", Space);
11961 }
11962 
11963 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
11964   verifyFormat("int a = 5;");
11965   verifyFormat("a += 42;");
11966   verifyFormat("a or_eq 8;");
11967 
11968   FormatStyle Spaces = getLLVMStyle();
11969   Spaces.SpaceBeforeAssignmentOperators = false;
11970   verifyFormat("int a= 5;", Spaces);
11971   verifyFormat("a+= 42;", Spaces);
11972   verifyFormat("a or_eq 8;", Spaces);
11973 }
11974 
11975 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
11976   verifyFormat("class Foo : public Bar {};");
11977   verifyFormat("Foo::Foo() : foo(1) {}");
11978   verifyFormat("for (auto a : b) {\n}");
11979   verifyFormat("int x = a ? b : c;");
11980   verifyFormat("{\n"
11981                "label0:\n"
11982                "  int x = 0;\n"
11983                "}");
11984   verifyFormat("switch (x) {\n"
11985                "case 1:\n"
11986                "default:\n"
11987                "}");
11988 
11989   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
11990   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
11991   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
11992   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
11993   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
11994   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
11995   verifyFormat("{\n"
11996                "label1:\n"
11997                "  int x = 0;\n"
11998                "}",
11999                CtorInitializerStyle);
12000   verifyFormat("switch (x) {\n"
12001                "case 1:\n"
12002                "default:\n"
12003                "}",
12004                CtorInitializerStyle);
12005   CtorInitializerStyle.BreakConstructorInitializers =
12006       FormatStyle::BCIS_AfterColon;
12007   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
12008                "    aaaaaaaaaaaaaaaa(1),\n"
12009                "    bbbbbbbbbbbbbbbb(2) {}",
12010                CtorInitializerStyle);
12011   CtorInitializerStyle.BreakConstructorInitializers =
12012       FormatStyle::BCIS_BeforeComma;
12013   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12014                "    : aaaaaaaaaaaaaaaa(1)\n"
12015                "    , bbbbbbbbbbbbbbbb(2) {}",
12016                CtorInitializerStyle);
12017   CtorInitializerStyle.BreakConstructorInitializers =
12018       FormatStyle::BCIS_BeforeColon;
12019   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12020                "    : aaaaaaaaaaaaaaaa(1),\n"
12021                "      bbbbbbbbbbbbbbbb(2) {}",
12022                CtorInitializerStyle);
12023   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
12024   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12025                ": aaaaaaaaaaaaaaaa(1),\n"
12026                "  bbbbbbbbbbbbbbbb(2) {}",
12027                CtorInitializerStyle);
12028 
12029   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
12030   InheritanceStyle.SpaceBeforeInheritanceColon = false;
12031   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
12032   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
12033   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
12034   verifyFormat("int x = a ? b : c;", InheritanceStyle);
12035   verifyFormat("{\n"
12036                "label2:\n"
12037                "  int x = 0;\n"
12038                "}",
12039                InheritanceStyle);
12040   verifyFormat("switch (x) {\n"
12041                "case 1:\n"
12042                "default:\n"
12043                "}",
12044                InheritanceStyle);
12045   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
12046   verifyFormat("class Foooooooooooooooooooooo:\n"
12047                "    public aaaaaaaaaaaaaaaaaa,\n"
12048                "    public bbbbbbbbbbbbbbbbbb {\n"
12049                "}",
12050                InheritanceStyle);
12051   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
12052   verifyFormat("class Foooooooooooooooooooooo\n"
12053                "    : public aaaaaaaaaaaaaaaaaa\n"
12054                "    , public bbbbbbbbbbbbbbbbbb {\n"
12055                "}",
12056                InheritanceStyle);
12057   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
12058   verifyFormat("class Foooooooooooooooooooooo\n"
12059                "    : public aaaaaaaaaaaaaaaaaa,\n"
12060                "      public bbbbbbbbbbbbbbbbbb {\n"
12061                "}",
12062                InheritanceStyle);
12063   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
12064   verifyFormat("class Foooooooooooooooooooooo\n"
12065                ": public aaaaaaaaaaaaaaaaaa,\n"
12066                "  public bbbbbbbbbbbbbbbbbb {}",
12067                InheritanceStyle);
12068 
12069   FormatStyle ForLoopStyle = getLLVMStyle();
12070   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
12071   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
12072   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
12073   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
12074   verifyFormat("int x = a ? b : c;", ForLoopStyle);
12075   verifyFormat("{\n"
12076                "label2:\n"
12077                "  int x = 0;\n"
12078                "}",
12079                ForLoopStyle);
12080   verifyFormat("switch (x) {\n"
12081                "case 1:\n"
12082                "default:\n"
12083                "}",
12084                ForLoopStyle);
12085 
12086   FormatStyle NoSpaceStyle = getLLVMStyle();
12087   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
12088   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
12089   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
12090   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
12091   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
12092   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
12093   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
12094   verifyFormat("{\n"
12095                "label3:\n"
12096                "  int x = 0;\n"
12097                "}",
12098                NoSpaceStyle);
12099   verifyFormat("switch (x) {\n"
12100                "case 1:\n"
12101                "default:\n"
12102                "}",
12103                NoSpaceStyle);
12104 }
12105 
12106 TEST_F(FormatTest, ConfigurableSpaceAroundPointerQualifiers) {
12107   FormatStyle Style = getLLVMStyle();
12108 
12109   Style.PointerAlignment = FormatStyle::PAS_Left;
12110   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
12111   verifyFormat("void* const* x = NULL;", Style);
12112 
12113 #define verifyQualifierSpaces(Code, Pointers, Qualifiers)                      \
12114   do {                                                                         \
12115     Style.PointerAlignment = FormatStyle::Pointers;                            \
12116     Style.SpaceAroundPointerQualifiers = FormatStyle::Qualifiers;              \
12117     verifyFormat(Code, Style);                                                 \
12118   } while (false)
12119 
12120   verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Default);
12121   verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_Default);
12122   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Default);
12123 
12124   verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Before);
12125   verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Before);
12126   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Before);
12127 
12128   verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_After);
12129   verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_After);
12130   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_After);
12131 
12132   verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_Both);
12133   verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Both);
12134   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Both);
12135 
12136 #undef verifyQualifierSpaces
12137 
12138   FormatStyle Spaces = getLLVMStyle();
12139   Spaces.AttributeMacros.push_back("qualified");
12140   Spaces.PointerAlignment = FormatStyle::PAS_Right;
12141   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
12142   verifyFormat("SomeType *volatile *a = NULL;", Spaces);
12143   verifyFormat("SomeType *__attribute__((attr)) *a = NULL;", Spaces);
12144   verifyFormat("std::vector<SomeType *const *> x;", Spaces);
12145   verifyFormat("std::vector<SomeType *qualified *> x;", Spaces);
12146   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12147   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
12148   verifyFormat("SomeType * volatile *a = NULL;", Spaces);
12149   verifyFormat("SomeType * __attribute__((attr)) *a = NULL;", Spaces);
12150   verifyFormat("std::vector<SomeType * const *> x;", Spaces);
12151   verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
12152   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12153 
12154   // Check that SAPQ_Before doesn't result in extra spaces for PAS_Left.
12155   Spaces.PointerAlignment = FormatStyle::PAS_Left;
12156   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
12157   verifyFormat("SomeType* volatile* a = NULL;", Spaces);
12158   verifyFormat("SomeType* __attribute__((attr))* a = NULL;", Spaces);
12159   verifyFormat("std::vector<SomeType* const*> x;", Spaces);
12160   verifyFormat("std::vector<SomeType* qualified*> x;", Spaces);
12161   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12162   // However, setting it to SAPQ_After should add spaces after __attribute, etc.
12163   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
12164   verifyFormat("SomeType* volatile * a = NULL;", Spaces);
12165   verifyFormat("SomeType* __attribute__((attr)) * a = NULL;", Spaces);
12166   verifyFormat("std::vector<SomeType* const *> x;", Spaces);
12167   verifyFormat("std::vector<SomeType* qualified *> x;", Spaces);
12168   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12169 
12170   // PAS_Middle should not have any noticeable changes even for SAPQ_Both
12171   Spaces.PointerAlignment = FormatStyle::PAS_Middle;
12172   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
12173   verifyFormat("SomeType * volatile * a = NULL;", Spaces);
12174   verifyFormat("SomeType * __attribute__((attr)) * a = NULL;", Spaces);
12175   verifyFormat("std::vector<SomeType * const *> x;", Spaces);
12176   verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
12177   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12178 }
12179 
12180 TEST_F(FormatTest, AlignConsecutiveMacros) {
12181   FormatStyle Style = getLLVMStyle();
12182   Style.AlignConsecutiveAssignments = true;
12183   Style.AlignConsecutiveDeclarations = true;
12184   Style.AlignConsecutiveMacros = false;
12185 
12186   verifyFormat("#define a 3\n"
12187                "#define bbbb 4\n"
12188                "#define ccc (5)",
12189                Style);
12190 
12191   verifyFormat("#define f(x) (x * x)\n"
12192                "#define fff(x, y, z) (x * y + z)\n"
12193                "#define ffff(x, y) (x - y)",
12194                Style);
12195 
12196   verifyFormat("#define foo(x, y) (x + y)\n"
12197                "#define bar (5, 6)(2 + 2)",
12198                Style);
12199 
12200   verifyFormat("#define a 3\n"
12201                "#define bbbb 4\n"
12202                "#define ccc (5)\n"
12203                "#define f(x) (x * x)\n"
12204                "#define fff(x, y, z) (x * y + z)\n"
12205                "#define ffff(x, y) (x - y)",
12206                Style);
12207 
12208   Style.AlignConsecutiveMacros = true;
12209   verifyFormat("#define a    3\n"
12210                "#define bbbb 4\n"
12211                "#define ccc  (5)",
12212                Style);
12213 
12214   verifyFormat("#define f(x)         (x * x)\n"
12215                "#define fff(x, y, z) (x * y + z)\n"
12216                "#define ffff(x, y)   (x - y)",
12217                Style);
12218 
12219   verifyFormat("#define foo(x, y) (x + y)\n"
12220                "#define bar       (5, 6)(2 + 2)",
12221                Style);
12222 
12223   verifyFormat("#define a            3\n"
12224                "#define bbbb         4\n"
12225                "#define ccc          (5)\n"
12226                "#define f(x)         (x * x)\n"
12227                "#define fff(x, y, z) (x * y + z)\n"
12228                "#define ffff(x, y)   (x - y)",
12229                Style);
12230 
12231   verifyFormat("#define a         5\n"
12232                "#define foo(x, y) (x + y)\n"
12233                "#define CCC       (6)\n"
12234                "auto lambda = []() {\n"
12235                "  auto  ii = 0;\n"
12236                "  float j  = 0;\n"
12237                "  return 0;\n"
12238                "};\n"
12239                "int   i  = 0;\n"
12240                "float i2 = 0;\n"
12241                "auto  v  = type{\n"
12242                "    i = 1,   //\n"
12243                "    (i = 2), //\n"
12244                "    i = 3    //\n"
12245                "};",
12246                Style);
12247 
12248   Style.AlignConsecutiveMacros = false;
12249   Style.ColumnLimit = 20;
12250 
12251   verifyFormat("#define a          \\\n"
12252                "  \"aabbbbbbbbbbbb\"\n"
12253                "#define D          \\\n"
12254                "  \"aabbbbbbbbbbbb\" \\\n"
12255                "  \"ccddeeeeeeeee\"\n"
12256                "#define B          \\\n"
12257                "  \"QQQQQQQQQQQQQ\"  \\\n"
12258                "  \"FFFFFFFFFFFFF\"  \\\n"
12259                "  \"LLLLLLLL\"\n",
12260                Style);
12261 
12262   Style.AlignConsecutiveMacros = true;
12263   verifyFormat("#define a          \\\n"
12264                "  \"aabbbbbbbbbbbb\"\n"
12265                "#define D          \\\n"
12266                "  \"aabbbbbbbbbbbb\" \\\n"
12267                "  \"ccddeeeeeeeee\"\n"
12268                "#define B          \\\n"
12269                "  \"QQQQQQQQQQQQQ\"  \\\n"
12270                "  \"FFFFFFFFFFFFF\"  \\\n"
12271                "  \"LLLLLLLL\"\n",
12272                Style);
12273 }
12274 
12275 TEST_F(FormatTest, AlignConsecutiveAssignments) {
12276   FormatStyle Alignment = getLLVMStyle();
12277   Alignment.AlignConsecutiveMacros = true;
12278   Alignment.AlignConsecutiveAssignments = false;
12279   verifyFormat("int a = 5;\n"
12280                "int oneTwoThree = 123;",
12281                Alignment);
12282   verifyFormat("int a = 5;\n"
12283                "int oneTwoThree = 123;",
12284                Alignment);
12285 
12286   Alignment.AlignConsecutiveAssignments = true;
12287   verifyFormat("int a           = 5;\n"
12288                "int oneTwoThree = 123;",
12289                Alignment);
12290   verifyFormat("int a           = method();\n"
12291                "int oneTwoThree = 133;",
12292                Alignment);
12293   verifyFormat("a &= 5;\n"
12294                "bcd *= 5;\n"
12295                "ghtyf += 5;\n"
12296                "dvfvdb -= 5;\n"
12297                "a /= 5;\n"
12298                "vdsvsv %= 5;\n"
12299                "sfdbddfbdfbb ^= 5;\n"
12300                "dvsdsv |= 5;\n"
12301                "int dsvvdvsdvvv = 123;",
12302                Alignment);
12303   verifyFormat("int i = 1, j = 10;\n"
12304                "something = 2000;",
12305                Alignment);
12306   verifyFormat("something = 2000;\n"
12307                "int i = 1, j = 10;\n",
12308                Alignment);
12309   verifyFormat("something = 2000;\n"
12310                "another   = 911;\n"
12311                "int i = 1, j = 10;\n"
12312                "oneMore = 1;\n"
12313                "i       = 2;",
12314                Alignment);
12315   verifyFormat("int a   = 5;\n"
12316                "int one = 1;\n"
12317                "method();\n"
12318                "int oneTwoThree = 123;\n"
12319                "int oneTwo      = 12;",
12320                Alignment);
12321   verifyFormat("int oneTwoThree = 123;\n"
12322                "int oneTwo      = 12;\n"
12323                "method();\n",
12324                Alignment);
12325   verifyFormat("int oneTwoThree = 123; // comment\n"
12326                "int oneTwo      = 12;  // comment",
12327                Alignment);
12328 
12329   // Bug 25167
12330   /* Uncomment when fixed
12331     verifyFormat("#if A\n"
12332                  "#else\n"
12333                  "int aaaaaaaa = 12;\n"
12334                  "#endif\n"
12335                  "#if B\n"
12336                  "#else\n"
12337                  "int a = 12;\n"
12338                  "#endif\n",
12339                  Alignment);
12340     verifyFormat("enum foo {\n"
12341                  "#if A\n"
12342                  "#else\n"
12343                  "  aaaaaaaa = 12;\n"
12344                  "#endif\n"
12345                  "#if B\n"
12346                  "#else\n"
12347                  "  a = 12;\n"
12348                  "#endif\n"
12349                  "};\n",
12350                  Alignment);
12351   */
12352 
12353   EXPECT_EQ("int a = 5;\n"
12354             "\n"
12355             "int oneTwoThree = 123;",
12356             format("int a       = 5;\n"
12357                    "\n"
12358                    "int oneTwoThree= 123;",
12359                    Alignment));
12360   EXPECT_EQ("int a   = 5;\n"
12361             "int one = 1;\n"
12362             "\n"
12363             "int oneTwoThree = 123;",
12364             format("int a = 5;\n"
12365                    "int one = 1;\n"
12366                    "\n"
12367                    "int oneTwoThree = 123;",
12368                    Alignment));
12369   EXPECT_EQ("int a   = 5;\n"
12370             "int one = 1;\n"
12371             "\n"
12372             "int oneTwoThree = 123;\n"
12373             "int oneTwo      = 12;",
12374             format("int a = 5;\n"
12375                    "int one = 1;\n"
12376                    "\n"
12377                    "int oneTwoThree = 123;\n"
12378                    "int oneTwo = 12;",
12379                    Alignment));
12380   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12381   verifyFormat("#define A \\\n"
12382                "  int aaaa       = 12; \\\n"
12383                "  int b          = 23; \\\n"
12384                "  int ccc        = 234; \\\n"
12385                "  int dddddddddd = 2345;",
12386                Alignment);
12387   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12388   verifyFormat("#define A               \\\n"
12389                "  int aaaa       = 12;  \\\n"
12390                "  int b          = 23;  \\\n"
12391                "  int ccc        = 234; \\\n"
12392                "  int dddddddddd = 2345;",
12393                Alignment);
12394   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12395   verifyFormat("#define A                                                      "
12396                "                \\\n"
12397                "  int aaaa       = 12;                                         "
12398                "                \\\n"
12399                "  int b          = 23;                                         "
12400                "                \\\n"
12401                "  int ccc        = 234;                                        "
12402                "                \\\n"
12403                "  int dddddddddd = 2345;",
12404                Alignment);
12405   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12406                "k = 4, int l = 5,\n"
12407                "                  int m = 6) {\n"
12408                "  int j      = 10;\n"
12409                "  otherThing = 1;\n"
12410                "}",
12411                Alignment);
12412   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12413                "  int i   = 1;\n"
12414                "  int j   = 2;\n"
12415                "  int big = 10000;\n"
12416                "}",
12417                Alignment);
12418   verifyFormat("class C {\n"
12419                "public:\n"
12420                "  int i            = 1;\n"
12421                "  virtual void f() = 0;\n"
12422                "};",
12423                Alignment);
12424   verifyFormat("int i = 1;\n"
12425                "if (SomeType t = getSomething()) {\n"
12426                "}\n"
12427                "int j   = 2;\n"
12428                "int big = 10000;",
12429                Alignment);
12430   verifyFormat("int j = 7;\n"
12431                "for (int k = 0; k < N; ++k) {\n"
12432                "}\n"
12433                "int j   = 2;\n"
12434                "int big = 10000;\n"
12435                "}",
12436                Alignment);
12437   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12438   verifyFormat("int i = 1;\n"
12439                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12440                "    = someLooooooooooooooooongFunction();\n"
12441                "int j = 2;",
12442                Alignment);
12443   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12444   verifyFormat("int i = 1;\n"
12445                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12446                "    someLooooooooooooooooongFunction();\n"
12447                "int j = 2;",
12448                Alignment);
12449 
12450   verifyFormat("auto lambda = []() {\n"
12451                "  auto i = 0;\n"
12452                "  return 0;\n"
12453                "};\n"
12454                "int i  = 0;\n"
12455                "auto v = type{\n"
12456                "    i = 1,   //\n"
12457                "    (i = 2), //\n"
12458                "    i = 3    //\n"
12459                "};",
12460                Alignment);
12461 
12462   verifyFormat(
12463       "int i      = 1;\n"
12464       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12465       "                          loooooooooooooooooooooongParameterB);\n"
12466       "int j      = 2;",
12467       Alignment);
12468 
12469   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12470                "          typename B   = very_long_type_name_1,\n"
12471                "          typename T_2 = very_long_type_name_2>\n"
12472                "auto foo() {}\n",
12473                Alignment);
12474   verifyFormat("int a, b = 1;\n"
12475                "int c  = 2;\n"
12476                "int dd = 3;\n",
12477                Alignment);
12478   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12479                "float b[1][] = {{3.f}};\n",
12480                Alignment);
12481   verifyFormat("for (int i = 0; i < 1; i++)\n"
12482                "  int x = 1;\n",
12483                Alignment);
12484   verifyFormat("for (i = 0; i < 1; i++)\n"
12485                "  x = 1;\n"
12486                "y = 1;\n",
12487                Alignment);
12488 
12489   Alignment.ReflowComments = true;
12490   Alignment.ColumnLimit = 50;
12491   EXPECT_EQ("int x   = 0;\n"
12492             "int yy  = 1; /// specificlennospace\n"
12493             "int zzz = 2;\n",
12494             format("int x   = 0;\n"
12495                    "int yy  = 1; ///specificlennospace\n"
12496                    "int zzz = 2;\n",
12497                    Alignment));
12498 }
12499 
12500 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12501   FormatStyle Alignment = getLLVMStyle();
12502   Alignment.AlignConsecutiveBitFields = true;
12503   verifyFormat("int const a     : 5;\n"
12504                "int oneTwoThree : 23;",
12505                Alignment);
12506 
12507   // Initializers are allowed starting with c++2a
12508   verifyFormat("int const a     : 5 = 1;\n"
12509                "int oneTwoThree : 23 = 0;",
12510                Alignment);
12511 
12512   Alignment.AlignConsecutiveDeclarations = true;
12513   verifyFormat("int const a           : 5;\n"
12514                "int       oneTwoThree : 23;",
12515                Alignment);
12516 
12517   verifyFormat("int const a           : 5;  // comment\n"
12518                "int       oneTwoThree : 23; // comment",
12519                Alignment);
12520 
12521   verifyFormat("int const a           : 5 = 1;\n"
12522                "int       oneTwoThree : 23 = 0;",
12523                Alignment);
12524 
12525   Alignment.AlignConsecutiveAssignments = true;
12526   verifyFormat("int const a           : 5  = 1;\n"
12527                "int       oneTwoThree : 23 = 0;",
12528                Alignment);
12529   verifyFormat("int const a           : 5  = {1};\n"
12530                "int       oneTwoThree : 23 = 0;",
12531                Alignment);
12532 
12533   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_None;
12534   verifyFormat("int const a          :5;\n"
12535                "int       oneTwoThree:23;",
12536                Alignment);
12537 
12538   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_Before;
12539   verifyFormat("int const a           :5;\n"
12540                "int       oneTwoThree :23;",
12541                Alignment);
12542 
12543   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_After;
12544   verifyFormat("int const a          : 5;\n"
12545                "int       oneTwoThree: 23;",
12546                Alignment);
12547 
12548   // Known limitations: ':' is only recognized as a bitfield colon when
12549   // followed by a number.
12550   /*
12551   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12552                "int a           : 5;",
12553                Alignment);
12554   */
12555 }
12556 
12557 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12558   FormatStyle Alignment = getLLVMStyle();
12559   Alignment.AlignConsecutiveMacros = true;
12560   Alignment.AlignConsecutiveDeclarations = false;
12561   verifyFormat("float const a = 5;\n"
12562                "int oneTwoThree = 123;",
12563                Alignment);
12564   verifyFormat("int a = 5;\n"
12565                "float const oneTwoThree = 123;",
12566                Alignment);
12567 
12568   Alignment.AlignConsecutiveDeclarations = true;
12569   verifyFormat("float const a = 5;\n"
12570                "int         oneTwoThree = 123;",
12571                Alignment);
12572   verifyFormat("int         a = method();\n"
12573                "float const oneTwoThree = 133;",
12574                Alignment);
12575   verifyFormat("int i = 1, j = 10;\n"
12576                "something = 2000;",
12577                Alignment);
12578   verifyFormat("something = 2000;\n"
12579                "int i = 1, j = 10;\n",
12580                Alignment);
12581   verifyFormat("float      something = 2000;\n"
12582                "double     another = 911;\n"
12583                "int        i = 1, j = 10;\n"
12584                "const int *oneMore = 1;\n"
12585                "unsigned   i = 2;",
12586                Alignment);
12587   verifyFormat("float a = 5;\n"
12588                "int   one = 1;\n"
12589                "method();\n"
12590                "const double       oneTwoThree = 123;\n"
12591                "const unsigned int oneTwo = 12;",
12592                Alignment);
12593   verifyFormat("int      oneTwoThree{0}; // comment\n"
12594                "unsigned oneTwo;         // comment",
12595                Alignment);
12596   EXPECT_EQ("float const a = 5;\n"
12597             "\n"
12598             "int oneTwoThree = 123;",
12599             format("float const   a = 5;\n"
12600                    "\n"
12601                    "int           oneTwoThree= 123;",
12602                    Alignment));
12603   EXPECT_EQ("float a = 5;\n"
12604             "int   one = 1;\n"
12605             "\n"
12606             "unsigned oneTwoThree = 123;",
12607             format("float    a = 5;\n"
12608                    "int      one = 1;\n"
12609                    "\n"
12610                    "unsigned oneTwoThree = 123;",
12611                    Alignment));
12612   EXPECT_EQ("float a = 5;\n"
12613             "int   one = 1;\n"
12614             "\n"
12615             "unsigned oneTwoThree = 123;\n"
12616             "int      oneTwo = 12;",
12617             format("float    a = 5;\n"
12618                    "int one = 1;\n"
12619                    "\n"
12620                    "unsigned oneTwoThree = 123;\n"
12621                    "int oneTwo = 12;",
12622                    Alignment));
12623   // Function prototype alignment
12624   verifyFormat("int    a();\n"
12625                "double b();",
12626                Alignment);
12627   verifyFormat("int    a(int x);\n"
12628                "double b();",
12629                Alignment);
12630   unsigned OldColumnLimit = Alignment.ColumnLimit;
12631   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12632   // otherwise the function parameters will be re-flowed onto a single line.
12633   Alignment.ColumnLimit = 0;
12634   EXPECT_EQ("int    a(int   x,\n"
12635             "         float y);\n"
12636             "double b(int    x,\n"
12637             "         double y);",
12638             format("int a(int x,\n"
12639                    " float y);\n"
12640                    "double b(int x,\n"
12641                    " double y);",
12642                    Alignment));
12643   // This ensures that function parameters of function declarations are
12644   // correctly indented when their owning functions are indented.
12645   // The failure case here is for 'double y' to not be indented enough.
12646   EXPECT_EQ("double a(int x);\n"
12647             "int    b(int    y,\n"
12648             "         double z);",
12649             format("double a(int x);\n"
12650                    "int b(int y,\n"
12651                    " double z);",
12652                    Alignment));
12653   // Set ColumnLimit low so that we induce wrapping immediately after
12654   // the function name and opening paren.
12655   Alignment.ColumnLimit = 13;
12656   verifyFormat("int function(\n"
12657                "    int  x,\n"
12658                "    bool y);",
12659                Alignment);
12660   Alignment.ColumnLimit = OldColumnLimit;
12661   // Ensure function pointers don't screw up recursive alignment
12662   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12663                "double b();",
12664                Alignment);
12665   Alignment.AlignConsecutiveAssignments = true;
12666   // Ensure recursive alignment is broken by function braces, so that the
12667   // "a = 1" does not align with subsequent assignments inside the function
12668   // body.
12669   verifyFormat("int func(int a = 1) {\n"
12670                "  int b  = 2;\n"
12671                "  int cc = 3;\n"
12672                "}",
12673                Alignment);
12674   verifyFormat("float      something = 2000;\n"
12675                "double     another   = 911;\n"
12676                "int        i = 1, j = 10;\n"
12677                "const int *oneMore = 1;\n"
12678                "unsigned   i       = 2;",
12679                Alignment);
12680   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12681                "unsigned oneTwo      = 0;   // comment",
12682                Alignment);
12683   // Make sure that scope is correctly tracked, in the absence of braces
12684   verifyFormat("for (int i = 0; i < n; i++)\n"
12685                "  j = i;\n"
12686                "double x = 1;\n",
12687                Alignment);
12688   verifyFormat("if (int i = 0)\n"
12689                "  j = i;\n"
12690                "double x = 1;\n",
12691                Alignment);
12692   // Ensure operator[] and operator() are comprehended
12693   verifyFormat("struct test {\n"
12694                "  long long int foo();\n"
12695                "  int           operator[](int a);\n"
12696                "  double        bar();\n"
12697                "};\n",
12698                Alignment);
12699   verifyFormat("struct test {\n"
12700                "  long long int foo();\n"
12701                "  int           operator()(int a);\n"
12702                "  double        bar();\n"
12703                "};\n",
12704                Alignment);
12705   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12706             "  int const i   = 1;\n"
12707             "  int *     j   = 2;\n"
12708             "  int       big = 10000;\n"
12709             "\n"
12710             "  unsigned oneTwoThree = 123;\n"
12711             "  int      oneTwo      = 12;\n"
12712             "  method();\n"
12713             "  float k  = 2;\n"
12714             "  int   ll = 10000;\n"
12715             "}",
12716             format("void SomeFunction(int parameter= 0) {\n"
12717                    " int const  i= 1;\n"
12718                    "  int *j=2;\n"
12719                    " int big  =  10000;\n"
12720                    "\n"
12721                    "unsigned oneTwoThree  =123;\n"
12722                    "int oneTwo = 12;\n"
12723                    "  method();\n"
12724                    "float k= 2;\n"
12725                    "int ll=10000;\n"
12726                    "}",
12727                    Alignment));
12728   Alignment.AlignConsecutiveAssignments = false;
12729   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12730   verifyFormat("#define A \\\n"
12731                "  int       aaaa = 12; \\\n"
12732                "  float     b = 23; \\\n"
12733                "  const int ccc = 234; \\\n"
12734                "  unsigned  dddddddddd = 2345;",
12735                Alignment);
12736   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12737   verifyFormat("#define A              \\\n"
12738                "  int       aaaa = 12; \\\n"
12739                "  float     b = 23;    \\\n"
12740                "  const int ccc = 234; \\\n"
12741                "  unsigned  dddddddddd = 2345;",
12742                Alignment);
12743   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12744   Alignment.ColumnLimit = 30;
12745   verifyFormat("#define A                    \\\n"
12746                "  int       aaaa = 12;       \\\n"
12747                "  float     b = 23;          \\\n"
12748                "  const int ccc = 234;       \\\n"
12749                "  int       dddddddddd = 2345;",
12750                Alignment);
12751   Alignment.ColumnLimit = 80;
12752   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12753                "k = 4, int l = 5,\n"
12754                "                  int m = 6) {\n"
12755                "  const int j = 10;\n"
12756                "  otherThing = 1;\n"
12757                "}",
12758                Alignment);
12759   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12760                "  int const i = 1;\n"
12761                "  int *     j = 2;\n"
12762                "  int       big = 10000;\n"
12763                "}",
12764                Alignment);
12765   verifyFormat("class C {\n"
12766                "public:\n"
12767                "  int          i = 1;\n"
12768                "  virtual void f() = 0;\n"
12769                "};",
12770                Alignment);
12771   verifyFormat("float i = 1;\n"
12772                "if (SomeType t = getSomething()) {\n"
12773                "}\n"
12774                "const unsigned j = 2;\n"
12775                "int            big = 10000;",
12776                Alignment);
12777   verifyFormat("float j = 7;\n"
12778                "for (int k = 0; k < N; ++k) {\n"
12779                "}\n"
12780                "unsigned j = 2;\n"
12781                "int      big = 10000;\n"
12782                "}",
12783                Alignment);
12784   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12785   verifyFormat("float              i = 1;\n"
12786                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12787                "    = someLooooooooooooooooongFunction();\n"
12788                "int j = 2;",
12789                Alignment);
12790   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12791   verifyFormat("int                i = 1;\n"
12792                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12793                "    someLooooooooooooooooongFunction();\n"
12794                "int j = 2;",
12795                Alignment);
12796 
12797   Alignment.AlignConsecutiveAssignments = true;
12798   verifyFormat("auto lambda = []() {\n"
12799                "  auto  ii = 0;\n"
12800                "  float j  = 0;\n"
12801                "  return 0;\n"
12802                "};\n"
12803                "int   i  = 0;\n"
12804                "float i2 = 0;\n"
12805                "auto  v  = type{\n"
12806                "    i = 1,   //\n"
12807                "    (i = 2), //\n"
12808                "    i = 3    //\n"
12809                "};",
12810                Alignment);
12811   Alignment.AlignConsecutiveAssignments = false;
12812 
12813   verifyFormat(
12814       "int      i = 1;\n"
12815       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12816       "                          loooooooooooooooooooooongParameterB);\n"
12817       "int      j = 2;",
12818       Alignment);
12819 
12820   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
12821   // We expect declarations and assignments to align, as long as it doesn't
12822   // exceed the column limit, starting a new alignment sequence whenever it
12823   // happens.
12824   Alignment.AlignConsecutiveAssignments = true;
12825   Alignment.ColumnLimit = 30;
12826   verifyFormat("float    ii              = 1;\n"
12827                "unsigned j               = 2;\n"
12828                "int someVerylongVariable = 1;\n"
12829                "AnotherLongType  ll = 123456;\n"
12830                "VeryVeryLongType k  = 2;\n"
12831                "int              myvar = 1;",
12832                Alignment);
12833   Alignment.ColumnLimit = 80;
12834   Alignment.AlignConsecutiveAssignments = false;
12835 
12836   verifyFormat(
12837       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
12838       "          typename LongType, typename B>\n"
12839       "auto foo() {}\n",
12840       Alignment);
12841   verifyFormat("float a, b = 1;\n"
12842                "int   c = 2;\n"
12843                "int   dd = 3;\n",
12844                Alignment);
12845   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
12846                "float b[1][] = {{3.f}};\n",
12847                Alignment);
12848   Alignment.AlignConsecutiveAssignments = true;
12849   verifyFormat("float a, b = 1;\n"
12850                "int   c  = 2;\n"
12851                "int   dd = 3;\n",
12852                Alignment);
12853   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
12854                "float b[1][] = {{3.f}};\n",
12855                Alignment);
12856   Alignment.AlignConsecutiveAssignments = false;
12857 
12858   Alignment.ColumnLimit = 30;
12859   Alignment.BinPackParameters = false;
12860   verifyFormat("void foo(float     a,\n"
12861                "         float     b,\n"
12862                "         int       c,\n"
12863                "         uint32_t *d) {\n"
12864                "  int *  e = 0;\n"
12865                "  float  f = 0;\n"
12866                "  double g = 0;\n"
12867                "}\n"
12868                "void bar(ino_t     a,\n"
12869                "         int       b,\n"
12870                "         uint32_t *c,\n"
12871                "         bool      d) {}\n",
12872                Alignment);
12873   Alignment.BinPackParameters = true;
12874   Alignment.ColumnLimit = 80;
12875 
12876   // Bug 33507
12877   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
12878   verifyFormat(
12879       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
12880       "  static const Version verVs2017;\n"
12881       "  return true;\n"
12882       "});\n",
12883       Alignment);
12884   Alignment.PointerAlignment = FormatStyle::PAS_Right;
12885 
12886   // See llvm.org/PR35641
12887   Alignment.AlignConsecutiveDeclarations = true;
12888   verifyFormat("int func() { //\n"
12889                "  int      b;\n"
12890                "  unsigned c;\n"
12891                "}",
12892                Alignment);
12893 
12894   // See PR37175
12895   FormatStyle Style = getMozillaStyle();
12896   Style.AlignConsecutiveDeclarations = true;
12897   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
12898             "foo(int a);",
12899             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
12900 }
12901 
12902 TEST_F(FormatTest, LinuxBraceBreaking) {
12903   FormatStyle LinuxBraceStyle = getLLVMStyle();
12904   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
12905   verifyFormat("namespace a\n"
12906                "{\n"
12907                "class A\n"
12908                "{\n"
12909                "  void f()\n"
12910                "  {\n"
12911                "    if (true) {\n"
12912                "      a();\n"
12913                "      b();\n"
12914                "    } else {\n"
12915                "      a();\n"
12916                "    }\n"
12917                "  }\n"
12918                "  void g() { return; }\n"
12919                "};\n"
12920                "struct B {\n"
12921                "  int x;\n"
12922                "};\n"
12923                "} // namespace a\n",
12924                LinuxBraceStyle);
12925   verifyFormat("enum X {\n"
12926                "  Y = 0,\n"
12927                "}\n",
12928                LinuxBraceStyle);
12929   verifyFormat("struct S {\n"
12930                "  int Type;\n"
12931                "  union {\n"
12932                "    int x;\n"
12933                "    double y;\n"
12934                "  } Value;\n"
12935                "  class C\n"
12936                "  {\n"
12937                "    MyFavoriteType Value;\n"
12938                "  } Class;\n"
12939                "}\n",
12940                LinuxBraceStyle);
12941 }
12942 
12943 TEST_F(FormatTest, MozillaBraceBreaking) {
12944   FormatStyle MozillaBraceStyle = getLLVMStyle();
12945   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
12946   MozillaBraceStyle.FixNamespaceComments = false;
12947   verifyFormat("namespace a {\n"
12948                "class A\n"
12949                "{\n"
12950                "  void f()\n"
12951                "  {\n"
12952                "    if (true) {\n"
12953                "      a();\n"
12954                "      b();\n"
12955                "    }\n"
12956                "  }\n"
12957                "  void g() { return; }\n"
12958                "};\n"
12959                "enum E\n"
12960                "{\n"
12961                "  A,\n"
12962                "  // foo\n"
12963                "  B,\n"
12964                "  C\n"
12965                "};\n"
12966                "struct B\n"
12967                "{\n"
12968                "  int x;\n"
12969                "};\n"
12970                "}\n",
12971                MozillaBraceStyle);
12972   verifyFormat("struct S\n"
12973                "{\n"
12974                "  int Type;\n"
12975                "  union\n"
12976                "  {\n"
12977                "    int x;\n"
12978                "    double y;\n"
12979                "  } Value;\n"
12980                "  class C\n"
12981                "  {\n"
12982                "    MyFavoriteType Value;\n"
12983                "  } Class;\n"
12984                "}\n",
12985                MozillaBraceStyle);
12986 }
12987 
12988 TEST_F(FormatTest, StroustrupBraceBreaking) {
12989   FormatStyle StroustrupBraceStyle = getLLVMStyle();
12990   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
12991   verifyFormat("namespace a {\n"
12992                "class A {\n"
12993                "  void f()\n"
12994                "  {\n"
12995                "    if (true) {\n"
12996                "      a();\n"
12997                "      b();\n"
12998                "    }\n"
12999                "  }\n"
13000                "  void g() { return; }\n"
13001                "};\n"
13002                "struct B {\n"
13003                "  int x;\n"
13004                "};\n"
13005                "} // namespace a\n",
13006                StroustrupBraceStyle);
13007 
13008   verifyFormat("void foo()\n"
13009                "{\n"
13010                "  if (a) {\n"
13011                "    a();\n"
13012                "  }\n"
13013                "  else {\n"
13014                "    b();\n"
13015                "  }\n"
13016                "}\n",
13017                StroustrupBraceStyle);
13018 
13019   verifyFormat("#ifdef _DEBUG\n"
13020                "int foo(int i = 0)\n"
13021                "#else\n"
13022                "int foo(int i = 5)\n"
13023                "#endif\n"
13024                "{\n"
13025                "  return i;\n"
13026                "}",
13027                StroustrupBraceStyle);
13028 
13029   verifyFormat("void foo() {}\n"
13030                "void bar()\n"
13031                "#ifdef _DEBUG\n"
13032                "{\n"
13033                "  foo();\n"
13034                "}\n"
13035                "#else\n"
13036                "{\n"
13037                "}\n"
13038                "#endif",
13039                StroustrupBraceStyle);
13040 
13041   verifyFormat("void foobar() { int i = 5; }\n"
13042                "#ifdef _DEBUG\n"
13043                "void bar() {}\n"
13044                "#else\n"
13045                "void bar() { foobar(); }\n"
13046                "#endif",
13047                StroustrupBraceStyle);
13048 }
13049 
13050 TEST_F(FormatTest, AllmanBraceBreaking) {
13051   FormatStyle AllmanBraceStyle = getLLVMStyle();
13052   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
13053 
13054   EXPECT_EQ("namespace a\n"
13055             "{\n"
13056             "void f();\n"
13057             "void g();\n"
13058             "} // namespace a\n",
13059             format("namespace a\n"
13060                    "{\n"
13061                    "void f();\n"
13062                    "void g();\n"
13063                    "}\n",
13064                    AllmanBraceStyle));
13065 
13066   verifyFormat("namespace a\n"
13067                "{\n"
13068                "class A\n"
13069                "{\n"
13070                "  void f()\n"
13071                "  {\n"
13072                "    if (true)\n"
13073                "    {\n"
13074                "      a();\n"
13075                "      b();\n"
13076                "    }\n"
13077                "  }\n"
13078                "  void g() { return; }\n"
13079                "};\n"
13080                "struct B\n"
13081                "{\n"
13082                "  int x;\n"
13083                "};\n"
13084                "union C\n"
13085                "{\n"
13086                "};\n"
13087                "} // namespace a",
13088                AllmanBraceStyle);
13089 
13090   verifyFormat("void f()\n"
13091                "{\n"
13092                "  if (true)\n"
13093                "  {\n"
13094                "    a();\n"
13095                "  }\n"
13096                "  else if (false)\n"
13097                "  {\n"
13098                "    b();\n"
13099                "  }\n"
13100                "  else\n"
13101                "  {\n"
13102                "    c();\n"
13103                "  }\n"
13104                "}\n",
13105                AllmanBraceStyle);
13106 
13107   verifyFormat("void f()\n"
13108                "{\n"
13109                "  for (int i = 0; i < 10; ++i)\n"
13110                "  {\n"
13111                "    a();\n"
13112                "  }\n"
13113                "  while (false)\n"
13114                "  {\n"
13115                "    b();\n"
13116                "  }\n"
13117                "  do\n"
13118                "  {\n"
13119                "    c();\n"
13120                "  } while (false)\n"
13121                "}\n",
13122                AllmanBraceStyle);
13123 
13124   verifyFormat("void f(int a)\n"
13125                "{\n"
13126                "  switch (a)\n"
13127                "  {\n"
13128                "  case 0:\n"
13129                "    break;\n"
13130                "  case 1:\n"
13131                "  {\n"
13132                "    break;\n"
13133                "  }\n"
13134                "  case 2:\n"
13135                "  {\n"
13136                "  }\n"
13137                "  break;\n"
13138                "  default:\n"
13139                "    break;\n"
13140                "  }\n"
13141                "}\n",
13142                AllmanBraceStyle);
13143 
13144   verifyFormat("enum X\n"
13145                "{\n"
13146                "  Y = 0,\n"
13147                "}\n",
13148                AllmanBraceStyle);
13149   verifyFormat("enum X\n"
13150                "{\n"
13151                "  Y = 0\n"
13152                "}\n",
13153                AllmanBraceStyle);
13154 
13155   verifyFormat("@interface BSApplicationController ()\n"
13156                "{\n"
13157                "@private\n"
13158                "  id _extraIvar;\n"
13159                "}\n"
13160                "@end\n",
13161                AllmanBraceStyle);
13162 
13163   verifyFormat("#ifdef _DEBUG\n"
13164                "int foo(int i = 0)\n"
13165                "#else\n"
13166                "int foo(int i = 5)\n"
13167                "#endif\n"
13168                "{\n"
13169                "  return i;\n"
13170                "}",
13171                AllmanBraceStyle);
13172 
13173   verifyFormat("void foo() {}\n"
13174                "void bar()\n"
13175                "#ifdef _DEBUG\n"
13176                "{\n"
13177                "  foo();\n"
13178                "}\n"
13179                "#else\n"
13180                "{\n"
13181                "}\n"
13182                "#endif",
13183                AllmanBraceStyle);
13184 
13185   verifyFormat("void foobar() { int i = 5; }\n"
13186                "#ifdef _DEBUG\n"
13187                "void bar() {}\n"
13188                "#else\n"
13189                "void bar() { foobar(); }\n"
13190                "#endif",
13191                AllmanBraceStyle);
13192 
13193   // This shouldn't affect ObjC blocks..
13194   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13195                "  // ...\n"
13196                "  int i;\n"
13197                "}];",
13198                AllmanBraceStyle);
13199   verifyFormat("void (^block)(void) = ^{\n"
13200                "  // ...\n"
13201                "  int i;\n"
13202                "};",
13203                AllmanBraceStyle);
13204   // .. or dict literals.
13205   verifyFormat("void f()\n"
13206                "{\n"
13207                "  // ...\n"
13208                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13209                "}",
13210                AllmanBraceStyle);
13211   verifyFormat("void f()\n"
13212                "{\n"
13213                "  // ...\n"
13214                "  [object someMethod:@{a : @\"b\"}];\n"
13215                "}",
13216                AllmanBraceStyle);
13217   verifyFormat("int f()\n"
13218                "{ // comment\n"
13219                "  return 42;\n"
13220                "}",
13221                AllmanBraceStyle);
13222 
13223   AllmanBraceStyle.ColumnLimit = 19;
13224   verifyFormat("void f() { int i; }", AllmanBraceStyle);
13225   AllmanBraceStyle.ColumnLimit = 18;
13226   verifyFormat("void f()\n"
13227                "{\n"
13228                "  int i;\n"
13229                "}",
13230                AllmanBraceStyle);
13231   AllmanBraceStyle.ColumnLimit = 80;
13232 
13233   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
13234   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13235       FormatStyle::SIS_WithoutElse;
13236   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13237   verifyFormat("void f(bool b)\n"
13238                "{\n"
13239                "  if (b)\n"
13240                "  {\n"
13241                "    return;\n"
13242                "  }\n"
13243                "}\n",
13244                BreakBeforeBraceShortIfs);
13245   verifyFormat("void f(bool b)\n"
13246                "{\n"
13247                "  if constexpr (b)\n"
13248                "  {\n"
13249                "    return;\n"
13250                "  }\n"
13251                "}\n",
13252                BreakBeforeBraceShortIfs);
13253   verifyFormat("void f(bool b)\n"
13254                "{\n"
13255                "  if CONSTEXPR (b)\n"
13256                "  {\n"
13257                "    return;\n"
13258                "  }\n"
13259                "}\n",
13260                BreakBeforeBraceShortIfs);
13261   verifyFormat("void f(bool b)\n"
13262                "{\n"
13263                "  if (b) return;\n"
13264                "}\n",
13265                BreakBeforeBraceShortIfs);
13266   verifyFormat("void f(bool b)\n"
13267                "{\n"
13268                "  if constexpr (b) return;\n"
13269                "}\n",
13270                BreakBeforeBraceShortIfs);
13271   verifyFormat("void f(bool b)\n"
13272                "{\n"
13273                "  if CONSTEXPR (b) return;\n"
13274                "}\n",
13275                BreakBeforeBraceShortIfs);
13276   verifyFormat("void f(bool b)\n"
13277                "{\n"
13278                "  while (b)\n"
13279                "  {\n"
13280                "    return;\n"
13281                "  }\n"
13282                "}\n",
13283                BreakBeforeBraceShortIfs);
13284 }
13285 
13286 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
13287   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
13288   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
13289 
13290   // Make a few changes to the style for testing purposes
13291   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
13292       FormatStyle::SFS_Empty;
13293   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
13294   WhitesmithsBraceStyle.ColumnLimit = 0;
13295 
13296   // FIXME: this test case can't decide whether there should be a blank line
13297   // after the ~D() line or not. It adds one if one doesn't exist in the test
13298   // and it removes the line if one exists.
13299   /*
13300   verifyFormat("class A;\n"
13301                "namespace B\n"
13302                "  {\n"
13303                "class C;\n"
13304                "// Comment\n"
13305                "class D\n"
13306                "  {\n"
13307                "public:\n"
13308                "  D();\n"
13309                "  ~D() {}\n"
13310                "private:\n"
13311                "  enum E\n"
13312                "    {\n"
13313                "    F\n"
13314                "    }\n"
13315                "  };\n"
13316                "  } // namespace B\n",
13317                WhitesmithsBraceStyle);
13318   */
13319 
13320   verifyFormat("namespace a\n"
13321                "  {\n"
13322                "class A\n"
13323                "  {\n"
13324                "  void f()\n"
13325                "    {\n"
13326                "    if (true)\n"
13327                "      {\n"
13328                "      a();\n"
13329                "      b();\n"
13330                "      }\n"
13331                "    }\n"
13332                "  void g()\n"
13333                "    {\n"
13334                "    return;\n"
13335                "    }\n"
13336                "  };\n"
13337                "struct B\n"
13338                "  {\n"
13339                "  int x;\n"
13340                "  };\n"
13341                "  } // namespace a",
13342                WhitesmithsBraceStyle);
13343 
13344   verifyFormat("void f()\n"
13345                "  {\n"
13346                "  if (true)\n"
13347                "    {\n"
13348                "    a();\n"
13349                "    }\n"
13350                "  else if (false)\n"
13351                "    {\n"
13352                "    b();\n"
13353                "    }\n"
13354                "  else\n"
13355                "    {\n"
13356                "    c();\n"
13357                "    }\n"
13358                "  }\n",
13359                WhitesmithsBraceStyle);
13360 
13361   verifyFormat("void f()\n"
13362                "  {\n"
13363                "  for (int i = 0; i < 10; ++i)\n"
13364                "    {\n"
13365                "    a();\n"
13366                "    }\n"
13367                "  while (false)\n"
13368                "    {\n"
13369                "    b();\n"
13370                "    }\n"
13371                "  do\n"
13372                "    {\n"
13373                "    c();\n"
13374                "    } while (false)\n"
13375                "  }\n",
13376                WhitesmithsBraceStyle);
13377 
13378   WhitesmithsBraceStyle.IndentCaseBlocks = true;
13379   verifyFormat("void switchTest1(int a)\n"
13380                "  {\n"
13381                "  switch (a)\n"
13382                "    {\n"
13383                "    case 2:\n"
13384                "      {\n"
13385                "      }\n"
13386                "    break;\n"
13387                "    }\n"
13388                "  }\n",
13389                WhitesmithsBraceStyle);
13390 
13391   verifyFormat("void switchTest2(int a)\n"
13392                "  {\n"
13393                "  switch (a)\n"
13394                "    {\n"
13395                "    case 0:\n"
13396                "    break;\n"
13397                "    case 1:\n"
13398                "      {\n"
13399                "      break;\n"
13400                "      }\n"
13401                "    case 2:\n"
13402                "      {\n"
13403                "      }\n"
13404                "    break;\n"
13405                "    default:\n"
13406                "    break;\n"
13407                "    }\n"
13408                "  }\n",
13409                WhitesmithsBraceStyle);
13410 
13411   verifyFormat("void switchTest3(int a)\n"
13412                "  {\n"
13413                "  switch (a)\n"
13414                "    {\n"
13415                "    case 0:\n"
13416                "      {\n"
13417                "      foo(x);\n"
13418                "      }\n"
13419                "    break;\n"
13420                "    default:\n"
13421                "      {\n"
13422                "      foo(1);\n"
13423                "      }\n"
13424                "    break;\n"
13425                "    }\n"
13426                "  }\n",
13427                WhitesmithsBraceStyle);
13428 
13429   WhitesmithsBraceStyle.IndentCaseBlocks = false;
13430 
13431   verifyFormat("void switchTest4(int a)\n"
13432                "  {\n"
13433                "  switch (a)\n"
13434                "    {\n"
13435                "    case 2:\n"
13436                "    {\n"
13437                "    }\n"
13438                "    break;\n"
13439                "    }\n"
13440                "  }\n",
13441                WhitesmithsBraceStyle);
13442 
13443   verifyFormat("void switchTest5(int a)\n"
13444                "  {\n"
13445                "  switch (a)\n"
13446                "    {\n"
13447                "    case 0:\n"
13448                "    break;\n"
13449                "    case 1:\n"
13450                "    {\n"
13451                "    foo();\n"
13452                "    break;\n"
13453                "    }\n"
13454                "    case 2:\n"
13455                "    {\n"
13456                "    }\n"
13457                "    break;\n"
13458                "    default:\n"
13459                "    break;\n"
13460                "    }\n"
13461                "  }\n",
13462                WhitesmithsBraceStyle);
13463 
13464   verifyFormat("void switchTest6(int a)\n"
13465                "  {\n"
13466                "  switch (a)\n"
13467                "    {\n"
13468                "    case 0:\n"
13469                "    {\n"
13470                "    foo(x);\n"
13471                "    }\n"
13472                "    break;\n"
13473                "    default:\n"
13474                "    {\n"
13475                "    foo(1);\n"
13476                "    }\n"
13477                "    break;\n"
13478                "    }\n"
13479                "  }\n",
13480                WhitesmithsBraceStyle);
13481 
13482   verifyFormat("enum X\n"
13483                "  {\n"
13484                "  Y = 0, // testing\n"
13485                "  }\n",
13486                WhitesmithsBraceStyle);
13487 
13488   verifyFormat("enum X\n"
13489                "  {\n"
13490                "  Y = 0\n"
13491                "  }\n",
13492                WhitesmithsBraceStyle);
13493   verifyFormat("enum X\n"
13494                "  {\n"
13495                "  Y = 0,\n"
13496                "  Z = 1\n"
13497                "  };\n",
13498                WhitesmithsBraceStyle);
13499 
13500   verifyFormat("@interface BSApplicationController ()\n"
13501                "  {\n"
13502                "@private\n"
13503                "  id _extraIvar;\n"
13504                "  }\n"
13505                "@end\n",
13506                WhitesmithsBraceStyle);
13507 
13508   verifyFormat("#ifdef _DEBUG\n"
13509                "int foo(int i = 0)\n"
13510                "#else\n"
13511                "int foo(int i = 5)\n"
13512                "#endif\n"
13513                "  {\n"
13514                "  return i;\n"
13515                "  }",
13516                WhitesmithsBraceStyle);
13517 
13518   verifyFormat("void foo() {}\n"
13519                "void bar()\n"
13520                "#ifdef _DEBUG\n"
13521                "  {\n"
13522                "  foo();\n"
13523                "  }\n"
13524                "#else\n"
13525                "  {\n"
13526                "  }\n"
13527                "#endif",
13528                WhitesmithsBraceStyle);
13529 
13530   verifyFormat("void foobar()\n"
13531                "  {\n"
13532                "  int i = 5;\n"
13533                "  }\n"
13534                "#ifdef _DEBUG\n"
13535                "void bar()\n"
13536                "  {\n"
13537                "  }\n"
13538                "#else\n"
13539                "void bar()\n"
13540                "  {\n"
13541                "  foobar();\n"
13542                "  }\n"
13543                "#endif",
13544                WhitesmithsBraceStyle);
13545 
13546   // This shouldn't affect ObjC blocks..
13547   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13548                "  // ...\n"
13549                "  int i;\n"
13550                "}];",
13551                WhitesmithsBraceStyle);
13552   verifyFormat("void (^block)(void) = ^{\n"
13553                "  // ...\n"
13554                "  int i;\n"
13555                "};",
13556                WhitesmithsBraceStyle);
13557   // .. or dict literals.
13558   verifyFormat("void f()\n"
13559                "  {\n"
13560                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13561                "  }",
13562                WhitesmithsBraceStyle);
13563 
13564   verifyFormat("int f()\n"
13565                "  { // comment\n"
13566                "  return 42;\n"
13567                "  }",
13568                WhitesmithsBraceStyle);
13569 
13570   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13571   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13572       FormatStyle::SIS_Always;
13573   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13574   verifyFormat("void f(bool b)\n"
13575                "  {\n"
13576                "  if (b)\n"
13577                "    {\n"
13578                "    return;\n"
13579                "    }\n"
13580                "  }\n",
13581                BreakBeforeBraceShortIfs);
13582   verifyFormat("void f(bool b)\n"
13583                "  {\n"
13584                "  if (b) return;\n"
13585                "  }\n",
13586                BreakBeforeBraceShortIfs);
13587   verifyFormat("void f(bool b)\n"
13588                "  {\n"
13589                "  while (b)\n"
13590                "    {\n"
13591                "    return;\n"
13592                "    }\n"
13593                "  }\n",
13594                BreakBeforeBraceShortIfs);
13595 }
13596 
13597 TEST_F(FormatTest, GNUBraceBreaking) {
13598   FormatStyle GNUBraceStyle = getLLVMStyle();
13599   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13600   verifyFormat("namespace a\n"
13601                "{\n"
13602                "class A\n"
13603                "{\n"
13604                "  void f()\n"
13605                "  {\n"
13606                "    int a;\n"
13607                "    {\n"
13608                "      int b;\n"
13609                "    }\n"
13610                "    if (true)\n"
13611                "      {\n"
13612                "        a();\n"
13613                "        b();\n"
13614                "      }\n"
13615                "  }\n"
13616                "  void g() { return; }\n"
13617                "}\n"
13618                "} // namespace a",
13619                GNUBraceStyle);
13620 
13621   verifyFormat("void f()\n"
13622                "{\n"
13623                "  if (true)\n"
13624                "    {\n"
13625                "      a();\n"
13626                "    }\n"
13627                "  else if (false)\n"
13628                "    {\n"
13629                "      b();\n"
13630                "    }\n"
13631                "  else\n"
13632                "    {\n"
13633                "      c();\n"
13634                "    }\n"
13635                "}\n",
13636                GNUBraceStyle);
13637 
13638   verifyFormat("void f()\n"
13639                "{\n"
13640                "  for (int i = 0; i < 10; ++i)\n"
13641                "    {\n"
13642                "      a();\n"
13643                "    }\n"
13644                "  while (false)\n"
13645                "    {\n"
13646                "      b();\n"
13647                "    }\n"
13648                "  do\n"
13649                "    {\n"
13650                "      c();\n"
13651                "    }\n"
13652                "  while (false);\n"
13653                "}\n",
13654                GNUBraceStyle);
13655 
13656   verifyFormat("void f(int a)\n"
13657                "{\n"
13658                "  switch (a)\n"
13659                "    {\n"
13660                "    case 0:\n"
13661                "      break;\n"
13662                "    case 1:\n"
13663                "      {\n"
13664                "        break;\n"
13665                "      }\n"
13666                "    case 2:\n"
13667                "      {\n"
13668                "      }\n"
13669                "      break;\n"
13670                "    default:\n"
13671                "      break;\n"
13672                "    }\n"
13673                "}\n",
13674                GNUBraceStyle);
13675 
13676   verifyFormat("enum X\n"
13677                "{\n"
13678                "  Y = 0,\n"
13679                "}\n",
13680                GNUBraceStyle);
13681 
13682   verifyFormat("@interface BSApplicationController ()\n"
13683                "{\n"
13684                "@private\n"
13685                "  id _extraIvar;\n"
13686                "}\n"
13687                "@end\n",
13688                GNUBraceStyle);
13689 
13690   verifyFormat("#ifdef _DEBUG\n"
13691                "int foo(int i = 0)\n"
13692                "#else\n"
13693                "int foo(int i = 5)\n"
13694                "#endif\n"
13695                "{\n"
13696                "  return i;\n"
13697                "}",
13698                GNUBraceStyle);
13699 
13700   verifyFormat("void foo() {}\n"
13701                "void bar()\n"
13702                "#ifdef _DEBUG\n"
13703                "{\n"
13704                "  foo();\n"
13705                "}\n"
13706                "#else\n"
13707                "{\n"
13708                "}\n"
13709                "#endif",
13710                GNUBraceStyle);
13711 
13712   verifyFormat("void foobar() { int i = 5; }\n"
13713                "#ifdef _DEBUG\n"
13714                "void bar() {}\n"
13715                "#else\n"
13716                "void bar() { foobar(); }\n"
13717                "#endif",
13718                GNUBraceStyle);
13719 }
13720 
13721 TEST_F(FormatTest, WebKitBraceBreaking) {
13722   FormatStyle WebKitBraceStyle = getLLVMStyle();
13723   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
13724   WebKitBraceStyle.FixNamespaceComments = false;
13725   verifyFormat("namespace a {\n"
13726                "class A {\n"
13727                "  void f()\n"
13728                "  {\n"
13729                "    if (true) {\n"
13730                "      a();\n"
13731                "      b();\n"
13732                "    }\n"
13733                "  }\n"
13734                "  void g() { return; }\n"
13735                "};\n"
13736                "enum E {\n"
13737                "  A,\n"
13738                "  // foo\n"
13739                "  B,\n"
13740                "  C\n"
13741                "};\n"
13742                "struct B {\n"
13743                "  int x;\n"
13744                "};\n"
13745                "}\n",
13746                WebKitBraceStyle);
13747   verifyFormat("struct S {\n"
13748                "  int Type;\n"
13749                "  union {\n"
13750                "    int x;\n"
13751                "    double y;\n"
13752                "  } Value;\n"
13753                "  class C {\n"
13754                "    MyFavoriteType Value;\n"
13755                "  } Class;\n"
13756                "};\n",
13757                WebKitBraceStyle);
13758 }
13759 
13760 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
13761   verifyFormat("void f() {\n"
13762                "  try {\n"
13763                "  } catch (const Exception &e) {\n"
13764                "  }\n"
13765                "}\n",
13766                getLLVMStyle());
13767 }
13768 
13769 TEST_F(FormatTest, UnderstandsPragmas) {
13770   verifyFormat("#pragma omp reduction(| : var)");
13771   verifyFormat("#pragma omp reduction(+ : var)");
13772 
13773   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
13774             "(including parentheses).",
13775             format("#pragma    mark   Any non-hyphenated or hyphenated string "
13776                    "(including parentheses)."));
13777 }
13778 
13779 TEST_F(FormatTest, UnderstandPragmaOption) {
13780   verifyFormat("#pragma option -C -A");
13781 
13782   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
13783 }
13784 
13785 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
13786   FormatStyle Style = getLLVMStyle();
13787   Style.ColumnLimit = 20;
13788 
13789   // See PR41213
13790   EXPECT_EQ("/*\n"
13791             " *\t9012345\n"
13792             " * /8901\n"
13793             " */",
13794             format("/*\n"
13795                    " *\t9012345 /8901\n"
13796                    " */",
13797                    Style));
13798   EXPECT_EQ("/*\n"
13799             " *345678\n"
13800             " *\t/8901\n"
13801             " */",
13802             format("/*\n"
13803                    " *345678\t/8901\n"
13804                    " */",
13805                    Style));
13806 
13807   verifyFormat("int a; // the\n"
13808                "       // comment",
13809                Style);
13810   EXPECT_EQ("int a; /* first line\n"
13811             "        * second\n"
13812             "        * line third\n"
13813             "        * line\n"
13814             "        */",
13815             format("int a; /* first line\n"
13816                    "        * second\n"
13817                    "        * line third\n"
13818                    "        * line\n"
13819                    "        */",
13820                    Style));
13821   EXPECT_EQ("int a; // first line\n"
13822             "       // second\n"
13823             "       // line third\n"
13824             "       // line",
13825             format("int a; // first line\n"
13826                    "       // second line\n"
13827                    "       // third line",
13828                    Style));
13829 
13830   Style.PenaltyExcessCharacter = 90;
13831   verifyFormat("int a; // the comment", Style);
13832   EXPECT_EQ("int a; // the comment\n"
13833             "       // aaa",
13834             format("int a; // the comment aaa", Style));
13835   EXPECT_EQ("int a; /* first line\n"
13836             "        * second line\n"
13837             "        * third line\n"
13838             "        */",
13839             format("int a; /* first line\n"
13840                    "        * second line\n"
13841                    "        * third line\n"
13842                    "        */",
13843                    Style));
13844   EXPECT_EQ("int a; // first line\n"
13845             "       // second line\n"
13846             "       // third line",
13847             format("int a; // first line\n"
13848                    "       // second line\n"
13849                    "       // third line",
13850                    Style));
13851   // FIXME: Investigate why this is not getting the same layout as the test
13852   // above.
13853   EXPECT_EQ("int a; /* first line\n"
13854             "        * second line\n"
13855             "        * third line\n"
13856             "        */",
13857             format("int a; /* first line second line third line"
13858                    "\n*/",
13859                    Style));
13860 
13861   EXPECT_EQ("// foo bar baz bazfoo\n"
13862             "// foo bar foo bar\n",
13863             format("// foo bar baz bazfoo\n"
13864                    "// foo bar foo           bar\n",
13865                    Style));
13866   EXPECT_EQ("// foo bar baz bazfoo\n"
13867             "// foo bar foo bar\n",
13868             format("// foo bar baz      bazfoo\n"
13869                    "// foo            bar foo bar\n",
13870                    Style));
13871 
13872   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
13873   // next one.
13874   EXPECT_EQ("// foo bar baz bazfoo\n"
13875             "// bar foo bar\n",
13876             format("// foo bar baz      bazfoo bar\n"
13877                    "// foo            bar\n",
13878                    Style));
13879 
13880   EXPECT_EQ("// foo bar baz bazfoo\n"
13881             "// foo bar baz bazfoo\n"
13882             "// bar foo bar\n",
13883             format("// foo bar baz      bazfoo\n"
13884                    "// foo bar baz      bazfoo bar\n"
13885                    "// foo bar\n",
13886                    Style));
13887 
13888   EXPECT_EQ("// foo bar baz bazfoo\n"
13889             "// foo bar baz bazfoo\n"
13890             "// bar foo bar\n",
13891             format("// foo bar baz      bazfoo\n"
13892                    "// foo bar baz      bazfoo bar\n"
13893                    "// foo           bar\n",
13894                    Style));
13895 
13896   // Make sure we do not keep protruding characters if strict mode reflow is
13897   // cheaper than keeping protruding characters.
13898   Style.ColumnLimit = 21;
13899   EXPECT_EQ(
13900       "// foo foo foo foo\n"
13901       "// foo foo foo foo\n"
13902       "// foo foo foo foo\n",
13903       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
13904 
13905   EXPECT_EQ("int a = /* long block\n"
13906             "           comment */\n"
13907             "    42;",
13908             format("int a = /* long block comment */ 42;", Style));
13909 }
13910 
13911 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
13912   for (size_t i = 1; i < Styles.size(); ++i)                                   \
13913   EXPECT_EQ(Styles[0], Styles[i])                                              \
13914       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
13915 
13916 TEST_F(FormatTest, GetsPredefinedStyleByName) {
13917   SmallVector<FormatStyle, 3> Styles;
13918   Styles.resize(3);
13919 
13920   Styles[0] = getLLVMStyle();
13921   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
13922   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
13923   EXPECT_ALL_STYLES_EQUAL(Styles);
13924 
13925   Styles[0] = getGoogleStyle();
13926   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
13927   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
13928   EXPECT_ALL_STYLES_EQUAL(Styles);
13929 
13930   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13931   EXPECT_TRUE(
13932       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
13933   EXPECT_TRUE(
13934       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
13935   EXPECT_ALL_STYLES_EQUAL(Styles);
13936 
13937   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
13938   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
13939   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
13940   EXPECT_ALL_STYLES_EQUAL(Styles);
13941 
13942   Styles[0] = getMozillaStyle();
13943   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
13944   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
13945   EXPECT_ALL_STYLES_EQUAL(Styles);
13946 
13947   Styles[0] = getWebKitStyle();
13948   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
13949   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
13950   EXPECT_ALL_STYLES_EQUAL(Styles);
13951 
13952   Styles[0] = getGNUStyle();
13953   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
13954   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
13955   EXPECT_ALL_STYLES_EQUAL(Styles);
13956 
13957   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
13958 }
13959 
13960 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
13961   SmallVector<FormatStyle, 8> Styles;
13962   Styles.resize(2);
13963 
13964   Styles[0] = getGoogleStyle();
13965   Styles[1] = getLLVMStyle();
13966   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13967   EXPECT_ALL_STYLES_EQUAL(Styles);
13968 
13969   Styles.resize(5);
13970   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
13971   Styles[1] = getLLVMStyle();
13972   Styles[1].Language = FormatStyle::LK_JavaScript;
13973   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
13974 
13975   Styles[2] = getLLVMStyle();
13976   Styles[2].Language = FormatStyle::LK_JavaScript;
13977   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
13978                                   "BasedOnStyle: Google",
13979                                   &Styles[2])
13980                    .value());
13981 
13982   Styles[3] = getLLVMStyle();
13983   Styles[3].Language = FormatStyle::LK_JavaScript;
13984   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
13985                                   "Language: JavaScript",
13986                                   &Styles[3])
13987                    .value());
13988 
13989   Styles[4] = getLLVMStyle();
13990   Styles[4].Language = FormatStyle::LK_JavaScript;
13991   EXPECT_EQ(0, parseConfiguration("---\n"
13992                                   "BasedOnStyle: LLVM\n"
13993                                   "IndentWidth: 123\n"
13994                                   "---\n"
13995                                   "BasedOnStyle: Google\n"
13996                                   "Language: JavaScript",
13997                                   &Styles[4])
13998                    .value());
13999   EXPECT_ALL_STYLES_EQUAL(Styles);
14000 }
14001 
14002 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
14003   Style.FIELD = false;                                                         \
14004   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
14005   EXPECT_TRUE(Style.FIELD);                                                    \
14006   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
14007   EXPECT_FALSE(Style.FIELD);
14008 
14009 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
14010 
14011 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
14012   Style.STRUCT.FIELD = false;                                                  \
14013   EXPECT_EQ(0,                                                                 \
14014             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
14015                 .value());                                                     \
14016   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
14017   EXPECT_EQ(0,                                                                 \
14018             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
14019                 .value());                                                     \
14020   EXPECT_FALSE(Style.STRUCT.FIELD);
14021 
14022 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
14023   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
14024 
14025 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
14026   EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!";          \
14027   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
14028   EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
14029 
14030 TEST_F(FormatTest, ParsesConfigurationBools) {
14031   FormatStyle Style = {};
14032   Style.Language = FormatStyle::LK_Cpp;
14033   CHECK_PARSE_BOOL(AlignTrailingComments);
14034   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
14035   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
14036   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
14037   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
14038   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
14039   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
14040   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
14041   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
14042   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
14043   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
14044   CHECK_PARSE_BOOL(BinPackArguments);
14045   CHECK_PARSE_BOOL(BinPackParameters);
14046   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
14047   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
14048   CHECK_PARSE_BOOL(BreakStringLiterals);
14049   CHECK_PARSE_BOOL(CompactNamespaces);
14050   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
14051   CHECK_PARSE_BOOL(DeriveLineEnding);
14052   CHECK_PARSE_BOOL(DerivePointerAlignment);
14053   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
14054   CHECK_PARSE_BOOL(DisableFormat);
14055   CHECK_PARSE_BOOL(IndentCaseLabels);
14056   CHECK_PARSE_BOOL(IndentCaseBlocks);
14057   CHECK_PARSE_BOOL(IndentGotoLabels);
14058   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
14059   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
14060   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
14061   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
14062   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
14063   CHECK_PARSE_BOOL(ReflowComments);
14064   CHECK_PARSE_BOOL(SortIncludes);
14065   CHECK_PARSE_BOOL(SortUsingDeclarations);
14066   CHECK_PARSE_BOOL(SpacesInParentheses);
14067   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
14068   CHECK_PARSE_BOOL(SpacesInAngles);
14069   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
14070   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
14071   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
14072   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
14073   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
14074   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
14075   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
14076   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
14077   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
14078   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
14079   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
14080   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
14081   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
14082   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
14083   CHECK_PARSE_BOOL(UseCRLF);
14084 
14085   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
14086   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
14087   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
14088   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
14089   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
14090   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
14091   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
14092   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
14093   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
14094   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
14095   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
14096   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
14097   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
14098   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
14099   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
14100   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
14101   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
14102 }
14103 
14104 #undef CHECK_PARSE_BOOL
14105 
14106 TEST_F(FormatTest, ParsesConfiguration) {
14107   FormatStyle Style = {};
14108   Style.Language = FormatStyle::LK_Cpp;
14109   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
14110   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
14111               ConstructorInitializerIndentWidth, 1234u);
14112   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
14113   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
14114   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
14115   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
14116   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
14117               PenaltyBreakBeforeFirstCallParameter, 1234u);
14118   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
14119               PenaltyBreakTemplateDeclaration, 1234u);
14120   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
14121   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
14122               PenaltyReturnTypeOnItsOwnLine, 1234u);
14123   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
14124               SpacesBeforeTrailingComments, 1234u);
14125   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
14126   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
14127   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
14128 
14129   Style.PointerAlignment = FormatStyle::PAS_Middle;
14130   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
14131               FormatStyle::PAS_Left);
14132   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
14133               FormatStyle::PAS_Right);
14134   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
14135               FormatStyle::PAS_Middle);
14136   // For backward compatibility:
14137   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
14138               FormatStyle::PAS_Left);
14139   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
14140               FormatStyle::PAS_Right);
14141   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
14142               FormatStyle::PAS_Middle);
14143 
14144   Style.Standard = FormatStyle::LS_Auto;
14145   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
14146   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
14147   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
14148   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
14149   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
14150   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
14151   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
14152   // Legacy aliases:
14153   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
14154   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
14155   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
14156   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
14157 
14158   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
14159   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
14160               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
14161   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
14162               FormatStyle::BOS_None);
14163   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
14164               FormatStyle::BOS_All);
14165   // For backward compatibility:
14166   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
14167               FormatStyle::BOS_None);
14168   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
14169               FormatStyle::BOS_All);
14170 
14171   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
14172   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
14173               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14174   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
14175               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
14176   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
14177               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
14178   // For backward compatibility:
14179   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
14180               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14181 
14182   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
14183   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
14184               FormatStyle::BILS_BeforeComma);
14185   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
14186               FormatStyle::BILS_AfterColon);
14187   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
14188               FormatStyle::BILS_BeforeColon);
14189   // For backward compatibility:
14190   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
14191               FormatStyle::BILS_BeforeComma);
14192 
14193   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14194   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
14195               FormatStyle::BAS_Align);
14196   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
14197               FormatStyle::BAS_DontAlign);
14198   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
14199               FormatStyle::BAS_AlwaysBreak);
14200   // For backward compatibility:
14201   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
14202               FormatStyle::BAS_DontAlign);
14203   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
14204               FormatStyle::BAS_Align);
14205 
14206   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
14207   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
14208               FormatStyle::ENAS_DontAlign);
14209   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
14210               FormatStyle::ENAS_Left);
14211   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
14212               FormatStyle::ENAS_Right);
14213   // For backward compatibility:
14214   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
14215               FormatStyle::ENAS_Left);
14216   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
14217               FormatStyle::ENAS_Right);
14218 
14219   Style.AlignOperands = FormatStyle::OAS_Align;
14220   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
14221               FormatStyle::OAS_DontAlign);
14222   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
14223   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
14224               FormatStyle::OAS_AlignAfterOperator);
14225   // For backward compatibility:
14226   CHECK_PARSE("AlignOperands: false", AlignOperands,
14227               FormatStyle::OAS_DontAlign);
14228   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
14229 
14230   Style.UseTab = FormatStyle::UT_ForIndentation;
14231   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
14232   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
14233   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
14234   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
14235               FormatStyle::UT_ForContinuationAndIndentation);
14236   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
14237               FormatStyle::UT_AlignWithSpaces);
14238   // For backward compatibility:
14239   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
14240   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
14241 
14242   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
14243   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
14244               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14245   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
14246               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
14247   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
14248               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14249   // For backward compatibility:
14250   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
14251               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14252   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
14253               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14254 
14255   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
14256   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
14257               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14258   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
14259               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
14260   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
14261               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
14262   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
14263               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14264   // For backward compatibility:
14265   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
14266               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14267   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
14268               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14269 
14270   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Both;
14271   CHECK_PARSE("SpaceAroundPointerQualifiers: Default",
14272               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Default);
14273   CHECK_PARSE("SpaceAroundPointerQualifiers: Before",
14274               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Before);
14275   CHECK_PARSE("SpaceAroundPointerQualifiers: After",
14276               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_After);
14277   CHECK_PARSE("SpaceAroundPointerQualifiers: Both",
14278               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Both);
14279 
14280   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
14281   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
14282               FormatStyle::SBPO_Never);
14283   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
14284               FormatStyle::SBPO_Always);
14285   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
14286               FormatStyle::SBPO_ControlStatements);
14287   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
14288               FormatStyle::SBPO_NonEmptyParentheses);
14289   // For backward compatibility:
14290   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
14291               FormatStyle::SBPO_Never);
14292   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
14293               FormatStyle::SBPO_ControlStatements);
14294 
14295   Style.ColumnLimit = 123;
14296   FormatStyle BaseStyle = getLLVMStyle();
14297   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
14298   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
14299 
14300   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
14301   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
14302               FormatStyle::BS_Attach);
14303   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
14304               FormatStyle::BS_Linux);
14305   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
14306               FormatStyle::BS_Mozilla);
14307   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
14308               FormatStyle::BS_Stroustrup);
14309   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
14310               FormatStyle::BS_Allman);
14311   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
14312               FormatStyle::BS_Whitesmiths);
14313   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
14314   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
14315               FormatStyle::BS_WebKit);
14316   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
14317               FormatStyle::BS_Custom);
14318 
14319   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
14320   CHECK_PARSE("BraceWrapping:\n"
14321               "  AfterControlStatement: MultiLine",
14322               BraceWrapping.AfterControlStatement,
14323               FormatStyle::BWACS_MultiLine);
14324   CHECK_PARSE("BraceWrapping:\n"
14325               "  AfterControlStatement: Always",
14326               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14327   CHECK_PARSE("BraceWrapping:\n"
14328               "  AfterControlStatement: Never",
14329               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14330   // For backward compatibility:
14331   CHECK_PARSE("BraceWrapping:\n"
14332               "  AfterControlStatement: true",
14333               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14334   CHECK_PARSE("BraceWrapping:\n"
14335               "  AfterControlStatement: false",
14336               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14337 
14338   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
14339   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
14340               FormatStyle::RTBS_None);
14341   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
14342               FormatStyle::RTBS_All);
14343   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
14344               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
14345   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
14346               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
14347   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
14348               AlwaysBreakAfterReturnType,
14349               FormatStyle::RTBS_TopLevelDefinitions);
14350 
14351   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
14352   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
14353               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
14354   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
14355               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14356   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
14357               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14358   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
14359               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14360   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
14361               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14362 
14363   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
14364   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
14365               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
14366   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
14367               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
14368   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
14369               AlwaysBreakAfterDefinitionReturnType,
14370               FormatStyle::DRTBS_TopLevel);
14371 
14372   Style.NamespaceIndentation = FormatStyle::NI_All;
14373   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
14374               FormatStyle::NI_None);
14375   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
14376               FormatStyle::NI_Inner);
14377   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
14378               FormatStyle::NI_All);
14379 
14380   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
14381   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
14382               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14383   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
14384               AllowShortIfStatementsOnASingleLine,
14385               FormatStyle::SIS_WithoutElse);
14386   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
14387               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
14388   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
14389               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14390   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
14391               AllowShortIfStatementsOnASingleLine,
14392               FormatStyle::SIS_WithoutElse);
14393 
14394   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
14395   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
14396               FormatStyle::IEBS_AfterExternBlock);
14397   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
14398               FormatStyle::IEBS_Indent);
14399   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
14400               FormatStyle::IEBS_NoIndent);
14401   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
14402               FormatStyle::IEBS_Indent);
14403   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
14404               FormatStyle::IEBS_NoIndent);
14405 
14406   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
14407   CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
14408               FormatStyle::BFCS_Both);
14409   CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
14410               FormatStyle::BFCS_None);
14411   CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
14412               FormatStyle::BFCS_Before);
14413   CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
14414               FormatStyle::BFCS_After);
14415 
14416   Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
14417   CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
14418               FormatStyle::SJSIO_After);
14419   CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
14420               FormatStyle::SJSIO_Before);
14421 
14422   // FIXME: This is required because parsing a configuration simply overwrites
14423   // the first N elements of the list instead of resetting it.
14424   Style.ForEachMacros.clear();
14425   std::vector<std::string> BoostForeach;
14426   BoostForeach.push_back("BOOST_FOREACH");
14427   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
14428   std::vector<std::string> BoostAndQForeach;
14429   BoostAndQForeach.push_back("BOOST_FOREACH");
14430   BoostAndQForeach.push_back("Q_FOREACH");
14431   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
14432               BoostAndQForeach);
14433 
14434   Style.AttributeMacros.clear();
14435   CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
14436               std::vector<std::string>{"__capability"});
14437   CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
14438               std::vector<std::string>({"attr1", "attr2"}));
14439 
14440   Style.StatementMacros.clear();
14441   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
14442               std::vector<std::string>{"QUNUSED"});
14443   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
14444               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
14445 
14446   Style.NamespaceMacros.clear();
14447   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
14448               std::vector<std::string>{"TESTSUITE"});
14449   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
14450               std::vector<std::string>({"TESTSUITE", "SUITE"}));
14451 
14452   Style.WhitespaceSensitiveMacros.clear();
14453   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
14454               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14455   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
14456               WhitespaceSensitiveMacros,
14457               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14458   Style.WhitespaceSensitiveMacros.clear();
14459   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
14460               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14461   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
14462               WhitespaceSensitiveMacros,
14463               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14464 
14465   Style.IncludeStyle.IncludeCategories.clear();
14466   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
14467       {"abc/.*", 2, 0}, {".*", 1, 0}};
14468   CHECK_PARSE("IncludeCategories:\n"
14469               "  - Regex: abc/.*\n"
14470               "    Priority: 2\n"
14471               "  - Regex: .*\n"
14472               "    Priority: 1",
14473               IncludeStyle.IncludeCategories, ExpectedCategories);
14474   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
14475               "abc$");
14476   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
14477               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
14478 
14479   Style.RawStringFormats.clear();
14480   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
14481       {
14482           FormatStyle::LK_TextProto,
14483           {"pb", "proto"},
14484           {"PARSE_TEXT_PROTO"},
14485           /*CanonicalDelimiter=*/"",
14486           "llvm",
14487       },
14488       {
14489           FormatStyle::LK_Cpp,
14490           {"cc", "cpp"},
14491           {"C_CODEBLOCK", "CPPEVAL"},
14492           /*CanonicalDelimiter=*/"cc",
14493           /*BasedOnStyle=*/"",
14494       },
14495   };
14496 
14497   CHECK_PARSE("RawStringFormats:\n"
14498               "  - Language: TextProto\n"
14499               "    Delimiters:\n"
14500               "      - 'pb'\n"
14501               "      - 'proto'\n"
14502               "    EnclosingFunctions:\n"
14503               "      - 'PARSE_TEXT_PROTO'\n"
14504               "    BasedOnStyle: llvm\n"
14505               "  - Language: Cpp\n"
14506               "    Delimiters:\n"
14507               "      - 'cc'\n"
14508               "      - 'cpp'\n"
14509               "    EnclosingFunctions:\n"
14510               "      - 'C_CODEBLOCK'\n"
14511               "      - 'CPPEVAL'\n"
14512               "    CanonicalDelimiter: 'cc'",
14513               RawStringFormats, ExpectedRawStringFormats);
14514 }
14515 
14516 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
14517   FormatStyle Style = {};
14518   Style.Language = FormatStyle::LK_Cpp;
14519   CHECK_PARSE("Language: Cpp\n"
14520               "IndentWidth: 12",
14521               IndentWidth, 12u);
14522   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
14523                                "IndentWidth: 34",
14524                                &Style),
14525             ParseError::Unsuitable);
14526   FormatStyle BinPackedTCS = {};
14527   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
14528   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
14529                                "InsertTrailingCommas: Wrapped",
14530                                &BinPackedTCS),
14531             ParseError::BinPackTrailingCommaConflict);
14532   EXPECT_EQ(12u, Style.IndentWidth);
14533   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14534   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14535 
14536   Style.Language = FormatStyle::LK_JavaScript;
14537   CHECK_PARSE("Language: JavaScript\n"
14538               "IndentWidth: 12",
14539               IndentWidth, 12u);
14540   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14541   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14542                                "IndentWidth: 34",
14543                                &Style),
14544             ParseError::Unsuitable);
14545   EXPECT_EQ(23u, Style.IndentWidth);
14546   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14547   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14548 
14549   CHECK_PARSE("BasedOnStyle: LLVM\n"
14550               "IndentWidth: 67",
14551               IndentWidth, 67u);
14552 
14553   CHECK_PARSE("---\n"
14554               "Language: JavaScript\n"
14555               "IndentWidth: 12\n"
14556               "---\n"
14557               "Language: Cpp\n"
14558               "IndentWidth: 34\n"
14559               "...\n",
14560               IndentWidth, 12u);
14561 
14562   Style.Language = FormatStyle::LK_Cpp;
14563   CHECK_PARSE("---\n"
14564               "Language: JavaScript\n"
14565               "IndentWidth: 12\n"
14566               "---\n"
14567               "Language: Cpp\n"
14568               "IndentWidth: 34\n"
14569               "...\n",
14570               IndentWidth, 34u);
14571   CHECK_PARSE("---\n"
14572               "IndentWidth: 78\n"
14573               "---\n"
14574               "Language: JavaScript\n"
14575               "IndentWidth: 56\n"
14576               "...\n",
14577               IndentWidth, 78u);
14578 
14579   Style.ColumnLimit = 123;
14580   Style.IndentWidth = 234;
14581   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14582   Style.TabWidth = 345;
14583   EXPECT_FALSE(parseConfiguration("---\n"
14584                                   "IndentWidth: 456\n"
14585                                   "BreakBeforeBraces: Allman\n"
14586                                   "---\n"
14587                                   "Language: JavaScript\n"
14588                                   "IndentWidth: 111\n"
14589                                   "TabWidth: 111\n"
14590                                   "---\n"
14591                                   "Language: Cpp\n"
14592                                   "BreakBeforeBraces: Stroustrup\n"
14593                                   "TabWidth: 789\n"
14594                                   "...\n",
14595                                   &Style));
14596   EXPECT_EQ(123u, Style.ColumnLimit);
14597   EXPECT_EQ(456u, Style.IndentWidth);
14598   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14599   EXPECT_EQ(789u, Style.TabWidth);
14600 
14601   EXPECT_EQ(parseConfiguration("---\n"
14602                                "Language: JavaScript\n"
14603                                "IndentWidth: 56\n"
14604                                "---\n"
14605                                "IndentWidth: 78\n"
14606                                "...\n",
14607                                &Style),
14608             ParseError::Error);
14609   EXPECT_EQ(parseConfiguration("---\n"
14610                                "Language: JavaScript\n"
14611                                "IndentWidth: 56\n"
14612                                "---\n"
14613                                "Language: JavaScript\n"
14614                                "IndentWidth: 78\n"
14615                                "...\n",
14616                                &Style),
14617             ParseError::Error);
14618 
14619   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14620 }
14621 
14622 #undef CHECK_PARSE
14623 
14624 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14625   FormatStyle Style = {};
14626   Style.Language = FormatStyle::LK_JavaScript;
14627   Style.BreakBeforeTernaryOperators = true;
14628   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14629   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14630 
14631   Style.BreakBeforeTernaryOperators = true;
14632   EXPECT_EQ(0, parseConfiguration("---\n"
14633                                   "BasedOnStyle: Google\n"
14634                                   "---\n"
14635                                   "Language: JavaScript\n"
14636                                   "IndentWidth: 76\n"
14637                                   "...\n",
14638                                   &Style)
14639                    .value());
14640   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14641   EXPECT_EQ(76u, Style.IndentWidth);
14642   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14643 }
14644 
14645 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14646   FormatStyle Style = getLLVMStyle();
14647   std::string YAML = configurationAsText(Style);
14648   FormatStyle ParsedStyle = {};
14649   ParsedStyle.Language = FormatStyle::LK_Cpp;
14650   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
14651   EXPECT_EQ(Style, ParsedStyle);
14652 }
14653 
14654 TEST_F(FormatTest, WorksFor8bitEncodings) {
14655   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
14656             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
14657             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
14658             "\"\xef\xee\xf0\xf3...\"",
14659             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
14660                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
14661                    "\xef\xee\xf0\xf3...\"",
14662                    getLLVMStyleWithColumns(12)));
14663 }
14664 
14665 TEST_F(FormatTest, HandlesUTF8BOM) {
14666   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
14667   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
14668             format("\xef\xbb\xbf#include <iostream>"));
14669   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
14670             format("\xef\xbb\xbf\n#include <iostream>"));
14671 }
14672 
14673 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
14674 #if !defined(_MSC_VER)
14675 
14676 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
14677   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
14678                getLLVMStyleWithColumns(35));
14679   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
14680                getLLVMStyleWithColumns(31));
14681   verifyFormat("// Однажды в студёную зимнюю пору...",
14682                getLLVMStyleWithColumns(36));
14683   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
14684   verifyFormat("/* Однажды в студёную зимнюю пору... */",
14685                getLLVMStyleWithColumns(39));
14686   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
14687                getLLVMStyleWithColumns(35));
14688 }
14689 
14690 TEST_F(FormatTest, SplitsUTF8Strings) {
14691   // Non-printable characters' width is currently considered to be the length in
14692   // bytes in UTF8. The characters can be displayed in very different manner
14693   // (zero-width, single width with a substitution glyph, expanded to their code
14694   // (e.g. "<8d>"), so there's no single correct way to handle them.
14695   EXPECT_EQ("\"aaaaÄ\"\n"
14696             "\"\xc2\x8d\";",
14697             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14698   EXPECT_EQ("\"aaaaaaaÄ\"\n"
14699             "\"\xc2\x8d\";",
14700             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
14701   EXPECT_EQ("\"Однажды, в \"\n"
14702             "\"студёную \"\n"
14703             "\"зимнюю \"\n"
14704             "\"пору,\"",
14705             format("\"Однажды, в студёную зимнюю пору,\"",
14706                    getLLVMStyleWithColumns(13)));
14707   EXPECT_EQ(
14708       "\"一 二 三 \"\n"
14709       "\"四 五六 \"\n"
14710       "\"七 八 九 \"\n"
14711       "\"十\"",
14712       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
14713   EXPECT_EQ("\"一\t\"\n"
14714             "\"二 \t\"\n"
14715             "\"三 四 \"\n"
14716             "\"五\t\"\n"
14717             "\"六 \t\"\n"
14718             "\"七 \"\n"
14719             "\"八九十\tqq\"",
14720             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
14721                    getLLVMStyleWithColumns(11)));
14722 
14723   // UTF8 character in an escape sequence.
14724   EXPECT_EQ("\"aaaaaa\"\n"
14725             "\"\\\xC2\x8D\"",
14726             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
14727 }
14728 
14729 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
14730   EXPECT_EQ("const char *sssss =\n"
14731             "    \"一二三四五六七八\\\n"
14732             " 九 十\";",
14733             format("const char *sssss = \"一二三四五六七八\\\n"
14734                    " 九 十\";",
14735                    getLLVMStyleWithColumns(30)));
14736 }
14737 
14738 TEST_F(FormatTest, SplitsUTF8LineComments) {
14739   EXPECT_EQ("// aaaaÄ\xc2\x8d",
14740             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
14741   EXPECT_EQ("// Я из лесу\n"
14742             "// вышел; был\n"
14743             "// сильный\n"
14744             "// мороз.",
14745             format("// Я из лесу вышел; был сильный мороз.",
14746                    getLLVMStyleWithColumns(13)));
14747   EXPECT_EQ("// 一二三\n"
14748             "// 四五六七\n"
14749             "// 八  九\n"
14750             "// 十",
14751             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
14752 }
14753 
14754 TEST_F(FormatTest, SplitsUTF8BlockComments) {
14755   EXPECT_EQ("/* Гляжу,\n"
14756             " * поднимается\n"
14757             " * медленно в\n"
14758             " * гору\n"
14759             " * Лошадка,\n"
14760             " * везущая\n"
14761             " * хворосту\n"
14762             " * воз. */",
14763             format("/* Гляжу, поднимается медленно в гору\n"
14764                    " * Лошадка, везущая хворосту воз. */",
14765                    getLLVMStyleWithColumns(13)));
14766   EXPECT_EQ(
14767       "/* 一二三\n"
14768       " * 四五六七\n"
14769       " * 八  九\n"
14770       " * 十  */",
14771       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
14772   EXPECT_EQ("/* �������� ��������\n"
14773             " * ��������\n"
14774             " * ������-�� */",
14775             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
14776 }
14777 
14778 #endif // _MSC_VER
14779 
14780 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
14781   FormatStyle Style = getLLVMStyle();
14782 
14783   Style.ConstructorInitializerIndentWidth = 4;
14784   verifyFormat(
14785       "SomeClass::Constructor()\n"
14786       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14787       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14788       Style);
14789 
14790   Style.ConstructorInitializerIndentWidth = 2;
14791   verifyFormat(
14792       "SomeClass::Constructor()\n"
14793       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14794       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14795       Style);
14796 
14797   Style.ConstructorInitializerIndentWidth = 0;
14798   verifyFormat(
14799       "SomeClass::Constructor()\n"
14800       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
14801       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
14802       Style);
14803   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14804   verifyFormat(
14805       "SomeLongTemplateVariableName<\n"
14806       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
14807       Style);
14808   verifyFormat("bool smaller = 1 < "
14809                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
14810                "                       "
14811                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
14812                Style);
14813 
14814   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
14815   verifyFormat("SomeClass::Constructor() :\n"
14816                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
14817                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
14818                Style);
14819 }
14820 
14821 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
14822   FormatStyle Style = getLLVMStyle();
14823   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
14824   Style.ConstructorInitializerIndentWidth = 4;
14825   verifyFormat("SomeClass::Constructor()\n"
14826                "    : a(a)\n"
14827                "    , b(b)\n"
14828                "    , c(c) {}",
14829                Style);
14830   verifyFormat("SomeClass::Constructor()\n"
14831                "    : a(a) {}",
14832                Style);
14833 
14834   Style.ColumnLimit = 0;
14835   verifyFormat("SomeClass::Constructor()\n"
14836                "    : a(a) {}",
14837                Style);
14838   verifyFormat("SomeClass::Constructor() noexcept\n"
14839                "    : a(a) {}",
14840                Style);
14841   verifyFormat("SomeClass::Constructor()\n"
14842                "    : a(a)\n"
14843                "    , b(b)\n"
14844                "    , c(c) {}",
14845                Style);
14846   verifyFormat("SomeClass::Constructor()\n"
14847                "    : a(a) {\n"
14848                "  foo();\n"
14849                "  bar();\n"
14850                "}",
14851                Style);
14852 
14853   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
14854   verifyFormat("SomeClass::Constructor()\n"
14855                "    : a(a)\n"
14856                "    , b(b)\n"
14857                "    , c(c) {\n}",
14858                Style);
14859   verifyFormat("SomeClass::Constructor()\n"
14860                "    : a(a) {\n}",
14861                Style);
14862 
14863   Style.ColumnLimit = 80;
14864   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
14865   Style.ConstructorInitializerIndentWidth = 2;
14866   verifyFormat("SomeClass::Constructor()\n"
14867                "  : a(a)\n"
14868                "  , b(b)\n"
14869                "  , c(c) {}",
14870                Style);
14871 
14872   Style.ConstructorInitializerIndentWidth = 0;
14873   verifyFormat("SomeClass::Constructor()\n"
14874                ": a(a)\n"
14875                ", b(b)\n"
14876                ", c(c) {}",
14877                Style);
14878 
14879   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
14880   Style.ConstructorInitializerIndentWidth = 4;
14881   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
14882   verifyFormat(
14883       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
14884       Style);
14885   verifyFormat(
14886       "SomeClass::Constructor()\n"
14887       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
14888       Style);
14889   Style.ConstructorInitializerIndentWidth = 4;
14890   Style.ColumnLimit = 60;
14891   verifyFormat("SomeClass::Constructor()\n"
14892                "    : aaaaaaaa(aaaaaaaa)\n"
14893                "    , aaaaaaaa(aaaaaaaa)\n"
14894                "    , aaaaaaaa(aaaaaaaa) {}",
14895                Style);
14896 }
14897 
14898 TEST_F(FormatTest, Destructors) {
14899   verifyFormat("void F(int &i) { i.~int(); }");
14900   verifyFormat("void F(int &i) { i->~int(); }");
14901 }
14902 
14903 TEST_F(FormatTest, FormatsWithWebKitStyle) {
14904   FormatStyle Style = getWebKitStyle();
14905 
14906   // Don't indent in outer namespaces.
14907   verifyFormat("namespace outer {\n"
14908                "int i;\n"
14909                "namespace inner {\n"
14910                "    int i;\n"
14911                "} // namespace inner\n"
14912                "} // namespace outer\n"
14913                "namespace other_outer {\n"
14914                "int i;\n"
14915                "}",
14916                Style);
14917 
14918   // Don't indent case labels.
14919   verifyFormat("switch (variable) {\n"
14920                "case 1:\n"
14921                "case 2:\n"
14922                "    doSomething();\n"
14923                "    break;\n"
14924                "default:\n"
14925                "    ++variable;\n"
14926                "}",
14927                Style);
14928 
14929   // Wrap before binary operators.
14930   EXPECT_EQ("void f()\n"
14931             "{\n"
14932             "    if (aaaaaaaaaaaaaaaa\n"
14933             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
14934             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14935             "        return;\n"
14936             "}",
14937             format("void f() {\n"
14938                    "if (aaaaaaaaaaaaaaaa\n"
14939                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
14940                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
14941                    "return;\n"
14942                    "}",
14943                    Style));
14944 
14945   // Allow functions on a single line.
14946   verifyFormat("void f() { return; }", Style);
14947 
14948   // Allow empty blocks on a single line and insert a space in empty blocks.
14949   EXPECT_EQ("void f() { }", format("void f() {}", Style));
14950   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
14951   // However, don't merge non-empty short loops.
14952   EXPECT_EQ("while (true) {\n"
14953             "    continue;\n"
14954             "}",
14955             format("while (true) { continue; }", Style));
14956 
14957   // Constructor initializers are formatted one per line with the "," on the
14958   // new line.
14959   verifyFormat("Constructor()\n"
14960                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
14961                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
14962                "          aaaaaaaaaaaaaa)\n"
14963                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
14964                "{\n"
14965                "}",
14966                Style);
14967   verifyFormat("SomeClass::Constructor()\n"
14968                "    : a(a)\n"
14969                "{\n"
14970                "}",
14971                Style);
14972   EXPECT_EQ("SomeClass::Constructor()\n"
14973             "    : a(a)\n"
14974             "{\n"
14975             "}",
14976             format("SomeClass::Constructor():a(a){}", Style));
14977   verifyFormat("SomeClass::Constructor()\n"
14978                "    : a(a)\n"
14979                "    , b(b)\n"
14980                "    , c(c)\n"
14981                "{\n"
14982                "}",
14983                Style);
14984   verifyFormat("SomeClass::Constructor()\n"
14985                "    : a(a)\n"
14986                "{\n"
14987                "    foo();\n"
14988                "    bar();\n"
14989                "}",
14990                Style);
14991 
14992   // Access specifiers should be aligned left.
14993   verifyFormat("class C {\n"
14994                "public:\n"
14995                "    int i;\n"
14996                "};",
14997                Style);
14998 
14999   // Do not align comments.
15000   verifyFormat("int a; // Do not\n"
15001                "double b; // align comments.",
15002                Style);
15003 
15004   // Do not align operands.
15005   EXPECT_EQ("ASSERT(aaaa\n"
15006             "    || bbbb);",
15007             format("ASSERT ( aaaa\n||bbbb);", Style));
15008 
15009   // Accept input's line breaks.
15010   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
15011             "    || bbbbbbbbbbbbbbb) {\n"
15012             "    i++;\n"
15013             "}",
15014             format("if (aaaaaaaaaaaaaaa\n"
15015                    "|| bbbbbbbbbbbbbbb) { i++; }",
15016                    Style));
15017   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
15018             "    i++;\n"
15019             "}",
15020             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
15021 
15022   // Don't automatically break all macro definitions (llvm.org/PR17842).
15023   verifyFormat("#define aNumber 10", Style);
15024   // However, generally keep the line breaks that the user authored.
15025   EXPECT_EQ("#define aNumber \\\n"
15026             "    10",
15027             format("#define aNumber \\\n"
15028                    " 10",
15029                    Style));
15030 
15031   // Keep empty and one-element array literals on a single line.
15032   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
15033             "                                  copyItems:YES];",
15034             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
15035                    "copyItems:YES];",
15036                    Style));
15037   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
15038             "                                  copyItems:YES];",
15039             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
15040                    "             copyItems:YES];",
15041                    Style));
15042   // FIXME: This does not seem right, there should be more indentation before
15043   // the array literal's entries. Nested blocks have the same problem.
15044   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
15045             "    @\"a\",\n"
15046             "    @\"a\"\n"
15047             "]\n"
15048             "                                  copyItems:YES];",
15049             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
15050                    "     @\"a\",\n"
15051                    "     @\"a\"\n"
15052                    "     ]\n"
15053                    "       copyItems:YES];",
15054                    Style));
15055   EXPECT_EQ(
15056       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
15057       "                                  copyItems:YES];",
15058       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
15059              "   copyItems:YES];",
15060              Style));
15061 
15062   verifyFormat("[self.a b:c c:d];", Style);
15063   EXPECT_EQ("[self.a b:c\n"
15064             "        c:d];",
15065             format("[self.a b:c\n"
15066                    "c:d];",
15067                    Style));
15068 }
15069 
15070 TEST_F(FormatTest, FormatsLambdas) {
15071   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
15072   verifyFormat(
15073       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
15074   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
15075   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
15076   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
15077   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
15078   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
15079   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
15080   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
15081   verifyFormat("int x = f(*+[] {});");
15082   verifyFormat("void f() {\n"
15083                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
15084                "}\n");
15085   verifyFormat("void f() {\n"
15086                "  other(x.begin(), //\n"
15087                "        x.end(),   //\n"
15088                "        [&](int, int) { return 1; });\n"
15089                "}\n");
15090   verifyFormat("void f() {\n"
15091                "  other.other.other.other.other(\n"
15092                "      x.begin(), x.end(),\n"
15093                "      [something, rather](int, int, int, int, int, int, int) { "
15094                "return 1; });\n"
15095                "}\n");
15096   verifyFormat(
15097       "void f() {\n"
15098       "  other.other.other.other.other(\n"
15099       "      x.begin(), x.end(),\n"
15100       "      [something, rather](int, int, int, int, int, int, int) {\n"
15101       "        //\n"
15102       "      });\n"
15103       "}\n");
15104   verifyFormat("SomeFunction([]() { // A cool function...\n"
15105                "  return 43;\n"
15106                "});");
15107   EXPECT_EQ("SomeFunction([]() {\n"
15108             "#define A a\n"
15109             "  return 43;\n"
15110             "});",
15111             format("SomeFunction([](){\n"
15112                    "#define A a\n"
15113                    "return 43;\n"
15114                    "});"));
15115   verifyFormat("void f() {\n"
15116                "  SomeFunction([](decltype(x), A *a) {});\n"
15117                "  SomeFunction([](typeof(x), A *a) {});\n"
15118                "  SomeFunction([](_Atomic(x), A *a) {});\n"
15119                "  SomeFunction([](__underlying_type(x), A *a) {});\n"
15120                "}");
15121   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15122                "    [](const aaaaaaaaaa &a) { return a; });");
15123   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
15124                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
15125                "});");
15126   verifyFormat("Constructor()\n"
15127                "    : Field([] { // comment\n"
15128                "        int i;\n"
15129                "      }) {}");
15130   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
15131                "  return some_parameter.size();\n"
15132                "};");
15133   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
15134                "    [](const string &s) { return s; };");
15135   verifyFormat("int i = aaaaaa ? 1 //\n"
15136                "               : [] {\n"
15137                "                   return 2; //\n"
15138                "                 }();");
15139   verifyFormat("llvm::errs() << \"number of twos is \"\n"
15140                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
15141                "                  return x == 2; // force break\n"
15142                "                });");
15143   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15144                "    [=](int iiiiiiiiiiii) {\n"
15145                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
15146                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
15147                "    });",
15148                getLLVMStyleWithColumns(60));
15149   verifyFormat("SomeFunction({[&] {\n"
15150                "                // comment\n"
15151                "              },\n"
15152                "              [&] {\n"
15153                "                // comment\n"
15154                "              }});");
15155   verifyFormat("SomeFunction({[&] {\n"
15156                "  // comment\n"
15157                "}});");
15158   verifyFormat(
15159       "virtual aaaaaaaaaaaaaaaa(\n"
15160       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
15161       "    aaaaa aaaaaaaaa);");
15162 
15163   // Lambdas with return types.
15164   verifyFormat("int c = []() -> int { return 2; }();\n");
15165   verifyFormat("int c = []() -> int * { return 2; }();\n");
15166   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
15167   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
15168   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
15169   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
15170   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
15171   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
15172   verifyFormat("[a, a]() -> a<1> {};");
15173   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
15174   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
15175   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
15176   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
15177   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
15178   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
15179   verifyFormat("[]() -> foo<!5> { return {}; };");
15180   verifyFormat("[]() -> foo<~5> { return {}; };");
15181   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
15182   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
15183   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
15184   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
15185   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
15186   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
15187   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
15188   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
15189   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
15190   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
15191   verifyFormat("namespace bar {\n"
15192                "// broken:\n"
15193                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
15194                "} // namespace bar");
15195   verifyFormat("namespace bar {\n"
15196                "// broken:\n"
15197                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
15198                "} // namespace bar");
15199   verifyFormat("namespace bar {\n"
15200                "// broken:\n"
15201                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
15202                "} // namespace bar");
15203   verifyFormat("namespace bar {\n"
15204                "// broken:\n"
15205                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
15206                "} // namespace bar");
15207   verifyFormat("namespace bar {\n"
15208                "// broken:\n"
15209                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
15210                "} // namespace bar");
15211   verifyFormat("namespace bar {\n"
15212                "// broken:\n"
15213                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
15214                "} // namespace bar");
15215   verifyFormat("namespace bar {\n"
15216                "// broken:\n"
15217                "auto foo{[]() -> foo<!5> { return {}; }};\n"
15218                "} // namespace bar");
15219   verifyFormat("namespace bar {\n"
15220                "// broken:\n"
15221                "auto foo{[]() -> foo<~5> { return {}; }};\n"
15222                "} // namespace bar");
15223   verifyFormat("namespace bar {\n"
15224                "// broken:\n"
15225                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
15226                "} // namespace bar");
15227   verifyFormat("namespace bar {\n"
15228                "// broken:\n"
15229                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
15230                "} // namespace bar");
15231   verifyFormat("namespace bar {\n"
15232                "// broken:\n"
15233                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
15234                "} // namespace bar");
15235   verifyFormat("namespace bar {\n"
15236                "// broken:\n"
15237                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
15238                "} // namespace bar");
15239   verifyFormat("namespace bar {\n"
15240                "// broken:\n"
15241                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
15242                "} // namespace bar");
15243   verifyFormat("namespace bar {\n"
15244                "// broken:\n"
15245                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
15246                "} // namespace bar");
15247   verifyFormat("namespace bar {\n"
15248                "// broken:\n"
15249                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
15250                "} // namespace bar");
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<2 ? 1 : 0> { return {}; }};\n"
15262                "} // namespace bar");
15263   verifyFormat("[]() -> a<1> {};");
15264   verifyFormat("[]() -> a<1> { ; };");
15265   verifyFormat("[]() -> a<1> { ; }();");
15266   verifyFormat("[a, a]() -> a<true> {};");
15267   verifyFormat("[]() -> a<true> {};");
15268   verifyFormat("[]() -> a<true> { ; };");
15269   verifyFormat("[]() -> a<true> { ; }();");
15270   verifyFormat("[a, a]() -> a<false> {};");
15271   verifyFormat("[]() -> a<false> {};");
15272   verifyFormat("[]() -> a<false> { ; };");
15273   verifyFormat("[]() -> a<false> { ; }();");
15274   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
15275   verifyFormat("namespace bar {\n"
15276                "auto foo{[]() -> foo<false> { ; }};\n"
15277                "} // namespace bar");
15278   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
15279                "                   int j) -> int {\n"
15280                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
15281                "};");
15282   verifyFormat(
15283       "aaaaaaaaaaaaaaaaaaaaaa(\n"
15284       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
15285       "      return aaaaaaaaaaaaaaaaa;\n"
15286       "    });",
15287       getLLVMStyleWithColumns(70));
15288   verifyFormat("[]() //\n"
15289                "    -> int {\n"
15290                "  return 1; //\n"
15291                "};");
15292   verifyFormat("[]() -> Void<T...> {};");
15293   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
15294 
15295   // Lambdas with explicit template argument lists.
15296   verifyFormat(
15297       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
15298 
15299   // Multiple lambdas in the same parentheses change indentation rules. These
15300   // lambdas are forced to start on new lines.
15301   verifyFormat("SomeFunction(\n"
15302                "    []() {\n"
15303                "      //\n"
15304                "    },\n"
15305                "    []() {\n"
15306                "      //\n"
15307                "    });");
15308 
15309   // A lambda passed as arg0 is always pushed to the next line.
15310   verifyFormat("SomeFunction(\n"
15311                "    [this] {\n"
15312                "      //\n"
15313                "    },\n"
15314                "    1);\n");
15315 
15316   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
15317   // the arg0 case above.
15318   auto Style = getGoogleStyle();
15319   Style.BinPackArguments = false;
15320   verifyFormat("SomeFunction(\n"
15321                "    a,\n"
15322                "    [this] {\n"
15323                "      //\n"
15324                "    },\n"
15325                "    b);\n",
15326                Style);
15327   verifyFormat("SomeFunction(\n"
15328                "    a,\n"
15329                "    [this] {\n"
15330                "      //\n"
15331                "    },\n"
15332                "    b);\n");
15333 
15334   // A lambda with a very long line forces arg0 to be pushed out irrespective of
15335   // the BinPackArguments value (as long as the code is wide enough).
15336   verifyFormat(
15337       "something->SomeFunction(\n"
15338       "    a,\n"
15339       "    [this] {\n"
15340       "      "
15341       "D0000000000000000000000000000000000000000000000000000000000001();\n"
15342       "    },\n"
15343       "    b);\n");
15344 
15345   // A multi-line lambda is pulled up as long as the introducer fits on the
15346   // previous line and there are no further args.
15347   verifyFormat("function(1, [this, that] {\n"
15348                "  //\n"
15349                "});\n");
15350   verifyFormat("function([this, that] {\n"
15351                "  //\n"
15352                "});\n");
15353   // FIXME: this format is not ideal and we should consider forcing the first
15354   // arg onto its own line.
15355   verifyFormat("function(a, b, c, //\n"
15356                "         d, [this, that] {\n"
15357                "           //\n"
15358                "         });\n");
15359 
15360   // Multiple lambdas are treated correctly even when there is a short arg0.
15361   verifyFormat("SomeFunction(\n"
15362                "    1,\n"
15363                "    [this] {\n"
15364                "      //\n"
15365                "    },\n"
15366                "    [this] {\n"
15367                "      //\n"
15368                "    },\n"
15369                "    1);\n");
15370 
15371   // More complex introducers.
15372   verifyFormat("return [i, args...] {};");
15373 
15374   // Not lambdas.
15375   verifyFormat("constexpr char hello[]{\"hello\"};");
15376   verifyFormat("double &operator[](int i) { return 0; }\n"
15377                "int i;");
15378   verifyFormat("std::unique_ptr<int[]> foo() {}");
15379   verifyFormat("int i = a[a][a]->f();");
15380   verifyFormat("int i = (*b)[a]->f();");
15381 
15382   // Other corner cases.
15383   verifyFormat("void f() {\n"
15384                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
15385                "  );\n"
15386                "}");
15387 
15388   // Lambdas created through weird macros.
15389   verifyFormat("void f() {\n"
15390                "  MACRO((const AA &a) { return 1; });\n"
15391                "  MACRO((AA &a) { return 1; });\n"
15392                "}");
15393 
15394   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
15395                "      doo_dah();\n"
15396                "      doo_dah();\n"
15397                "    })) {\n"
15398                "}");
15399   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
15400                "                doo_dah();\n"
15401                "                doo_dah();\n"
15402                "              })) {\n"
15403                "}");
15404   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
15405                "                doo_dah();\n"
15406                "                doo_dah();\n"
15407                "              })) {\n"
15408                "}");
15409   verifyFormat("auto lambda = []() {\n"
15410                "  int a = 2\n"
15411                "#if A\n"
15412                "          + 2\n"
15413                "#endif\n"
15414                "      ;\n"
15415                "};");
15416 
15417   // Lambdas with complex multiline introducers.
15418   verifyFormat(
15419       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15420       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
15421       "        -> ::std::unordered_set<\n"
15422       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
15423       "      //\n"
15424       "    });");
15425 
15426   FormatStyle DoNotMerge = getLLVMStyle();
15427   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
15428   verifyFormat("auto c = []() {\n"
15429                "  return b;\n"
15430                "};",
15431                "auto c = []() { return b; };", DoNotMerge);
15432   verifyFormat("auto c = []() {\n"
15433                "};",
15434                " auto c = []() {};", DoNotMerge);
15435 
15436   FormatStyle MergeEmptyOnly = getLLVMStyle();
15437   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
15438   verifyFormat("auto c = []() {\n"
15439                "  return b;\n"
15440                "};",
15441                "auto c = []() {\n"
15442                "  return b;\n"
15443                " };",
15444                MergeEmptyOnly);
15445   verifyFormat("auto c = []() {};",
15446                "auto c = []() {\n"
15447                "};",
15448                MergeEmptyOnly);
15449 
15450   FormatStyle MergeInline = getLLVMStyle();
15451   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
15452   verifyFormat("auto c = []() {\n"
15453                "  return b;\n"
15454                "};",
15455                "auto c = []() { return b; };", MergeInline);
15456   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
15457                MergeInline);
15458   verifyFormat("function([]() { return b; }, a)",
15459                "function([]() { return b; }, a)", MergeInline);
15460   verifyFormat("function(a, []() { return b; })",
15461                "function(a, []() { return b; })", MergeInline);
15462 
15463   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
15464   // AllowShortLambdasOnASingleLine
15465   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15466   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15467   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15468   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15469       FormatStyle::ShortLambdaStyle::SLS_None;
15470   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
15471                "    []()\n"
15472                "    {\n"
15473                "      return 17;\n"
15474                "    });",
15475                LLVMWithBeforeLambdaBody);
15476   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
15477                "    []()\n"
15478                "    {\n"
15479                "    });",
15480                LLVMWithBeforeLambdaBody);
15481   verifyFormat("auto fct_SLS_None = []()\n"
15482                "{\n"
15483                "  return 17;\n"
15484                "};",
15485                LLVMWithBeforeLambdaBody);
15486   verifyFormat("TwoNestedLambdas_SLS_None(\n"
15487                "    []()\n"
15488                "    {\n"
15489                "      return Call(\n"
15490                "          []()\n"
15491                "          {\n"
15492                "            return 17;\n"
15493                "          });\n"
15494                "    });",
15495                LLVMWithBeforeLambdaBody);
15496   verifyFormat("void Fct()\n"
15497                "{\n"
15498                "  return {[]()\n"
15499                "          {\n"
15500                "            return 17;\n"
15501                "          }};\n"
15502                "}",
15503                LLVMWithBeforeLambdaBody);
15504 
15505   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15506       FormatStyle::ShortLambdaStyle::SLS_Empty;
15507   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
15508                "    []()\n"
15509                "    {\n"
15510                "      return 17;\n"
15511                "    });",
15512                LLVMWithBeforeLambdaBody);
15513   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
15514                LLVMWithBeforeLambdaBody);
15515   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
15516                "ongFunctionName_SLS_Empty(\n"
15517                "    []() {});",
15518                LLVMWithBeforeLambdaBody);
15519   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
15520                "                                []()\n"
15521                "                                {\n"
15522                "                                  return 17;\n"
15523                "                                });",
15524                LLVMWithBeforeLambdaBody);
15525   verifyFormat("auto fct_SLS_Empty = []()\n"
15526                "{\n"
15527                "  return 17;\n"
15528                "};",
15529                LLVMWithBeforeLambdaBody);
15530   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
15531                "    []()\n"
15532                "    {\n"
15533                "      return Call([]() {});\n"
15534                "    });",
15535                LLVMWithBeforeLambdaBody);
15536   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15537                "                           []()\n"
15538                "                           {\n"
15539                "                             return Call([]() {});\n"
15540                "                           });",
15541                LLVMWithBeforeLambdaBody);
15542   verifyFormat(
15543       "FctWithLongLineInLambda_SLS_Empty(\n"
15544       "    []()\n"
15545       "    {\n"
15546       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15547       "                               AndShouldNotBeConsiderAsInline,\n"
15548       "                               LambdaBodyMustBeBreak);\n"
15549       "    });",
15550       LLVMWithBeforeLambdaBody);
15551 
15552   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15553       FormatStyle::ShortLambdaStyle::SLS_Inline;
15554   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15555                LLVMWithBeforeLambdaBody);
15556   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15557                LLVMWithBeforeLambdaBody);
15558   verifyFormat("auto fct_SLS_Inline = []()\n"
15559                "{\n"
15560                "  return 17;\n"
15561                "};",
15562                LLVMWithBeforeLambdaBody);
15563   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15564                "17; }); });",
15565                LLVMWithBeforeLambdaBody);
15566   verifyFormat(
15567       "FctWithLongLineInLambda_SLS_Inline(\n"
15568       "    []()\n"
15569       "    {\n"
15570       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15571       "                               AndShouldNotBeConsiderAsInline,\n"
15572       "                               LambdaBodyMustBeBreak);\n"
15573       "    });",
15574       LLVMWithBeforeLambdaBody);
15575   verifyFormat("FctWithMultipleParams_SLS_Inline("
15576                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15577                "                                 []() { return 17; });",
15578                LLVMWithBeforeLambdaBody);
15579   verifyFormat(
15580       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15581       LLVMWithBeforeLambdaBody);
15582 
15583   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15584       FormatStyle::ShortLambdaStyle::SLS_All;
15585   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15586                LLVMWithBeforeLambdaBody);
15587   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15588                LLVMWithBeforeLambdaBody);
15589   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15590                LLVMWithBeforeLambdaBody);
15591   verifyFormat("FctWithOneParam_SLS_All(\n"
15592                "    []()\n"
15593                "    {\n"
15594                "      // A cool function...\n"
15595                "      return 43;\n"
15596                "    });",
15597                LLVMWithBeforeLambdaBody);
15598   verifyFormat("FctWithMultipleParams_SLS_All("
15599                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15600                "                              []() { return 17; });",
15601                LLVMWithBeforeLambdaBody);
15602   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15603                LLVMWithBeforeLambdaBody);
15604   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15605                LLVMWithBeforeLambdaBody);
15606   verifyFormat(
15607       "FctWithLongLineInLambda_SLS_All(\n"
15608       "    []()\n"
15609       "    {\n"
15610       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15611       "                               AndShouldNotBeConsiderAsInline,\n"
15612       "                               LambdaBodyMustBeBreak);\n"
15613       "    });",
15614       LLVMWithBeforeLambdaBody);
15615   verifyFormat(
15616       "auto fct_SLS_All = []()\n"
15617       "{\n"
15618       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15619       "                           AndShouldNotBeConsiderAsInline,\n"
15620       "                           LambdaBodyMustBeBreak);\n"
15621       "};",
15622       LLVMWithBeforeLambdaBody);
15623   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15624   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15625                LLVMWithBeforeLambdaBody);
15626   verifyFormat(
15627       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15628       "                                FirstParam,\n"
15629       "                                SecondParam,\n"
15630       "                                ThirdParam,\n"
15631       "                                FourthParam);",
15632       LLVMWithBeforeLambdaBody);
15633   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15634                "    []() { return "
15635                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15636                "    FirstParam,\n"
15637                "    SecondParam,\n"
15638                "    ThirdParam,\n"
15639                "    FourthParam);",
15640                LLVMWithBeforeLambdaBody);
15641   verifyFormat(
15642       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15643       "                                SecondParam,\n"
15644       "                                ThirdParam,\n"
15645       "                                FourthParam,\n"
15646       "                                []() { return SomeValueNotSoLong; });",
15647       LLVMWithBeforeLambdaBody);
15648   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15649                "    []()\n"
15650                "    {\n"
15651                "      return "
15652                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
15653                "eConsiderAsInline;\n"
15654                "    });",
15655                LLVMWithBeforeLambdaBody);
15656   verifyFormat(
15657       "FctWithLongLineInLambda_SLS_All(\n"
15658       "    []()\n"
15659       "    {\n"
15660       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15661       "                               AndShouldNotBeConsiderAsInline,\n"
15662       "                               LambdaBodyMustBeBreak);\n"
15663       "    });",
15664       LLVMWithBeforeLambdaBody);
15665   verifyFormat("FctWithTwoParams_SLS_All(\n"
15666                "    []()\n"
15667                "    {\n"
15668                "      // A cool function...\n"
15669                "      return 43;\n"
15670                "    },\n"
15671                "    87);",
15672                LLVMWithBeforeLambdaBody);
15673   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
15674                LLVMWithBeforeLambdaBody);
15675   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
15676                LLVMWithBeforeLambdaBody);
15677   verifyFormat(
15678       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
15679       LLVMWithBeforeLambdaBody);
15680   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
15681                "}); }, x);",
15682                LLVMWithBeforeLambdaBody);
15683   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15684                "    []()\n"
15685                "    {\n"
15686                "      // A cool function...\n"
15687                "      return Call([]() { return 17; });\n"
15688                "    });",
15689                LLVMWithBeforeLambdaBody);
15690   verifyFormat("TwoNestedLambdas_SLS_All(\n"
15691                "    []()\n"
15692                "    {\n"
15693                "      return Call(\n"
15694                "          []()\n"
15695                "          {\n"
15696                "            // A cool function...\n"
15697                "            return 17;\n"
15698                "          });\n"
15699                "    });",
15700                LLVMWithBeforeLambdaBody);
15701 }
15702 
15703 TEST_F(FormatTest, LambdaWithLineComments) {
15704   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15705   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15706   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15707   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15708       FormatStyle::ShortLambdaStyle::SLS_All;
15709 
15710   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
15711   verifyFormat("auto k = []() // comment\n"
15712                "{ return; }",
15713                LLVMWithBeforeLambdaBody);
15714   verifyFormat("auto k = []() /* comment */ { return; }",
15715                LLVMWithBeforeLambdaBody);
15716   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
15717                LLVMWithBeforeLambdaBody);
15718   verifyFormat("auto k = []() // X\n"
15719                "{ return; }",
15720                LLVMWithBeforeLambdaBody);
15721   verifyFormat(
15722       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
15723       "{ return; }",
15724       LLVMWithBeforeLambdaBody);
15725 }
15726 
15727 TEST_F(FormatTest, EmptyLinesInLambdas) {
15728   verifyFormat("auto lambda = []() {\n"
15729                "  x(); //\n"
15730                "};",
15731                "auto lambda = []() {\n"
15732                "\n"
15733                "  x(); //\n"
15734                "\n"
15735                "};");
15736 }
15737 
15738 TEST_F(FormatTest, FormatsBlocks) {
15739   FormatStyle ShortBlocks = getLLVMStyle();
15740   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15741   verifyFormat("int (^Block)(int, int);", ShortBlocks);
15742   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
15743   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
15744   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
15745   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
15746   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
15747 
15748   verifyFormat("foo(^{ bar(); });", ShortBlocks);
15749   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
15750   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
15751 
15752   verifyFormat("[operation setCompletionBlock:^{\n"
15753                "  [self onOperationDone];\n"
15754                "}];");
15755   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
15756                "  [self onOperationDone];\n"
15757                "}]};");
15758   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
15759                "  f();\n"
15760                "}];");
15761   verifyFormat("int a = [operation block:^int(int *i) {\n"
15762                "  return 1;\n"
15763                "}];");
15764   verifyFormat("[myObject doSomethingWith:arg1\n"
15765                "                      aaa:^int(int *a) {\n"
15766                "                        return 1;\n"
15767                "                      }\n"
15768                "                      bbb:f(a * bbbbbbbb)];");
15769 
15770   verifyFormat("[operation setCompletionBlock:^{\n"
15771                "  [self.delegate newDataAvailable];\n"
15772                "}];",
15773                getLLVMStyleWithColumns(60));
15774   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
15775                "  NSString *path = [self sessionFilePath];\n"
15776                "  if (path) {\n"
15777                "    // ...\n"
15778                "  }\n"
15779                "});");
15780   verifyFormat("[[SessionService sharedService]\n"
15781                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15782                "      if (window) {\n"
15783                "        [self windowDidLoad:window];\n"
15784                "      } else {\n"
15785                "        [self errorLoadingWindow];\n"
15786                "      }\n"
15787                "    }];");
15788   verifyFormat("void (^largeBlock)(void) = ^{\n"
15789                "  // ...\n"
15790                "};\n",
15791                getLLVMStyleWithColumns(40));
15792   verifyFormat("[[SessionService sharedService]\n"
15793                "    loadWindowWithCompletionBlock: //\n"
15794                "        ^(SessionWindow *window) {\n"
15795                "          if (window) {\n"
15796                "            [self windowDidLoad:window];\n"
15797                "          } else {\n"
15798                "            [self errorLoadingWindow];\n"
15799                "          }\n"
15800                "        }];",
15801                getLLVMStyleWithColumns(60));
15802   verifyFormat("[myObject doSomethingWith:arg1\n"
15803                "    firstBlock:^(Foo *a) {\n"
15804                "      // ...\n"
15805                "      int i;\n"
15806                "    }\n"
15807                "    secondBlock:^(Bar *b) {\n"
15808                "      // ...\n"
15809                "      int i;\n"
15810                "    }\n"
15811                "    thirdBlock:^Foo(Bar *b) {\n"
15812                "      // ...\n"
15813                "      int i;\n"
15814                "    }];");
15815   verifyFormat("[myObject doSomethingWith:arg1\n"
15816                "               firstBlock:-1\n"
15817                "              secondBlock:^(Bar *b) {\n"
15818                "                // ...\n"
15819                "                int i;\n"
15820                "              }];");
15821 
15822   verifyFormat("f(^{\n"
15823                "  @autoreleasepool {\n"
15824                "    if (a) {\n"
15825                "      g();\n"
15826                "    }\n"
15827                "  }\n"
15828                "});");
15829   verifyFormat("Block b = ^int *(A *a, B *b) {}");
15830   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
15831                "};");
15832 
15833   FormatStyle FourIndent = getLLVMStyle();
15834   FourIndent.ObjCBlockIndentWidth = 4;
15835   verifyFormat("[operation setCompletionBlock:^{\n"
15836                "    [self onOperationDone];\n"
15837                "}];",
15838                FourIndent);
15839 }
15840 
15841 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
15842   FormatStyle ZeroColumn = getLLVMStyle();
15843   ZeroColumn.ColumnLimit = 0;
15844 
15845   verifyFormat("[[SessionService sharedService] "
15846                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15847                "  if (window) {\n"
15848                "    [self windowDidLoad:window];\n"
15849                "  } else {\n"
15850                "    [self errorLoadingWindow];\n"
15851                "  }\n"
15852                "}];",
15853                ZeroColumn);
15854   EXPECT_EQ("[[SessionService sharedService]\n"
15855             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15856             "      if (window) {\n"
15857             "        [self windowDidLoad:window];\n"
15858             "      } else {\n"
15859             "        [self errorLoadingWindow];\n"
15860             "      }\n"
15861             "    }];",
15862             format("[[SessionService sharedService]\n"
15863                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
15864                    "                if (window) {\n"
15865                    "    [self windowDidLoad:window];\n"
15866                    "  } else {\n"
15867                    "    [self errorLoadingWindow];\n"
15868                    "  }\n"
15869                    "}];",
15870                    ZeroColumn));
15871   verifyFormat("[myObject doSomethingWith:arg1\n"
15872                "    firstBlock:^(Foo *a) {\n"
15873                "      // ...\n"
15874                "      int i;\n"
15875                "    }\n"
15876                "    secondBlock:^(Bar *b) {\n"
15877                "      // ...\n"
15878                "      int i;\n"
15879                "    }\n"
15880                "    thirdBlock:^Foo(Bar *b) {\n"
15881                "      // ...\n"
15882                "      int i;\n"
15883                "    }];",
15884                ZeroColumn);
15885   verifyFormat("f(^{\n"
15886                "  @autoreleasepool {\n"
15887                "    if (a) {\n"
15888                "      g();\n"
15889                "    }\n"
15890                "  }\n"
15891                "});",
15892                ZeroColumn);
15893   verifyFormat("void (^largeBlock)(void) = ^{\n"
15894                "  // ...\n"
15895                "};",
15896                ZeroColumn);
15897 
15898   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
15899   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
15900             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15901   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
15902   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
15903             "  int i;\n"
15904             "};",
15905             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
15906 }
15907 
15908 TEST_F(FormatTest, SupportsCRLF) {
15909   EXPECT_EQ("int a;\r\n"
15910             "int b;\r\n"
15911             "int c;\r\n",
15912             format("int a;\r\n"
15913                    "  int b;\r\n"
15914                    "    int c;\r\n",
15915                    getLLVMStyle()));
15916   EXPECT_EQ("int a;\r\n"
15917             "int b;\r\n"
15918             "int c;\r\n",
15919             format("int a;\r\n"
15920                    "  int b;\n"
15921                    "    int c;\r\n",
15922                    getLLVMStyle()));
15923   EXPECT_EQ("int a;\n"
15924             "int b;\n"
15925             "int c;\n",
15926             format("int a;\r\n"
15927                    "  int b;\n"
15928                    "    int c;\n",
15929                    getLLVMStyle()));
15930   EXPECT_EQ("\"aaaaaaa \"\r\n"
15931             "\"bbbbbbb\";\r\n",
15932             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
15933   EXPECT_EQ("#define A \\\r\n"
15934             "  b;      \\\r\n"
15935             "  c;      \\\r\n"
15936             "  d;\r\n",
15937             format("#define A \\\r\n"
15938                    "  b; \\\r\n"
15939                    "  c; d; \r\n",
15940                    getGoogleStyle()));
15941 
15942   EXPECT_EQ("/*\r\n"
15943             "multi line block comments\r\n"
15944             "should not introduce\r\n"
15945             "an extra carriage return\r\n"
15946             "*/\r\n",
15947             format("/*\r\n"
15948                    "multi line block comments\r\n"
15949                    "should not introduce\r\n"
15950                    "an extra carriage return\r\n"
15951                    "*/\r\n"));
15952   EXPECT_EQ("/*\r\n"
15953             "\r\n"
15954             "*/",
15955             format("/*\r\n"
15956                    "    \r\r\r\n"
15957                    "*/"));
15958 
15959   FormatStyle style = getLLVMStyle();
15960 
15961   style.DeriveLineEnding = true;
15962   style.UseCRLF = false;
15963   EXPECT_EQ("union FooBarBazQux {\n"
15964             "  int foo;\n"
15965             "  int bar;\n"
15966             "  int baz;\n"
15967             "};",
15968             format("union FooBarBazQux {\r\n"
15969                    "  int foo;\n"
15970                    "  int bar;\r\n"
15971                    "  int baz;\n"
15972                    "};",
15973                    style));
15974   style.UseCRLF = true;
15975   EXPECT_EQ("union FooBarBazQux {\r\n"
15976             "  int foo;\r\n"
15977             "  int bar;\r\n"
15978             "  int baz;\r\n"
15979             "};",
15980             format("union FooBarBazQux {\r\n"
15981                    "  int foo;\n"
15982                    "  int bar;\r\n"
15983                    "  int baz;\n"
15984                    "};",
15985                    style));
15986 
15987   style.DeriveLineEnding = false;
15988   style.UseCRLF = false;
15989   EXPECT_EQ("union FooBarBazQux {\n"
15990             "  int foo;\n"
15991             "  int bar;\n"
15992             "  int baz;\n"
15993             "  int qux;\n"
15994             "};",
15995             format("union FooBarBazQux {\r\n"
15996                    "  int foo;\n"
15997                    "  int bar;\r\n"
15998                    "  int baz;\n"
15999                    "  int qux;\r\n"
16000                    "};",
16001                    style));
16002   style.UseCRLF = true;
16003   EXPECT_EQ("union FooBarBazQux {\r\n"
16004             "  int foo;\r\n"
16005             "  int bar;\r\n"
16006             "  int baz;\r\n"
16007             "  int qux;\r\n"
16008             "};",
16009             format("union FooBarBazQux {\r\n"
16010                    "  int foo;\n"
16011                    "  int bar;\r\n"
16012                    "  int baz;\n"
16013                    "  int qux;\n"
16014                    "};",
16015                    style));
16016 
16017   style.DeriveLineEnding = true;
16018   style.UseCRLF = false;
16019   EXPECT_EQ("union FooBarBazQux {\r\n"
16020             "  int foo;\r\n"
16021             "  int bar;\r\n"
16022             "  int baz;\r\n"
16023             "  int qux;\r\n"
16024             "};",
16025             format("union FooBarBazQux {\r\n"
16026                    "  int foo;\n"
16027                    "  int bar;\r\n"
16028                    "  int baz;\n"
16029                    "  int qux;\r\n"
16030                    "};",
16031                    style));
16032   style.UseCRLF = true;
16033   EXPECT_EQ("union FooBarBazQux {\n"
16034             "  int foo;\n"
16035             "  int bar;\n"
16036             "  int baz;\n"
16037             "  int qux;\n"
16038             "};",
16039             format("union FooBarBazQux {\r\n"
16040                    "  int foo;\n"
16041                    "  int bar;\r\n"
16042                    "  int baz;\n"
16043                    "  int qux;\n"
16044                    "};",
16045                    style));
16046 }
16047 
16048 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
16049   verifyFormat("MY_CLASS(C) {\n"
16050                "  int i;\n"
16051                "  int j;\n"
16052                "};");
16053 }
16054 
16055 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
16056   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
16057   TwoIndent.ContinuationIndentWidth = 2;
16058 
16059   EXPECT_EQ("int i =\n"
16060             "  longFunction(\n"
16061             "    arg);",
16062             format("int i = longFunction(arg);", TwoIndent));
16063 
16064   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
16065   SixIndent.ContinuationIndentWidth = 6;
16066 
16067   EXPECT_EQ("int i =\n"
16068             "      longFunction(\n"
16069             "            arg);",
16070             format("int i = longFunction(arg);", SixIndent));
16071 }
16072 
16073 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
16074   FormatStyle Style = getLLVMStyle();
16075   verifyFormat("int Foo::getter(\n"
16076                "    //\n"
16077                ") const {\n"
16078                "  return foo;\n"
16079                "}",
16080                Style);
16081   verifyFormat("void Foo::setter(\n"
16082                "    //\n"
16083                ") {\n"
16084                "  foo = 1;\n"
16085                "}",
16086                Style);
16087 }
16088 
16089 TEST_F(FormatTest, SpacesInAngles) {
16090   FormatStyle Spaces = getLLVMStyle();
16091   Spaces.SpacesInAngles = true;
16092 
16093   verifyFormat("static_cast< int >(arg);", Spaces);
16094   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
16095   verifyFormat("f< int, float >();", Spaces);
16096   verifyFormat("template <> g() {}", Spaces);
16097   verifyFormat("template < std::vector< int > > f() {}", Spaces);
16098   verifyFormat("std::function< void(int, int) > fct;", Spaces);
16099   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
16100                Spaces);
16101 
16102   Spaces.Standard = FormatStyle::LS_Cpp03;
16103   Spaces.SpacesInAngles = true;
16104   verifyFormat("A< A< int > >();", Spaces);
16105 
16106   Spaces.SpacesInAngles = false;
16107   verifyFormat("A<A<int> >();", Spaces);
16108 
16109   Spaces.Standard = FormatStyle::LS_Cpp11;
16110   Spaces.SpacesInAngles = true;
16111   verifyFormat("A< A< int > >();", Spaces);
16112 
16113   Spaces.SpacesInAngles = false;
16114   verifyFormat("A<A<int>>();", Spaces);
16115 }
16116 
16117 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
16118   FormatStyle Style = getLLVMStyle();
16119   Style.SpaceAfterTemplateKeyword = false;
16120   verifyFormat("template<int> void foo();", Style);
16121 }
16122 
16123 TEST_F(FormatTest, TripleAngleBrackets) {
16124   verifyFormat("f<<<1, 1>>>();");
16125   verifyFormat("f<<<1, 1, 1, s>>>();");
16126   verifyFormat("f<<<a, b, c, d>>>();");
16127   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
16128   verifyFormat("f<param><<<1, 1>>>();");
16129   verifyFormat("f<1><<<1, 1>>>();");
16130   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
16131   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16132                "aaaaaaaaaaa<<<\n    1, 1>>>();");
16133   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
16134                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
16135 }
16136 
16137 TEST_F(FormatTest, MergeLessLessAtEnd) {
16138   verifyFormat("<<");
16139   EXPECT_EQ("< < <", format("\\\n<<<"));
16140   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16141                "aaallvm::outs() <<");
16142   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16143                "aaaallvm::outs()\n    <<");
16144 }
16145 
16146 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
16147   std::string code = "#if A\n"
16148                      "#if B\n"
16149                      "a.\n"
16150                      "#endif\n"
16151                      "    a = 1;\n"
16152                      "#else\n"
16153                      "#endif\n"
16154                      "#if C\n"
16155                      "#else\n"
16156                      "#endif\n";
16157   EXPECT_EQ(code, format(code));
16158 }
16159 
16160 TEST_F(FormatTest, HandleConflictMarkers) {
16161   // Git/SVN conflict markers.
16162   EXPECT_EQ("int a;\n"
16163             "void f() {\n"
16164             "  callme(some(parameter1,\n"
16165             "<<<<<<< text by the vcs\n"
16166             "              parameter2),\n"
16167             "||||||| text by the vcs\n"
16168             "              parameter2),\n"
16169             "         parameter3,\n"
16170             "======= text by the vcs\n"
16171             "              parameter2, parameter3),\n"
16172             ">>>>>>> text by the vcs\n"
16173             "         otherparameter);\n",
16174             format("int a;\n"
16175                    "void f() {\n"
16176                    "  callme(some(parameter1,\n"
16177                    "<<<<<<< text by the vcs\n"
16178                    "  parameter2),\n"
16179                    "||||||| text by the vcs\n"
16180                    "  parameter2),\n"
16181                    "  parameter3,\n"
16182                    "======= text by the vcs\n"
16183                    "  parameter2,\n"
16184                    "  parameter3),\n"
16185                    ">>>>>>> text by the vcs\n"
16186                    "  otherparameter);\n"));
16187 
16188   // Perforce markers.
16189   EXPECT_EQ("void f() {\n"
16190             "  function(\n"
16191             ">>>> text by the vcs\n"
16192             "      parameter,\n"
16193             "==== text by the vcs\n"
16194             "      parameter,\n"
16195             "==== text by the vcs\n"
16196             "      parameter,\n"
16197             "<<<< text by the vcs\n"
16198             "      parameter);\n",
16199             format("void f() {\n"
16200                    "  function(\n"
16201                    ">>>> text by the vcs\n"
16202                    "  parameter,\n"
16203                    "==== text by the vcs\n"
16204                    "  parameter,\n"
16205                    "==== text by the vcs\n"
16206                    "  parameter,\n"
16207                    "<<<< text by the vcs\n"
16208                    "  parameter);\n"));
16209 
16210   EXPECT_EQ("<<<<<<<\n"
16211             "|||||||\n"
16212             "=======\n"
16213             ">>>>>>>",
16214             format("<<<<<<<\n"
16215                    "|||||||\n"
16216                    "=======\n"
16217                    ">>>>>>>"));
16218 
16219   EXPECT_EQ("<<<<<<<\n"
16220             "|||||||\n"
16221             "int i;\n"
16222             "=======\n"
16223             ">>>>>>>",
16224             format("<<<<<<<\n"
16225                    "|||||||\n"
16226                    "int i;\n"
16227                    "=======\n"
16228                    ">>>>>>>"));
16229 
16230   // FIXME: Handle parsing of macros around conflict markers correctly:
16231   EXPECT_EQ("#define Macro \\\n"
16232             "<<<<<<<\n"
16233             "Something \\\n"
16234             "|||||||\n"
16235             "Else \\\n"
16236             "=======\n"
16237             "Other \\\n"
16238             ">>>>>>>\n"
16239             "    End int i;\n",
16240             format("#define Macro \\\n"
16241                    "<<<<<<<\n"
16242                    "  Something \\\n"
16243                    "|||||||\n"
16244                    "  Else \\\n"
16245                    "=======\n"
16246                    "  Other \\\n"
16247                    ">>>>>>>\n"
16248                    "  End\n"
16249                    "int i;\n"));
16250 }
16251 
16252 TEST_F(FormatTest, DisableRegions) {
16253   EXPECT_EQ("int i;\n"
16254             "// clang-format off\n"
16255             "  int j;\n"
16256             "// clang-format on\n"
16257             "int k;",
16258             format(" int  i;\n"
16259                    "   // clang-format off\n"
16260                    "  int j;\n"
16261                    " // clang-format on\n"
16262                    "   int   k;"));
16263   EXPECT_EQ("int i;\n"
16264             "/* clang-format off */\n"
16265             "  int j;\n"
16266             "/* clang-format on */\n"
16267             "int k;",
16268             format(" int  i;\n"
16269                    "   /* clang-format off */\n"
16270                    "  int j;\n"
16271                    " /* clang-format on */\n"
16272                    "   int   k;"));
16273 
16274   // Don't reflow comments within disabled regions.
16275   EXPECT_EQ("// clang-format off\n"
16276             "// long long long long long long line\n"
16277             "/* clang-format on */\n"
16278             "/* long long long\n"
16279             " * long long long\n"
16280             " * line */\n"
16281             "int i;\n"
16282             "/* clang-format off */\n"
16283             "/* long long long long long long line */\n",
16284             format("// clang-format off\n"
16285                    "// long long long long long long line\n"
16286                    "/* clang-format on */\n"
16287                    "/* long long long long long long line */\n"
16288                    "int i;\n"
16289                    "/* clang-format off */\n"
16290                    "/* long long long long long long line */\n",
16291                    getLLVMStyleWithColumns(20)));
16292 }
16293 
16294 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
16295   format("? ) =");
16296   verifyNoCrash("#define a\\\n /**/}");
16297 }
16298 
16299 TEST_F(FormatTest, FormatsTableGenCode) {
16300   FormatStyle Style = getLLVMStyle();
16301   Style.Language = FormatStyle::LK_TableGen;
16302   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
16303 }
16304 
16305 TEST_F(FormatTest, ArrayOfTemplates) {
16306   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
16307             format("auto a = new unique_ptr<int > [ 10];"));
16308 
16309   FormatStyle Spaces = getLLVMStyle();
16310   Spaces.SpacesInSquareBrackets = true;
16311   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
16312             format("auto a = new unique_ptr<int > [10];", Spaces));
16313 }
16314 
16315 TEST_F(FormatTest, ArrayAsTemplateType) {
16316   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
16317             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
16318 
16319   FormatStyle Spaces = getLLVMStyle();
16320   Spaces.SpacesInSquareBrackets = true;
16321   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
16322             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
16323 }
16324 
16325 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
16326 
16327 TEST(FormatStyle, GetStyleWithEmptyFileName) {
16328   llvm::vfs::InMemoryFileSystem FS;
16329   auto Style1 = getStyle("file", "", "Google", "", &FS);
16330   ASSERT_TRUE((bool)Style1);
16331   ASSERT_EQ(*Style1, getGoogleStyle());
16332 }
16333 
16334 TEST(FormatStyle, GetStyleOfFile) {
16335   llvm::vfs::InMemoryFileSystem FS;
16336   // Test 1: format file in the same directory.
16337   ASSERT_TRUE(
16338       FS.addFile("/a/.clang-format", 0,
16339                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
16340   ASSERT_TRUE(
16341       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16342   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
16343   ASSERT_TRUE((bool)Style1);
16344   ASSERT_EQ(*Style1, getLLVMStyle());
16345 
16346   // Test 2.1: fallback to default.
16347   ASSERT_TRUE(
16348       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16349   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
16350   ASSERT_TRUE((bool)Style2);
16351   ASSERT_EQ(*Style2, getMozillaStyle());
16352 
16353   // Test 2.2: no format on 'none' fallback style.
16354   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16355   ASSERT_TRUE((bool)Style2);
16356   ASSERT_EQ(*Style2, getNoStyle());
16357 
16358   // Test 2.3: format if config is found with no based style while fallback is
16359   // 'none'.
16360   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
16361                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
16362   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16363   ASSERT_TRUE((bool)Style2);
16364   ASSERT_EQ(*Style2, getLLVMStyle());
16365 
16366   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
16367   Style2 = getStyle("{}", "a.h", "none", "", &FS);
16368   ASSERT_TRUE((bool)Style2);
16369   ASSERT_EQ(*Style2, getLLVMStyle());
16370 
16371   // Test 3: format file in parent directory.
16372   ASSERT_TRUE(
16373       FS.addFile("/c/.clang-format", 0,
16374                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
16375   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
16376                          llvm::MemoryBuffer::getMemBuffer("int i;")));
16377   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
16378   ASSERT_TRUE((bool)Style3);
16379   ASSERT_EQ(*Style3, getGoogleStyle());
16380 
16381   // Test 4: error on invalid fallback style
16382   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
16383   ASSERT_FALSE((bool)Style4);
16384   llvm::consumeError(Style4.takeError());
16385 
16386   // Test 5: error on invalid yaml on command line
16387   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
16388   ASSERT_FALSE((bool)Style5);
16389   llvm::consumeError(Style5.takeError());
16390 
16391   // Test 6: error on invalid style
16392   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
16393   ASSERT_FALSE((bool)Style6);
16394   llvm::consumeError(Style6.takeError());
16395 
16396   // Test 7: found config file, error on parsing it
16397   ASSERT_TRUE(
16398       FS.addFile("/d/.clang-format", 0,
16399                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
16400                                                   "InvalidKey: InvalidValue")));
16401   ASSERT_TRUE(
16402       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16403   auto Style7a = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
16404   ASSERT_FALSE((bool)Style7a);
16405   llvm::consumeError(Style7a.takeError());
16406 
16407   auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
16408   ASSERT_TRUE((bool)Style7b);
16409 
16410   // Test 8: inferred per-language defaults apply.
16411   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
16412   ASSERT_TRUE((bool)StyleTd);
16413   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
16414 }
16415 
16416 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
16417   // Column limit is 20.
16418   std::string Code = "Type *a =\n"
16419                      "    new Type();\n"
16420                      "g(iiiii, 0, jjjjj,\n"
16421                      "  0, kkkkk, 0, mm);\n"
16422                      "int  bad     = format   ;";
16423   std::string Expected = "auto a = new Type();\n"
16424                          "g(iiiii, nullptr,\n"
16425                          "  jjjjj, nullptr,\n"
16426                          "  kkkkk, nullptr,\n"
16427                          "  mm);\n"
16428                          "int  bad     = format   ;";
16429   FileID ID = Context.createInMemoryFile("format.cpp", Code);
16430   tooling::Replacements Replaces = toReplacements(
16431       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
16432                             "auto "),
16433        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
16434                             "nullptr"),
16435        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
16436                             "nullptr"),
16437        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
16438                             "nullptr")});
16439 
16440   format::FormatStyle Style = format::getLLVMStyle();
16441   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
16442   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16443   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16444       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16445   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16446   EXPECT_TRUE(static_cast<bool>(Result));
16447   EXPECT_EQ(Expected, *Result);
16448 }
16449 
16450 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
16451   std::string Code = "#include \"a.h\"\n"
16452                      "#include \"c.h\"\n"
16453                      "\n"
16454                      "int main() {\n"
16455                      "  return 0;\n"
16456                      "}";
16457   std::string Expected = "#include \"a.h\"\n"
16458                          "#include \"b.h\"\n"
16459                          "#include \"c.h\"\n"
16460                          "\n"
16461                          "int main() {\n"
16462                          "  return 0;\n"
16463                          "}";
16464   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
16465   tooling::Replacements Replaces = toReplacements(
16466       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
16467                             "#include \"b.h\"\n")});
16468 
16469   format::FormatStyle Style = format::getLLVMStyle();
16470   Style.SortIncludes = true;
16471   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16472   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16473       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16474   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16475   EXPECT_TRUE(static_cast<bool>(Result));
16476   EXPECT_EQ(Expected, *Result);
16477 }
16478 
16479 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
16480   EXPECT_EQ("using std::cin;\n"
16481             "using std::cout;",
16482             format("using std::cout;\n"
16483                    "using std::cin;",
16484                    getGoogleStyle()));
16485 }
16486 
16487 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
16488   format::FormatStyle Style = format::getLLVMStyle();
16489   Style.Standard = FormatStyle::LS_Cpp03;
16490   // cpp03 recognize this string as identifier u8 and literal character 'a'
16491   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
16492 }
16493 
16494 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
16495   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
16496   // all modes, including C++11, C++14 and C++17
16497   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
16498 }
16499 
16500 TEST_F(FormatTest, DoNotFormatLikelyXml) {
16501   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
16502   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
16503 }
16504 
16505 TEST_F(FormatTest, StructuredBindings) {
16506   // Structured bindings is a C++17 feature.
16507   // all modes, including C++11, C++14 and C++17
16508   verifyFormat("auto [a, b] = f();");
16509   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
16510   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
16511   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
16512   EXPECT_EQ("auto const volatile [a, b] = f();",
16513             format("auto  const   volatile[a, b] = f();"));
16514   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
16515   EXPECT_EQ("auto &[a, b, c] = f();",
16516             format("auto   &[  a  ,  b,c   ] = f();"));
16517   EXPECT_EQ("auto &&[a, b, c] = f();",
16518             format("auto   &&[  a  ,  b,c   ] = f();"));
16519   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
16520   EXPECT_EQ("auto const volatile &&[a, b] = f();",
16521             format("auto  const  volatile  &&[a, b] = f();"));
16522   EXPECT_EQ("auto const &&[a, b] = f();",
16523             format("auto  const   &&  [a, b] = f();"));
16524   EXPECT_EQ("const auto &[a, b] = f();",
16525             format("const  auto  &  [a, b] = f();"));
16526   EXPECT_EQ("const auto volatile &&[a, b] = f();",
16527             format("const  auto   volatile  &&[a, b] = f();"));
16528   EXPECT_EQ("volatile const auto &&[a, b] = f();",
16529             format("volatile  const  auto   &&[a, b] = f();"));
16530   EXPECT_EQ("const auto &&[a, b] = f();",
16531             format("const  auto  &&  [a, b] = f();"));
16532 
16533   // Make sure we don't mistake structured bindings for lambdas.
16534   FormatStyle PointerMiddle = getLLVMStyle();
16535   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16536   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16537   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16538   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16539   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16540   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16541   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16542   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16543   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16544   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16545   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16546   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16547   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16548 
16549   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16550             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16551   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16552             format("for (const auto   &   [a, b] : some_range) {\n}"));
16553   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16554             format("for (const auto[a, b] : some_range) {\n}"));
16555   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16556   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16557   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16558   EXPECT_EQ("auto const &[x, y](expr);",
16559             format("auto  const  &  [x,y]  (expr);"));
16560   EXPECT_EQ("auto const &&[x, y](expr);",
16561             format("auto  const  &&  [x,y]  (expr);"));
16562   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16563   EXPECT_EQ("auto const &[x, y]{expr};",
16564             format("auto  const  &  [x,y]  {expr};"));
16565   EXPECT_EQ("auto const &&[x, y]{expr};",
16566             format("auto  const  &&  [x,y]  {expr};"));
16567 
16568   format::FormatStyle Spaces = format::getLLVMStyle();
16569   Spaces.SpacesInSquareBrackets = true;
16570   verifyFormat("auto [ a, b ] = f();", Spaces);
16571   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16572   verifyFormat("auto &[ a, b ] = f();", Spaces);
16573   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16574   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16575 }
16576 
16577 TEST_F(FormatTest, FileAndCode) {
16578   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16579   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16580   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16581   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16582   EXPECT_EQ(FormatStyle::LK_ObjC,
16583             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16584   EXPECT_EQ(
16585       FormatStyle::LK_ObjC,
16586       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16587   EXPECT_EQ(FormatStyle::LK_ObjC,
16588             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16589   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16590   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16591   EXPECT_EQ(FormatStyle::LK_ObjC,
16592             guessLanguage("foo", "@interface Foo\n@end\n"));
16593   EXPECT_EQ(FormatStyle::LK_ObjC,
16594             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16595   EXPECT_EQ(
16596       FormatStyle::LK_ObjC,
16597       guessLanguage("foo.h",
16598                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16599   EXPECT_EQ(
16600       FormatStyle::LK_Cpp,
16601       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16602 }
16603 
16604 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16605   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16606   EXPECT_EQ(FormatStyle::LK_ObjC,
16607             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16608   EXPECT_EQ(FormatStyle::LK_Cpp,
16609             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16610   EXPECT_EQ(
16611       FormatStyle::LK_Cpp,
16612       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16613   EXPECT_EQ(FormatStyle::LK_ObjC,
16614             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16615   EXPECT_EQ(FormatStyle::LK_Cpp,
16616             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16617   EXPECT_EQ(FormatStyle::LK_ObjC,
16618             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16619   EXPECT_EQ(FormatStyle::LK_Cpp,
16620             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16621   EXPECT_EQ(FormatStyle::LK_Cpp,
16622             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16623   EXPECT_EQ(FormatStyle::LK_ObjC,
16624             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16625   EXPECT_EQ(FormatStyle::LK_Cpp,
16626             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16627   EXPECT_EQ(
16628       FormatStyle::LK_Cpp,
16629       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16630   EXPECT_EQ(
16631       FormatStyle::LK_Cpp,
16632       guessLanguage("foo.h",
16633                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16634   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16635 }
16636 
16637 TEST_F(FormatTest, GuessLanguageWithCaret) {
16638   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16639   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16640   EXPECT_EQ(FormatStyle::LK_ObjC,
16641             guessLanguage("foo.h", "int(^)(char, float);"));
16642   EXPECT_EQ(FormatStyle::LK_ObjC,
16643             guessLanguage("foo.h", "int(^foo)(char, float);"));
16644   EXPECT_EQ(FormatStyle::LK_ObjC,
16645             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16646   EXPECT_EQ(FormatStyle::LK_ObjC,
16647             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
16648   EXPECT_EQ(
16649       FormatStyle::LK_ObjC,
16650       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
16651 }
16652 
16653 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
16654   // ASM symbolic names are identifiers that must be surrounded by [] without
16655   // space in between:
16656   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
16657 
16658   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
16659   verifyFormat(R"(//
16660 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
16661 )");
16662 
16663   // A list of several ASM symbolic names.
16664   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
16665 
16666   // ASM symbolic names in inline ASM with inputs and outputs.
16667   verifyFormat(R"(//
16668 asm("cmoveq %1, %2, %[result]"
16669     : [result] "=r"(result)
16670     : "r"(test), "r"(new), "[result]"(old));
16671 )");
16672 
16673   // ASM symbolic names in inline ASM with no outputs.
16674   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
16675 }
16676 
16677 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
16678   EXPECT_EQ(FormatStyle::LK_Cpp,
16679             guessLanguage("foo.h", "void f() {\n"
16680                                    "  asm (\"mov %[e], %[d]\"\n"
16681                                    "     : [d] \"=rm\" (d)\n"
16682                                    "       [e] \"rm\" (*e));\n"
16683                                    "}"));
16684   EXPECT_EQ(FormatStyle::LK_Cpp,
16685             guessLanguage("foo.h", "void f() {\n"
16686                                    "  _asm (\"mov %[e], %[d]\"\n"
16687                                    "     : [d] \"=rm\" (d)\n"
16688                                    "       [e] \"rm\" (*e));\n"
16689                                    "}"));
16690   EXPECT_EQ(FormatStyle::LK_Cpp,
16691             guessLanguage("foo.h", "void f() {\n"
16692                                    "  __asm (\"mov %[e], %[d]\"\n"
16693                                    "     : [d] \"=rm\" (d)\n"
16694                                    "       [e] \"rm\" (*e));\n"
16695                                    "}"));
16696   EXPECT_EQ(FormatStyle::LK_Cpp,
16697             guessLanguage("foo.h", "void f() {\n"
16698                                    "  __asm__ (\"mov %[e], %[d]\"\n"
16699                                    "     : [d] \"=rm\" (d)\n"
16700                                    "       [e] \"rm\" (*e));\n"
16701                                    "}"));
16702   EXPECT_EQ(FormatStyle::LK_Cpp,
16703             guessLanguage("foo.h", "void f() {\n"
16704                                    "  asm (\"mov %[e], %[d]\"\n"
16705                                    "     : [d] \"=rm\" (d),\n"
16706                                    "       [e] \"rm\" (*e));\n"
16707                                    "}"));
16708   EXPECT_EQ(FormatStyle::LK_Cpp,
16709             guessLanguage("foo.h", "void f() {\n"
16710                                    "  asm volatile (\"mov %[e], %[d]\"\n"
16711                                    "     : [d] \"=rm\" (d)\n"
16712                                    "       [e] \"rm\" (*e));\n"
16713                                    "}"));
16714 }
16715 
16716 TEST_F(FormatTest, GuessLanguageWithChildLines) {
16717   EXPECT_EQ(FormatStyle::LK_Cpp,
16718             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
16719   EXPECT_EQ(FormatStyle::LK_ObjC,
16720             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
16721   EXPECT_EQ(
16722       FormatStyle::LK_Cpp,
16723       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
16724   EXPECT_EQ(
16725       FormatStyle::LK_ObjC,
16726       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
16727 }
16728 
16729 TEST_F(FormatTest, TypenameMacros) {
16730   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
16731 
16732   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
16733   FormatStyle Google = getGoogleStyleWithColumns(0);
16734   Google.TypenameMacros = TypenameMacros;
16735   verifyFormat("struct foo {\n"
16736                "  int bar;\n"
16737                "  TAILQ_ENTRY(a) bleh;\n"
16738                "};",
16739                Google);
16740 
16741   FormatStyle Macros = getLLVMStyle();
16742   Macros.TypenameMacros = TypenameMacros;
16743 
16744   verifyFormat("STACK_OF(int) a;", Macros);
16745   verifyFormat("STACK_OF(int) *a;", Macros);
16746   verifyFormat("STACK_OF(int const *) *a;", Macros);
16747   verifyFormat("STACK_OF(int *const) *a;", Macros);
16748   verifyFormat("STACK_OF(int, string) a;", Macros);
16749   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
16750   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
16751   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
16752   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
16753   verifyFormat("vector<LIST(uint64_t) *attr> x;", Macros);
16754   verifyFormat("vector<LIST(uint64_t) *const> f(LIST(uint64_t) *arg);", Macros);
16755 
16756   Macros.PointerAlignment = FormatStyle::PAS_Left;
16757   verifyFormat("STACK_OF(int)* a;", Macros);
16758   verifyFormat("STACK_OF(int*)* a;", Macros);
16759   verifyFormat("x = (STACK_OF(uint64_t))*a;", Macros);
16760   verifyFormat("x = (STACK_OF(uint64_t))&a;", Macros);
16761   verifyFormat("vector<STACK_OF(uint64_t)* attr> x;", Macros);
16762 }
16763 
16764 TEST_F(FormatTest, AtomicQualifier) {
16765   // Check that we treate _Atomic as a type and not a function call
16766   FormatStyle Google = getGoogleStyleWithColumns(0);
16767   verifyFormat("struct foo {\n"
16768                "  int a1;\n"
16769                "  _Atomic(a) a2;\n"
16770                "  _Atomic(_Atomic(int) *const) a3;\n"
16771                "};",
16772                Google);
16773   verifyFormat("_Atomic(uint64_t) a;");
16774   verifyFormat("_Atomic(uint64_t) *a;");
16775   verifyFormat("_Atomic(uint64_t const *) *a;");
16776   verifyFormat("_Atomic(uint64_t *const) *a;");
16777   verifyFormat("_Atomic(const uint64_t *) *a;");
16778   verifyFormat("_Atomic(uint64_t) a;");
16779   verifyFormat("_Atomic(_Atomic(uint64_t)) a;");
16780   verifyFormat("_Atomic(_Atomic(uint64_t)) a, b;");
16781   verifyFormat("for (_Atomic(uint64_t) *a = NULL; a;) {\n}");
16782   verifyFormat("_Atomic(uint64_t) f(_Atomic(uint64_t) *arg);");
16783 
16784   verifyFormat("_Atomic(uint64_t) *s(InitValue);");
16785   verifyFormat("_Atomic(uint64_t) *s{InitValue};");
16786   FormatStyle Style = getLLVMStyle();
16787   Style.PointerAlignment = FormatStyle::PAS_Left;
16788   verifyFormat("_Atomic(uint64_t)* s(InitValue);", Style);
16789   verifyFormat("_Atomic(uint64_t)* s{InitValue};", Style);
16790   verifyFormat("_Atomic(int)* a;", Style);
16791   verifyFormat("_Atomic(int*)* a;", Style);
16792   verifyFormat("vector<_Atomic(uint64_t)* attr> x;", Style);
16793 
16794   Style.SpacesInCStyleCastParentheses = true;
16795   Style.SpacesInParentheses = false;
16796   verifyFormat("x = ( _Atomic(uint64_t) )*a;", Style);
16797   Style.SpacesInCStyleCastParentheses = false;
16798   Style.SpacesInParentheses = true;
16799   verifyFormat("x = (_Atomic( uint64_t ))*a;", Style);
16800   verifyFormat("x = (_Atomic( uint64_t ))&a;", Style);
16801 }
16802 
16803 TEST_F(FormatTest, AmbersandInLamda) {
16804   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
16805   FormatStyle AlignStyle = getLLVMStyle();
16806   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
16807   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16808   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
16809   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
16810 }
16811 
16812 TEST_F(FormatTest, SpacesInConditionalStatement) {
16813   FormatStyle Spaces = getLLVMStyle();
16814   Spaces.SpacesInConditionalStatement = true;
16815   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
16816   verifyFormat("if ( !a )\n  return;", Spaces);
16817   verifyFormat("if ( a )\n  return;", Spaces);
16818   verifyFormat("if constexpr ( a )\n  return;", Spaces);
16819   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
16820   verifyFormat("while ( a )\n  return;", Spaces);
16821   verifyFormat("while ( (a && b) )\n  return;", Spaces);
16822   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
16823   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
16824   // Check that space on the left of "::" is inserted as expected at beginning
16825   // of condition.
16826   verifyFormat("while ( ::func() )\n  return;", Spaces);
16827 }
16828 
16829 TEST_F(FormatTest, AlternativeOperators) {
16830   // Test case for ensuring alternate operators are not
16831   // combined with their right most neighbour.
16832   verifyFormat("int a and b;");
16833   verifyFormat("int a and_eq b;");
16834   verifyFormat("int a bitand b;");
16835   verifyFormat("int a bitor b;");
16836   verifyFormat("int a compl b;");
16837   verifyFormat("int a not b;");
16838   verifyFormat("int a not_eq b;");
16839   verifyFormat("int a or b;");
16840   verifyFormat("int a xor b;");
16841   verifyFormat("int a xor_eq b;");
16842   verifyFormat("return this not_eq bitand other;");
16843   verifyFormat("bool operator not_eq(const X bitand other)");
16844 
16845   verifyFormat("int a and 5;");
16846   verifyFormat("int a and_eq 5;");
16847   verifyFormat("int a bitand 5;");
16848   verifyFormat("int a bitor 5;");
16849   verifyFormat("int a compl 5;");
16850   verifyFormat("int a not 5;");
16851   verifyFormat("int a not_eq 5;");
16852   verifyFormat("int a or 5;");
16853   verifyFormat("int a xor 5;");
16854   verifyFormat("int a xor_eq 5;");
16855 
16856   verifyFormat("int a compl(5);");
16857   verifyFormat("int a not(5);");
16858 
16859   /* FIXME handle alternate tokens
16860    * https://en.cppreference.com/w/cpp/language/operator_alternative
16861   // alternative tokens
16862   verifyFormat("compl foo();");     //  ~foo();
16863   verifyFormat("foo() <%%>;");      // foo();
16864   verifyFormat("void foo() <%%>;"); // void foo(){}
16865   verifyFormat("int a <:1:>;");     // int a[1];[
16866   verifyFormat("%:define ABC abc"); // #define ABC abc
16867   verifyFormat("%:%:");             // ##
16868   */
16869 }
16870 
16871 TEST_F(FormatTest, STLWhileNotDefineChed) {
16872   verifyFormat("#if defined(while)\n"
16873                "#define while EMIT WARNING C4005\n"
16874                "#endif // while");
16875 }
16876 
16877 TEST_F(FormatTest, OperatorSpacing) {
16878   FormatStyle Style = getLLVMStyle();
16879   Style.PointerAlignment = FormatStyle::PAS_Right;
16880   verifyFormat("Foo::operator*();", Style);
16881   verifyFormat("Foo::operator void *();", Style);
16882   verifyFormat("Foo::operator void **();", Style);
16883   verifyFormat("Foo::operator void *&();", Style);
16884   verifyFormat("Foo::operator void *&&();", Style);
16885   verifyFormat("Foo::operator()(void *);", Style);
16886   verifyFormat("Foo::operator*(void *);", Style);
16887   verifyFormat("Foo::operator*();", Style);
16888   verifyFormat("Foo::operator**();", Style);
16889   verifyFormat("Foo::operator&();", Style);
16890   verifyFormat("Foo::operator<int> *();", Style);
16891   verifyFormat("Foo::operator<Foo> *();", Style);
16892   verifyFormat("Foo::operator<int> **();", Style);
16893   verifyFormat("Foo::operator<Foo> **();", Style);
16894   verifyFormat("Foo::operator<int> &();", Style);
16895   verifyFormat("Foo::operator<Foo> &();", Style);
16896   verifyFormat("Foo::operator<int> &&();", Style);
16897   verifyFormat("Foo::operator<Foo> &&();", Style);
16898   verifyFormat("Foo::operator<int> *&();", Style);
16899   verifyFormat("Foo::operator<Foo> *&();", Style);
16900   verifyFormat("Foo::operator<int> *&&();", Style);
16901   verifyFormat("Foo::operator<Foo> *&&();", Style);
16902   verifyFormat("operator*(int (*)(), class Foo);", Style);
16903 
16904   verifyFormat("Foo::operator&();", Style);
16905   verifyFormat("Foo::operator void &();", Style);
16906   verifyFormat("Foo::operator()(void &);", Style);
16907   verifyFormat("Foo::operator&(void &);", Style);
16908   verifyFormat("Foo::operator&();", Style);
16909   verifyFormat("operator&(int (&)(), class Foo);", Style);
16910 
16911   verifyFormat("Foo::operator&&();", Style);
16912   verifyFormat("Foo::operator**();", Style);
16913   verifyFormat("Foo::operator void &&();", Style);
16914   verifyFormat("Foo::operator()(void &&);", Style);
16915   verifyFormat("Foo::operator&&(void &&);", Style);
16916   verifyFormat("Foo::operator&&();", Style);
16917   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16918   verifyFormat("operator const nsTArrayRight<E> &()", Style);
16919   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
16920                Style);
16921   verifyFormat("operator void **()", Style);
16922   verifyFormat("operator const FooRight<Object> &()", Style);
16923   verifyFormat("operator const FooRight<Object> *()", Style);
16924   verifyFormat("operator const FooRight<Object> **()", Style);
16925   verifyFormat("operator const FooRight<Object> *&()", Style);
16926   verifyFormat("operator const FooRight<Object> *&&()", Style);
16927 
16928   Style.PointerAlignment = FormatStyle::PAS_Left;
16929   verifyFormat("Foo::operator*();", Style);
16930   verifyFormat("Foo::operator**();", Style);
16931   verifyFormat("Foo::operator void*();", Style);
16932   verifyFormat("Foo::operator void**();", Style);
16933   verifyFormat("Foo::operator void*&();", Style);
16934   verifyFormat("Foo::operator/*comment*/ void*();", Style);
16935   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
16936   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
16937   verifyFormat("Foo::operator()(void*);", Style);
16938   verifyFormat("Foo::operator*(void*);", Style);
16939   verifyFormat("Foo::operator*();", Style);
16940   verifyFormat("Foo::operator<int>*();", Style);
16941   verifyFormat("Foo::operator<Foo>*();", Style);
16942   verifyFormat("Foo::operator<int>**();", Style);
16943   verifyFormat("Foo::operator<Foo>**();", Style);
16944   verifyFormat("Foo::operator<Foo>*&();", Style);
16945   verifyFormat("Foo::operator<int>&();", Style);
16946   verifyFormat("Foo::operator<Foo>&();", Style);
16947   verifyFormat("Foo::operator<int>&&();", Style);
16948   verifyFormat("Foo::operator<Foo>&&();", Style);
16949   verifyFormat("Foo::operator<int>*&();", Style);
16950   verifyFormat("Foo::operator<Foo>*&();", Style);
16951   verifyFormat("operator*(int (*)(), class Foo);", Style);
16952 
16953   verifyFormat("Foo::operator&();", Style);
16954   verifyFormat("Foo::operator void&();", Style);
16955   verifyFormat("Foo::operator/*comment*/ void&();", Style);
16956   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
16957   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
16958   verifyFormat("Foo::operator()(void&);", Style);
16959   verifyFormat("Foo::operator&(void&);", Style);
16960   verifyFormat("Foo::operator&();", Style);
16961   verifyFormat("operator&(int (&)(), class Foo);", Style);
16962 
16963   verifyFormat("Foo::operator&&();", Style);
16964   verifyFormat("Foo::operator void&&();", Style);
16965   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
16966   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
16967   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
16968   verifyFormat("Foo::operator()(void&&);", Style);
16969   verifyFormat("Foo::operator&&(void&&);", Style);
16970   verifyFormat("Foo::operator&&();", Style);
16971   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
16972   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
16973   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
16974                Style);
16975   verifyFormat("operator void**()", Style);
16976   verifyFormat("operator const FooLeft<Object>&()", Style);
16977   verifyFormat("operator const FooLeft<Object>*()", Style);
16978   verifyFormat("operator const FooLeft<Object>**()", Style);
16979   verifyFormat("operator const FooLeft<Object>*&()", Style);
16980   verifyFormat("operator const FooLeft<Object>*&&()", Style);
16981 
16982   // PR45107
16983   verifyFormat("operator Vector<String>&();", Style);
16984   verifyFormat("operator const Vector<String>&();", Style);
16985   verifyFormat("operator foo::Bar*();", Style);
16986   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
16987   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
16988                Style);
16989 
16990   Style.PointerAlignment = FormatStyle::PAS_Middle;
16991   verifyFormat("Foo::operator*();", Style);
16992   verifyFormat("Foo::operator void *();", Style);
16993   verifyFormat("Foo::operator()(void *);", Style);
16994   verifyFormat("Foo::operator*(void *);", Style);
16995   verifyFormat("Foo::operator*();", Style);
16996   verifyFormat("operator*(int (*)(), class Foo);", Style);
16997 
16998   verifyFormat("Foo::operator&();", Style);
16999   verifyFormat("Foo::operator void &();", Style);
17000   verifyFormat("Foo::operator()(void &);", Style);
17001   verifyFormat("Foo::operator&(void &);", Style);
17002   verifyFormat("Foo::operator&();", Style);
17003   verifyFormat("operator&(int (&)(), class Foo);", Style);
17004 
17005   verifyFormat("Foo::operator&&();", Style);
17006   verifyFormat("Foo::operator void &&();", Style);
17007   verifyFormat("Foo::operator()(void &&);", Style);
17008   verifyFormat("Foo::operator&&(void &&);", Style);
17009   verifyFormat("Foo::operator&&();", Style);
17010   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
17011 }
17012 
17013 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
17014   FormatStyle Style = getLLVMStyle();
17015   // PR46157
17016   verifyFormat("foo(operator+, -42);", Style);
17017   verifyFormat("foo(operator++, -42);", Style);
17018   verifyFormat("foo(operator--, -42);", Style);
17019   verifyFormat("foo(-42, operator--);", Style);
17020   verifyFormat("foo(-42, operator, );", Style);
17021   verifyFormat("foo(operator, , -42);", Style);
17022 }
17023 
17024 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
17025   FormatStyle Style = getLLVMStyle();
17026   Style.WhitespaceSensitiveMacros.push_back("FOO");
17027 
17028   // Don't use the helpers here, since 'mess up' will change the whitespace
17029   // and these are all whitespace sensitive by definition
17030   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
17031             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
17032   EXPECT_EQ(
17033       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
17034       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
17035   EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
17036             format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
17037   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
17038             "       Still=Intentional);",
17039             format("FOO(String-ized&Messy+But,: :\n"
17040                    "       Still=Intentional);",
17041                    Style));
17042   Style.AlignConsecutiveAssignments = true;
17043   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
17044             "       Still=Intentional);",
17045             format("FOO(String-ized=&Messy+But,: :\n"
17046                    "       Still=Intentional);",
17047                    Style));
17048 
17049   Style.ColumnLimit = 21;
17050   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
17051             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
17052 }
17053 
17054 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
17055   // These tests are not in NamespaceFixer because that doesn't
17056   // test its interaction with line wrapping
17057   FormatStyle Style = getLLVMStyle();
17058   Style.ColumnLimit = 80;
17059   verifyFormat("namespace {\n"
17060                "int i;\n"
17061                "int j;\n"
17062                "} // namespace",
17063                Style);
17064 
17065   verifyFormat("namespace AAA {\n"
17066                "int i;\n"
17067                "int j;\n"
17068                "} // namespace AAA",
17069                Style);
17070 
17071   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
17072             "int i;\n"
17073             "int j;\n"
17074             "} // namespace Averyveryveryverylongnamespace",
17075             format("namespace Averyveryveryverylongnamespace {\n"
17076                    "int i;\n"
17077                    "int j;\n"
17078                    "}",
17079                    Style));
17080 
17081   EXPECT_EQ(
17082       "namespace "
17083       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
17084       "    went::mad::now {\n"
17085       "int i;\n"
17086       "int j;\n"
17087       "} // namespace\n"
17088       "  // "
17089       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
17090       "went::mad::now",
17091       format("namespace "
17092              "would::it::save::you::a::lot::of::time::if_::i::"
17093              "just::gave::up::and_::went::mad::now {\n"
17094              "int i;\n"
17095              "int j;\n"
17096              "}",
17097              Style));
17098 
17099   // This used to duplicate the comment again and again on subsequent runs
17100   EXPECT_EQ(
17101       "namespace "
17102       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
17103       "    went::mad::now {\n"
17104       "int i;\n"
17105       "int j;\n"
17106       "} // namespace\n"
17107       "  // "
17108       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
17109       "went::mad::now",
17110       format("namespace "
17111              "would::it::save::you::a::lot::of::time::if_::i::"
17112              "just::gave::up::and_::went::mad::now {\n"
17113              "int i;\n"
17114              "int j;\n"
17115              "} // namespace\n"
17116              "  // "
17117              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
17118              "and_::went::mad::now",
17119              Style));
17120 }
17121 
17122 TEST_F(FormatTest, LikelyUnlikely) {
17123   FormatStyle Style = getLLVMStyle();
17124 
17125   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17126                "  return 29;\n"
17127                "}",
17128                Style);
17129 
17130   verifyFormat("if (argc > 5) [[likely]] {\n"
17131                "  return 29;\n"
17132                "}",
17133                Style);
17134 
17135   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17136                "  return 29;\n"
17137                "} else [[likely]] {\n"
17138                "  return 42;\n"
17139                "}\n",
17140                Style);
17141 
17142   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17143                "  return 29;\n"
17144                "} else if (argc > 10) [[likely]] {\n"
17145                "  return 99;\n"
17146                "} else {\n"
17147                "  return 42;\n"
17148                "}\n",
17149                Style);
17150 
17151   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
17152                "  return 29;\n"
17153                "}",
17154                Style);
17155 }
17156 
17157 TEST_F(FormatTest, LLVMDefaultStyle) {
17158   FormatStyle Style = getLLVMStyle();
17159   verifyFormat("extern \"C\" {\n"
17160                "int foo();\n"
17161                "}",
17162                Style);
17163 }
17164 TEST_F(FormatTest, GNUDefaultStyle) {
17165   FormatStyle Style = getGNUStyle();
17166   verifyFormat("extern \"C\"\n"
17167                "{\n"
17168                "  int foo ();\n"
17169                "}",
17170                Style);
17171 }
17172 TEST_F(FormatTest, MozillaDefaultStyle) {
17173   FormatStyle Style = getMozillaStyle();
17174   verifyFormat("extern \"C\"\n"
17175                "{\n"
17176                "  int foo();\n"
17177                "}",
17178                Style);
17179 }
17180 TEST_F(FormatTest, GoogleDefaultStyle) {
17181   FormatStyle Style = getGoogleStyle();
17182   verifyFormat("extern \"C\" {\n"
17183                "int foo();\n"
17184                "}",
17185                Style);
17186 }
17187 TEST_F(FormatTest, ChromiumDefaultStyle) {
17188   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
17189   verifyFormat("extern \"C\" {\n"
17190                "int foo();\n"
17191                "}",
17192                Style);
17193 }
17194 TEST_F(FormatTest, MicrosoftDefaultStyle) {
17195   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
17196   verifyFormat("extern \"C\"\n"
17197                "{\n"
17198                "    int foo();\n"
17199                "}",
17200                Style);
17201 }
17202 TEST_F(FormatTest, WebKitDefaultStyle) {
17203   FormatStyle Style = getWebKitStyle();
17204   verifyFormat("extern \"C\" {\n"
17205                "int foo();\n"
17206                "}",
17207                Style);
17208 }
17209 } // namespace
17210 } // namespace format
17211 } // namespace clang
17212