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   verifyFormat("class A {\n"
2731                "  int a;\n"
2732                "  A() try : a(0), b{1} {\n"
2733                "  } catch (...) {\n"
2734                "    throw;\n"
2735                "  }\n"
2736                "};\n");
2737   verifyFormat("class A {\n"
2738                "  int a;\n"
2739                "  A() try : a(0), b{1}, c{2} {\n"
2740                "  } catch (...) {\n"
2741                "    throw;\n"
2742                "  }\n"
2743                "};\n");
2744   verifyFormat("class A {\n"
2745                "  int a;\n"
2746                "  A() try : a(0), b{1}, c{2} {\n"
2747                "    { // New scope.\n"
2748                "    }\n"
2749                "  } catch (...) {\n"
2750                "    throw;\n"
2751                "  }\n"
2752                "};\n");
2753 
2754   // Incomplete try-catch blocks.
2755   verifyIncompleteFormat("try {} catch (");
2756 }
2757 
2758 TEST_F(FormatTest, FormatTryAsAVariable) {
2759   verifyFormat("int try;");
2760   verifyFormat("int try, size;");
2761   verifyFormat("try = foo();");
2762   verifyFormat("if (try < size) {\n  return true;\n}");
2763 
2764   verifyFormat("int catch;");
2765   verifyFormat("int catch, size;");
2766   verifyFormat("catch = foo();");
2767   verifyFormat("if (catch < size) {\n  return true;\n}");
2768 
2769   FormatStyle Style = getLLVMStyle();
2770   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2771   Style.BraceWrapping.AfterFunction = true;
2772   Style.BraceWrapping.BeforeCatch = true;
2773   verifyFormat("try {\n"
2774                "  int bar = 1;\n"
2775                "}\n"
2776                "catch (...) {\n"
2777                "  int bar = 1;\n"
2778                "}",
2779                Style);
2780   verifyFormat("#if NO_EX\n"
2781                "try\n"
2782                "#endif\n"
2783                "{\n"
2784                "}\n"
2785                "#if NO_EX\n"
2786                "catch (...) {\n"
2787                "}",
2788                Style);
2789   verifyFormat("try /* abc */ {\n"
2790                "  int bar = 1;\n"
2791                "}\n"
2792                "catch (...) {\n"
2793                "  int bar = 1;\n"
2794                "}",
2795                Style);
2796   verifyFormat("try\n"
2797                "// abc\n"
2798                "{\n"
2799                "  int bar = 1;\n"
2800                "}\n"
2801                "catch (...) {\n"
2802                "  int bar = 1;\n"
2803                "}",
2804                Style);
2805 }
2806 
2807 TEST_F(FormatTest, FormatSEHTryCatch) {
2808   verifyFormat("__try {\n"
2809                "  int a = b * c;\n"
2810                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
2811                "  // Do nothing.\n"
2812                "}");
2813 
2814   verifyFormat("__try {\n"
2815                "  int a = b * c;\n"
2816                "} __finally {\n"
2817                "  // Do nothing.\n"
2818                "}");
2819 
2820   verifyFormat("DEBUG({\n"
2821                "  __try {\n"
2822                "  } __finally {\n"
2823                "  }\n"
2824                "});\n");
2825 }
2826 
2827 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
2828   verifyFormat("try {\n"
2829                "  f();\n"
2830                "} catch {\n"
2831                "  g();\n"
2832                "}");
2833   verifyFormat("try {\n"
2834                "  f();\n"
2835                "} catch (A a) MACRO(x) {\n"
2836                "  g();\n"
2837                "} catch (B b) MACRO(x) {\n"
2838                "  g();\n"
2839                "}");
2840 }
2841 
2842 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
2843   FormatStyle Style = getLLVMStyle();
2844   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
2845                           FormatStyle::BS_WebKit}) {
2846     Style.BreakBeforeBraces = BraceStyle;
2847     verifyFormat("try {\n"
2848                  "  // something\n"
2849                  "} catch (...) {\n"
2850                  "  // something\n"
2851                  "}",
2852                  Style);
2853   }
2854   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
2855   verifyFormat("try {\n"
2856                "  // something\n"
2857                "}\n"
2858                "catch (...) {\n"
2859                "  // something\n"
2860                "}",
2861                Style);
2862   verifyFormat("__try {\n"
2863                "  // something\n"
2864                "}\n"
2865                "__finally {\n"
2866                "  // something\n"
2867                "}",
2868                Style);
2869   verifyFormat("@try {\n"
2870                "  // something\n"
2871                "}\n"
2872                "@finally {\n"
2873                "  // something\n"
2874                "}",
2875                Style);
2876   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
2877   verifyFormat("try\n"
2878                "{\n"
2879                "  // something\n"
2880                "}\n"
2881                "catch (...)\n"
2882                "{\n"
2883                "  // something\n"
2884                "}",
2885                Style);
2886   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
2887   verifyFormat("try\n"
2888                "  {\n"
2889                "  // something white\n"
2890                "  }\n"
2891                "catch (...)\n"
2892                "  {\n"
2893                "  // something white\n"
2894                "  }",
2895                Style);
2896   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
2897   verifyFormat("try\n"
2898                "  {\n"
2899                "    // something\n"
2900                "  }\n"
2901                "catch (...)\n"
2902                "  {\n"
2903                "    // something\n"
2904                "  }",
2905                Style);
2906   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2907   Style.BraceWrapping.BeforeCatch = true;
2908   verifyFormat("try {\n"
2909                "  // something\n"
2910                "}\n"
2911                "catch (...) {\n"
2912                "  // something\n"
2913                "}",
2914                Style);
2915 }
2916 
2917 TEST_F(FormatTest, StaticInitializers) {
2918   verifyFormat("static SomeClass SC = {1, 'a'};");
2919 
2920   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
2921                "    100000000, "
2922                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
2923 
2924   // Here, everything other than the "}" would fit on a line.
2925   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
2926                "    10000000000000000000000000};");
2927   EXPECT_EQ("S s = {a,\n"
2928             "\n"
2929             "       b};",
2930             format("S s = {\n"
2931                    "  a,\n"
2932                    "\n"
2933                    "  b\n"
2934                    "};"));
2935 
2936   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
2937   // line. However, the formatting looks a bit off and this probably doesn't
2938   // happen often in practice.
2939   verifyFormat("static int Variable[1] = {\n"
2940                "    {1000000000000000000000000000000000000}};",
2941                getLLVMStyleWithColumns(40));
2942 }
2943 
2944 TEST_F(FormatTest, DesignatedInitializers) {
2945   verifyFormat("const struct A a = {.a = 1, .b = 2};");
2946   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
2947                "                    .bbbbbbbbbb = 2,\n"
2948                "                    .cccccccccc = 3,\n"
2949                "                    .dddddddddd = 4,\n"
2950                "                    .eeeeeeeeee = 5};");
2951   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2952                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
2953                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
2954                "    .ccccccccccccccccccccccccccc = 3,\n"
2955                "    .ddddddddddddddddddddddddddd = 4,\n"
2956                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
2957 
2958   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
2959 
2960   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
2961   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
2962                "                    [2] = bbbbbbbbbb,\n"
2963                "                    [3] = cccccccccc,\n"
2964                "                    [4] = dddddddddd,\n"
2965                "                    [5] = eeeeeeeeee};");
2966   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
2967                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2968                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
2969                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
2970                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
2971                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
2972 }
2973 
2974 TEST_F(FormatTest, NestedStaticInitializers) {
2975   verifyFormat("static A x = {{{}}};\n");
2976   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
2977                "               {init1, init2, init3, init4}}};",
2978                getLLVMStyleWithColumns(50));
2979 
2980   verifyFormat("somes Status::global_reps[3] = {\n"
2981                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2982                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2983                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
2984                getLLVMStyleWithColumns(60));
2985   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
2986                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
2987                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
2988                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
2989   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
2990                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
2991                "rect.fTop}};");
2992 
2993   verifyFormat(
2994       "SomeArrayOfSomeType a = {\n"
2995       "    {{1, 2, 3},\n"
2996       "     {1, 2, 3},\n"
2997       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
2998       "      333333333333333333333333333333},\n"
2999       "     {1, 2, 3},\n"
3000       "     {1, 2, 3}}};");
3001   verifyFormat(
3002       "SomeArrayOfSomeType a = {\n"
3003       "    {{1, 2, 3}},\n"
3004       "    {{1, 2, 3}},\n"
3005       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
3006       "      333333333333333333333333333333}},\n"
3007       "    {{1, 2, 3}},\n"
3008       "    {{1, 2, 3}}};");
3009 
3010   verifyFormat("struct {\n"
3011                "  unsigned bit;\n"
3012                "  const char *const name;\n"
3013                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
3014                "                 {kOsWin, \"Windows\"},\n"
3015                "                 {kOsLinux, \"Linux\"},\n"
3016                "                 {kOsCrOS, \"Chrome OS\"}};");
3017   verifyFormat("struct {\n"
3018                "  unsigned bit;\n"
3019                "  const char *const name;\n"
3020                "} kBitsToOs[] = {\n"
3021                "    {kOsMac, \"Mac\"},\n"
3022                "    {kOsWin, \"Windows\"},\n"
3023                "    {kOsLinux, \"Linux\"},\n"
3024                "    {kOsCrOS, \"Chrome OS\"},\n"
3025                "};");
3026 }
3027 
3028 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
3029   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3030                "                      \\\n"
3031                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
3032 }
3033 
3034 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
3035   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
3036                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
3037 
3038   // Do break defaulted and deleted functions.
3039   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
3040                "    default;",
3041                getLLVMStyleWithColumns(40));
3042   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
3043                "    delete;",
3044                getLLVMStyleWithColumns(40));
3045 }
3046 
3047 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
3048   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
3049                getLLVMStyleWithColumns(40));
3050   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
3051                getLLVMStyleWithColumns(40));
3052   EXPECT_EQ("#define Q                              \\\n"
3053             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
3054             "  \"aaaaaaaa.cpp\"",
3055             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
3056                    getLLVMStyleWithColumns(40)));
3057 }
3058 
3059 TEST_F(FormatTest, UnderstandsLinePPDirective) {
3060   EXPECT_EQ("# 123 \"A string literal\"",
3061             format("   #     123    \"A string literal\""));
3062 }
3063 
3064 TEST_F(FormatTest, LayoutUnknownPPDirective) {
3065   EXPECT_EQ("#;", format("#;"));
3066   verifyFormat("#\n;\n;\n;");
3067 }
3068 
3069 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
3070   EXPECT_EQ("#line 42 \"test\"\n",
3071             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
3072   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
3073                                     getLLVMStyleWithColumns(12)));
3074 }
3075 
3076 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
3077   EXPECT_EQ("#line 42 \"test\"",
3078             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
3079   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
3080 }
3081 
3082 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
3083   verifyFormat("#define A \\x20");
3084   verifyFormat("#define A \\ x20");
3085   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
3086   verifyFormat("#define A ''");
3087   verifyFormat("#define A ''qqq");
3088   verifyFormat("#define A `qqq");
3089   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
3090   EXPECT_EQ("const char *c = STRINGIFY(\n"
3091             "\\na : b);",
3092             format("const char * c = STRINGIFY(\n"
3093                    "\\na : b);"));
3094 
3095   verifyFormat("a\r\\");
3096   verifyFormat("a\v\\");
3097   verifyFormat("a\f\\");
3098 }
3099 
3100 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
3101   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
3102   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
3103   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
3104   // FIXME: We never break before the macro name.
3105   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
3106 
3107   verifyFormat("#define A A\n#define A A");
3108   verifyFormat("#define A(X) A\n#define A A");
3109 
3110   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
3111   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
3112 }
3113 
3114 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
3115   EXPECT_EQ("// somecomment\n"
3116             "#include \"a.h\"\n"
3117             "#define A(  \\\n"
3118             "    A, B)\n"
3119             "#include \"b.h\"\n"
3120             "// somecomment\n",
3121             format("  // somecomment\n"
3122                    "  #include \"a.h\"\n"
3123                    "#define A(A,\\\n"
3124                    "    B)\n"
3125                    "    #include \"b.h\"\n"
3126                    " // somecomment\n",
3127                    getLLVMStyleWithColumns(13)));
3128 }
3129 
3130 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
3131 
3132 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
3133   EXPECT_EQ("#define A    \\\n"
3134             "  c;         \\\n"
3135             "  e;\n"
3136             "f;",
3137             format("#define A c; e;\n"
3138                    "f;",
3139                    getLLVMStyleWithColumns(14)));
3140 }
3141 
3142 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
3143 
3144 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
3145   EXPECT_EQ("int x,\n"
3146             "#define A\n"
3147             "    y;",
3148             format("int x,\n#define A\ny;"));
3149 }
3150 
3151 TEST_F(FormatTest, HashInMacroDefinition) {
3152   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
3153   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
3154   verifyFormat("#define A  \\\n"
3155                "  {        \\\n"
3156                "    f(#c); \\\n"
3157                "  }",
3158                getLLVMStyleWithColumns(11));
3159 
3160   verifyFormat("#define A(X)         \\\n"
3161                "  void function##X()",
3162                getLLVMStyleWithColumns(22));
3163 
3164   verifyFormat("#define A(a, b, c)   \\\n"
3165                "  void a##b##c()",
3166                getLLVMStyleWithColumns(22));
3167 
3168   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
3169 }
3170 
3171 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
3172   EXPECT_EQ("#define A (x)", format("#define A (x)"));
3173   EXPECT_EQ("#define A(x)", format("#define A(x)"));
3174 
3175   FormatStyle Style = getLLVMStyle();
3176   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
3177   verifyFormat("#define true ((foo)1)", Style);
3178   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
3179   verifyFormat("#define false((foo)0)", Style);
3180 }
3181 
3182 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
3183   EXPECT_EQ("#define A b;", format("#define A \\\n"
3184                                    "          \\\n"
3185                                    "  b;",
3186                                    getLLVMStyleWithColumns(25)));
3187   EXPECT_EQ("#define A \\\n"
3188             "          \\\n"
3189             "  a;      \\\n"
3190             "  b;",
3191             format("#define A \\\n"
3192                    "          \\\n"
3193                    "  a;      \\\n"
3194                    "  b;",
3195                    getLLVMStyleWithColumns(11)));
3196   EXPECT_EQ("#define A \\\n"
3197             "  a;      \\\n"
3198             "          \\\n"
3199             "  b;",
3200             format("#define A \\\n"
3201                    "  a;      \\\n"
3202                    "          \\\n"
3203                    "  b;",
3204                    getLLVMStyleWithColumns(11)));
3205 }
3206 
3207 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
3208   verifyIncompleteFormat("#define A :");
3209   verifyFormat("#define SOMECASES  \\\n"
3210                "  case 1:          \\\n"
3211                "  case 2\n",
3212                getLLVMStyleWithColumns(20));
3213   verifyFormat("#define MACRO(a) \\\n"
3214                "  if (a)         \\\n"
3215                "    f();         \\\n"
3216                "  else           \\\n"
3217                "    g()",
3218                getLLVMStyleWithColumns(18));
3219   verifyFormat("#define A template <typename T>");
3220   verifyIncompleteFormat("#define STR(x) #x\n"
3221                          "f(STR(this_is_a_string_literal{));");
3222   verifyFormat("#pragma omp threadprivate( \\\n"
3223                "    y)), // expected-warning",
3224                getLLVMStyleWithColumns(28));
3225   verifyFormat("#d, = };");
3226   verifyFormat("#if \"a");
3227   verifyIncompleteFormat("({\n"
3228                          "#define b     \\\n"
3229                          "  }           \\\n"
3230                          "  a\n"
3231                          "a",
3232                          getLLVMStyleWithColumns(15));
3233   verifyFormat("#define A     \\\n"
3234                "  {           \\\n"
3235                "    {\n"
3236                "#define B     \\\n"
3237                "  }           \\\n"
3238                "  }",
3239                getLLVMStyleWithColumns(15));
3240   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
3241   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
3242   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
3243   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
3244 }
3245 
3246 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
3247   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
3248   EXPECT_EQ("class A : public QObject {\n"
3249             "  Q_OBJECT\n"
3250             "\n"
3251             "  A() {}\n"
3252             "};",
3253             format("class A  :  public QObject {\n"
3254                    "     Q_OBJECT\n"
3255                    "\n"
3256                    "  A() {\n}\n"
3257                    "}  ;"));
3258   EXPECT_EQ("MACRO\n"
3259             "/*static*/ int i;",
3260             format("MACRO\n"
3261                    " /*static*/ int   i;"));
3262   EXPECT_EQ("SOME_MACRO\n"
3263             "namespace {\n"
3264             "void f();\n"
3265             "} // namespace",
3266             format("SOME_MACRO\n"
3267                    "  namespace    {\n"
3268                    "void   f(  );\n"
3269                    "} // namespace"));
3270   // Only if the identifier contains at least 5 characters.
3271   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
3272   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
3273   // Only if everything is upper case.
3274   EXPECT_EQ("class A : public QObject {\n"
3275             "  Q_Object A() {}\n"
3276             "};",
3277             format("class A  :  public QObject {\n"
3278                    "     Q_Object\n"
3279                    "  A() {\n}\n"
3280                    "}  ;"));
3281 
3282   // Only if the next line can actually start an unwrapped line.
3283   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
3284             format("SOME_WEIRD_LOG_MACRO\n"
3285                    "<< SomeThing;"));
3286 
3287   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
3288                "(n, buffers))\n",
3289                getChromiumStyle(FormatStyle::LK_Cpp));
3290 
3291   // See PR41483
3292   EXPECT_EQ("/**/ FOO(a)\n"
3293             "FOO(b)",
3294             format("/**/ FOO(a)\n"
3295                    "FOO(b)"));
3296 }
3297 
3298 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
3299   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3300             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3301             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3302             "class X {};\n"
3303             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3304             "int *createScopDetectionPass() { return 0; }",
3305             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
3306                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
3307                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
3308                    "  class X {};\n"
3309                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
3310                    "  int *createScopDetectionPass() { return 0; }"));
3311   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
3312   // braces, so that inner block is indented one level more.
3313   EXPECT_EQ("int q() {\n"
3314             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3315             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3316             "  IPC_END_MESSAGE_MAP()\n"
3317             "}",
3318             format("int q() {\n"
3319                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
3320                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
3321                    "  IPC_END_MESSAGE_MAP()\n"
3322                    "}"));
3323 
3324   // Same inside macros.
3325   EXPECT_EQ("#define LIST(L) \\\n"
3326             "  L(A)          \\\n"
3327             "  L(B)          \\\n"
3328             "  L(C)",
3329             format("#define LIST(L) \\\n"
3330                    "  L(A) \\\n"
3331                    "  L(B) \\\n"
3332                    "  L(C)",
3333                    getGoogleStyle()));
3334 
3335   // These must not be recognized as macros.
3336   EXPECT_EQ("int q() {\n"
3337             "  f(x);\n"
3338             "  f(x) {}\n"
3339             "  f(x)->g();\n"
3340             "  f(x)->*g();\n"
3341             "  f(x).g();\n"
3342             "  f(x) = x;\n"
3343             "  f(x) += x;\n"
3344             "  f(x) -= x;\n"
3345             "  f(x) *= x;\n"
3346             "  f(x) /= x;\n"
3347             "  f(x) %= x;\n"
3348             "  f(x) &= x;\n"
3349             "  f(x) |= x;\n"
3350             "  f(x) ^= x;\n"
3351             "  f(x) >>= x;\n"
3352             "  f(x) <<= x;\n"
3353             "  f(x)[y].z();\n"
3354             "  LOG(INFO) << x;\n"
3355             "  ifstream(x) >> x;\n"
3356             "}\n",
3357             format("int q() {\n"
3358                    "  f(x)\n;\n"
3359                    "  f(x)\n {}\n"
3360                    "  f(x)\n->g();\n"
3361                    "  f(x)\n->*g();\n"
3362                    "  f(x)\n.g();\n"
3363                    "  f(x)\n = x;\n"
3364                    "  f(x)\n += x;\n"
3365                    "  f(x)\n -= x;\n"
3366                    "  f(x)\n *= x;\n"
3367                    "  f(x)\n /= x;\n"
3368                    "  f(x)\n %= x;\n"
3369                    "  f(x)\n &= x;\n"
3370                    "  f(x)\n |= x;\n"
3371                    "  f(x)\n ^= x;\n"
3372                    "  f(x)\n >>= x;\n"
3373                    "  f(x)\n <<= x;\n"
3374                    "  f(x)\n[y].z();\n"
3375                    "  LOG(INFO)\n << x;\n"
3376                    "  ifstream(x)\n >> x;\n"
3377                    "}\n"));
3378   EXPECT_EQ("int q() {\n"
3379             "  F(x)\n"
3380             "  if (1) {\n"
3381             "  }\n"
3382             "  F(x)\n"
3383             "  while (1) {\n"
3384             "  }\n"
3385             "  F(x)\n"
3386             "  G(x);\n"
3387             "  F(x)\n"
3388             "  try {\n"
3389             "    Q();\n"
3390             "  } catch (...) {\n"
3391             "  }\n"
3392             "}\n",
3393             format("int q() {\n"
3394                    "F(x)\n"
3395                    "if (1) {}\n"
3396                    "F(x)\n"
3397                    "while (1) {}\n"
3398                    "F(x)\n"
3399                    "G(x);\n"
3400                    "F(x)\n"
3401                    "try { Q(); } catch (...) {}\n"
3402                    "}\n"));
3403   EXPECT_EQ("class A {\n"
3404             "  A() : t(0) {}\n"
3405             "  A(int i) noexcept() : {}\n"
3406             "  A(X x)\n" // FIXME: function-level try blocks are broken.
3407             "  try : t(0) {\n"
3408             "  } catch (...) {\n"
3409             "  }\n"
3410             "};",
3411             format("class A {\n"
3412                    "  A()\n : t(0) {}\n"
3413                    "  A(int i)\n noexcept() : {}\n"
3414                    "  A(X x)\n"
3415                    "  try : t(0) {} catch (...) {}\n"
3416                    "};"));
3417   FormatStyle Style = getLLVMStyle();
3418   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3419   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
3420   Style.BraceWrapping.AfterFunction = true;
3421   EXPECT_EQ("void f()\n"
3422             "try\n"
3423             "{\n"
3424             "}",
3425             format("void f() try {\n"
3426                    "}",
3427                    Style));
3428   EXPECT_EQ("class SomeClass {\n"
3429             "public:\n"
3430             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3431             "};",
3432             format("class SomeClass {\n"
3433                    "public:\n"
3434                    "  SomeClass()\n"
3435                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3436                    "};"));
3437   EXPECT_EQ("class SomeClass {\n"
3438             "public:\n"
3439             "  SomeClass()\n"
3440             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3441             "};",
3442             format("class SomeClass {\n"
3443                    "public:\n"
3444                    "  SomeClass()\n"
3445                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
3446                    "};",
3447                    getLLVMStyleWithColumns(40)));
3448 
3449   verifyFormat("MACRO(>)");
3450 
3451   // Some macros contain an implicit semicolon.
3452   Style = getLLVMStyle();
3453   Style.StatementMacros.push_back("FOO");
3454   verifyFormat("FOO(a) int b = 0;");
3455   verifyFormat("FOO(a)\n"
3456                "int b = 0;",
3457                Style);
3458   verifyFormat("FOO(a);\n"
3459                "int b = 0;",
3460                Style);
3461   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
3462                "int b = 0;",
3463                Style);
3464   verifyFormat("FOO()\n"
3465                "int b = 0;",
3466                Style);
3467   verifyFormat("FOO\n"
3468                "int b = 0;",
3469                Style);
3470   verifyFormat("void f() {\n"
3471                "  FOO(a)\n"
3472                "  return a;\n"
3473                "}",
3474                Style);
3475   verifyFormat("FOO(a)\n"
3476                "FOO(b)",
3477                Style);
3478   verifyFormat("int a = 0;\n"
3479                "FOO(b)\n"
3480                "int c = 0;",
3481                Style);
3482   verifyFormat("int a = 0;\n"
3483                "int x = FOO(a)\n"
3484                "int b = 0;",
3485                Style);
3486   verifyFormat("void foo(int a) { FOO(a) }\n"
3487                "uint32_t bar() {}",
3488                Style);
3489 }
3490 
3491 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
3492   verifyFormat("#define A \\\n"
3493                "  f({     \\\n"
3494                "    g();  \\\n"
3495                "  });",
3496                getLLVMStyleWithColumns(11));
3497 }
3498 
3499 TEST_F(FormatTest, IndentPreprocessorDirectives) {
3500   FormatStyle Style = getLLVMStyle();
3501   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
3502   Style.ColumnLimit = 40;
3503   verifyFormat("#ifdef _WIN32\n"
3504                "#define A 0\n"
3505                "#ifdef VAR2\n"
3506                "#define B 1\n"
3507                "#include <someheader.h>\n"
3508                "#define MACRO                          \\\n"
3509                "  some_very_long_func_aaaaaaaaaa();\n"
3510                "#endif\n"
3511                "#else\n"
3512                "#define A 1\n"
3513                "#endif",
3514                Style);
3515   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
3516   verifyFormat("#ifdef _WIN32\n"
3517                "#  define A 0\n"
3518                "#  ifdef VAR2\n"
3519                "#    define B 1\n"
3520                "#    include <someheader.h>\n"
3521                "#    define MACRO                      \\\n"
3522                "      some_very_long_func_aaaaaaaaaa();\n"
3523                "#  endif\n"
3524                "#else\n"
3525                "#  define A 1\n"
3526                "#endif",
3527                Style);
3528   verifyFormat("#if A\n"
3529                "#  define MACRO                        \\\n"
3530                "    void a(int x) {                    \\\n"
3531                "      b();                             \\\n"
3532                "      c();                             \\\n"
3533                "      d();                             \\\n"
3534                "      e();                             \\\n"
3535                "      f();                             \\\n"
3536                "    }\n"
3537                "#endif",
3538                Style);
3539   // Comments before include guard.
3540   verifyFormat("// file comment\n"
3541                "// file comment\n"
3542                "#ifndef HEADER_H\n"
3543                "#define HEADER_H\n"
3544                "code();\n"
3545                "#endif",
3546                Style);
3547   // Test with include guards.
3548   verifyFormat("#ifndef HEADER_H\n"
3549                "#define HEADER_H\n"
3550                "code();\n"
3551                "#endif",
3552                Style);
3553   // Include guards must have a #define with the same variable immediately
3554   // after #ifndef.
3555   verifyFormat("#ifndef NOT_GUARD\n"
3556                "#  define FOO\n"
3557                "code();\n"
3558                "#endif",
3559                Style);
3560 
3561   // Include guards must cover the entire file.
3562   verifyFormat("code();\n"
3563                "code();\n"
3564                "#ifndef NOT_GUARD\n"
3565                "#  define NOT_GUARD\n"
3566                "code();\n"
3567                "#endif",
3568                Style);
3569   verifyFormat("#ifndef NOT_GUARD\n"
3570                "#  define NOT_GUARD\n"
3571                "code();\n"
3572                "#endif\n"
3573                "code();",
3574                Style);
3575   // Test with trailing blank lines.
3576   verifyFormat("#ifndef HEADER_H\n"
3577                "#define HEADER_H\n"
3578                "code();\n"
3579                "#endif\n",
3580                Style);
3581   // Include guards don't have #else.
3582   verifyFormat("#ifndef NOT_GUARD\n"
3583                "#  define NOT_GUARD\n"
3584                "code();\n"
3585                "#else\n"
3586                "#endif",
3587                Style);
3588   verifyFormat("#ifndef NOT_GUARD\n"
3589                "#  define NOT_GUARD\n"
3590                "code();\n"
3591                "#elif FOO\n"
3592                "#endif",
3593                Style);
3594   // Non-identifier #define after potential include guard.
3595   verifyFormat("#ifndef FOO\n"
3596                "#  define 1\n"
3597                "#endif\n",
3598                Style);
3599   // #if closes past last non-preprocessor line.
3600   verifyFormat("#ifndef FOO\n"
3601                "#define FOO\n"
3602                "#if 1\n"
3603                "int i;\n"
3604                "#  define A 0\n"
3605                "#endif\n"
3606                "#endif\n",
3607                Style);
3608   // Don't crash if there is an #elif directive without a condition.
3609   verifyFormat("#if 1\n"
3610                "int x;\n"
3611                "#elif\n"
3612                "int y;\n"
3613                "#else\n"
3614                "int z;\n"
3615                "#endif",
3616                Style);
3617   // FIXME: This doesn't handle the case where there's code between the
3618   // #ifndef and #define but all other conditions hold. This is because when
3619   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
3620   // previous code line yet, so we can't detect it.
3621   EXPECT_EQ("#ifndef NOT_GUARD\n"
3622             "code();\n"
3623             "#define NOT_GUARD\n"
3624             "code();\n"
3625             "#endif",
3626             format("#ifndef NOT_GUARD\n"
3627                    "code();\n"
3628                    "#  define NOT_GUARD\n"
3629                    "code();\n"
3630                    "#endif",
3631                    Style));
3632   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
3633   // be outside an include guard. Examples are #pragma once and
3634   // #pragma GCC diagnostic, or anything else that does not change the meaning
3635   // of the file if it's included multiple times.
3636   EXPECT_EQ("#ifdef WIN32\n"
3637             "#  pragma once\n"
3638             "#endif\n"
3639             "#ifndef HEADER_H\n"
3640             "#  define HEADER_H\n"
3641             "code();\n"
3642             "#endif",
3643             format("#ifdef WIN32\n"
3644                    "#  pragma once\n"
3645                    "#endif\n"
3646                    "#ifndef HEADER_H\n"
3647                    "#define HEADER_H\n"
3648                    "code();\n"
3649                    "#endif",
3650                    Style));
3651   // FIXME: This does not detect when there is a single non-preprocessor line
3652   // in front of an include-guard-like structure where other conditions hold
3653   // because ScopedLineState hides the line.
3654   EXPECT_EQ("code();\n"
3655             "#ifndef HEADER_H\n"
3656             "#define HEADER_H\n"
3657             "code();\n"
3658             "#endif",
3659             format("code();\n"
3660                    "#ifndef HEADER_H\n"
3661                    "#  define HEADER_H\n"
3662                    "code();\n"
3663                    "#endif",
3664                    Style));
3665   // Keep comments aligned with #, otherwise indent comments normally. These
3666   // tests cannot use verifyFormat because messUp manipulates leading
3667   // whitespace.
3668   {
3669     const char *Expected = ""
3670                            "void f() {\n"
3671                            "#if 1\n"
3672                            "// Preprocessor aligned.\n"
3673                            "#  define A 0\n"
3674                            "  // Code. Separated by blank line.\n"
3675                            "\n"
3676                            "#  define B 0\n"
3677                            "  // Code. Not aligned with #\n"
3678                            "#  define C 0\n"
3679                            "#endif";
3680     const char *ToFormat = ""
3681                            "void f() {\n"
3682                            "#if 1\n"
3683                            "// Preprocessor aligned.\n"
3684                            "#  define A 0\n"
3685                            "// Code. Separated by blank line.\n"
3686                            "\n"
3687                            "#  define B 0\n"
3688                            "   // Code. Not aligned with #\n"
3689                            "#  define C 0\n"
3690                            "#endif";
3691     EXPECT_EQ(Expected, format(ToFormat, Style));
3692     EXPECT_EQ(Expected, format(Expected, Style));
3693   }
3694   // Keep block quotes aligned.
3695   {
3696     const char *Expected = ""
3697                            "void f() {\n"
3698                            "#if 1\n"
3699                            "/* Preprocessor aligned. */\n"
3700                            "#  define A 0\n"
3701                            "  /* Code. Separated by blank line. */\n"
3702                            "\n"
3703                            "#  define B 0\n"
3704                            "  /* Code. Not aligned with # */\n"
3705                            "#  define C 0\n"
3706                            "#endif";
3707     const char *ToFormat = ""
3708                            "void f() {\n"
3709                            "#if 1\n"
3710                            "/* Preprocessor aligned. */\n"
3711                            "#  define A 0\n"
3712                            "/* Code. Separated by blank line. */\n"
3713                            "\n"
3714                            "#  define B 0\n"
3715                            "   /* Code. Not aligned with # */\n"
3716                            "#  define C 0\n"
3717                            "#endif";
3718     EXPECT_EQ(Expected, format(ToFormat, Style));
3719     EXPECT_EQ(Expected, format(Expected, Style));
3720   }
3721   // Keep comments aligned with un-indented directives.
3722   {
3723     const char *Expected = ""
3724                            "void f() {\n"
3725                            "// Preprocessor aligned.\n"
3726                            "#define A 0\n"
3727                            "  // Code. Separated by blank line.\n"
3728                            "\n"
3729                            "#define B 0\n"
3730                            "  // Code. Not aligned with #\n"
3731                            "#define C 0\n";
3732     const char *ToFormat = ""
3733                            "void f() {\n"
3734                            "// Preprocessor aligned.\n"
3735                            "#define A 0\n"
3736                            "// Code. Separated by blank line.\n"
3737                            "\n"
3738                            "#define B 0\n"
3739                            "   // Code. Not aligned with #\n"
3740                            "#define C 0\n";
3741     EXPECT_EQ(Expected, format(ToFormat, Style));
3742     EXPECT_EQ(Expected, format(Expected, Style));
3743   }
3744   // Test AfterHash with tabs.
3745   {
3746     FormatStyle Tabbed = Style;
3747     Tabbed.UseTab = FormatStyle::UT_Always;
3748     Tabbed.IndentWidth = 8;
3749     Tabbed.TabWidth = 8;
3750     verifyFormat("#ifdef _WIN32\n"
3751                  "#\tdefine A 0\n"
3752                  "#\tifdef VAR2\n"
3753                  "#\t\tdefine B 1\n"
3754                  "#\t\tinclude <someheader.h>\n"
3755                  "#\t\tdefine MACRO          \\\n"
3756                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
3757                  "#\tendif\n"
3758                  "#else\n"
3759                  "#\tdefine A 1\n"
3760                  "#endif",
3761                  Tabbed);
3762   }
3763 
3764   // Regression test: Multiline-macro inside include guards.
3765   verifyFormat("#ifndef HEADER_H\n"
3766                "#define HEADER_H\n"
3767                "#define A()        \\\n"
3768                "  int i;           \\\n"
3769                "  int j;\n"
3770                "#endif // HEADER_H",
3771                getLLVMStyleWithColumns(20));
3772 
3773   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
3774   // Basic before hash indent tests
3775   verifyFormat("#ifdef _WIN32\n"
3776                "  #define A 0\n"
3777                "  #ifdef VAR2\n"
3778                "    #define B 1\n"
3779                "    #include <someheader.h>\n"
3780                "    #define MACRO                      \\\n"
3781                "      some_very_long_func_aaaaaaaaaa();\n"
3782                "  #endif\n"
3783                "#else\n"
3784                "  #define A 1\n"
3785                "#endif",
3786                Style);
3787   verifyFormat("#if A\n"
3788                "  #define MACRO                        \\\n"
3789                "    void a(int x) {                    \\\n"
3790                "      b();                             \\\n"
3791                "      c();                             \\\n"
3792                "      d();                             \\\n"
3793                "      e();                             \\\n"
3794                "      f();                             \\\n"
3795                "    }\n"
3796                "#endif",
3797                Style);
3798   // Keep comments aligned with indented directives. These
3799   // tests cannot use verifyFormat because messUp manipulates leading
3800   // whitespace.
3801   {
3802     const char *Expected = "void f() {\n"
3803                            "// Aligned to preprocessor.\n"
3804                            "#if 1\n"
3805                            "  // Aligned to code.\n"
3806                            "  int a;\n"
3807                            "  #if 1\n"
3808                            "    // Aligned to preprocessor.\n"
3809                            "    #define A 0\n"
3810                            "  // Aligned to code.\n"
3811                            "  int b;\n"
3812                            "  #endif\n"
3813                            "#endif\n"
3814                            "}";
3815     const char *ToFormat = "void f() {\n"
3816                            "// Aligned to preprocessor.\n"
3817                            "#if 1\n"
3818                            "// Aligned to code.\n"
3819                            "int a;\n"
3820                            "#if 1\n"
3821                            "// Aligned to preprocessor.\n"
3822                            "#define A 0\n"
3823                            "// Aligned to code.\n"
3824                            "int b;\n"
3825                            "#endif\n"
3826                            "#endif\n"
3827                            "}";
3828     EXPECT_EQ(Expected, format(ToFormat, Style));
3829     EXPECT_EQ(Expected, format(Expected, Style));
3830   }
3831   {
3832     const char *Expected = "void f() {\n"
3833                            "/* Aligned to preprocessor. */\n"
3834                            "#if 1\n"
3835                            "  /* Aligned to code. */\n"
3836                            "  int a;\n"
3837                            "  #if 1\n"
3838                            "    /* Aligned to preprocessor. */\n"
3839                            "    #define A 0\n"
3840                            "  /* Aligned to code. */\n"
3841                            "  int b;\n"
3842                            "  #endif\n"
3843                            "#endif\n"
3844                            "}";
3845     const char *ToFormat = "void f() {\n"
3846                            "/* Aligned to preprocessor. */\n"
3847                            "#if 1\n"
3848                            "/* Aligned to code. */\n"
3849                            "int a;\n"
3850                            "#if 1\n"
3851                            "/* Aligned to preprocessor. */\n"
3852                            "#define A 0\n"
3853                            "/* Aligned to code. */\n"
3854                            "int b;\n"
3855                            "#endif\n"
3856                            "#endif\n"
3857                            "}";
3858     EXPECT_EQ(Expected, format(ToFormat, Style));
3859     EXPECT_EQ(Expected, format(Expected, Style));
3860   }
3861 
3862   // Test single comment before preprocessor
3863   verifyFormat("// Comment\n"
3864                "\n"
3865                "#if 1\n"
3866                "#endif",
3867                Style);
3868 }
3869 
3870 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
3871   verifyFormat("{\n  { a #c; }\n}");
3872 }
3873 
3874 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
3875   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
3876             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
3877   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
3878             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
3879 }
3880 
3881 TEST_F(FormatTest, EscapedNewlines) {
3882   FormatStyle Narrow = getLLVMStyleWithColumns(11);
3883   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
3884             format("#define A \\\nint i;\\\n  int j;", Narrow));
3885   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
3886   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3887   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
3888   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
3889 
3890   FormatStyle AlignLeft = getLLVMStyle();
3891   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
3892   EXPECT_EQ("#define MACRO(x) \\\n"
3893             "private:         \\\n"
3894             "  int x(int a);\n",
3895             format("#define MACRO(x) \\\n"
3896                    "private:         \\\n"
3897                    "  int x(int a);\n",
3898                    AlignLeft));
3899 
3900   // CRLF line endings
3901   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
3902             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
3903   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
3904   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
3905   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
3906   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
3907   EXPECT_EQ("#define MACRO(x) \\\r\n"
3908             "private:         \\\r\n"
3909             "  int x(int a);\r\n",
3910             format("#define MACRO(x) \\\r\n"
3911                    "private:         \\\r\n"
3912                    "  int x(int a);\r\n",
3913                    AlignLeft));
3914 
3915   FormatStyle DontAlign = getLLVMStyle();
3916   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
3917   DontAlign.MaxEmptyLinesToKeep = 3;
3918   // FIXME: can't use verifyFormat here because the newline before
3919   // "public:" is not inserted the first time it's reformatted
3920   EXPECT_EQ("#define A \\\n"
3921             "  class Foo { \\\n"
3922             "    void bar(); \\\n"
3923             "\\\n"
3924             "\\\n"
3925             "\\\n"
3926             "  public: \\\n"
3927             "    void baz(); \\\n"
3928             "  };",
3929             format("#define A \\\n"
3930                    "  class Foo { \\\n"
3931                    "    void bar(); \\\n"
3932                    "\\\n"
3933                    "\\\n"
3934                    "\\\n"
3935                    "  public: \\\n"
3936                    "    void baz(); \\\n"
3937                    "  };",
3938                    DontAlign));
3939 }
3940 
3941 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
3942   verifyFormat("#define A \\\n"
3943                "  int v(  \\\n"
3944                "      a); \\\n"
3945                "  int i;",
3946                getLLVMStyleWithColumns(11));
3947 }
3948 
3949 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
3950   EXPECT_EQ(
3951       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
3952       "                      \\\n"
3953       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3954       "\n"
3955       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3956       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
3957       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
3958              "\\\n"
3959              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
3960              "  \n"
3961              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
3962              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
3963 }
3964 
3965 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
3966   EXPECT_EQ("int\n"
3967             "#define A\n"
3968             "    a;",
3969             format("int\n#define A\na;"));
3970   verifyFormat("functionCallTo(\n"
3971                "    someOtherFunction(\n"
3972                "        withSomeParameters, whichInSequence,\n"
3973                "        areLongerThanALine(andAnotherCall,\n"
3974                "#define A B\n"
3975                "                           withMoreParamters,\n"
3976                "                           whichStronglyInfluenceTheLayout),\n"
3977                "        andMoreParameters),\n"
3978                "    trailing);",
3979                getLLVMStyleWithColumns(69));
3980   verifyFormat("Foo::Foo()\n"
3981                "#ifdef BAR\n"
3982                "    : baz(0)\n"
3983                "#endif\n"
3984                "{\n"
3985                "}");
3986   verifyFormat("void f() {\n"
3987                "  if (true)\n"
3988                "#ifdef A\n"
3989                "    f(42);\n"
3990                "  x();\n"
3991                "#else\n"
3992                "    g();\n"
3993                "  x();\n"
3994                "#endif\n"
3995                "}");
3996   verifyFormat("void f(param1, param2,\n"
3997                "       param3,\n"
3998                "#ifdef A\n"
3999                "       param4(param5,\n"
4000                "#ifdef A1\n"
4001                "              param6,\n"
4002                "#ifdef A2\n"
4003                "              param7),\n"
4004                "#else\n"
4005                "              param8),\n"
4006                "       param9,\n"
4007                "#endif\n"
4008                "       param10,\n"
4009                "#endif\n"
4010                "       param11)\n"
4011                "#else\n"
4012                "       param12)\n"
4013                "#endif\n"
4014                "{\n"
4015                "  x();\n"
4016                "}",
4017                getLLVMStyleWithColumns(28));
4018   verifyFormat("#if 1\n"
4019                "int i;");
4020   verifyFormat("#if 1\n"
4021                "#endif\n"
4022                "#if 1\n"
4023                "#else\n"
4024                "#endif\n");
4025   verifyFormat("DEBUG({\n"
4026                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4027                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
4028                "});\n"
4029                "#if a\n"
4030                "#else\n"
4031                "#endif");
4032 
4033   verifyIncompleteFormat("void f(\n"
4034                          "#if A\n"
4035                          ");\n"
4036                          "#else\n"
4037                          "#endif");
4038 }
4039 
4040 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
4041   verifyFormat("#endif\n"
4042                "#if B");
4043 }
4044 
4045 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
4046   FormatStyle SingleLine = getLLVMStyle();
4047   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
4048   verifyFormat("#if 0\n"
4049                "#elif 1\n"
4050                "#endif\n"
4051                "void foo() {\n"
4052                "  if (test) foo2();\n"
4053                "}",
4054                SingleLine);
4055 }
4056 
4057 TEST_F(FormatTest, LayoutBlockInsideParens) {
4058   verifyFormat("functionCall({ int i; });");
4059   verifyFormat("functionCall({\n"
4060                "  int i;\n"
4061                "  int j;\n"
4062                "});");
4063   verifyFormat("functionCall(\n"
4064                "    {\n"
4065                "      int i;\n"
4066                "      int j;\n"
4067                "    },\n"
4068                "    aaaa, bbbb, cccc);");
4069   verifyFormat("functionA(functionB({\n"
4070                "            int i;\n"
4071                "            int j;\n"
4072                "          }),\n"
4073                "          aaaa, bbbb, cccc);");
4074   verifyFormat("functionCall(\n"
4075                "    {\n"
4076                "      int i;\n"
4077                "      int j;\n"
4078                "    },\n"
4079                "    aaaa, bbbb, // comment\n"
4080                "    cccc);");
4081   verifyFormat("functionA(functionB({\n"
4082                "            int i;\n"
4083                "            int j;\n"
4084                "          }),\n"
4085                "          aaaa, bbbb, // comment\n"
4086                "          cccc);");
4087   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
4088   verifyFormat("functionCall(aaaa, bbbb, {\n"
4089                "  int i;\n"
4090                "  int j;\n"
4091                "});");
4092   verifyFormat(
4093       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
4094       "    {\n"
4095       "      int i; // break\n"
4096       "    },\n"
4097       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
4098       "                                     ccccccccccccccccc));");
4099   verifyFormat("DEBUG({\n"
4100                "  if (a)\n"
4101                "    f();\n"
4102                "});");
4103 }
4104 
4105 TEST_F(FormatTest, LayoutBlockInsideStatement) {
4106   EXPECT_EQ("SOME_MACRO { int i; }\n"
4107             "int i;",
4108             format("  SOME_MACRO  {int i;}  int i;"));
4109 }
4110 
4111 TEST_F(FormatTest, LayoutNestedBlocks) {
4112   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
4113                "  struct s {\n"
4114                "    int i;\n"
4115                "  };\n"
4116                "  s kBitsToOs[] = {{10}};\n"
4117                "  for (int i = 0; i < 10; ++i)\n"
4118                "    return;\n"
4119                "}");
4120   verifyFormat("call(parameter, {\n"
4121                "  something();\n"
4122                "  // Comment using all columns.\n"
4123                "  somethingelse();\n"
4124                "});",
4125                getLLVMStyleWithColumns(40));
4126   verifyFormat("DEBUG( //\n"
4127                "    { f(); }, a);");
4128   verifyFormat("DEBUG( //\n"
4129                "    {\n"
4130                "      f(); //\n"
4131                "    },\n"
4132                "    a);");
4133 
4134   EXPECT_EQ("call(parameter, {\n"
4135             "  something();\n"
4136             "  // Comment too\n"
4137             "  // looooooooooong.\n"
4138             "  somethingElse();\n"
4139             "});",
4140             format("call(parameter, {\n"
4141                    "  something();\n"
4142                    "  // Comment too looooooooooong.\n"
4143                    "  somethingElse();\n"
4144                    "});",
4145                    getLLVMStyleWithColumns(29)));
4146   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
4147   EXPECT_EQ("DEBUG({ // comment\n"
4148             "  int i;\n"
4149             "});",
4150             format("DEBUG({ // comment\n"
4151                    "int  i;\n"
4152                    "});"));
4153   EXPECT_EQ("DEBUG({\n"
4154             "  int i;\n"
4155             "\n"
4156             "  // comment\n"
4157             "  int j;\n"
4158             "});",
4159             format("DEBUG({\n"
4160                    "  int  i;\n"
4161                    "\n"
4162                    "  // comment\n"
4163                    "  int  j;\n"
4164                    "});"));
4165 
4166   verifyFormat("DEBUG({\n"
4167                "  if (a)\n"
4168                "    return;\n"
4169                "});");
4170   verifyGoogleFormat("DEBUG({\n"
4171                      "  if (a) return;\n"
4172                      "});");
4173   FormatStyle Style = getGoogleStyle();
4174   Style.ColumnLimit = 45;
4175   verifyFormat("Debug(\n"
4176                "    aaaaa,\n"
4177                "    {\n"
4178                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
4179                "    },\n"
4180                "    a);",
4181                Style);
4182 
4183   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
4184 
4185   verifyNoCrash("^{v^{a}}");
4186 }
4187 
4188 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
4189   EXPECT_EQ("#define MACRO()                     \\\n"
4190             "  Debug(aaa, /* force line break */ \\\n"
4191             "        {                           \\\n"
4192             "          int i;                    \\\n"
4193             "          int j;                    \\\n"
4194             "        })",
4195             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
4196                    "          {  int   i;  int  j;   })",
4197                    getGoogleStyle()));
4198 
4199   EXPECT_EQ("#define A                                       \\\n"
4200             "  [] {                                          \\\n"
4201             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
4202             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
4203             "  }",
4204             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
4205                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
4206                    getGoogleStyle()));
4207 }
4208 
4209 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
4210   EXPECT_EQ("{}", format("{}"));
4211   verifyFormat("enum E {};");
4212   verifyFormat("enum E {}");
4213   FormatStyle Style = getLLVMStyle();
4214   Style.SpaceInEmptyBlock = true;
4215   EXPECT_EQ("void f() { }", format("void f() {}", Style));
4216   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
4217   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
4218 }
4219 
4220 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
4221   FormatStyle Style = getLLVMStyle();
4222   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
4223   Style.MacroBlockEnd = "^[A-Z_]+_END$";
4224   verifyFormat("FOO_BEGIN\n"
4225                "  FOO_ENTRY\n"
4226                "FOO_END",
4227                Style);
4228   verifyFormat("FOO_BEGIN\n"
4229                "  NESTED_FOO_BEGIN\n"
4230                "    NESTED_FOO_ENTRY\n"
4231                "  NESTED_FOO_END\n"
4232                "FOO_END",
4233                Style);
4234   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
4235                "  int x;\n"
4236                "  x = 1;\n"
4237                "FOO_END(Baz)",
4238                Style);
4239 }
4240 
4241 //===----------------------------------------------------------------------===//
4242 // Line break tests.
4243 //===----------------------------------------------------------------------===//
4244 
4245 TEST_F(FormatTest, PreventConfusingIndents) {
4246   verifyFormat(
4247       "void f() {\n"
4248       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
4249       "                         parameter, parameter, parameter)),\n"
4250       "                     SecondLongCall(parameter));\n"
4251       "}");
4252   verifyFormat(
4253       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4254       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4255       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4256       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
4257   verifyFormat(
4258       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4259       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
4260       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
4261       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
4262   verifyFormat(
4263       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
4264       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
4265       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
4266       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
4267   verifyFormat("int a = bbbb && ccc &&\n"
4268                "        fffff(\n"
4269                "#define A Just forcing a new line\n"
4270                "            ddd);");
4271 }
4272 
4273 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
4274   verifyFormat(
4275       "bool aaaaaaa =\n"
4276       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
4277       "    bbbbbbbb();");
4278   verifyFormat(
4279       "bool aaaaaaa =\n"
4280       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
4281       "    bbbbbbbb();");
4282 
4283   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4284                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
4285                "    ccccccccc == ddddddddddd;");
4286   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
4287                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
4288                "    ccccccccc == ddddddddddd;");
4289   verifyFormat(
4290       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
4291       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
4292       "    ccccccccc == ddddddddddd;");
4293 
4294   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4295                "                 aaaaaa) &&\n"
4296                "         bbbbbb && cccccc;");
4297   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
4298                "                 aaaaaa) >>\n"
4299                "         bbbbbb;");
4300   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
4301                "    SourceMgr.getSpellingColumnNumber(\n"
4302                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
4303                "    1);");
4304 
4305   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4306                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
4307                "    cccccc) {\n}");
4308   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4309                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4310                "              cccccc) {\n}");
4311   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4312                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
4313                "              cccccc) {\n}");
4314   verifyFormat("b = a &&\n"
4315                "    // Comment\n"
4316                "    b.c && d;");
4317 
4318   // If the LHS of a comparison is not a binary expression itself, the
4319   // additional linebreak confuses many people.
4320   verifyFormat(
4321       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4322       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
4323       "}");
4324   verifyFormat(
4325       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4326       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4327       "}");
4328   verifyFormat(
4329       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
4330       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4331       "}");
4332   verifyFormat(
4333       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4334       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
4335       "}");
4336   // Even explicit parentheses stress the precedence enough to make the
4337   // additional break unnecessary.
4338   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4339                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
4340                "}");
4341   // This cases is borderline, but with the indentation it is still readable.
4342   verifyFormat(
4343       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4344       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4345       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
4346       "}",
4347       getLLVMStyleWithColumns(75));
4348 
4349   // If the LHS is a binary expression, we should still use the additional break
4350   // as otherwise the formatting hides the operator precedence.
4351   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4352                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4353                "    5) {\n"
4354                "}");
4355   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4356                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
4357                "    5) {\n"
4358                "}");
4359 
4360   FormatStyle OnePerLine = getLLVMStyle();
4361   OnePerLine.BinPackParameters = false;
4362   verifyFormat(
4363       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4364       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
4365       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
4366       OnePerLine);
4367 
4368   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
4369                "                .aaa(aaaaaaaaaaaaa) *\n"
4370                "            aaaaaaa +\n"
4371                "        aaaaaaa;",
4372                getLLVMStyleWithColumns(40));
4373 }
4374 
4375 TEST_F(FormatTest, ExpressionIndentation) {
4376   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4377                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4378                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4379                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4380                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
4381                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
4382                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4383                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
4384                "                 ccccccccccccccccccccccccccccccccccccccccc;");
4385   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4386                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4387                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4388                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4389   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4390                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4391                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4392                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4393   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
4394                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
4395                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4396                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
4397   verifyFormat("if () {\n"
4398                "} else if (aaaaa && bbbbb > // break\n"
4399                "                        ccccc) {\n"
4400                "}");
4401   verifyFormat("if () {\n"
4402                "} else if constexpr (aaaaa && bbbbb > // break\n"
4403                "                                  ccccc) {\n"
4404                "}");
4405   verifyFormat("if () {\n"
4406                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
4407                "                                  ccccc) {\n"
4408                "}");
4409   verifyFormat("if () {\n"
4410                "} else if (aaaaa &&\n"
4411                "           bbbbb > // break\n"
4412                "               ccccc &&\n"
4413                "           ddddd) {\n"
4414                "}");
4415 
4416   // Presence of a trailing comment used to change indentation of b.
4417   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
4418                "       b;\n"
4419                "return aaaaaaaaaaaaaaaaaaa +\n"
4420                "       b; //",
4421                getLLVMStyleWithColumns(30));
4422 }
4423 
4424 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
4425   // Not sure what the best system is here. Like this, the LHS can be found
4426   // immediately above an operator (everything with the same or a higher
4427   // indent). The RHS is aligned right of the operator and so compasses
4428   // everything until something with the same indent as the operator is found.
4429   // FIXME: Is this a good system?
4430   FormatStyle Style = getLLVMStyle();
4431   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4432   verifyFormat(
4433       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4434       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4435       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4436       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4437       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4438       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4439       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4440       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4441       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
4442       Style);
4443   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4444                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4445                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4446                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4447                Style);
4448   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4449                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4450                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4451                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4452                Style);
4453   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4454                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4455                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4456                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4457                Style);
4458   verifyFormat("if () {\n"
4459                "} else if (aaaaa\n"
4460                "           && bbbbb // break\n"
4461                "                  > ccccc) {\n"
4462                "}",
4463                Style);
4464   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4465                "       && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4466                Style);
4467   verifyFormat("return (a)\n"
4468                "       // comment\n"
4469                "       + b;",
4470                Style);
4471   verifyFormat(
4472       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4473       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4474       "             + cc;",
4475       Style);
4476 
4477   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4478                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4479                Style);
4480 
4481   // Forced by comments.
4482   verifyFormat(
4483       "unsigned ContentSize =\n"
4484       "    sizeof(int16_t)   // DWARF ARange version number\n"
4485       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4486       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4487       "    + sizeof(int8_t); // Segment Size (in bytes)");
4488 
4489   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4490                "       == boost::fusion::at_c<1>(iiii).second;",
4491                Style);
4492 
4493   Style.ColumnLimit = 60;
4494   verifyFormat("zzzzzzzzzz\n"
4495                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4496                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4497                Style);
4498 
4499   Style.ColumnLimit = 80;
4500   Style.IndentWidth = 4;
4501   Style.TabWidth = 4;
4502   Style.UseTab = FormatStyle::UT_Always;
4503   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4504   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4505   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
4506             "\t&& (someOtherLongishConditionPart1\n"
4507             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
4508             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
4509                    "(someOtherLongishConditionPart1 || "
4510                    "someOtherEvenLongerNestedConditionPart2);",
4511                    Style));
4512 }
4513 
4514 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
4515   FormatStyle Style = getLLVMStyle();
4516   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
4517   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
4518 
4519   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4520                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4521                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4522                "              == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4523                "                         * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4524                "                     + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4525                "          && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4526                "                     * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4527                "                 > ccccccccccccccccccccccccccccccccccccccccc;",
4528                Style);
4529   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4530                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4531                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4532                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4533                Style);
4534   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4535                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4536                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4537                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4538                Style);
4539   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4540                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4541                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4542                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
4543                Style);
4544   verifyFormat("if () {\n"
4545                "} else if (aaaaa\n"
4546                "           && bbbbb // break\n"
4547                "                  > ccccc) {\n"
4548                "}",
4549                Style);
4550   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4551                "    && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4552                Style);
4553   verifyFormat("return (a)\n"
4554                "     // comment\n"
4555                "     + b;",
4556                Style);
4557   verifyFormat(
4558       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4559       "               * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4560       "           + cc;",
4561       Style);
4562   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
4563                "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4564                "                        : 3333333333333333;",
4565                Style);
4566   verifyFormat(
4567       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
4568       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
4569       "                                             : eeeeeeeeeeeeeeeeee)\n"
4570       "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
4571       "                        : 3333333333333333;",
4572       Style);
4573   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4574                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
4575                Style);
4576 
4577   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
4578                "    == boost::fusion::at_c<1>(iiii).second;",
4579                Style);
4580 
4581   Style.ColumnLimit = 60;
4582   verifyFormat("zzzzzzzzzzzzz\n"
4583                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4584                "   >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
4585                Style);
4586 
4587   // Forced by comments.
4588   Style.ColumnLimit = 80;
4589   verifyFormat(
4590       "unsigned ContentSize\n"
4591       "    = sizeof(int16_t) // DWARF ARange version number\n"
4592       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4593       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4594       "    + sizeof(int8_t); // Segment Size (in bytes)",
4595       Style);
4596 
4597   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4598   verifyFormat(
4599       "unsigned ContentSize =\n"
4600       "    sizeof(int16_t)   // DWARF ARange version number\n"
4601       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4602       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4603       "    + sizeof(int8_t); // Segment Size (in bytes)",
4604       Style);
4605 
4606   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4607   verifyFormat(
4608       "unsigned ContentSize =\n"
4609       "    sizeof(int16_t)   // DWARF ARange version number\n"
4610       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
4611       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
4612       "    + sizeof(int8_t); // Segment Size (in bytes)",
4613       Style);
4614 }
4615 
4616 TEST_F(FormatTest, EnforcedOperatorWraps) {
4617   // Here we'd like to wrap after the || operators, but a comment is forcing an
4618   // earlier wrap.
4619   verifyFormat("bool x = aaaaa //\n"
4620                "         || bbbbb\n"
4621                "         //\n"
4622                "         || cccc;");
4623 }
4624 
4625 TEST_F(FormatTest, NoOperandAlignment) {
4626   FormatStyle Style = getLLVMStyle();
4627   Style.AlignOperands = FormatStyle::OAS_DontAlign;
4628   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
4629                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
4630                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
4631                Style);
4632   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4633   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4634                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4635                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4636                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4637                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4638                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4639                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4640                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4641                "        > ccccccccccccccccccccccccccccccccccccccccc;",
4642                Style);
4643 
4644   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4645                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4646                "    + cc;",
4647                Style);
4648   verifyFormat("int a = aa\n"
4649                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
4650                "        * cccccccccccccccccccccccccccccccccccc;\n",
4651                Style);
4652 
4653   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
4654   verifyFormat("return (a > b\n"
4655                "    // comment1\n"
4656                "    // comment2\n"
4657                "    || c);",
4658                Style);
4659 }
4660 
4661 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
4662   FormatStyle Style = getLLVMStyle();
4663   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4664   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
4665                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
4666                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
4667                Style);
4668 }
4669 
4670 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
4671   FormatStyle Style = getLLVMStyle();
4672   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
4673   Style.BinPackArguments = false;
4674   Style.ColumnLimit = 40;
4675   verifyFormat("void test() {\n"
4676                "  someFunction(\n"
4677                "      this + argument + is + quite\n"
4678                "      + long + so + it + gets + wrapped\n"
4679                "      + but + remains + bin - packed);\n"
4680                "}",
4681                Style);
4682   verifyFormat("void test() {\n"
4683                "  someFunction(arg1,\n"
4684                "               this + argument + is\n"
4685                "                   + quite + long + so\n"
4686                "                   + it + gets + wrapped\n"
4687                "                   + but + remains + bin\n"
4688                "                   - packed,\n"
4689                "               arg3);\n"
4690                "}",
4691                Style);
4692   verifyFormat("void test() {\n"
4693                "  someFunction(\n"
4694                "      arg1,\n"
4695                "      this + argument + has\n"
4696                "          + anotherFunc(nested,\n"
4697                "                        calls + whose\n"
4698                "                            + arguments\n"
4699                "                            + are + also\n"
4700                "                            + wrapped,\n"
4701                "                        in + addition)\n"
4702                "          + to + being + bin - packed,\n"
4703                "      arg3);\n"
4704                "}",
4705                Style);
4706 
4707   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
4708   verifyFormat("void test() {\n"
4709                "  someFunction(\n"
4710                "      arg1,\n"
4711                "      this + argument + has +\n"
4712                "          anotherFunc(nested,\n"
4713                "                      calls + whose +\n"
4714                "                          arguments +\n"
4715                "                          are + also +\n"
4716                "                          wrapped,\n"
4717                "                      in + addition) +\n"
4718                "          to + being + bin - packed,\n"
4719                "      arg3);\n"
4720                "}",
4721                Style);
4722 }
4723 
4724 TEST_F(FormatTest, ConstructorInitializers) {
4725   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
4726   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
4727                getLLVMStyleWithColumns(45));
4728   verifyFormat("Constructor()\n"
4729                "    : Inttializer(FitsOnTheLine) {}",
4730                getLLVMStyleWithColumns(44));
4731   verifyFormat("Constructor()\n"
4732                "    : Inttializer(FitsOnTheLine) {}",
4733                getLLVMStyleWithColumns(43));
4734 
4735   verifyFormat("template <typename T>\n"
4736                "Constructor() : Initializer(FitsOnTheLine) {}",
4737                getLLVMStyleWithColumns(45));
4738 
4739   verifyFormat(
4740       "SomeClass::Constructor()\n"
4741       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4742 
4743   verifyFormat(
4744       "SomeClass::Constructor()\n"
4745       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4746       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
4747   verifyFormat(
4748       "SomeClass::Constructor()\n"
4749       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4750       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
4751   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4752                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
4753                "    : aaaaaaaaaa(aaaaaa) {}");
4754 
4755   verifyFormat("Constructor()\n"
4756                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4757                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4758                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
4759                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
4760 
4761   verifyFormat("Constructor()\n"
4762                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4763                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4764 
4765   verifyFormat("Constructor(int Parameter = 0)\n"
4766                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
4767                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
4768   verifyFormat("Constructor()\n"
4769                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
4770                "}",
4771                getLLVMStyleWithColumns(60));
4772   verifyFormat("Constructor()\n"
4773                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
4774                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
4775 
4776   // Here a line could be saved by splitting the second initializer onto two
4777   // lines, but that is not desirable.
4778   verifyFormat("Constructor()\n"
4779                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
4780                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
4781                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
4782 
4783   FormatStyle OnePerLine = getLLVMStyle();
4784   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4785   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
4786   verifyFormat("SomeClass::Constructor()\n"
4787                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4788                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4789                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4790                OnePerLine);
4791   verifyFormat("SomeClass::Constructor()\n"
4792                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
4793                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
4794                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
4795                OnePerLine);
4796   verifyFormat("MyClass::MyClass(int var)\n"
4797                "    : some_var_(var),            // 4 space indent\n"
4798                "      some_other_var_(var + 1) { // lined up\n"
4799                "}",
4800                OnePerLine);
4801   verifyFormat("Constructor()\n"
4802                "    : aaaaa(aaaaaa),\n"
4803                "      aaaaa(aaaaaa),\n"
4804                "      aaaaa(aaaaaa),\n"
4805                "      aaaaa(aaaaaa),\n"
4806                "      aaaaa(aaaaaa) {}",
4807                OnePerLine);
4808   verifyFormat("Constructor()\n"
4809                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
4810                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
4811                OnePerLine);
4812   OnePerLine.BinPackParameters = false;
4813   verifyFormat(
4814       "Constructor()\n"
4815       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
4816       "          aaaaaaaaaaa().aaa(),\n"
4817       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
4818       OnePerLine);
4819   OnePerLine.ColumnLimit = 60;
4820   verifyFormat("Constructor()\n"
4821                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4822                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
4823                OnePerLine);
4824 
4825   EXPECT_EQ("Constructor()\n"
4826             "    : // Comment forcing unwanted break.\n"
4827             "      aaaa(aaaa) {}",
4828             format("Constructor() :\n"
4829                    "    // Comment forcing unwanted break.\n"
4830                    "    aaaa(aaaa) {}"));
4831 }
4832 
4833 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
4834   FormatStyle Style = getLLVMStyle();
4835   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4836   Style.ColumnLimit = 60;
4837   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
4838   Style.AllowAllConstructorInitializersOnNextLine = true;
4839   Style.BinPackParameters = false;
4840 
4841   for (int i = 0; i < 4; ++i) {
4842     // Test all combinations of parameters that should not have an effect.
4843     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4844     Style.AllowAllArgumentsOnNextLine = i & 2;
4845 
4846     Style.AllowAllConstructorInitializersOnNextLine = true;
4847     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4848     verifyFormat("Constructor()\n"
4849                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4850                  Style);
4851     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4852 
4853     Style.AllowAllConstructorInitializersOnNextLine = false;
4854     verifyFormat("Constructor()\n"
4855                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4856                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4857                  Style);
4858     verifyFormat("Constructor() : a(a), b(b) {}", Style);
4859 
4860     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4861     Style.AllowAllConstructorInitializersOnNextLine = true;
4862     verifyFormat("Constructor()\n"
4863                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4864                  Style);
4865 
4866     Style.AllowAllConstructorInitializersOnNextLine = false;
4867     verifyFormat("Constructor()\n"
4868                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4869                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4870                  Style);
4871 
4872     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4873     Style.AllowAllConstructorInitializersOnNextLine = true;
4874     verifyFormat("Constructor() :\n"
4875                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4876                  Style);
4877 
4878     Style.AllowAllConstructorInitializersOnNextLine = false;
4879     verifyFormat("Constructor() :\n"
4880                  "    aaaaaaaaaaaaaaaaaa(a),\n"
4881                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4882                  Style);
4883   }
4884 
4885   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
4886   // AllowAllConstructorInitializersOnNextLine in all
4887   // BreakConstructorInitializers modes
4888   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
4889   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4890   Style.AllowAllConstructorInitializersOnNextLine = false;
4891   verifyFormat("SomeClassWithALongName::Constructor(\n"
4892                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4893                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4894                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4895                Style);
4896 
4897   Style.AllowAllConstructorInitializersOnNextLine = true;
4898   verifyFormat("SomeClassWithALongName::Constructor(\n"
4899                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4900                "    int bbbbbbbbbbbbb,\n"
4901                "    int cccccccccccccccc)\n"
4902                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4903                Style);
4904 
4905   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4906   Style.AllowAllConstructorInitializersOnNextLine = false;
4907   verifyFormat("SomeClassWithALongName::Constructor(\n"
4908                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4909                "    int bbbbbbbbbbbbb)\n"
4910                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
4911                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
4912                Style);
4913 
4914   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
4915 
4916   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4917   verifyFormat("SomeClassWithALongName::Constructor(\n"
4918                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
4919                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4920                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4921                Style);
4922 
4923   Style.AllowAllConstructorInitializersOnNextLine = true;
4924   verifyFormat("SomeClassWithALongName::Constructor(\n"
4925                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4926                "    int bbbbbbbbbbbbb,\n"
4927                "    int cccccccccccccccc)\n"
4928                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4929                Style);
4930 
4931   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4932   Style.AllowAllConstructorInitializersOnNextLine = false;
4933   verifyFormat("SomeClassWithALongName::Constructor(\n"
4934                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4935                "    int bbbbbbbbbbbbb)\n"
4936                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
4937                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
4938                Style);
4939 
4940   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
4941   Style.AllowAllParametersOfDeclarationOnNextLine = true;
4942   verifyFormat("SomeClassWithALongName::Constructor(\n"
4943                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
4944                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4945                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4946                Style);
4947 
4948   Style.AllowAllConstructorInitializersOnNextLine = true;
4949   verifyFormat("SomeClassWithALongName::Constructor(\n"
4950                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4951                "    int bbbbbbbbbbbbb,\n"
4952                "    int cccccccccccccccc) :\n"
4953                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
4954                Style);
4955 
4956   Style.AllowAllParametersOfDeclarationOnNextLine = false;
4957   Style.AllowAllConstructorInitializersOnNextLine = false;
4958   verifyFormat("SomeClassWithALongName::Constructor(\n"
4959                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
4960                "    int bbbbbbbbbbbbb) :\n"
4961                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
4962                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
4963                Style);
4964 }
4965 
4966 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
4967   FormatStyle Style = getLLVMStyle();
4968   Style.ColumnLimit = 60;
4969   Style.BinPackArguments = false;
4970   for (int i = 0; i < 4; ++i) {
4971     // Test all combinations of parameters that should not have an effect.
4972     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
4973     Style.AllowAllConstructorInitializersOnNextLine = i & 2;
4974 
4975     Style.AllowAllArgumentsOnNextLine = true;
4976     verifyFormat("void foo() {\n"
4977                  "  FunctionCallWithReallyLongName(\n"
4978                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
4979                  "}",
4980                  Style);
4981     Style.AllowAllArgumentsOnNextLine = false;
4982     verifyFormat("void foo() {\n"
4983                  "  FunctionCallWithReallyLongName(\n"
4984                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4985                  "      bbbbbbbbbbbb);\n"
4986                  "}",
4987                  Style);
4988 
4989     Style.AllowAllArgumentsOnNextLine = true;
4990     verifyFormat("void foo() {\n"
4991                  "  auto VariableWithReallyLongName = {\n"
4992                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
4993                  "}",
4994                  Style);
4995     Style.AllowAllArgumentsOnNextLine = false;
4996     verifyFormat("void foo() {\n"
4997                  "  auto VariableWithReallyLongName = {\n"
4998                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4999                  "      bbbbbbbbbbbb};\n"
5000                  "}",
5001                  Style);
5002   }
5003 
5004   // This parameter should not affect declarations.
5005   Style.BinPackParameters = false;
5006   Style.AllowAllArgumentsOnNextLine = false;
5007   Style.AllowAllParametersOfDeclarationOnNextLine = true;
5008   verifyFormat("void FunctionCallWithReallyLongName(\n"
5009                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
5010                Style);
5011   Style.AllowAllParametersOfDeclarationOnNextLine = false;
5012   verifyFormat("void FunctionCallWithReallyLongName(\n"
5013                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
5014                "    int bbbbbbbbbbbb);",
5015                Style);
5016 }
5017 
5018 TEST_F(FormatTest, AllowAllArgumentsOnNextLineDontAlign) {
5019   // Check that AllowAllArgumentsOnNextLine is respected for both BAS_DontAlign
5020   // and BAS_Align.
5021   auto Style = getLLVMStyle();
5022   Style.ColumnLimit = 35;
5023   StringRef Input = "functionCall(paramA, paramB, paramC);\n"
5024                     "void functionDecl(int A, int B, int C);";
5025   Style.AllowAllArgumentsOnNextLine = false;
5026   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5027   EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
5028                       "    paramC);\n"
5029                       "void functionDecl(int A, int B,\n"
5030                       "    int C);"),
5031             format(Input, Style));
5032   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
5033   EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
5034                       "             paramC);\n"
5035                       "void functionDecl(int A, int B,\n"
5036                       "                  int C);"),
5037             format(Input, Style));
5038   // However, BAS_AlwaysBreak should take precedence over
5039   // AllowAllArgumentsOnNextLine.
5040   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5041   EXPECT_EQ(StringRef("functionCall(\n"
5042                       "    paramA, paramB, paramC);\n"
5043                       "void functionDecl(\n"
5044                       "    int A, int B, int C);"),
5045             format(Input, Style));
5046 
5047   // When AllowAllArgumentsOnNextLine is set, we prefer breaking before the
5048   // first argument.
5049   Style.AllowAllArgumentsOnNextLine = true;
5050   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
5051   EXPECT_EQ(StringRef("functionCall(\n"
5052                       "    paramA, paramB, paramC);\n"
5053                       "void functionDecl(\n"
5054                       "    int A, int B, int C);"),
5055             format(Input, Style));
5056   // It wouldn't fit on one line with aligned parameters so this setting
5057   // doesn't change anything for BAS_Align.
5058   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
5059   EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
5060                       "             paramC);\n"
5061                       "void functionDecl(int A, int B,\n"
5062                       "                  int C);"),
5063             format(Input, Style));
5064   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5065   EXPECT_EQ(StringRef("functionCall(\n"
5066                       "    paramA, paramB, paramC);\n"
5067                       "void functionDecl(\n"
5068                       "    int A, int B, int C);"),
5069             format(Input, Style));
5070 }
5071 
5072 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
5073   FormatStyle Style = getLLVMStyle();
5074   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
5075 
5076   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
5077   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
5078                getStyleWithColumns(Style, 45));
5079   verifyFormat("Constructor() :\n"
5080                "    Initializer(FitsOnTheLine) {}",
5081                getStyleWithColumns(Style, 44));
5082   verifyFormat("Constructor() :\n"
5083                "    Initializer(FitsOnTheLine) {}",
5084                getStyleWithColumns(Style, 43));
5085 
5086   verifyFormat("template <typename T>\n"
5087                "Constructor() : Initializer(FitsOnTheLine) {}",
5088                getStyleWithColumns(Style, 50));
5089   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5090   verifyFormat(
5091       "SomeClass::Constructor() :\n"
5092       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5093       Style);
5094 
5095   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = false;
5096   verifyFormat(
5097       "SomeClass::Constructor() :\n"
5098       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5099       Style);
5100 
5101   verifyFormat(
5102       "SomeClass::Constructor() :\n"
5103       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5104       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5105       Style);
5106   verifyFormat(
5107       "SomeClass::Constructor() :\n"
5108       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5109       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
5110       Style);
5111   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5112                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
5113                "    aaaaaaaaaa(aaaaaa) {}",
5114                Style);
5115 
5116   verifyFormat("Constructor() :\n"
5117                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5118                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5119                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5120                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
5121                Style);
5122 
5123   verifyFormat("Constructor() :\n"
5124                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5125                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5126                Style);
5127 
5128   verifyFormat("Constructor(int Parameter = 0) :\n"
5129                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
5130                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
5131                Style);
5132   verifyFormat("Constructor() :\n"
5133                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
5134                "}",
5135                getStyleWithColumns(Style, 60));
5136   verifyFormat("Constructor() :\n"
5137                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5138                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
5139                Style);
5140 
5141   // Here a line could be saved by splitting the second initializer onto two
5142   // lines, but that is not desirable.
5143   verifyFormat("Constructor() :\n"
5144                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
5145                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
5146                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5147                Style);
5148 
5149   FormatStyle OnePerLine = Style;
5150   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5151   OnePerLine.AllowAllConstructorInitializersOnNextLine = false;
5152   verifyFormat("SomeClass::Constructor() :\n"
5153                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5154                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5155                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5156                OnePerLine);
5157   verifyFormat("SomeClass::Constructor() :\n"
5158                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
5159                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5160                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5161                OnePerLine);
5162   verifyFormat("MyClass::MyClass(int var) :\n"
5163                "    some_var_(var),            // 4 space indent\n"
5164                "    some_other_var_(var + 1) { // lined up\n"
5165                "}",
5166                OnePerLine);
5167   verifyFormat("Constructor() :\n"
5168                "    aaaaa(aaaaaa),\n"
5169                "    aaaaa(aaaaaa),\n"
5170                "    aaaaa(aaaaaa),\n"
5171                "    aaaaa(aaaaaa),\n"
5172                "    aaaaa(aaaaaa) {}",
5173                OnePerLine);
5174   verifyFormat("Constructor() :\n"
5175                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
5176                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
5177                OnePerLine);
5178   OnePerLine.BinPackParameters = false;
5179   verifyFormat("Constructor() :\n"
5180                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5181                "        aaaaaaaaaaa().aaa(),\n"
5182                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5183                OnePerLine);
5184   OnePerLine.ColumnLimit = 60;
5185   verifyFormat("Constructor() :\n"
5186                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
5187                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
5188                OnePerLine);
5189 
5190   EXPECT_EQ("Constructor() :\n"
5191             "    // Comment forcing unwanted break.\n"
5192             "    aaaa(aaaa) {}",
5193             format("Constructor() :\n"
5194                    "    // Comment forcing unwanted break.\n"
5195                    "    aaaa(aaaa) {}",
5196                    Style));
5197 
5198   Style.ColumnLimit = 0;
5199   verifyFormat("SomeClass::Constructor() :\n"
5200                "    a(a) {}",
5201                Style);
5202   verifyFormat("SomeClass::Constructor() noexcept :\n"
5203                "    a(a) {}",
5204                Style);
5205   verifyFormat("SomeClass::Constructor() :\n"
5206                "    a(a), b(b), c(c) {}",
5207                Style);
5208   verifyFormat("SomeClass::Constructor() :\n"
5209                "    a(a) {\n"
5210                "  foo();\n"
5211                "  bar();\n"
5212                "}",
5213                Style);
5214 
5215   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
5216   verifyFormat("SomeClass::Constructor() :\n"
5217                "    a(a), b(b), c(c) {\n"
5218                "}",
5219                Style);
5220   verifyFormat("SomeClass::Constructor() :\n"
5221                "    a(a) {\n"
5222                "}",
5223                Style);
5224 
5225   Style.ColumnLimit = 80;
5226   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
5227   Style.ConstructorInitializerIndentWidth = 2;
5228   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
5229   verifyFormat("SomeClass::Constructor() :\n"
5230                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5231                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
5232                Style);
5233 
5234   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
5235   // well
5236   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
5237   verifyFormat(
5238       "class SomeClass\n"
5239       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5240       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5241       Style);
5242   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
5243   verifyFormat(
5244       "class SomeClass\n"
5245       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5246       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5247       Style);
5248   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
5249   verifyFormat(
5250       "class SomeClass :\n"
5251       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5252       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
5253       Style);
5254 }
5255 
5256 #ifndef EXPENSIVE_CHECKS
5257 // Expensive checks enables libstdc++ checking which includes validating the
5258 // state of ranges used in std::priority_queue - this blows out the
5259 // runtime/scalability of the function and makes this test unacceptably slow.
5260 TEST_F(FormatTest, MemoizationTests) {
5261   // This breaks if the memoization lookup does not take \c Indent and
5262   // \c LastSpace into account.
5263   verifyFormat(
5264       "extern CFRunLoopTimerRef\n"
5265       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
5266       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
5267       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
5268       "                     CFRunLoopTimerContext *context) {}");
5269 
5270   // Deep nesting somewhat works around our memoization.
5271   verifyFormat(
5272       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5273       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5274       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5275       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
5276       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
5277       getLLVMStyleWithColumns(65));
5278   verifyFormat(
5279       "aaaaa(\n"
5280       "    aaaaa,\n"
5281       "    aaaaa(\n"
5282       "        aaaaa,\n"
5283       "        aaaaa(\n"
5284       "            aaaaa,\n"
5285       "            aaaaa(\n"
5286       "                aaaaa,\n"
5287       "                aaaaa(\n"
5288       "                    aaaaa,\n"
5289       "                    aaaaa(\n"
5290       "                        aaaaa,\n"
5291       "                        aaaaa(\n"
5292       "                            aaaaa,\n"
5293       "                            aaaaa(\n"
5294       "                                aaaaa,\n"
5295       "                                aaaaa(\n"
5296       "                                    aaaaa,\n"
5297       "                                    aaaaa(\n"
5298       "                                        aaaaa,\n"
5299       "                                        aaaaa(\n"
5300       "                                            aaaaa,\n"
5301       "                                            aaaaa(\n"
5302       "                                                aaaaa,\n"
5303       "                                                aaaaa))))))))))));",
5304       getLLVMStyleWithColumns(65));
5305   verifyFormat(
5306       "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"
5307       "                                  a),\n"
5308       "                                a),\n"
5309       "                              a),\n"
5310       "                            a),\n"
5311       "                          a),\n"
5312       "                        a),\n"
5313       "                      a),\n"
5314       "                    a),\n"
5315       "                  a),\n"
5316       "                a),\n"
5317       "              a),\n"
5318       "            a),\n"
5319       "          a),\n"
5320       "        a),\n"
5321       "      a),\n"
5322       "    a),\n"
5323       "  a)",
5324       getLLVMStyleWithColumns(65));
5325 
5326   // This test takes VERY long when memoization is broken.
5327   FormatStyle OnePerLine = getLLVMStyle();
5328   OnePerLine.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
5329   OnePerLine.BinPackParameters = false;
5330   std::string input = "Constructor()\n"
5331                       "    : aaaa(a,\n";
5332   for (unsigned i = 0, e = 80; i != e; ++i) {
5333     input += "           a,\n";
5334   }
5335   input += "           a) {}";
5336   verifyFormat(input, OnePerLine);
5337 }
5338 #endif
5339 
5340 TEST_F(FormatTest, BreaksAsHighAsPossible) {
5341   verifyFormat(
5342       "void f() {\n"
5343       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
5344       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
5345       "    f();\n"
5346       "}");
5347   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
5348                "    Intervals[i - 1].getRange().getLast()) {\n}");
5349 }
5350 
5351 TEST_F(FormatTest, BreaksFunctionDeclarations) {
5352   // Principially, we break function declarations in a certain order:
5353   // 1) break amongst arguments.
5354   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
5355                "                              Cccccccccccccc cccccccccccccc);");
5356   verifyFormat("template <class TemplateIt>\n"
5357                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
5358                "                            TemplateIt *stop) {}");
5359 
5360   // 2) break after return type.
5361   verifyFormat(
5362       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5363       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
5364       getGoogleStyle());
5365 
5366   // 3) break after (.
5367   verifyFormat(
5368       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
5369       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
5370       getGoogleStyle());
5371 
5372   // 4) break before after nested name specifiers.
5373   verifyFormat(
5374       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5375       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
5376       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
5377       getGoogleStyle());
5378 
5379   // However, there are exceptions, if a sufficient amount of lines can be
5380   // saved.
5381   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
5382   // more adjusting.
5383   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5384                "                                  Cccccccccccccc cccccccccc,\n"
5385                "                                  Cccccccccccccc cccccccccc,\n"
5386                "                                  Cccccccccccccc cccccccccc,\n"
5387                "                                  Cccccccccccccc cccccccccc);");
5388   verifyFormat(
5389       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5390       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5391       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5392       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
5393       getGoogleStyle());
5394   verifyFormat(
5395       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
5396       "                                          Cccccccccccccc cccccccccc,\n"
5397       "                                          Cccccccccccccc cccccccccc,\n"
5398       "                                          Cccccccccccccc cccccccccc,\n"
5399       "                                          Cccccccccccccc cccccccccc,\n"
5400       "                                          Cccccccccccccc cccccccccc,\n"
5401       "                                          Cccccccccccccc cccccccccc);");
5402   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5403                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5404                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5405                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
5406                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
5407 
5408   // Break after multi-line parameters.
5409   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5410                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5411                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5412                "    bbbb bbbb);");
5413   verifyFormat("void SomeLoooooooooooongFunction(\n"
5414                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
5415                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5416                "    int bbbbbbbbbbbbb);");
5417 
5418   // Treat overloaded operators like other functions.
5419   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5420                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
5421   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5422                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
5423   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
5424                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
5425   verifyGoogleFormat(
5426       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
5427       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5428   verifyGoogleFormat(
5429       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
5430       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
5431   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5432                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5433   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
5434                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
5435   verifyGoogleFormat(
5436       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
5437       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5438       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
5439   verifyGoogleFormat("template <typename T>\n"
5440                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5441                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
5442                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
5443 
5444   FormatStyle Style = getLLVMStyle();
5445   Style.PointerAlignment = FormatStyle::PAS_Left;
5446   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5447                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
5448                Style);
5449   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
5450                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5451                Style);
5452 }
5453 
5454 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
5455   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
5456   // Prefer keeping `::` followed by `operator` together.
5457   EXPECT_EQ("const aaaa::bbbbbbb &\n"
5458             "ccccccccc::operator++() {\n"
5459             "  stuff();\n"
5460             "}",
5461             format("const aaaa::bbbbbbb\n"
5462                    "&ccccccccc::operator++() { stuff(); }",
5463                    getLLVMStyleWithColumns(40)));
5464 }
5465 
5466 TEST_F(FormatTest, TrailingReturnType) {
5467   verifyFormat("auto foo() -> int;\n");
5468   // correct trailing return type spacing
5469   verifyFormat("auto operator->() -> int;\n");
5470   verifyFormat("auto operator++(int) -> int;\n");
5471 
5472   verifyFormat("struct S {\n"
5473                "  auto bar() const -> int;\n"
5474                "};");
5475   verifyFormat("template <size_t Order, typename T>\n"
5476                "auto load_img(const std::string &filename)\n"
5477                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
5478   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
5479                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
5480   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
5481   verifyFormat("template <typename T>\n"
5482                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
5483                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
5484 
5485   // Not trailing return types.
5486   verifyFormat("void f() { auto a = b->c(); }");
5487 }
5488 
5489 TEST_F(FormatTest, DeductionGuides) {
5490   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
5491   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
5492   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
5493   verifyFormat(
5494       "template <class... T>\n"
5495       "array(T &&...t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
5496   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
5497   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
5498   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
5499   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
5500   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
5501   verifyFormat("template <class T> x() -> x<1>;");
5502   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
5503 
5504   // Ensure not deduction guides.
5505   verifyFormat("c()->f<int>();");
5506   verifyFormat("x()->foo<1>;");
5507   verifyFormat("x = p->foo<3>();");
5508   verifyFormat("x()->x<1>();");
5509   verifyFormat("x()->x<1>;");
5510 }
5511 
5512 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
5513   // Avoid breaking before trailing 'const' or other trailing annotations, if
5514   // they are not function-like.
5515   FormatStyle Style = getGoogleStyle();
5516   Style.ColumnLimit = 47;
5517   verifyFormat("void someLongFunction(\n"
5518                "    int someLoooooooooooooongParameter) const {\n}",
5519                getLLVMStyleWithColumns(47));
5520   verifyFormat("LoooooongReturnType\n"
5521                "someLoooooooongFunction() const {}",
5522                getLLVMStyleWithColumns(47));
5523   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
5524                "    const {}",
5525                Style);
5526   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5527                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
5528   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5529                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
5530   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
5531                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
5532   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
5533                "                   aaaaaaaaaaa aaaaa) const override;");
5534   verifyGoogleFormat(
5535       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5536       "    const override;");
5537 
5538   // Even if the first parameter has to be wrapped.
5539   verifyFormat("void someLongFunction(\n"
5540                "    int someLongParameter) const {}",
5541                getLLVMStyleWithColumns(46));
5542   verifyFormat("void someLongFunction(\n"
5543                "    int someLongParameter) const {}",
5544                Style);
5545   verifyFormat("void someLongFunction(\n"
5546                "    int someLongParameter) override {}",
5547                Style);
5548   verifyFormat("void someLongFunction(\n"
5549                "    int someLongParameter) OVERRIDE {}",
5550                Style);
5551   verifyFormat("void someLongFunction(\n"
5552                "    int someLongParameter) final {}",
5553                Style);
5554   verifyFormat("void someLongFunction(\n"
5555                "    int someLongParameter) FINAL {}",
5556                Style);
5557   verifyFormat("void someLongFunction(\n"
5558                "    int parameter) const override {}",
5559                Style);
5560 
5561   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
5562   verifyFormat("void someLongFunction(\n"
5563                "    int someLongParameter) const\n"
5564                "{\n"
5565                "}",
5566                Style);
5567 
5568   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
5569   verifyFormat("void someLongFunction(\n"
5570                "    int someLongParameter) const\n"
5571                "  {\n"
5572                "  }",
5573                Style);
5574 
5575   // Unless these are unknown annotations.
5576   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
5577                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5578                "    LONG_AND_UGLY_ANNOTATION;");
5579 
5580   // Breaking before function-like trailing annotations is fine to keep them
5581   // close to their arguments.
5582   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5583                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5584   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5585                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
5586   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
5587                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
5588   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
5589                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
5590   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
5591 
5592   verifyFormat(
5593       "void aaaaaaaaaaaaaaaaaa()\n"
5594       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
5595       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
5596   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5597                "    __attribute__((unused));");
5598   verifyGoogleFormat(
5599       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5600       "    GUARDED_BY(aaaaaaaaaaaa);");
5601   verifyGoogleFormat(
5602       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5603       "    GUARDED_BY(aaaaaaaaaaaa);");
5604   verifyGoogleFormat(
5605       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5606       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
5607   verifyGoogleFormat(
5608       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
5609       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
5610 }
5611 
5612 TEST_F(FormatTest, FunctionAnnotations) {
5613   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5614                "int OldFunction(const string &parameter) {}");
5615   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5616                "string OldFunction(const string &parameter) {}");
5617   verifyFormat("template <typename T>\n"
5618                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
5619                "string OldFunction(const string &parameter) {}");
5620 
5621   // Not function annotations.
5622   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5623                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
5624   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
5625                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
5626   verifyFormat("MACRO(abc).function() // wrap\n"
5627                "    << abc;");
5628   verifyFormat("MACRO(abc)->function() // wrap\n"
5629                "    << abc;");
5630   verifyFormat("MACRO(abc)::function() // wrap\n"
5631                "    << abc;");
5632 }
5633 
5634 TEST_F(FormatTest, BreaksDesireably) {
5635   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5636                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
5637                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
5638   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5639                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
5640                "}");
5641 
5642   verifyFormat(
5643       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5644       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5645 
5646   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5647                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5648                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5649 
5650   verifyFormat(
5651       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5652       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5653       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5654       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5655       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
5656 
5657   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5658                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5659 
5660   verifyFormat(
5661       "void f() {\n"
5662       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
5663       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5664       "}");
5665   verifyFormat(
5666       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5667       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5668   verifyFormat(
5669       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5670       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
5671   verifyFormat(
5672       "aaaaaa(aaa,\n"
5673       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5674       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5675       "       aaaa);");
5676   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5677                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5678                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5679 
5680   // Indent consistently independent of call expression and unary operator.
5681   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5682                "    dddddddddddddddddddddddddddddd));");
5683   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
5684                "    dddddddddddddddddddddddddddddd));");
5685   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
5686                "    dddddddddddddddddddddddddddddd));");
5687 
5688   // This test case breaks on an incorrect memoization, i.e. an optimization not
5689   // taking into account the StopAt value.
5690   verifyFormat(
5691       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5692       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5693       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
5694       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5695 
5696   verifyFormat("{\n  {\n    {\n"
5697                "      Annotation.SpaceRequiredBefore =\n"
5698                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
5699                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
5700                "    }\n  }\n}");
5701 
5702   // Break on an outer level if there was a break on an inner level.
5703   EXPECT_EQ("f(g(h(a, // comment\n"
5704             "      b, c),\n"
5705             "    d, e),\n"
5706             "  x, y);",
5707             format("f(g(h(a, // comment\n"
5708                    "    b, c), d, e), x, y);"));
5709 
5710   // Prefer breaking similar line breaks.
5711   verifyFormat(
5712       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
5713       "                             NSTrackingMouseEnteredAndExited |\n"
5714       "                             NSTrackingActiveAlways;");
5715 }
5716 
5717 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
5718   FormatStyle NoBinPacking = getGoogleStyle();
5719   NoBinPacking.BinPackParameters = false;
5720   NoBinPacking.BinPackArguments = true;
5721   verifyFormat("void f() {\n"
5722                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
5723                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
5724                "}",
5725                NoBinPacking);
5726   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
5727                "       int aaaaaaaaaaaaaaaaaaaa,\n"
5728                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
5729                NoBinPacking);
5730 
5731   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5732   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5733                "                        vector<int> bbbbbbbbbbbbbbb);",
5734                NoBinPacking);
5735   // FIXME: This behavior difference is probably not wanted. However, currently
5736   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
5737   // template arguments from BreakBeforeParameter being set because of the
5738   // one-per-line formatting.
5739   verifyFormat(
5740       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5741       "                                             aaaaaaaaaa> aaaaaaaaaa);",
5742       NoBinPacking);
5743   verifyFormat(
5744       "void fffffffffff(\n"
5745       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
5746       "        aaaaaaaaaa);");
5747 }
5748 
5749 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
5750   FormatStyle NoBinPacking = getGoogleStyle();
5751   NoBinPacking.BinPackParameters = false;
5752   NoBinPacking.BinPackArguments = false;
5753   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
5754                "  aaaaaaaaaaaaaaaaaaaa,\n"
5755                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
5756                NoBinPacking);
5757   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
5758                "        aaaaaaaaaaaaa,\n"
5759                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
5760                NoBinPacking);
5761   verifyFormat(
5762       "aaaaaaaa(aaaaaaaaaaaaa,\n"
5763       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5764       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
5765       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5766       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
5767       NoBinPacking);
5768   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5769                "    .aaaaaaaaaaaaaaaaaa();",
5770                NoBinPacking);
5771   verifyFormat("void f() {\n"
5772                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5773                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
5774                "}",
5775                NoBinPacking);
5776 
5777   verifyFormat(
5778       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5779       "             aaaaaaaaaaaa,\n"
5780       "             aaaaaaaaaaaa);",
5781       NoBinPacking);
5782   verifyFormat(
5783       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
5784       "                               ddddddddddddddddddddddddddddd),\n"
5785       "             test);",
5786       NoBinPacking);
5787 
5788   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
5789                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
5790                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
5791                "    aaaaaaaaaaaaaaaaaa;",
5792                NoBinPacking);
5793   verifyFormat("a(\"a\"\n"
5794                "  \"a\",\n"
5795                "  a);");
5796 
5797   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
5798   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
5799                "                aaaaaaaaa,\n"
5800                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5801                NoBinPacking);
5802   verifyFormat(
5803       "void f() {\n"
5804       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
5805       "      .aaaaaaa();\n"
5806       "}",
5807       NoBinPacking);
5808   verifyFormat(
5809       "template <class SomeType, class SomeOtherType>\n"
5810       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
5811       NoBinPacking);
5812 }
5813 
5814 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
5815   FormatStyle Style = getLLVMStyleWithColumns(15);
5816   Style.ExperimentalAutoDetectBinPacking = true;
5817   EXPECT_EQ("aaa(aaaa,\n"
5818             "    aaaa,\n"
5819             "    aaaa);\n"
5820             "aaa(aaaa,\n"
5821             "    aaaa,\n"
5822             "    aaaa);",
5823             format("aaa(aaaa,\n" // one-per-line
5824                    "  aaaa,\n"
5825                    "    aaaa  );\n"
5826                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5827                    Style));
5828   EXPECT_EQ("aaa(aaaa, aaaa,\n"
5829             "    aaaa);\n"
5830             "aaa(aaaa, aaaa,\n"
5831             "    aaaa);",
5832             format("aaa(aaaa,  aaaa,\n" // bin-packed
5833                    "    aaaa  );\n"
5834                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
5835                    Style));
5836 }
5837 
5838 TEST_F(FormatTest, FormatsBuilderPattern) {
5839   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
5840                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
5841                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
5842                "    .StartsWith(\".init\", ORDER_INIT)\n"
5843                "    .StartsWith(\".fini\", ORDER_FINI)\n"
5844                "    .StartsWith(\".hash\", ORDER_HASH)\n"
5845                "    .Default(ORDER_TEXT);\n");
5846 
5847   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
5848                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
5849   verifyFormat("aaaaaaa->aaaaaaa\n"
5850                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5851                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5852                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5853   verifyFormat(
5854       "aaaaaaa->aaaaaaa\n"
5855       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5856       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
5857   verifyFormat(
5858       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
5859       "    aaaaaaaaaaaaaa);");
5860   verifyFormat(
5861       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
5862       "    aaaaaa->aaaaaaaaaaaa()\n"
5863       "        ->aaaaaaaaaaaaaaaa(\n"
5864       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5865       "        ->aaaaaaaaaaaaaaaaa();");
5866   verifyGoogleFormat(
5867       "void f() {\n"
5868       "  someo->Add((new util::filetools::Handler(dir))\n"
5869       "                 ->OnEvent1(NewPermanentCallback(\n"
5870       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
5871       "                 ->OnEvent2(NewPermanentCallback(\n"
5872       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
5873       "                 ->OnEvent3(NewPermanentCallback(\n"
5874       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
5875       "                 ->OnEvent5(NewPermanentCallback(\n"
5876       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
5877       "                 ->OnEvent6(NewPermanentCallback(\n"
5878       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
5879       "}");
5880 
5881   verifyFormat(
5882       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
5883   verifyFormat("aaaaaaaaaaaaaaa()\n"
5884                "    .aaaaaaaaaaaaaaa()\n"
5885                "    .aaaaaaaaaaaaaaa()\n"
5886                "    .aaaaaaaaaaaaaaa()\n"
5887                "    .aaaaaaaaaaaaaaa();");
5888   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5889                "    .aaaaaaaaaaaaaaa()\n"
5890                "    .aaaaaaaaaaaaaaa()\n"
5891                "    .aaaaaaaaaaaaaaa();");
5892   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5893                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
5894                "    .aaaaaaaaaaaaaaa();");
5895   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
5896                "    ->aaaaaaaaaaaaaae(0)\n"
5897                "    ->aaaaaaaaaaaaaaa();");
5898 
5899   // Don't linewrap after very short segments.
5900   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5901                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5902                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5903   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5904                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5905                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5906   verifyFormat("aaa()\n"
5907                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5908                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5909                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
5910 
5911   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5912                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
5913                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
5914   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
5915                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5916                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
5917 
5918   // Prefer not to break after empty parentheses.
5919   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
5920                "    First->LastNewlineOffset);");
5921 
5922   // Prefer not to create "hanging" indents.
5923   verifyFormat(
5924       "return !soooooooooooooome_map\n"
5925       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5926       "            .second;");
5927   verifyFormat(
5928       "return aaaaaaaaaaaaaaaa\n"
5929       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
5930       "    .aaaa(aaaaaaaaaaaaaa);");
5931   // No hanging indent here.
5932   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
5933                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5934   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
5935                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5936   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5937                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5938                getLLVMStyleWithColumns(60));
5939   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
5940                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
5941                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5942                getLLVMStyleWithColumns(59));
5943   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5944                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5945                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
5946 
5947   // Dont break if only closing statements before member call
5948   verifyFormat("test() {\n"
5949                "  ([]() -> {\n"
5950                "    int b = 32;\n"
5951                "    return 3;\n"
5952                "  }).foo();\n"
5953                "}");
5954   verifyFormat("test() {\n"
5955                "  (\n"
5956                "      []() -> {\n"
5957                "        int b = 32;\n"
5958                "        return 3;\n"
5959                "      },\n"
5960                "      foo, bar)\n"
5961                "      .foo();\n"
5962                "}");
5963   verifyFormat("test() {\n"
5964                "  ([]() -> {\n"
5965                "    int b = 32;\n"
5966                "    return 3;\n"
5967                "  })\n"
5968                "      .foo()\n"
5969                "      .bar();\n"
5970                "}");
5971   verifyFormat("test() {\n"
5972                "  ([]() -> {\n"
5973                "    int b = 32;\n"
5974                "    return 3;\n"
5975                "  })\n"
5976                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
5977                "           \"bbbb\");\n"
5978                "}",
5979                getLLVMStyleWithColumns(30));
5980 }
5981 
5982 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
5983   verifyFormat(
5984       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5985       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
5986   verifyFormat(
5987       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
5988       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
5989 
5990   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5991                "    ccccccccccccccccccccccccc) {\n}");
5992   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
5993                "    ccccccccccccccccccccccccc) {\n}");
5994 
5995   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
5996                "    ccccccccccccccccccccccccc) {\n}");
5997   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
5998                "    ccccccccccccccccccccccccc) {\n}");
5999 
6000   verifyFormat(
6001       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
6002       "    ccccccccccccccccccccccccc) {\n}");
6003   verifyFormat(
6004       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
6005       "    ccccccccccccccccccccccccc) {\n}");
6006 
6007   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
6008                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
6009                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
6010                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
6011   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
6012                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
6013                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
6014                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
6015 
6016   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
6017                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
6018                "    aaaaaaaaaaaaaaa != aa) {\n}");
6019   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
6020                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
6021                "    aaaaaaaaaaaaaaa != aa) {\n}");
6022 }
6023 
6024 TEST_F(FormatTest, BreaksAfterAssignments) {
6025   verifyFormat(
6026       "unsigned Cost =\n"
6027       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
6028       "                        SI->getPointerAddressSpaceee());\n");
6029   verifyFormat(
6030       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
6031       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
6032 
6033   verifyFormat(
6034       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
6035       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
6036   verifyFormat("unsigned OriginalStartColumn =\n"
6037                "    SourceMgr.getSpellingColumnNumber(\n"
6038                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
6039                "    1;");
6040 }
6041 
6042 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
6043   FormatStyle Style = getLLVMStyle();
6044   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6045                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
6046                Style);
6047 
6048   Style.PenaltyBreakAssignment = 20;
6049   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
6050                "                                 cccccccccccccccccccccccccc;",
6051                Style);
6052 }
6053 
6054 TEST_F(FormatTest, AlignsAfterAssignments) {
6055   verifyFormat(
6056       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6057       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
6058   verifyFormat(
6059       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6060       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
6061   verifyFormat(
6062       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6063       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
6064   verifyFormat(
6065       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6066       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
6067   verifyFormat(
6068       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
6069       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
6070       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
6071 }
6072 
6073 TEST_F(FormatTest, AlignsAfterReturn) {
6074   verifyFormat(
6075       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6076       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
6077   verifyFormat(
6078       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6079       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
6080   verifyFormat(
6081       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
6082       "       aaaaaaaaaaaaaaaaaaaaaa();");
6083   verifyFormat(
6084       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
6085       "        aaaaaaaaaaaaaaaaaaaaaa());");
6086   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6087                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6088   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6089                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
6090                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6091   verifyFormat("return\n"
6092                "    // true if code is one of a or b.\n"
6093                "    code == a || code == b;");
6094 }
6095 
6096 TEST_F(FormatTest, AlignsAfterOpenBracket) {
6097   verifyFormat(
6098       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
6099       "                                                aaaaaaaaa aaaaaaa) {}");
6100   verifyFormat(
6101       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
6102       "                                               aaaaaaaaaaa aaaaaaaaa);");
6103   verifyFormat(
6104       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6105       "                                             aaaaaaaaaaaaaaaaaaaaa));");
6106   FormatStyle Style = getLLVMStyle();
6107   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6108   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6109                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
6110                Style);
6111   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6112                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
6113                Style);
6114   verifyFormat("SomeLongVariableName->someFunction(\n"
6115                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
6116                Style);
6117   verifyFormat(
6118       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
6119       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6120       Style);
6121   verifyFormat(
6122       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
6123       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6124       Style);
6125   verifyFormat(
6126       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
6127       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6128       Style);
6129 
6130   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
6131                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
6132                "        b));",
6133                Style);
6134 
6135   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6136   Style.BinPackArguments = false;
6137   Style.BinPackParameters = false;
6138   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6139                "    aaaaaaaaaaa aaaaaaaa,\n"
6140                "    aaaaaaaaa aaaaaaa,\n"
6141                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6142                Style);
6143   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
6144                "    aaaaaaaaaaa aaaaaaaaa,\n"
6145                "    aaaaaaaaaaa aaaaaaaaa,\n"
6146                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6147                Style);
6148   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
6149                "    aaaaaaaaaaaaaaa,\n"
6150                "    aaaaaaaaaaaaaaaaaaaaa,\n"
6151                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
6152                Style);
6153   verifyFormat(
6154       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
6155       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6156       Style);
6157   verifyFormat(
6158       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
6159       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
6160       Style);
6161   verifyFormat(
6162       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6163       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6164       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
6165       "    aaaaaaaaaaaaaaaa);",
6166       Style);
6167   verifyFormat(
6168       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6169       "    aaaaaaaaaaaaaaaaaaaaa(\n"
6170       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
6171       "    aaaaaaaaaaaaaaaa);",
6172       Style);
6173 }
6174 
6175 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
6176   FormatStyle Style = getLLVMStyleWithColumns(40);
6177   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6178                "          bbbbbbbbbbbbbbbbbbbbbb);",
6179                Style);
6180   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6181   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6182   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6183                "          bbbbbbbbbbbbbbbbbbbbbb);",
6184                Style);
6185   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6186   Style.AlignOperands = FormatStyle::OAS_Align;
6187   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6188                "          bbbbbbbbbbbbbbbbbbbbbb);",
6189                Style);
6190   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6191   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6192   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
6193                "    bbbbbbbbbbbbbbbbbbbbbb);",
6194                Style);
6195 }
6196 
6197 TEST_F(FormatTest, BreaksConditionalExpressions) {
6198   verifyFormat(
6199       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6200       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6201       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6202   verifyFormat(
6203       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6204       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6205       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6206   verifyFormat(
6207       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6208       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6209   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
6210                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6211                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6212   verifyFormat(
6213       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
6214       "                                                    : aaaaaaaaaaaaa);");
6215   verifyFormat(
6216       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6217       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6218       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6219       "                   aaaaaaaaaaaaa);");
6220   verifyFormat(
6221       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6222       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6223       "                   aaaaaaaaaaaaa);");
6224   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6225                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6226                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6227                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6228                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6229   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6230                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6231                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6232                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6233                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6234                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6235                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6236   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6237                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6238                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6239                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6240                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6241   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6242                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6243                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6244   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6245                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6246                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6247                "        : aaaaaaaaaaaaaaaa;");
6248   verifyFormat(
6249       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6250       "    ? aaaaaaaaaaaaaaa\n"
6251       "    : aaaaaaaaaaaaaaa;");
6252   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6253                "          aaaaaaaaa\n"
6254                "      ? b\n"
6255                "      : c);");
6256   verifyFormat("return aaaa == bbbb\n"
6257                "           // comment\n"
6258                "           ? aaaa\n"
6259                "           : bbbb;");
6260   verifyFormat("unsigned Indent =\n"
6261                "    format(TheLine.First,\n"
6262                "           IndentForLevel[TheLine.Level] >= 0\n"
6263                "               ? IndentForLevel[TheLine.Level]\n"
6264                "               : TheLine * 2,\n"
6265                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6266                getLLVMStyleWithColumns(60));
6267   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6268                "                  ? aaaaaaaaaaaaaaa\n"
6269                "                  : bbbbbbbbbbbbbbb //\n"
6270                "                        ? ccccccccccccccc\n"
6271                "                        : ddddddddddddddd;");
6272   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
6273                "                  ? aaaaaaaaaaaaaaa\n"
6274                "                  : (bbbbbbbbbbbbbbb //\n"
6275                "                         ? ccccccccccccccc\n"
6276                "                         : ddddddddddddddd);");
6277   verifyFormat(
6278       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6279       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6280       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
6281       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
6282       "                                      : aaaaaaaaaa;");
6283   verifyFormat(
6284       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6285       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
6286       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6287 
6288   FormatStyle NoBinPacking = getLLVMStyle();
6289   NoBinPacking.BinPackArguments = false;
6290   verifyFormat(
6291       "void f() {\n"
6292       "  g(aaa,\n"
6293       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6294       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6295       "        ? aaaaaaaaaaaaaaa\n"
6296       "        : aaaaaaaaaaaaaaa);\n"
6297       "}",
6298       NoBinPacking);
6299   verifyFormat(
6300       "void f() {\n"
6301       "  g(aaa,\n"
6302       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
6303       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6304       "        ?: aaaaaaaaaaaaaaa);\n"
6305       "}",
6306       NoBinPacking);
6307 
6308   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
6309                "             // comment.\n"
6310                "             ccccccccccccccccccccccccccccccccccccccc\n"
6311                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6312                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
6313 
6314   // Assignments in conditional expressions. Apparently not uncommon :-(.
6315   verifyFormat("return a != b\n"
6316                "           // comment\n"
6317                "           ? a = b\n"
6318                "           : a = b;");
6319   verifyFormat("return a != b\n"
6320                "           // comment\n"
6321                "           ? a = a != b\n"
6322                "                     // comment\n"
6323                "                     ? a = b\n"
6324                "                     : a\n"
6325                "           : a;\n");
6326   verifyFormat("return a != b\n"
6327                "           // comment\n"
6328                "           ? a\n"
6329                "           : a = a != b\n"
6330                "                     // comment\n"
6331                "                     ? a = b\n"
6332                "                     : a;");
6333 
6334   // Chained conditionals
6335   FormatStyle Style = getLLVMStyle();
6336   Style.ColumnLimit = 70;
6337   Style.AlignOperands = FormatStyle::OAS_Align;
6338   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6339                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6340                "                        : 3333333333333333;",
6341                Style);
6342   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6343                "       : bbbbbbbbbb     ? 2222222222222222\n"
6344                "                        : 3333333333333333;",
6345                Style);
6346   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
6347                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
6348                "                          : 3333333333333333;",
6349                Style);
6350   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6351                "       : bbbbbbbbbbbbbb ? 222222\n"
6352                "                        : 333333;",
6353                Style);
6354   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6355                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6356                "       : cccccccccccccc ? 3333333333333333\n"
6357                "                        : 4444444444444444;",
6358                Style);
6359   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
6360                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6361                "                        : 3333333333333333;",
6362                Style);
6363   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6364                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6365                "                        : (aaa ? bbb : ccc);",
6366                Style);
6367   verifyFormat(
6368       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6369       "                                             : cccccccccccccccccc)\n"
6370       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6371       "                        : 3333333333333333;",
6372       Style);
6373   verifyFormat(
6374       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6375       "                                             : cccccccccccccccccc)\n"
6376       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6377       "                        : 3333333333333333;",
6378       Style);
6379   verifyFormat(
6380       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6381       "                                             : dddddddddddddddddd)\n"
6382       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6383       "                        : 3333333333333333;",
6384       Style);
6385   verifyFormat(
6386       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6387       "                                             : dddddddddddddddddd)\n"
6388       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6389       "                        : 3333333333333333;",
6390       Style);
6391   verifyFormat(
6392       "return aaaaaaaaa        ? 1111111111111111\n"
6393       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6394       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6395       "                                             : dddddddddddddddddd)\n",
6396       Style);
6397   verifyFormat(
6398       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
6399       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6400       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6401       "                                             : cccccccccccccccccc);",
6402       Style);
6403   verifyFormat(
6404       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6405       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6406       "                                             : eeeeeeeeeeeeeeeeee)\n"
6407       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6408       "                        : 3333333333333333;",
6409       Style);
6410   verifyFormat(
6411       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
6412       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
6413       "                                             : eeeeeeeeeeeeeeeeee)\n"
6414       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6415       "                        : 3333333333333333;",
6416       Style);
6417   verifyFormat(
6418       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6419       "                           : cccccccccccc    ? dddddddddddddddddd\n"
6420       "                                             : eeeeeeeeeeeeeeeeee)\n"
6421       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6422       "                        : 3333333333333333;",
6423       Style);
6424   verifyFormat(
6425       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6426       "                                             : cccccccccccccccccc\n"
6427       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6428       "                        : 3333333333333333;",
6429       Style);
6430   verifyFormat(
6431       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6432       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
6433       "                                             : eeeeeeeeeeeeeeeeee\n"
6434       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
6435       "                        : 3333333333333333;",
6436       Style);
6437   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
6438                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
6439                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
6440                "                                   : eeeeeeeeeeeeeeeeee)\n"
6441                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6442                "                             : 3333333333333333;",
6443                Style);
6444   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
6445                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
6446                "             : cccccccccccccccc ? dddddddddddddddddd\n"
6447                "                                : eeeeeeeeeeeeeeeeee\n"
6448                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
6449                "                                 : 3333333333333333;",
6450                Style);
6451 
6452   Style.AlignOperands = FormatStyle::OAS_DontAlign;
6453   Style.BreakBeforeTernaryOperators = false;
6454   // FIXME: Aligning the question marks is weird given DontAlign.
6455   // Consider disabling this alignment in this case. Also check whether this
6456   // will render the adjustment from https://reviews.llvm.org/D82199
6457   // unnecessary.
6458   verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
6459                "    bbbb                ? cccccccccccccccccc :\n"
6460                "                          ddddd;\n",
6461                Style);
6462 }
6463 
6464 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
6465   FormatStyle Style = getLLVMStyle();
6466   Style.BreakBeforeTernaryOperators = false;
6467   Style.ColumnLimit = 70;
6468   verifyFormat(
6469       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6470       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6471       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6472       Style);
6473   verifyFormat(
6474       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
6475       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6476       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6477       Style);
6478   verifyFormat(
6479       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6480       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6481       Style);
6482   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
6483                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6484                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6485                Style);
6486   verifyFormat(
6487       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
6488       "                                                      aaaaaaaaaaaaa);",
6489       Style);
6490   verifyFormat(
6491       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6492       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6493       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6494       "                   aaaaaaaaaaaaa);",
6495       Style);
6496   verifyFormat(
6497       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6498       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6499       "                   aaaaaaaaaaaaa);",
6500       Style);
6501   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6502                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6503                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6504                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6505                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6506                Style);
6507   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6508                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6509                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6510                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6511                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6512                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6513                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6514                Style);
6515   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6516                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
6517                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6518                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6519                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
6520                Style);
6521   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6522                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6523                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6524                Style);
6525   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
6526                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6527                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
6528                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
6529                Style);
6530   verifyFormat(
6531       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6532       "    aaaaaaaaaaaaaaa :\n"
6533       "    aaaaaaaaaaaaaaa;",
6534       Style);
6535   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
6536                "          aaaaaaaaa ?\n"
6537                "      b :\n"
6538                "      c);",
6539                Style);
6540   verifyFormat("unsigned Indent =\n"
6541                "    format(TheLine.First,\n"
6542                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
6543                "               IndentForLevel[TheLine.Level] :\n"
6544                "               TheLine * 2,\n"
6545                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
6546                Style);
6547   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6548                "                  aaaaaaaaaaaaaaa :\n"
6549                "                  bbbbbbbbbbbbbbb ? //\n"
6550                "                      ccccccccccccccc :\n"
6551                "                      ddddddddddddddd;",
6552                Style);
6553   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
6554                "                  aaaaaaaaaaaaaaa :\n"
6555                "                  (bbbbbbbbbbbbbbb ? //\n"
6556                "                       ccccccccccccccc :\n"
6557                "                       ddddddddddddddd);",
6558                Style);
6559   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6560                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
6561                "            ccccccccccccccccccccccccccc;",
6562                Style);
6563   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
6564                "           aaaaa :\n"
6565                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
6566                Style);
6567 
6568   // Chained conditionals
6569   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6570                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6571                "                          3333333333333333;",
6572                Style);
6573   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6574                "       bbbbbbbbbb       ? 2222222222222222 :\n"
6575                "                          3333333333333333;",
6576                Style);
6577   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
6578                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6579                "                          3333333333333333;",
6580                Style);
6581   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6582                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
6583                "                          333333;",
6584                Style);
6585   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6586                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6587                "       cccccccccccccccc ? 3333333333333333 :\n"
6588                "                          4444444444444444;",
6589                Style);
6590   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
6591                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6592                "                          3333333333333333;",
6593                Style);
6594   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6595                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6596                "                          (aaa ? bbb : ccc);",
6597                Style);
6598   verifyFormat(
6599       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6600       "                                               cccccccccccccccccc) :\n"
6601       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6602       "                          3333333333333333;",
6603       Style);
6604   verifyFormat(
6605       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6606       "                                               cccccccccccccccccc) :\n"
6607       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6608       "                          3333333333333333;",
6609       Style);
6610   verifyFormat(
6611       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6612       "                                               dddddddddddddddddd) :\n"
6613       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6614       "                          3333333333333333;",
6615       Style);
6616   verifyFormat(
6617       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6618       "                                               dddddddddddddddddd) :\n"
6619       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6620       "                          3333333333333333;",
6621       Style);
6622   verifyFormat(
6623       "return aaaaaaaaa        ? 1111111111111111 :\n"
6624       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6625       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6626       "                                               dddddddddddddddddd)\n",
6627       Style);
6628   verifyFormat(
6629       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
6630       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6631       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6632       "                                               cccccccccccccccccc);",
6633       Style);
6634   verifyFormat(
6635       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6636       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6637       "                                               eeeeeeeeeeeeeeeeee) :\n"
6638       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6639       "                          3333333333333333;",
6640       Style);
6641   verifyFormat(
6642       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6643       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
6644       "                                               eeeeeeeeeeeeeeeeee) :\n"
6645       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6646       "                          3333333333333333;",
6647       Style);
6648   verifyFormat(
6649       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
6650       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
6651       "                                               eeeeeeeeeeeeeeeeee) :\n"
6652       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6653       "                          3333333333333333;",
6654       Style);
6655   verifyFormat(
6656       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6657       "                                               cccccccccccccccccc :\n"
6658       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6659       "                          3333333333333333;",
6660       Style);
6661   verifyFormat(
6662       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6663       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
6664       "                                               eeeeeeeeeeeeeeeeee :\n"
6665       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6666       "                          3333333333333333;",
6667       Style);
6668   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6669                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6670                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
6671                "                                 eeeeeeeeeeeeeeeeee) :\n"
6672                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6673                "                               3333333333333333;",
6674                Style);
6675   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
6676                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
6677                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
6678                "                                  eeeeeeeeeeeeeeeeee :\n"
6679                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
6680                "                               3333333333333333;",
6681                Style);
6682 }
6683 
6684 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
6685   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
6686                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
6687   verifyFormat("bool a = true, b = false;");
6688 
6689   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
6690                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
6691                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
6692                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
6693   verifyFormat(
6694       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
6695       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
6696       "     d = e && f;");
6697   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
6698                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
6699   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6700                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
6701   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
6702                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
6703 
6704   FormatStyle Style = getGoogleStyle();
6705   Style.PointerAlignment = FormatStyle::PAS_Left;
6706   Style.DerivePointerAlignment = false;
6707   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6708                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
6709                "    *b = bbbbbbbbbbbbbbbbbbb;",
6710                Style);
6711   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
6712                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
6713                Style);
6714   verifyFormat("vector<int*> a, b;", Style);
6715   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
6716 }
6717 
6718 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
6719   verifyFormat("arr[foo ? bar : baz];");
6720   verifyFormat("f()[foo ? bar : baz];");
6721   verifyFormat("(a + b)[foo ? bar : baz];");
6722   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
6723 }
6724 
6725 TEST_F(FormatTest, AlignsStringLiterals) {
6726   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
6727                "                                      \"short literal\");");
6728   verifyFormat(
6729       "looooooooooooooooooooooooongFunction(\n"
6730       "    \"short literal\"\n"
6731       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
6732   verifyFormat("someFunction(\"Always break between multi-line\"\n"
6733                "             \" string literals\",\n"
6734                "             and, other, parameters);");
6735   EXPECT_EQ("fun + \"1243\" /* comment */\n"
6736             "      \"5678\";",
6737             format("fun + \"1243\" /* comment */\n"
6738                    "    \"5678\";",
6739                    getLLVMStyleWithColumns(28)));
6740   EXPECT_EQ(
6741       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
6742       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
6743       "         \"aaaaaaaaaaaaaaaa\";",
6744       format("aaaaaa ="
6745              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
6746              "aaaaaaaaaaaaaaaaaaaaa\" "
6747              "\"aaaaaaaaaaaaaaaa\";"));
6748   verifyFormat("a = a + \"a\"\n"
6749                "        \"a\"\n"
6750                "        \"a\";");
6751   verifyFormat("f(\"a\", \"b\"\n"
6752                "       \"c\");");
6753 
6754   verifyFormat(
6755       "#define LL_FORMAT \"ll\"\n"
6756       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
6757       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
6758 
6759   verifyFormat("#define A(X)          \\\n"
6760                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
6761                "  \"ccccc\"",
6762                getLLVMStyleWithColumns(23));
6763   verifyFormat("#define A \"def\"\n"
6764                "f(\"abc\" A \"ghi\"\n"
6765                "  \"jkl\");");
6766 
6767   verifyFormat("f(L\"a\"\n"
6768                "  L\"b\");");
6769   verifyFormat("#define A(X)            \\\n"
6770                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
6771                "  L\"ccccc\"",
6772                getLLVMStyleWithColumns(25));
6773 
6774   verifyFormat("f(@\"a\"\n"
6775                "  @\"b\");");
6776   verifyFormat("NSString s = @\"a\"\n"
6777                "             @\"b\"\n"
6778                "             @\"c\";");
6779   verifyFormat("NSString s = @\"a\"\n"
6780                "              \"b\"\n"
6781                "              \"c\";");
6782 }
6783 
6784 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
6785   FormatStyle Style = getLLVMStyle();
6786   // No declarations or definitions should be moved to own line.
6787   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
6788   verifyFormat("class A {\n"
6789                "  int f() { return 1; }\n"
6790                "  int g();\n"
6791                "};\n"
6792                "int f() { return 1; }\n"
6793                "int g();\n",
6794                Style);
6795 
6796   // All declarations and definitions should have the return type moved to its
6797   // own line.
6798   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
6799   Style.TypenameMacros = {"LIST"};
6800   verifyFormat("SomeType\n"
6801                "funcdecl(LIST(uint64_t));",
6802                Style);
6803   verifyFormat("class E {\n"
6804                "  int\n"
6805                "  f() {\n"
6806                "    return 1;\n"
6807                "  }\n"
6808                "  int\n"
6809                "  g();\n"
6810                "};\n"
6811                "int\n"
6812                "f() {\n"
6813                "  return 1;\n"
6814                "}\n"
6815                "int\n"
6816                "g();\n",
6817                Style);
6818 
6819   // Top-level definitions, and no kinds of declarations should have the
6820   // return type moved to its own line.
6821   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
6822   verifyFormat("class B {\n"
6823                "  int f() { return 1; }\n"
6824                "  int g();\n"
6825                "};\n"
6826                "int\n"
6827                "f() {\n"
6828                "  return 1;\n"
6829                "}\n"
6830                "int g();\n",
6831                Style);
6832 
6833   // Top-level definitions and declarations should have the return type moved
6834   // to its own line.
6835   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
6836   verifyFormat("class C {\n"
6837                "  int f() { return 1; }\n"
6838                "  int g();\n"
6839                "};\n"
6840                "int\n"
6841                "f() {\n"
6842                "  return 1;\n"
6843                "}\n"
6844                "int\n"
6845                "g();\n",
6846                Style);
6847 
6848   // All definitions should have the return type moved to its own line, but no
6849   // kinds of declarations.
6850   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
6851   verifyFormat("class D {\n"
6852                "  int\n"
6853                "  f() {\n"
6854                "    return 1;\n"
6855                "  }\n"
6856                "  int g();\n"
6857                "};\n"
6858                "int\n"
6859                "f() {\n"
6860                "  return 1;\n"
6861                "}\n"
6862                "int g();\n",
6863                Style);
6864   verifyFormat("const char *\n"
6865                "f(void) {\n" // Break here.
6866                "  return \"\";\n"
6867                "}\n"
6868                "const char *bar(void);\n", // No break here.
6869                Style);
6870   verifyFormat("template <class T>\n"
6871                "T *\n"
6872                "f(T &c) {\n" // Break here.
6873                "  return NULL;\n"
6874                "}\n"
6875                "template <class T> T *f(T &c);\n", // No break here.
6876                Style);
6877   verifyFormat("class C {\n"
6878                "  int\n"
6879                "  operator+() {\n"
6880                "    return 1;\n"
6881                "  }\n"
6882                "  int\n"
6883                "  operator()() {\n"
6884                "    return 1;\n"
6885                "  }\n"
6886                "};\n",
6887                Style);
6888   verifyFormat("void\n"
6889                "A::operator()() {}\n"
6890                "void\n"
6891                "A::operator>>() {}\n"
6892                "void\n"
6893                "A::operator+() {}\n"
6894                "void\n"
6895                "A::operator*() {}\n"
6896                "void\n"
6897                "A::operator->() {}\n"
6898                "void\n"
6899                "A::operator void *() {}\n"
6900                "void\n"
6901                "A::operator void &() {}\n"
6902                "void\n"
6903                "A::operator void &&() {}\n"
6904                "void\n"
6905                "A::operator char *() {}\n"
6906                "void\n"
6907                "A::operator[]() {}\n"
6908                "void\n"
6909                "A::operator!() {}\n"
6910                "void\n"
6911                "A::operator**() {}\n"
6912                "void\n"
6913                "A::operator<Foo> *() {}\n"
6914                "void\n"
6915                "A::operator<Foo> **() {}\n"
6916                "void\n"
6917                "A::operator<Foo> &() {}\n"
6918                "void\n"
6919                "A::operator void **() {}\n",
6920                Style);
6921   verifyFormat("constexpr auto\n"
6922                "operator()() const -> reference {}\n"
6923                "constexpr auto\n"
6924                "operator>>() const -> reference {}\n"
6925                "constexpr auto\n"
6926                "operator+() const -> reference {}\n"
6927                "constexpr auto\n"
6928                "operator*() const -> reference {}\n"
6929                "constexpr auto\n"
6930                "operator->() const -> reference {}\n"
6931                "constexpr auto\n"
6932                "operator++() const -> reference {}\n"
6933                "constexpr auto\n"
6934                "operator void *() const -> reference {}\n"
6935                "constexpr auto\n"
6936                "operator void **() const -> reference {}\n"
6937                "constexpr auto\n"
6938                "operator void *() const -> reference {}\n"
6939                "constexpr auto\n"
6940                "operator void &() const -> reference {}\n"
6941                "constexpr auto\n"
6942                "operator void &&() const -> reference {}\n"
6943                "constexpr auto\n"
6944                "operator char *() const -> reference {}\n"
6945                "constexpr auto\n"
6946                "operator!() const -> reference {}\n"
6947                "constexpr auto\n"
6948                "operator[]() const -> reference {}\n",
6949                Style);
6950   verifyFormat("void *operator new(std::size_t s);", // No break here.
6951                Style);
6952   verifyFormat("void *\n"
6953                "operator new(std::size_t s) {}",
6954                Style);
6955   verifyFormat("void *\n"
6956                "operator delete[](void *ptr) {}",
6957                Style);
6958   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
6959   verifyFormat("const char *\n"
6960                "f(void)\n" // Break here.
6961                "{\n"
6962                "  return \"\";\n"
6963                "}\n"
6964                "const char *bar(void);\n", // No break here.
6965                Style);
6966   verifyFormat("template <class T>\n"
6967                "T *\n"     // Problem here: no line break
6968                "f(T &c)\n" // Break here.
6969                "{\n"
6970                "  return NULL;\n"
6971                "}\n"
6972                "template <class T> T *f(T &c);\n", // No break here.
6973                Style);
6974   verifyFormat("int\n"
6975                "foo(A<bool> a)\n"
6976                "{\n"
6977                "  return a;\n"
6978                "}\n",
6979                Style);
6980   verifyFormat("int\n"
6981                "foo(A<8> a)\n"
6982                "{\n"
6983                "  return a;\n"
6984                "}\n",
6985                Style);
6986   verifyFormat("int\n"
6987                "foo(A<B<bool>, 8> a)\n"
6988                "{\n"
6989                "  return a;\n"
6990                "}\n",
6991                Style);
6992   verifyFormat("int\n"
6993                "foo(A<B<8>, bool> a)\n"
6994                "{\n"
6995                "  return a;\n"
6996                "}\n",
6997                Style);
6998   verifyFormat("int\n"
6999                "foo(A<B<bool>, bool> a)\n"
7000                "{\n"
7001                "  return a;\n"
7002                "}\n",
7003                Style);
7004   verifyFormat("int\n"
7005                "foo(A<B<8>, 8> a)\n"
7006                "{\n"
7007                "  return a;\n"
7008                "}\n",
7009                Style);
7010 
7011   Style = getGNUStyle();
7012 
7013   // Test for comments at the end of function declarations.
7014   verifyFormat("void\n"
7015                "foo (int a, /*abc*/ int b) // def\n"
7016                "{\n"
7017                "}\n",
7018                Style);
7019 
7020   verifyFormat("void\n"
7021                "foo (int a, /* abc */ int b) /* def */\n"
7022                "{\n"
7023                "}\n",
7024                Style);
7025 
7026   // Definitions that should not break after return type
7027   verifyFormat("void foo (int a, int b); // def\n", Style);
7028   verifyFormat("void foo (int a, int b); /* def */\n", Style);
7029   verifyFormat("void foo (int a, int b);\n", Style);
7030 }
7031 
7032 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
7033   FormatStyle NoBreak = getLLVMStyle();
7034   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
7035   FormatStyle Break = getLLVMStyle();
7036   Break.AlwaysBreakBeforeMultilineStrings = true;
7037   verifyFormat("aaaa = \"bbbb\"\n"
7038                "       \"cccc\";",
7039                NoBreak);
7040   verifyFormat("aaaa =\n"
7041                "    \"bbbb\"\n"
7042                "    \"cccc\";",
7043                Break);
7044   verifyFormat("aaaa(\"bbbb\"\n"
7045                "     \"cccc\");",
7046                NoBreak);
7047   verifyFormat("aaaa(\n"
7048                "    \"bbbb\"\n"
7049                "    \"cccc\");",
7050                Break);
7051   verifyFormat("aaaa(qqq, \"bbbb\"\n"
7052                "          \"cccc\");",
7053                NoBreak);
7054   verifyFormat("aaaa(qqq,\n"
7055                "     \"bbbb\"\n"
7056                "     \"cccc\");",
7057                Break);
7058   verifyFormat("aaaa(qqq,\n"
7059                "     L\"bbbb\"\n"
7060                "     L\"cccc\");",
7061                Break);
7062   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
7063                "                      \"bbbb\"));",
7064                Break);
7065   verifyFormat("string s = someFunction(\n"
7066                "    \"abc\"\n"
7067                "    \"abc\");",
7068                Break);
7069 
7070   // As we break before unary operators, breaking right after them is bad.
7071   verifyFormat("string foo = abc ? \"x\"\n"
7072                "                   \"blah blah blah blah blah blah\"\n"
7073                "                 : \"y\";",
7074                Break);
7075 
7076   // Don't break if there is no column gain.
7077   verifyFormat("f(\"aaaa\"\n"
7078                "  \"bbbb\");",
7079                Break);
7080 
7081   // Treat literals with escaped newlines like multi-line string literals.
7082   EXPECT_EQ("x = \"a\\\n"
7083             "b\\\n"
7084             "c\";",
7085             format("x = \"a\\\n"
7086                    "b\\\n"
7087                    "c\";",
7088                    NoBreak));
7089   EXPECT_EQ("xxxx =\n"
7090             "    \"a\\\n"
7091             "b\\\n"
7092             "c\";",
7093             format("xxxx = \"a\\\n"
7094                    "b\\\n"
7095                    "c\";",
7096                    Break));
7097 
7098   EXPECT_EQ("NSString *const kString =\n"
7099             "    @\"aaaa\"\n"
7100             "    @\"bbbb\";",
7101             format("NSString *const kString = @\"aaaa\"\n"
7102                    "@\"bbbb\";",
7103                    Break));
7104 
7105   Break.ColumnLimit = 0;
7106   verifyFormat("const char *hello = \"hello llvm\";", Break);
7107 }
7108 
7109 TEST_F(FormatTest, AlignsPipes) {
7110   verifyFormat(
7111       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7112       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7113       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7114   verifyFormat(
7115       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
7116       "                     << aaaaaaaaaaaaaaaaaaaa;");
7117   verifyFormat(
7118       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7119       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7120   verifyFormat(
7121       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7122       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7123   verifyFormat(
7124       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
7125       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
7126       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
7127   verifyFormat(
7128       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7129       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7130       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7131   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7132                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7133                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7134                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7135   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
7136                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
7137   verifyFormat(
7138       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7139       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7140   verifyFormat(
7141       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
7142       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
7143 
7144   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
7145                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
7146   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7147                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7148                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
7149                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
7150   verifyFormat("LOG_IF(aaa == //\n"
7151                "       bbb)\n"
7152                "    << a << b;");
7153 
7154   // But sometimes, breaking before the first "<<" is desirable.
7155   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7156                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
7157   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
7158                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7159                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7160   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
7161                "    << BEF << IsTemplate << Description << E->getType();");
7162   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7163                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7164                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7165   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
7166                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7167                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7168                "    << aaa;");
7169 
7170   verifyFormat(
7171       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7172       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7173 
7174   // Incomplete string literal.
7175   EXPECT_EQ("llvm::errs() << \"\n"
7176             "             << a;",
7177             format("llvm::errs() << \"\n<<a;"));
7178 
7179   verifyFormat("void f() {\n"
7180                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
7181                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
7182                "}");
7183 
7184   // Handle 'endl'.
7185   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
7186                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7187   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
7188 
7189   // Handle '\n'.
7190   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
7191                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7192   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
7193                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
7194   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
7195                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
7196   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
7197 }
7198 
7199 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
7200   verifyFormat("return out << \"somepacket = {\\n\"\n"
7201                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
7202                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
7203                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
7204                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
7205                "           << \"}\";");
7206 
7207   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7208                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
7209                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
7210   verifyFormat(
7211       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
7212       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
7213       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
7214       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
7215       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
7216   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
7217                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
7218   verifyFormat(
7219       "void f() {\n"
7220       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
7221       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
7222       "}");
7223 
7224   // Breaking before the first "<<" is generally not desirable.
7225   verifyFormat(
7226       "llvm::errs()\n"
7227       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7228       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7229       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7230       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7231       getLLVMStyleWithColumns(70));
7232   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7233                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7234                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7235                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7236                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
7237                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7238                getLLVMStyleWithColumns(70));
7239 
7240   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7241                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
7242                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
7243   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7244                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
7245                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
7246   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
7247                "           (aaaa + aaaa);",
7248                getLLVMStyleWithColumns(40));
7249   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
7250                "                  (aaaaaaa + aaaaa));",
7251                getLLVMStyleWithColumns(40));
7252   verifyFormat(
7253       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
7254       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
7255       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
7256 }
7257 
7258 TEST_F(FormatTest, UnderstandsEquals) {
7259   verifyFormat(
7260       "aaaaaaaaaaaaaaaaa =\n"
7261       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7262   verifyFormat(
7263       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7264       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7265   verifyFormat(
7266       "if (a) {\n"
7267       "  f();\n"
7268       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7269       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
7270       "}");
7271 
7272   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7273                "        100000000 + 10000000) {\n}");
7274 }
7275 
7276 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
7277   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7278                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
7279 
7280   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
7281                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
7282 
7283   verifyFormat(
7284       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
7285       "                                                          Parameter2);");
7286 
7287   verifyFormat(
7288       "ShortObject->shortFunction(\n"
7289       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
7290       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
7291 
7292   verifyFormat("loooooooooooooongFunction(\n"
7293                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
7294 
7295   verifyFormat(
7296       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
7297       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
7298 
7299   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7300                "    .WillRepeatedly(Return(SomeValue));");
7301   verifyFormat("void f() {\n"
7302                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
7303                "      .Times(2)\n"
7304                "      .WillRepeatedly(Return(SomeValue));\n"
7305                "}");
7306   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
7307                "    ccccccccccccccccccccccc);");
7308   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7309                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7310                "          .aaaaa(aaaaa),\n"
7311                "      aaaaaaaaaaaaaaaaaaaaa);");
7312   verifyFormat("void f() {\n"
7313                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7314                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
7315                "}");
7316   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7317                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7318                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7319                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7320                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7321   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7322                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7323                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7324                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
7325                "}");
7326 
7327   // Here, it is not necessary to wrap at "." or "->".
7328   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
7329                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
7330   verifyFormat(
7331       "aaaaaaaaaaa->aaaaaaaaa(\n"
7332       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7333       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
7334 
7335   verifyFormat(
7336       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7337       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
7338   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
7339                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7340   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
7341                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
7342 
7343   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7344                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7345                "    .a();");
7346 
7347   FormatStyle NoBinPacking = getLLVMStyle();
7348   NoBinPacking.BinPackParameters = false;
7349   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7350                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
7351                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
7352                "                         aaaaaaaaaaaaaaaaaaa,\n"
7353                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7354                NoBinPacking);
7355 
7356   // If there is a subsequent call, change to hanging indentation.
7357   verifyFormat(
7358       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7359       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
7360       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7361   verifyFormat(
7362       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7363       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
7364   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7365                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7366                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7367   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7368                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7369                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7370 }
7371 
7372 TEST_F(FormatTest, WrapsTemplateDeclarations) {
7373   verifyFormat("template <typename T>\n"
7374                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7375   verifyFormat("template <typename T>\n"
7376                "// T should be one of {A, B}.\n"
7377                "virtual void loooooooooooongFunction(int Param1, int Param2);");
7378   verifyFormat(
7379       "template <typename T>\n"
7380       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
7381   verifyFormat("template <typename T>\n"
7382                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
7383                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
7384   verifyFormat(
7385       "template <typename T>\n"
7386       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
7387       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
7388   verifyFormat(
7389       "template <typename T>\n"
7390       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
7391       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
7392       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7393   verifyFormat("template <typename T>\n"
7394                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7395                "    int aaaaaaaaaaaaaaaaaaaaaa);");
7396   verifyFormat(
7397       "template <typename T1, typename T2 = char, typename T3 = char,\n"
7398       "          typename T4 = char>\n"
7399       "void f();");
7400   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
7401                "          template <typename> class cccccccccccccccccccccc,\n"
7402                "          typename ddddddddddddd>\n"
7403                "class C {};");
7404   verifyFormat(
7405       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
7406       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7407 
7408   verifyFormat("void f() {\n"
7409                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
7410                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
7411                "}");
7412 
7413   verifyFormat("template <typename T> class C {};");
7414   verifyFormat("template <typename T> void f();");
7415   verifyFormat("template <typename T> void f() {}");
7416   verifyFormat(
7417       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7418       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7419       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
7420       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
7421       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7422       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
7423       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
7424       getLLVMStyleWithColumns(72));
7425   EXPECT_EQ("static_cast<A< //\n"
7426             "    B> *>(\n"
7427             "\n"
7428             ");",
7429             format("static_cast<A<//\n"
7430                    "    B>*>(\n"
7431                    "\n"
7432                    "    );"));
7433   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7434                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
7435 
7436   FormatStyle AlwaysBreak = getLLVMStyle();
7437   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7438   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
7439   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
7440   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
7441   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7442                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7443                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
7444   verifyFormat("template <template <typename> class Fooooooo,\n"
7445                "          template <typename> class Baaaaaaar>\n"
7446                "struct C {};",
7447                AlwaysBreak);
7448   verifyFormat("template <typename T> // T can be A, B or C.\n"
7449                "struct C {};",
7450                AlwaysBreak);
7451   verifyFormat("template <enum E> class A {\n"
7452                "public:\n"
7453                "  E *f();\n"
7454                "};");
7455 
7456   FormatStyle NeverBreak = getLLVMStyle();
7457   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
7458   verifyFormat("template <typename T> class C {};", NeverBreak);
7459   verifyFormat("template <typename T> void f();", NeverBreak);
7460   verifyFormat("template <typename T> void f() {}", NeverBreak);
7461   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7462                "bbbbbbbbbbbbbbbbbbbb) {}",
7463                NeverBreak);
7464   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7465                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
7466                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
7467                NeverBreak);
7468   verifyFormat("template <template <typename> class Fooooooo,\n"
7469                "          template <typename> class Baaaaaaar>\n"
7470                "struct C {};",
7471                NeverBreak);
7472   verifyFormat("template <typename T> // T can be A, B or C.\n"
7473                "struct C {};",
7474                NeverBreak);
7475   verifyFormat("template <enum E> class A {\n"
7476                "public:\n"
7477                "  E *f();\n"
7478                "};",
7479                NeverBreak);
7480   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
7481   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
7482                "bbbbbbbbbbbbbbbbbbbb) {}",
7483                NeverBreak);
7484 }
7485 
7486 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
7487   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
7488   Style.ColumnLimit = 60;
7489   EXPECT_EQ("// Baseline - no comments.\n"
7490             "template <\n"
7491             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7492             "void f() {}",
7493             format("// Baseline - no comments.\n"
7494                    "template <\n"
7495                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
7496                    "void f() {}",
7497                    Style));
7498 
7499   EXPECT_EQ("template <\n"
7500             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7501             "void f() {}",
7502             format("template <\n"
7503                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7504                    "void f() {}",
7505                    Style));
7506 
7507   EXPECT_EQ(
7508       "template <\n"
7509       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
7510       "void f() {}",
7511       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
7512              "void f() {}",
7513              Style));
7514 
7515   EXPECT_EQ(
7516       "template <\n"
7517       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
7518       "                                               // multiline\n"
7519       "void f() {}",
7520       format("template <\n"
7521              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
7522              "                                              // multiline\n"
7523              "void f() {}",
7524              Style));
7525 
7526   EXPECT_EQ(
7527       "template <typename aaaaaaaaaa<\n"
7528       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
7529       "void f() {}",
7530       format(
7531           "template <\n"
7532           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
7533           "void f() {}",
7534           Style));
7535 }
7536 
7537 TEST_F(FormatTest, WrapsTemplateParameters) {
7538   FormatStyle Style = getLLVMStyle();
7539   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7540   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7541   verifyFormat(
7542       "template <typename... a> struct q {};\n"
7543       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7544       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7545       "    y;",
7546       Style);
7547   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7548   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7549   verifyFormat(
7550       "template <typename... a> struct r {};\n"
7551       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
7552       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
7553       "    y;",
7554       Style);
7555   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7556   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
7557   verifyFormat("template <typename... a> struct s {};\n"
7558                "extern s<\n"
7559                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7560                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7561                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7562                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7563                "    y;",
7564                Style);
7565   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7566   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
7567   verifyFormat("template <typename... a> struct t {};\n"
7568                "extern t<\n"
7569                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7570                "aaaaaaaaaaaaaaaaaaaaaa,\n"
7571                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
7572                "aaaaaaaaaaaaaaaaaaaaaa>\n"
7573                "    y;",
7574                Style);
7575 }
7576 
7577 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
7578   verifyFormat(
7579       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7580       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7581   verifyFormat(
7582       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7583       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7584       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
7585 
7586   // FIXME: Should we have the extra indent after the second break?
7587   verifyFormat(
7588       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7589       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7590       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7591 
7592   verifyFormat(
7593       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
7594       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
7595 
7596   // Breaking at nested name specifiers is generally not desirable.
7597   verifyFormat(
7598       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7599       "    aaaaaaaaaaaaaaaaaaaaaaa);");
7600 
7601   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
7602                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7603                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7604                "                   aaaaaaaaaaaaaaaaaaaaa);",
7605                getLLVMStyleWithColumns(74));
7606 
7607   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
7608                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7609                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7610 }
7611 
7612 TEST_F(FormatTest, UnderstandsTemplateParameters) {
7613   verifyFormat("A<int> a;");
7614   verifyFormat("A<A<A<int>>> a;");
7615   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
7616   verifyFormat("bool x = a < 1 || 2 > a;");
7617   verifyFormat("bool x = 5 < f<int>();");
7618   verifyFormat("bool x = f<int>() > 5;");
7619   verifyFormat("bool x = 5 < a<int>::x;");
7620   verifyFormat("bool x = a < 4 ? a > 2 : false;");
7621   verifyFormat("bool x = f() ? a < 2 : a > 2;");
7622 
7623   verifyGoogleFormat("A<A<int>> a;");
7624   verifyGoogleFormat("A<A<A<int>>> a;");
7625   verifyGoogleFormat("A<A<A<A<int>>>> a;");
7626   verifyGoogleFormat("A<A<int> > a;");
7627   verifyGoogleFormat("A<A<A<int> > > a;");
7628   verifyGoogleFormat("A<A<A<A<int> > > > a;");
7629   verifyGoogleFormat("A<::A<int>> a;");
7630   verifyGoogleFormat("A<::A> a;");
7631   verifyGoogleFormat("A< ::A> a;");
7632   verifyGoogleFormat("A< ::A<int> > a;");
7633   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
7634   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
7635   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
7636   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
7637   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
7638             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
7639 
7640   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
7641 
7642   // template closer followed by a token that starts with > or =
7643   verifyFormat("bool b = a<1> > 1;");
7644   verifyFormat("bool b = a<1> >= 1;");
7645   verifyFormat("int i = a<1> >> 1;");
7646   FormatStyle Style = getLLVMStyle();
7647   Style.SpaceBeforeAssignmentOperators = false;
7648   verifyFormat("bool b= a<1> == 1;", Style);
7649   verifyFormat("a<int> = 1;", Style);
7650   verifyFormat("a<int> >>= 1;", Style);
7651 
7652   verifyFormat("test >> a >> b;");
7653   verifyFormat("test << a >> b;");
7654 
7655   verifyFormat("f<int>();");
7656   verifyFormat("template <typename T> void f() {}");
7657   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
7658   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
7659                "sizeof(char)>::type>;");
7660   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
7661   verifyFormat("f(a.operator()<A>());");
7662   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7663                "      .template operator()<A>());",
7664                getLLVMStyleWithColumns(35));
7665 
7666   // Not template parameters.
7667   verifyFormat("return a < b && c > d;");
7668   verifyFormat("void f() {\n"
7669                "  while (a < b && c > d) {\n"
7670                "  }\n"
7671                "}");
7672   verifyFormat("template <typename... Types>\n"
7673                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
7674 
7675   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7676                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
7677                getLLVMStyleWithColumns(60));
7678   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
7679   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
7680   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
7681   verifyFormat("some_templated_type<decltype([](int i) { return i; })>");
7682 }
7683 
7684 TEST_F(FormatTest, UnderstandsShiftOperators) {
7685   verifyFormat("if (i < x >> 1)");
7686   verifyFormat("while (i < x >> 1)");
7687   verifyFormat("for (unsigned i = 0; i < i; ++i, v = v >> 1)");
7688   verifyFormat("for (unsigned i = 0; i < x >> 1; ++i, v = v >> 1)");
7689   verifyFormat(
7690       "for (std::vector<int>::iterator i = 0; i < x >> 1; ++i, v = v >> 1)");
7691   verifyFormat("Foo.call<Bar<Function>>()");
7692   verifyFormat("if (Foo.call<Bar<Function>>() == 0)");
7693   verifyFormat("for (std::vector<std::pair<int>>::iterator i = 0; i < x >> 1; "
7694                "++i, v = v >> 1)");
7695   verifyFormat("if (w<u<v<x>>, 1>::t)");
7696 }
7697 
7698 TEST_F(FormatTest, BitshiftOperatorWidth) {
7699   EXPECT_EQ("int a = 1 << 2; /* foo\n"
7700             "                   bar */",
7701             format("int    a=1<<2;  /* foo\n"
7702                    "                   bar */"));
7703 
7704   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
7705             "                     bar */",
7706             format("int  b  =256>>1 ;  /* foo\n"
7707                    "                      bar */"));
7708 }
7709 
7710 TEST_F(FormatTest, UnderstandsBinaryOperators) {
7711   verifyFormat("COMPARE(a, ==, b);");
7712   verifyFormat("auto s = sizeof...(Ts) - 1;");
7713 }
7714 
7715 TEST_F(FormatTest, UnderstandsPointersToMembers) {
7716   verifyFormat("int A::*x;");
7717   verifyFormat("int (S::*func)(void *);");
7718   verifyFormat("void f() { int (S::*func)(void *); }");
7719   verifyFormat("typedef bool *(Class::*Member)() const;");
7720   verifyFormat("void f() {\n"
7721                "  (a->*f)();\n"
7722                "  a->*x;\n"
7723                "  (a.*f)();\n"
7724                "  ((*a).*f)();\n"
7725                "  a.*x;\n"
7726                "}");
7727   verifyFormat("void f() {\n"
7728                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
7729                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
7730                "}");
7731   verifyFormat(
7732       "(aaaaaaaaaa->*bbbbbbb)(\n"
7733       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
7734   FormatStyle Style = getLLVMStyle();
7735   Style.PointerAlignment = FormatStyle::PAS_Left;
7736   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
7737 }
7738 
7739 TEST_F(FormatTest, UnderstandsUnaryOperators) {
7740   verifyFormat("int a = -2;");
7741   verifyFormat("f(-1, -2, -3);");
7742   verifyFormat("a[-1] = 5;");
7743   verifyFormat("int a = 5 + -2;");
7744   verifyFormat("if (i == -1) {\n}");
7745   verifyFormat("if (i != -1) {\n}");
7746   verifyFormat("if (i > -1) {\n}");
7747   verifyFormat("if (i < -1) {\n}");
7748   verifyFormat("++(a->f());");
7749   verifyFormat("--(a->f());");
7750   verifyFormat("(a->f())++;");
7751   verifyFormat("a[42]++;");
7752   verifyFormat("if (!(a->f())) {\n}");
7753   verifyFormat("if (!+i) {\n}");
7754   verifyFormat("~&a;");
7755 
7756   verifyFormat("a-- > b;");
7757   verifyFormat("b ? -a : c;");
7758   verifyFormat("n * sizeof char16;");
7759   verifyFormat("n * alignof char16;", getGoogleStyle());
7760   verifyFormat("sizeof(char);");
7761   verifyFormat("alignof(char);", getGoogleStyle());
7762 
7763   verifyFormat("return -1;");
7764   verifyFormat("throw -1;");
7765   verifyFormat("switch (a) {\n"
7766                "case -1:\n"
7767                "  break;\n"
7768                "}");
7769   verifyFormat("#define X -1");
7770   verifyFormat("#define X -kConstant");
7771 
7772   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
7773   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
7774 
7775   verifyFormat("int a = /* confusing comment */ -1;");
7776   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
7777   verifyFormat("int a = i /* confusing comment */++;");
7778 
7779   verifyFormat("co_yield -1;");
7780   verifyFormat("co_return -1;");
7781 
7782   // Check that * is not treated as a binary operator when we set
7783   // PointerAlignment as PAS_Left after a keyword and not a declaration.
7784   FormatStyle PASLeftStyle = getLLVMStyle();
7785   PASLeftStyle.PointerAlignment = FormatStyle::PAS_Left;
7786   verifyFormat("co_return *a;", PASLeftStyle);
7787   verifyFormat("co_await *a;", PASLeftStyle);
7788   verifyFormat("co_yield *a", PASLeftStyle);
7789   verifyFormat("return *a;", PASLeftStyle);
7790 }
7791 
7792 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
7793   verifyFormat("if (!aaaaaaaaaa( // break\n"
7794                "        aaaaa)) {\n"
7795                "}");
7796   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
7797                "    aaaaa));");
7798   verifyFormat("*aaa = aaaaaaa( // break\n"
7799                "    bbbbbb);");
7800 }
7801 
7802 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
7803   verifyFormat("bool operator<();");
7804   verifyFormat("bool operator>();");
7805   verifyFormat("bool operator=();");
7806   verifyFormat("bool operator==();");
7807   verifyFormat("bool operator!=();");
7808   verifyFormat("int operator+();");
7809   verifyFormat("int operator++();");
7810   verifyFormat("int operator++(int) volatile noexcept;");
7811   verifyFormat("bool operator,();");
7812   verifyFormat("bool operator();");
7813   verifyFormat("bool operator()();");
7814   verifyFormat("bool operator[]();");
7815   verifyFormat("operator bool();");
7816   verifyFormat("operator int();");
7817   verifyFormat("operator void *();");
7818   verifyFormat("operator SomeType<int>();");
7819   verifyFormat("operator SomeType<int, int>();");
7820   verifyFormat("operator SomeType<SomeType<int>>();");
7821   verifyFormat("void *operator new(std::size_t size);");
7822   verifyFormat("void *operator new[](std::size_t size);");
7823   verifyFormat("void operator delete(void *ptr);");
7824   verifyFormat("void operator delete[](void *ptr);");
7825   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
7826                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
7827   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
7828                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
7829 
7830   verifyFormat(
7831       "ostream &operator<<(ostream &OutputStream,\n"
7832       "                    SomeReallyLongType WithSomeReallyLongValue);");
7833   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
7834                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
7835                "  return left.group < right.group;\n"
7836                "}");
7837   verifyFormat("SomeType &operator=(const SomeType &S);");
7838   verifyFormat("f.template operator()<int>();");
7839 
7840   verifyGoogleFormat("operator void*();");
7841   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
7842   verifyGoogleFormat("operator ::A();");
7843 
7844   verifyFormat("using A::operator+;");
7845   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
7846                "int i;");
7847 }
7848 
7849 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
7850   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
7851   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
7852   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
7853   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
7854   verifyFormat("Deleted &operator=(const Deleted &) &;");
7855   verifyFormat("Deleted &operator=(const Deleted &) &&;");
7856   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
7857   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
7858   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
7859   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
7860   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
7861   verifyFormat("void Fn(T const &) const &;");
7862   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
7863   verifyFormat("template <typename T>\n"
7864                "void F(T) && = delete;",
7865                getGoogleStyle());
7866 
7867   FormatStyle AlignLeft = getLLVMStyle();
7868   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
7869   verifyFormat("void A::b() && {}", AlignLeft);
7870   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
7871   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
7872                AlignLeft);
7873   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
7874   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
7875   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
7876   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
7877   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
7878   verifyFormat("auto Function(T) & -> void;", AlignLeft);
7879   verifyFormat("void Fn(T const&) const&;", AlignLeft);
7880   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
7881 
7882   FormatStyle Spaces = getLLVMStyle();
7883   Spaces.SpacesInCStyleCastParentheses = true;
7884   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
7885   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
7886   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
7887   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
7888 
7889   Spaces.SpacesInCStyleCastParentheses = false;
7890   Spaces.SpacesInParentheses = true;
7891   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
7892   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
7893                Spaces);
7894   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
7895   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
7896 
7897   FormatStyle BreakTemplate = getLLVMStyle();
7898   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
7899 
7900   verifyFormat("struct f {\n"
7901                "  template <class T>\n"
7902                "  int &foo(const std::string &str) &noexcept {}\n"
7903                "};",
7904                BreakTemplate);
7905 
7906   verifyFormat("struct f {\n"
7907                "  template <class T>\n"
7908                "  int &foo(const std::string &str) &&noexcept {}\n"
7909                "};",
7910                BreakTemplate);
7911 
7912   verifyFormat("struct f {\n"
7913                "  template <class T>\n"
7914                "  int &foo(const std::string &str) const &noexcept {}\n"
7915                "};",
7916                BreakTemplate);
7917 
7918   verifyFormat("struct f {\n"
7919                "  template <class T>\n"
7920                "  int &foo(const std::string &str) const &noexcept {}\n"
7921                "};",
7922                BreakTemplate);
7923 
7924   verifyFormat("struct f {\n"
7925                "  template <class T>\n"
7926                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
7927                "};",
7928                BreakTemplate);
7929 
7930   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
7931   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
7932       FormatStyle::BTDS_Yes;
7933   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
7934 
7935   verifyFormat("struct f {\n"
7936                "  template <class T>\n"
7937                "  int& foo(const std::string& str) & noexcept {}\n"
7938                "};",
7939                AlignLeftBreakTemplate);
7940 
7941   verifyFormat("struct f {\n"
7942                "  template <class T>\n"
7943                "  int& foo(const std::string& str) && noexcept {}\n"
7944                "};",
7945                AlignLeftBreakTemplate);
7946 
7947   verifyFormat("struct f {\n"
7948                "  template <class T>\n"
7949                "  int& foo(const std::string& str) const& noexcept {}\n"
7950                "};",
7951                AlignLeftBreakTemplate);
7952 
7953   verifyFormat("struct f {\n"
7954                "  template <class T>\n"
7955                "  int& foo(const std::string& str) const&& noexcept {}\n"
7956                "};",
7957                AlignLeftBreakTemplate);
7958 
7959   verifyFormat("struct f {\n"
7960                "  template <class T>\n"
7961                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
7962                "};",
7963                AlignLeftBreakTemplate);
7964 
7965   // The `&` in `Type&` should not be confused with a trailing `&` of
7966   // DEPRECATED(reason) member function.
7967   verifyFormat("struct f {\n"
7968                "  template <class T>\n"
7969                "  DEPRECATED(reason)\n"
7970                "  Type &foo(arguments) {}\n"
7971                "};",
7972                BreakTemplate);
7973 
7974   verifyFormat("struct f {\n"
7975                "  template <class T>\n"
7976                "  DEPRECATED(reason)\n"
7977                "  Type& foo(arguments) {}\n"
7978                "};",
7979                AlignLeftBreakTemplate);
7980 
7981   verifyFormat("void (*foopt)(int) = &func;");
7982 }
7983 
7984 TEST_F(FormatTest, UnderstandsNewAndDelete) {
7985   verifyFormat("void f() {\n"
7986                "  A *a = new A;\n"
7987                "  A *a = new (placement) A;\n"
7988                "  delete a;\n"
7989                "  delete (A *)a;\n"
7990                "}");
7991   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7992                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7993   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7994                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
7995                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
7996   verifyFormat("delete[] h->p;");
7997 }
7998 
7999 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
8000   verifyFormat("int *f(int *a) {}");
8001   verifyFormat("int main(int argc, char **argv) {}");
8002   verifyFormat("Test::Test(int b) : a(b * b) {}");
8003   verifyIndependentOfContext("f(a, *a);");
8004   verifyFormat("void g() { f(*a); }");
8005   verifyIndependentOfContext("int a = b * 10;");
8006   verifyIndependentOfContext("int a = 10 * b;");
8007   verifyIndependentOfContext("int a = b * c;");
8008   verifyIndependentOfContext("int a += b * c;");
8009   verifyIndependentOfContext("int a -= b * c;");
8010   verifyIndependentOfContext("int a *= b * c;");
8011   verifyIndependentOfContext("int a /= b * c;");
8012   verifyIndependentOfContext("int a = *b;");
8013   verifyIndependentOfContext("int a = *b * c;");
8014   verifyIndependentOfContext("int a = b * *c;");
8015   verifyIndependentOfContext("int a = b * (10);");
8016   verifyIndependentOfContext("S << b * (10);");
8017   verifyIndependentOfContext("return 10 * b;");
8018   verifyIndependentOfContext("return *b * *c;");
8019   verifyIndependentOfContext("return a & ~b;");
8020   verifyIndependentOfContext("f(b ? *c : *d);");
8021   verifyIndependentOfContext("int a = b ? *c : *d;");
8022   verifyIndependentOfContext("*b = a;");
8023   verifyIndependentOfContext("a * ~b;");
8024   verifyIndependentOfContext("a * !b;");
8025   verifyIndependentOfContext("a * +b;");
8026   verifyIndependentOfContext("a * -b;");
8027   verifyIndependentOfContext("a * ++b;");
8028   verifyIndependentOfContext("a * --b;");
8029   verifyIndependentOfContext("a[4] * b;");
8030   verifyIndependentOfContext("a[a * a] = 1;");
8031   verifyIndependentOfContext("f() * b;");
8032   verifyIndependentOfContext("a * [self dostuff];");
8033   verifyIndependentOfContext("int x = a * (a + b);");
8034   verifyIndependentOfContext("(a *)(a + b);");
8035   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
8036   verifyIndependentOfContext("int *pa = (int *)&a;");
8037   verifyIndependentOfContext("return sizeof(int **);");
8038   verifyIndependentOfContext("return sizeof(int ******);");
8039   verifyIndependentOfContext("return (int **&)a;");
8040   verifyIndependentOfContext("f((*PointerToArray)[10]);");
8041   verifyFormat("void f(Type (*parameter)[10]) {}");
8042   verifyFormat("void f(Type (&parameter)[10]) {}");
8043   verifyGoogleFormat("return sizeof(int**);");
8044   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
8045   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
8046   verifyFormat("auto a = [](int **&, int ***) {};");
8047   verifyFormat("auto PointerBinding = [](const char *S) {};");
8048   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
8049   verifyFormat("[](const decltype(*a) &value) {}");
8050   verifyFormat("[](const typeof(*a) &value) {}");
8051   verifyFormat("[](const _Atomic(a *) &value) {}");
8052   verifyFormat("[](const __underlying_type(a) &value) {}");
8053   verifyFormat("decltype(a * b) F();");
8054   verifyFormat("typeof(a * b) F();");
8055   verifyFormat("#define MACRO() [](A *a) { return 1; }");
8056   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
8057   verifyIndependentOfContext("typedef void (*f)(int *a);");
8058   verifyIndependentOfContext("int i{a * b};");
8059   verifyIndependentOfContext("aaa && aaa->f();");
8060   verifyIndependentOfContext("int x = ~*p;");
8061   verifyFormat("Constructor() : a(a), area(width * height) {}");
8062   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
8063   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
8064   verifyFormat("void f() { f(a, c * d); }");
8065   verifyFormat("void f() { f(new a(), c * d); }");
8066   verifyFormat("void f(const MyOverride &override);");
8067   verifyFormat("void f(const MyFinal &final);");
8068   verifyIndependentOfContext("bool a = f() && override.f();");
8069   verifyIndependentOfContext("bool a = f() && final.f();");
8070 
8071   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
8072 
8073   verifyIndependentOfContext("A<int *> a;");
8074   verifyIndependentOfContext("A<int **> a;");
8075   verifyIndependentOfContext("A<int *, int *> a;");
8076   verifyIndependentOfContext("A<int *[]> a;");
8077   verifyIndependentOfContext(
8078       "const char *const p = reinterpret_cast<const char *const>(q);");
8079   verifyIndependentOfContext("A<int **, int **> a;");
8080   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
8081   verifyFormat("for (char **a = b; *a; ++a) {\n}");
8082   verifyFormat("for (; a && b;) {\n}");
8083   verifyFormat("bool foo = true && [] { return false; }();");
8084 
8085   verifyFormat(
8086       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8087       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8088 
8089   verifyGoogleFormat("int const* a = &b;");
8090   verifyGoogleFormat("**outparam = 1;");
8091   verifyGoogleFormat("*outparam = a * b;");
8092   verifyGoogleFormat("int main(int argc, char** argv) {}");
8093   verifyGoogleFormat("A<int*> a;");
8094   verifyGoogleFormat("A<int**> a;");
8095   verifyGoogleFormat("A<int*, int*> a;");
8096   verifyGoogleFormat("A<int**, int**> a;");
8097   verifyGoogleFormat("f(b ? *c : *d);");
8098   verifyGoogleFormat("int a = b ? *c : *d;");
8099   verifyGoogleFormat("Type* t = **x;");
8100   verifyGoogleFormat("Type* t = *++*x;");
8101   verifyGoogleFormat("*++*x;");
8102   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
8103   verifyGoogleFormat("Type* t = x++ * y;");
8104   verifyGoogleFormat(
8105       "const char* const p = reinterpret_cast<const char* const>(q);");
8106   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
8107   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
8108   verifyGoogleFormat("template <typename T>\n"
8109                      "void f(int i = 0, SomeType** temps = NULL);");
8110 
8111   FormatStyle Left = getLLVMStyle();
8112   Left.PointerAlignment = FormatStyle::PAS_Left;
8113   verifyFormat("x = *a(x) = *a(y);", Left);
8114   verifyFormat("for (;; *a = b) {\n}", Left);
8115   verifyFormat("return *this += 1;", Left);
8116   verifyFormat("throw *x;", Left);
8117   verifyFormat("delete *x;", Left);
8118   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
8119   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
8120   verifyFormat("[](const typeof(*a)* ptr) {}", Left);
8121   verifyFormat("[](const _Atomic(a*)* ptr) {}", Left);
8122   verifyFormat("[](const __underlying_type(a)* ptr) {}", Left);
8123   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
8124   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
8125   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
8126   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
8127 
8128   verifyIndependentOfContext("a = *(x + y);");
8129   verifyIndependentOfContext("a = &(x + y);");
8130   verifyIndependentOfContext("*(x + y).call();");
8131   verifyIndependentOfContext("&(x + y)->call();");
8132   verifyFormat("void f() { &(*I).first; }");
8133 
8134   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
8135   verifyFormat(
8136       "int *MyValues = {\n"
8137       "    *A, // Operator detection might be confused by the '{'\n"
8138       "    *BB // Operator detection might be confused by previous comment\n"
8139       "};");
8140 
8141   verifyIndependentOfContext("if (int *a = &b)");
8142   verifyIndependentOfContext("if (int &a = *b)");
8143   verifyIndependentOfContext("if (a & b[i])");
8144   verifyIndependentOfContext("if constexpr (a & b[i])");
8145   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
8146   verifyIndependentOfContext("if (a * (b * c))");
8147   verifyIndependentOfContext("if constexpr (a * (b * c))");
8148   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
8149   verifyIndependentOfContext("if (a::b::c::d & b[i])");
8150   verifyIndependentOfContext("if (*b[i])");
8151   verifyIndependentOfContext("if (int *a = (&b))");
8152   verifyIndependentOfContext("while (int *a = &b)");
8153   verifyIndependentOfContext("while (a * (b * c))");
8154   verifyIndependentOfContext("size = sizeof *a;");
8155   verifyIndependentOfContext("if (a && (b = c))");
8156   verifyFormat("void f() {\n"
8157                "  for (const int &v : Values) {\n"
8158                "  }\n"
8159                "}");
8160   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
8161   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
8162   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
8163 
8164   verifyFormat("#define A (!a * b)");
8165   verifyFormat("#define MACRO     \\\n"
8166                "  int *i = a * b; \\\n"
8167                "  void f(a *b);",
8168                getLLVMStyleWithColumns(19));
8169 
8170   verifyIndependentOfContext("A = new SomeType *[Length];");
8171   verifyIndependentOfContext("A = new SomeType *[Length]();");
8172   verifyIndependentOfContext("T **t = new T *;");
8173   verifyIndependentOfContext("T **t = new T *();");
8174   verifyGoogleFormat("A = new SomeType*[Length]();");
8175   verifyGoogleFormat("A = new SomeType*[Length];");
8176   verifyGoogleFormat("T** t = new T*;");
8177   verifyGoogleFormat("T** t = new T*();");
8178 
8179   verifyFormat("STATIC_ASSERT((a & b) == 0);");
8180   verifyFormat("STATIC_ASSERT(0 == (a & b));");
8181   verifyFormat("template <bool a, bool b> "
8182                "typename t::if<x && y>::type f() {}");
8183   verifyFormat("template <int *y> f() {}");
8184   verifyFormat("vector<int *> v;");
8185   verifyFormat("vector<int *const> v;");
8186   verifyFormat("vector<int *const **const *> v;");
8187   verifyFormat("vector<int *volatile> v;");
8188   verifyFormat("vector<a *_Nonnull> v;");
8189   verifyFormat("vector<a *_Nullable> v;");
8190   verifyFormat("vector<a *_Null_unspecified> v;");
8191   verifyFormat("vector<a *__ptr32> v;");
8192   verifyFormat("vector<a *__ptr64> v;");
8193   verifyFormat("vector<a *__capability> v;");
8194   FormatStyle TypeMacros = getLLVMStyle();
8195   TypeMacros.TypenameMacros = {"LIST"};
8196   verifyFormat("vector<LIST(uint64_t)> v;", TypeMacros);
8197   verifyFormat("vector<LIST(uint64_t) *> v;", TypeMacros);
8198   verifyFormat("vector<LIST(uint64_t) **> v;", TypeMacros);
8199   verifyFormat("vector<LIST(uint64_t) *attr> v;", TypeMacros);
8200   verifyFormat("vector<A(uint64_t) * attr> v;", TypeMacros); // multiplication
8201 
8202   FormatStyle CustomQualifier = getLLVMStyle();
8203   // Add indentifers that should not be parsed as a qualifier by default.
8204   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8205   CustomQualifier.AttributeMacros.push_back("_My_qualifier");
8206   CustomQualifier.AttributeMacros.push_back("my_other_qualifier");
8207   verifyFormat("vector<a * __my_qualifier> parse_as_multiply;");
8208   verifyFormat("vector<a *__my_qualifier> v;", CustomQualifier);
8209   verifyFormat("vector<a * _My_qualifier> parse_as_multiply;");
8210   verifyFormat("vector<a *_My_qualifier> v;", CustomQualifier);
8211   verifyFormat("vector<a * my_other_qualifier> parse_as_multiply;");
8212   verifyFormat("vector<a *my_other_qualifier> v;", CustomQualifier);
8213   verifyFormat("vector<a * _NotAQualifier> v;");
8214   verifyFormat("vector<a * __not_a_qualifier> v;");
8215   verifyFormat("vector<a * b> v;");
8216   verifyFormat("foo<b && false>();");
8217   verifyFormat("foo<b & 1>();");
8218   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
8219   verifyFormat("typeof(*::std::declval<const T &>()) void F();");
8220   verifyFormat("_Atomic(*::std::declval<const T &>()) void F();");
8221   verifyFormat("__underlying_type(*::std::declval<const T &>()) void F();");
8222   verifyFormat(
8223       "template <class T, class = typename std::enable_if<\n"
8224       "                       std::is_integral<T>::value &&\n"
8225       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
8226       "void F();",
8227       getLLVMStyleWithColumns(70));
8228   verifyFormat("template <class T,\n"
8229                "          class = typename std::enable_if<\n"
8230                "              std::is_integral<T>::value &&\n"
8231                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
8232                "          class U>\n"
8233                "void F();",
8234                getLLVMStyleWithColumns(70));
8235   verifyFormat(
8236       "template <class T,\n"
8237       "          class = typename ::std::enable_if<\n"
8238       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
8239       "void F();",
8240       getGoogleStyleWithColumns(68));
8241 
8242   verifyIndependentOfContext("MACRO(int *i);");
8243   verifyIndependentOfContext("MACRO(auto *a);");
8244   verifyIndependentOfContext("MACRO(const A *a);");
8245   verifyIndependentOfContext("MACRO(_Atomic(A) *a);");
8246   verifyIndependentOfContext("MACRO(decltype(A) *a);");
8247   verifyIndependentOfContext("MACRO(typeof(A) *a);");
8248   verifyIndependentOfContext("MACRO(__underlying_type(A) *a);");
8249   verifyIndependentOfContext("MACRO(A *const a);");
8250   verifyIndependentOfContext("MACRO(A *restrict a);");
8251   verifyIndependentOfContext("MACRO(A *__restrict__ a);");
8252   verifyIndependentOfContext("MACRO(A *__restrict a);");
8253   verifyIndependentOfContext("MACRO(A *volatile a);");
8254   verifyIndependentOfContext("MACRO(A *__volatile a);");
8255   verifyIndependentOfContext("MACRO(A *__volatile__ a);");
8256   verifyIndependentOfContext("MACRO(A *_Nonnull a);");
8257   verifyIndependentOfContext("MACRO(A *_Nullable a);");
8258   verifyIndependentOfContext("MACRO(A *_Null_unspecified a);");
8259   verifyIndependentOfContext("MACRO(A *__attribute__((foo)) a);");
8260   verifyIndependentOfContext("MACRO(A *__attribute((foo)) a);");
8261   verifyIndependentOfContext("MACRO(A *[[clang::attr]] a);");
8262   verifyIndependentOfContext("MACRO(A *[[clang::attr(\"foo\")]] a);");
8263   verifyIndependentOfContext("MACRO(A *__ptr32 a);");
8264   verifyIndependentOfContext("MACRO(A *__ptr64 a);");
8265   verifyIndependentOfContext("MACRO(A *__capability);");
8266   verifyIndependentOfContext("MACRO(A &__capability);");
8267   verifyFormat("MACRO(A *__my_qualifier);");               // type declaration
8268   verifyFormat("void f() { MACRO(A * __my_qualifier); }"); // multiplication
8269   // If we add __my_qualifier to AttributeMacros it should always be parsed as
8270   // a type declaration:
8271   verifyFormat("MACRO(A *__my_qualifier);", CustomQualifier);
8272   verifyFormat("void f() { MACRO(A *__my_qualifier); }", CustomQualifier);
8273   // Also check that TypenameMacros prevents parsing it as multiplication:
8274   verifyIndependentOfContext("MACRO(LIST(uint64_t) * a);"); // multiplication
8275   verifyIndependentOfContext("MACRO(LIST(uint64_t) *a);", TypeMacros); // type
8276 
8277   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
8278   verifyFormat("void f() { f(float{1}, a * a); }");
8279   // FIXME: Is there a way to make this work?
8280   // verifyIndependentOfContext("MACRO(A *a);");
8281   verifyFormat("MACRO(A &B);");
8282   verifyFormat("MACRO(A *B);");
8283   verifyFormat("void f() { MACRO(A * B); }");
8284   verifyFormat("void f() { MACRO(A & B); }");
8285 
8286   // This lambda was mis-formatted after D88956 (treating it as a binop):
8287   verifyFormat("auto x = [](const decltype(x) &ptr) {};");
8288   verifyFormat("auto x = [](const decltype(x) *ptr) {};");
8289   verifyFormat("#define lambda [](const decltype(x) &ptr) {}");
8290   verifyFormat("#define lambda [](const decltype(x) *ptr) {}");
8291 
8292   verifyFormat("DatumHandle const *operator->() const { return input_; }");
8293   verifyFormat("return options != nullptr && operator==(*options);");
8294 
8295   EXPECT_EQ("#define OP(x)                                    \\\n"
8296             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
8297             "    return s << a.DebugString();                 \\\n"
8298             "  }",
8299             format("#define OP(x) \\\n"
8300                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
8301                    "    return s << a.DebugString(); \\\n"
8302                    "  }",
8303                    getLLVMStyleWithColumns(50)));
8304 
8305   // FIXME: We cannot handle this case yet; we might be able to figure out that
8306   // foo<x> d > v; doesn't make sense.
8307   verifyFormat("foo<a<b && c> d> v;");
8308 
8309   FormatStyle PointerMiddle = getLLVMStyle();
8310   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
8311   verifyFormat("delete *x;", PointerMiddle);
8312   verifyFormat("int * x;", PointerMiddle);
8313   verifyFormat("int *[] x;", PointerMiddle);
8314   verifyFormat("template <int * y> f() {}", PointerMiddle);
8315   verifyFormat("int * f(int * a) {}", PointerMiddle);
8316   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
8317   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
8318   verifyFormat("A<int *> a;", PointerMiddle);
8319   verifyFormat("A<int **> a;", PointerMiddle);
8320   verifyFormat("A<int *, int *> a;", PointerMiddle);
8321   verifyFormat("A<int *[]> a;", PointerMiddle);
8322   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
8323   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
8324   verifyFormat("T ** t = new T *;", PointerMiddle);
8325 
8326   // Member function reference qualifiers aren't binary operators.
8327   verifyFormat("string // break\n"
8328                "operator()() & {}");
8329   verifyFormat("string // break\n"
8330                "operator()() && {}");
8331   verifyGoogleFormat("template <typename T>\n"
8332                      "auto x() & -> int {}");
8333 }
8334 
8335 TEST_F(FormatTest, UnderstandsAttributes) {
8336   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
8337   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
8338                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8339   FormatStyle AfterType = getLLVMStyle();
8340   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
8341   verifyFormat("__attribute__((nodebug)) void\n"
8342                "foo() {}\n",
8343                AfterType);
8344   verifyFormat("__unused void\n"
8345                "foo() {}",
8346                AfterType);
8347 
8348   FormatStyle CustomAttrs = getLLVMStyle();
8349   CustomAttrs.AttributeMacros.push_back("__unused");
8350   CustomAttrs.AttributeMacros.push_back("__attr1");
8351   CustomAttrs.AttributeMacros.push_back("__attr2");
8352   CustomAttrs.AttributeMacros.push_back("no_underscore_attr");
8353   verifyFormat("vector<SomeType *__attribute((foo))> v;");
8354   verifyFormat("vector<SomeType *__attribute__((foo))> v;");
8355   verifyFormat("vector<SomeType * __not_attribute__((foo))> v;");
8356   // Check that it is parsed as a multiplication without AttributeMacros and
8357   // as a pointer qualifier when we add __attr1/__attr2 to AttributeMacros.
8358   verifyFormat("vector<SomeType * __attr1> v;");
8359   verifyFormat("vector<SomeType __attr1 *> v;");
8360   verifyFormat("vector<SomeType __attr1 *const> v;");
8361   verifyFormat("vector<SomeType __attr1 * __attr2> v;");
8362   verifyFormat("vector<SomeType *__attr1> v;", CustomAttrs);
8363   verifyFormat("vector<SomeType *__attr2> v;", CustomAttrs);
8364   verifyFormat("vector<SomeType *no_underscore_attr> v;", CustomAttrs);
8365   verifyFormat("vector<SomeType __attr1 *> v;", CustomAttrs);
8366   verifyFormat("vector<SomeType __attr1 *const> v;", CustomAttrs);
8367   verifyFormat("vector<SomeType __attr1 *__attr2> v;", CustomAttrs);
8368   verifyFormat("vector<SomeType __attr1 *no_underscore_attr> v;", CustomAttrs);
8369 
8370   // Check that these are not parsed as function declarations:
8371   CustomAttrs.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8372   CustomAttrs.BreakBeforeBraces = FormatStyle::BS_Allman;
8373   verifyFormat("SomeType s(InitValue);", CustomAttrs);
8374   verifyFormat("SomeType s{InitValue};", CustomAttrs);
8375   verifyFormat("SomeType *__unused s(InitValue);", CustomAttrs);
8376   verifyFormat("SomeType *__unused s{InitValue};", CustomAttrs);
8377   verifyFormat("SomeType s __unused(InitValue);", CustomAttrs);
8378   verifyFormat("SomeType s __unused{InitValue};", CustomAttrs);
8379   verifyFormat("SomeType *__capability s(InitValue);", CustomAttrs);
8380   verifyFormat("SomeType *__capability s{InitValue};", CustomAttrs);
8381 }
8382 
8383 TEST_F(FormatTest, UnderstandsPointerQualifiersInCast) {
8384   // Check that qualifiers on pointers don't break parsing of casts.
8385   verifyFormat("x = (foo *const)*v;");
8386   verifyFormat("x = (foo *volatile)*v;");
8387   verifyFormat("x = (foo *restrict)*v;");
8388   verifyFormat("x = (foo *__attribute__((foo)))*v;");
8389   verifyFormat("x = (foo *_Nonnull)*v;");
8390   verifyFormat("x = (foo *_Nullable)*v;");
8391   verifyFormat("x = (foo *_Null_unspecified)*v;");
8392   verifyFormat("x = (foo *_Nonnull)*v;");
8393   verifyFormat("x = (foo *[[clang::attr]])*v;");
8394   verifyFormat("x = (foo *[[clang::attr(\"foo\")]])*v;");
8395   verifyFormat("x = (foo *__ptr32)*v;");
8396   verifyFormat("x = (foo *__ptr64)*v;");
8397   verifyFormat("x = (foo *__capability)*v;");
8398 
8399   // Check that we handle multiple trailing qualifiers and skip them all to
8400   // determine that the expression is a cast to a pointer type.
8401   FormatStyle LongPointerRight = getLLVMStyleWithColumns(999);
8402   FormatStyle LongPointerLeft = getLLVMStyleWithColumns(999);
8403   LongPointerLeft.PointerAlignment = FormatStyle::PAS_Left;
8404   StringRef AllQualifiers =
8405       "const volatile restrict __attribute__((foo)) _Nonnull _Null_unspecified "
8406       "_Nonnull [[clang::attr]] __ptr32 __ptr64 __capability";
8407   verifyFormat(("x = (foo *" + AllQualifiers + ")*v;").str(), LongPointerRight);
8408   verifyFormat(("x = (foo* " + AllQualifiers + ")*v;").str(), LongPointerLeft);
8409 
8410   // Also check that address-of is not parsed as a binary bitwise-and:
8411   verifyFormat("x = (foo *const)&v;");
8412   verifyFormat(("x = (foo *" + AllQualifiers + ")&v;").str(), LongPointerRight);
8413   verifyFormat(("x = (foo* " + AllQualifiers + ")&v;").str(), LongPointerLeft);
8414 
8415   // Check custom qualifiers:
8416   FormatStyle CustomQualifier = getLLVMStyleWithColumns(999);
8417   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
8418   verifyFormat("x = (foo * __my_qualifier) * v;"); // not parsed as qualifier.
8419   verifyFormat("x = (foo *__my_qualifier)*v;", CustomQualifier);
8420   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)*v;").str(),
8421                CustomQualifier);
8422   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)&v;").str(),
8423                CustomQualifier);
8424 
8425   // Check that unknown identifiers result in binary operator parsing:
8426   verifyFormat("x = (foo * __unknown_qualifier) * v;");
8427   verifyFormat("x = (foo * __unknown_qualifier) & v;");
8428 }
8429 
8430 TEST_F(FormatTest, UnderstandsSquareAttributes) {
8431   verifyFormat("SomeType s [[unused]] (InitValue);");
8432   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
8433   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
8434   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
8435   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
8436   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8437                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
8438   verifyFormat("[[nodiscard]] bool f() { return false; }");
8439   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
8440   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
8441   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
8442 
8443   // Make sure we do not mistake attributes for array subscripts.
8444   verifyFormat("int a() {}\n"
8445                "[[unused]] int b() {}\n");
8446   verifyFormat("NSArray *arr;\n"
8447                "arr[[Foo() bar]];");
8448 
8449   // On the other hand, we still need to correctly find array subscripts.
8450   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
8451 
8452   // Make sure that we do not mistake Objective-C method inside array literals
8453   // as attributes, even if those method names are also keywords.
8454   verifyFormat("@[ [foo bar] ];");
8455   verifyFormat("@[ [NSArray class] ];");
8456   verifyFormat("@[ [foo enum] ];");
8457 
8458   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
8459 
8460   // Make sure we do not parse attributes as lambda introducers.
8461   FormatStyle MultiLineFunctions = getLLVMStyle();
8462   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
8463   verifyFormat("[[unused]] int b() {\n"
8464                "  return 42;\n"
8465                "}\n",
8466                MultiLineFunctions);
8467 }
8468 
8469 TEST_F(FormatTest, AttributeClass) {
8470   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
8471   verifyFormat("class S {\n"
8472                "  S(S&&) = default;\n"
8473                "};",
8474                Style);
8475   verifyFormat("class [[nodiscard]] S {\n"
8476                "  S(S&&) = default;\n"
8477                "};",
8478                Style);
8479   verifyFormat("class __attribute((maybeunused)) S {\n"
8480                "  S(S&&) = default;\n"
8481                "};",
8482                Style);
8483   verifyFormat("struct S {\n"
8484                "  S(S&&) = default;\n"
8485                "};",
8486                Style);
8487   verifyFormat("struct [[nodiscard]] S {\n"
8488                "  S(S&&) = default;\n"
8489                "};",
8490                Style);
8491 }
8492 
8493 TEST_F(FormatTest, AttributesAfterMacro) {
8494   FormatStyle Style = getLLVMStyle();
8495   verifyFormat("MACRO;\n"
8496                "__attribute__((maybe_unused)) int foo() {\n"
8497                "  //...\n"
8498                "}");
8499 
8500   verifyFormat("MACRO;\n"
8501                "[[nodiscard]] int foo() {\n"
8502                "  //...\n"
8503                "}");
8504 
8505   EXPECT_EQ("MACRO\n\n"
8506             "__attribute__((maybe_unused)) int foo() {\n"
8507             "  //...\n"
8508             "}",
8509             format("MACRO\n\n"
8510                    "__attribute__((maybe_unused)) int foo() {\n"
8511                    "  //...\n"
8512                    "}"));
8513 
8514   EXPECT_EQ("MACRO\n\n"
8515             "[[nodiscard]] int foo() {\n"
8516             "  //...\n"
8517             "}",
8518             format("MACRO\n\n"
8519                    "[[nodiscard]] int foo() {\n"
8520                    "  //...\n"
8521                    "}"));
8522 }
8523 
8524 TEST_F(FormatTest, AttributePenaltyBreaking) {
8525   FormatStyle Style = getLLVMStyle();
8526   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
8527                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8528                Style);
8529   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
8530                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
8531                Style);
8532   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
8533                "shared_ptr<ALongTypeName> &C d) {\n}",
8534                Style);
8535 }
8536 
8537 TEST_F(FormatTest, UnderstandsEllipsis) {
8538   FormatStyle Style = getLLVMStyle();
8539   verifyFormat("int printf(const char *fmt, ...);");
8540   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
8541   verifyFormat("template <class... Ts> void Foo(Ts *...ts) {}");
8542 
8543   verifyFormat("template <int *...PP> a;", Style);
8544 
8545   Style.PointerAlignment = FormatStyle::PAS_Left;
8546   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", Style);
8547 
8548   verifyFormat("template <int*... PP> a;", Style);
8549 
8550   Style.PointerAlignment = FormatStyle::PAS_Middle;
8551   verifyFormat("template <int *... PP> a;", Style);
8552 }
8553 
8554 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
8555   EXPECT_EQ("int *a;\n"
8556             "int *a;\n"
8557             "int *a;",
8558             format("int *a;\n"
8559                    "int* a;\n"
8560                    "int *a;",
8561                    getGoogleStyle()));
8562   EXPECT_EQ("int* a;\n"
8563             "int* a;\n"
8564             "int* a;",
8565             format("int* a;\n"
8566                    "int* a;\n"
8567                    "int *a;",
8568                    getGoogleStyle()));
8569   EXPECT_EQ("int *a;\n"
8570             "int *a;\n"
8571             "int *a;",
8572             format("int *a;\n"
8573                    "int * a;\n"
8574                    "int *  a;",
8575                    getGoogleStyle()));
8576   EXPECT_EQ("auto x = [] {\n"
8577             "  int *a;\n"
8578             "  int *a;\n"
8579             "  int *a;\n"
8580             "};",
8581             format("auto x=[]{int *a;\n"
8582                    "int * a;\n"
8583                    "int *  a;};",
8584                    getGoogleStyle()));
8585 }
8586 
8587 TEST_F(FormatTest, UnderstandsRvalueReferences) {
8588   verifyFormat("int f(int &&a) {}");
8589   verifyFormat("int f(int a, char &&b) {}");
8590   verifyFormat("void f() { int &&a = b; }");
8591   verifyGoogleFormat("int f(int a, char&& b) {}");
8592   verifyGoogleFormat("void f() { int&& a = b; }");
8593 
8594   verifyIndependentOfContext("A<int &&> a;");
8595   verifyIndependentOfContext("A<int &&, int &&> a;");
8596   verifyGoogleFormat("A<int&&> a;");
8597   verifyGoogleFormat("A<int&&, int&&> a;");
8598 
8599   // Not rvalue references:
8600   verifyFormat("template <bool B, bool C> class A {\n"
8601                "  static_assert(B && C, \"Something is wrong\");\n"
8602                "};");
8603   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
8604   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
8605   verifyFormat("#define A(a, b) (a && b)");
8606 }
8607 
8608 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
8609   verifyFormat("void f() {\n"
8610                "  x[aaaaaaaaa -\n"
8611                "    b] = 23;\n"
8612                "}",
8613                getLLVMStyleWithColumns(15));
8614 }
8615 
8616 TEST_F(FormatTest, FormatsCasts) {
8617   verifyFormat("Type *A = static_cast<Type *>(P);");
8618   verifyFormat("Type *A = (Type *)P;");
8619   verifyFormat("Type *A = (vector<Type *, int *>)P;");
8620   verifyFormat("int a = (int)(2.0f);");
8621   verifyFormat("int a = (int)2.0f;");
8622   verifyFormat("x[(int32)y];");
8623   verifyFormat("x = (int32)y;");
8624   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
8625   verifyFormat("int a = (int)*b;");
8626   verifyFormat("int a = (int)2.0f;");
8627   verifyFormat("int a = (int)~0;");
8628   verifyFormat("int a = (int)++a;");
8629   verifyFormat("int a = (int)sizeof(int);");
8630   verifyFormat("int a = (int)+2;");
8631   verifyFormat("my_int a = (my_int)2.0f;");
8632   verifyFormat("my_int a = (my_int)sizeof(int);");
8633   verifyFormat("return (my_int)aaa;");
8634   verifyFormat("#define x ((int)-1)");
8635   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
8636   verifyFormat("#define p(q) ((int *)&q)");
8637   verifyFormat("fn(a)(b) + 1;");
8638 
8639   verifyFormat("void f() { my_int a = (my_int)*b; }");
8640   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
8641   verifyFormat("my_int a = (my_int)~0;");
8642   verifyFormat("my_int a = (my_int)++a;");
8643   verifyFormat("my_int a = (my_int)-2;");
8644   verifyFormat("my_int a = (my_int)1;");
8645   verifyFormat("my_int a = (my_int *)1;");
8646   verifyFormat("my_int a = (const my_int)-1;");
8647   verifyFormat("my_int a = (const my_int *)-1;");
8648   verifyFormat("my_int a = (my_int)(my_int)-1;");
8649   verifyFormat("my_int a = (ns::my_int)-2;");
8650   verifyFormat("case (my_int)ONE:");
8651   verifyFormat("auto x = (X)this;");
8652   // Casts in Obj-C style calls used to not be recognized as such.
8653   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
8654 
8655   // FIXME: single value wrapped with paren will be treated as cast.
8656   verifyFormat("void f(int i = (kValue)*kMask) {}");
8657 
8658   verifyFormat("{ (void)F; }");
8659 
8660   // Don't break after a cast's
8661   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8662                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
8663                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
8664 
8665   // These are not casts.
8666   verifyFormat("void f(int *) {}");
8667   verifyFormat("f(foo)->b;");
8668   verifyFormat("f(foo).b;");
8669   verifyFormat("f(foo)(b);");
8670   verifyFormat("f(foo)[b];");
8671   verifyFormat("[](foo) { return 4; }(bar);");
8672   verifyFormat("(*funptr)(foo)[4];");
8673   verifyFormat("funptrs[4](foo)[4];");
8674   verifyFormat("void f(int *);");
8675   verifyFormat("void f(int *) = 0;");
8676   verifyFormat("void f(SmallVector<int>) {}");
8677   verifyFormat("void f(SmallVector<int>);");
8678   verifyFormat("void f(SmallVector<int>) = 0;");
8679   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
8680   verifyFormat("int a = sizeof(int) * b;");
8681   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
8682   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
8683   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
8684   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
8685 
8686   // These are not casts, but at some point were confused with casts.
8687   verifyFormat("virtual void foo(int *) override;");
8688   verifyFormat("virtual void foo(char &) const;");
8689   verifyFormat("virtual void foo(int *a, char *) const;");
8690   verifyFormat("int a = sizeof(int *) + b;");
8691   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
8692   verifyFormat("bool b = f(g<int>) && c;");
8693   verifyFormat("typedef void (*f)(int i) func;");
8694   verifyFormat("void operator++(int) noexcept;");
8695   verifyFormat("void operator++(int &) noexcept;");
8696   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
8697                "&) noexcept;");
8698   verifyFormat(
8699       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
8700   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
8701   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
8702   verifyFormat("void operator delete(nothrow_t &) noexcept;");
8703   verifyFormat("void operator delete(foo &) noexcept;");
8704   verifyFormat("void operator delete(foo) noexcept;");
8705   verifyFormat("void operator delete(int) noexcept;");
8706   verifyFormat("void operator delete(int &) noexcept;");
8707   verifyFormat("void operator delete(int &) volatile noexcept;");
8708   verifyFormat("void operator delete(int &) const");
8709   verifyFormat("void operator delete(int &) = default");
8710   verifyFormat("void operator delete(int &) = delete");
8711   verifyFormat("void operator delete(int &) [[noreturn]]");
8712   verifyFormat("void operator delete(int &) throw();");
8713   verifyFormat("void operator delete(int &) throw(int);");
8714   verifyFormat("auto operator delete(int &) -> int;");
8715   verifyFormat("auto operator delete(int &) override");
8716   verifyFormat("auto operator delete(int &) final");
8717 
8718   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
8719                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8720   // FIXME: The indentation here is not ideal.
8721   verifyFormat(
8722       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8723       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
8724       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
8725 }
8726 
8727 TEST_F(FormatTest, FormatsFunctionTypes) {
8728   verifyFormat("A<bool()> a;");
8729   verifyFormat("A<SomeType()> a;");
8730   verifyFormat("A<void (*)(int, std::string)> a;");
8731   verifyFormat("A<void *(int)>;");
8732   verifyFormat("void *(*a)(int *, SomeType *);");
8733   verifyFormat("int (*func)(void *);");
8734   verifyFormat("void f() { int (*func)(void *); }");
8735   verifyFormat("template <class CallbackClass>\n"
8736                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
8737 
8738   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
8739   verifyGoogleFormat("void* (*a)(int);");
8740   verifyGoogleFormat(
8741       "template <class CallbackClass>\n"
8742       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
8743 
8744   // Other constructs can look somewhat like function types:
8745   verifyFormat("A<sizeof(*x)> a;");
8746   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
8747   verifyFormat("some_var = function(*some_pointer_var)[0];");
8748   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
8749   verifyFormat("int x = f(&h)();");
8750   verifyFormat("returnsFunction(&param1, &param2)(param);");
8751   verifyFormat("std::function<\n"
8752                "    LooooooooooongTemplatedType<\n"
8753                "        SomeType>*(\n"
8754                "        LooooooooooooooooongType type)>\n"
8755                "    function;",
8756                getGoogleStyleWithColumns(40));
8757 }
8758 
8759 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
8760   verifyFormat("A (*foo_)[6];");
8761   verifyFormat("vector<int> (*foo_)[6];");
8762 }
8763 
8764 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
8765   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8766                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8767   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
8768                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
8769   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8770                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
8771 
8772   // Different ways of ()-initializiation.
8773   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8774                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
8775   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8776                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
8777   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8778                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
8779   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
8780                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
8781 
8782   // Lambdas should not confuse the variable declaration heuristic.
8783   verifyFormat("LooooooooooooooooongType\n"
8784                "    variable(nullptr, [](A *a) {});",
8785                getLLVMStyleWithColumns(40));
8786 }
8787 
8788 TEST_F(FormatTest, BreaksLongDeclarations) {
8789   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
8790                "    AnotherNameForTheLongType;");
8791   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
8792                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8793   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8794                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8795   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
8796                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
8797   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8798                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8799   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
8800                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8801   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8802                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8803   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8804                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8805   verifyFormat("typeof(LoooooooooooooooooooooooooooooooooooooooooongName)\n"
8806                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8807   verifyFormat("_Atomic(LooooooooooooooooooooooooooooooooooooooooongName)\n"
8808                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8809   verifyFormat("__underlying_type(LooooooooooooooooooooooooooooooongName)\n"
8810                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
8811   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8812                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
8813   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8814                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
8815   FormatStyle Indented = getLLVMStyle();
8816   Indented.IndentWrappedFunctionNames = true;
8817   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8818                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
8819                Indented);
8820   verifyFormat(
8821       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
8822       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8823       Indented);
8824   verifyFormat(
8825       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
8826       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8827       Indented);
8828   verifyFormat(
8829       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
8830       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
8831       Indented);
8832 
8833   // FIXME: Without the comment, this breaks after "(".
8834   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
8835                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
8836                getGoogleStyle());
8837 
8838   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
8839                "                  int LoooooooooooooooooooongParam2) {}");
8840   verifyFormat(
8841       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
8842       "                                   SourceLocation L, IdentifierIn *II,\n"
8843       "                                   Type *T) {}");
8844   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
8845                "ReallyReaaallyLongFunctionName(\n"
8846                "    const std::string &SomeParameter,\n"
8847                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8848                "        &ReallyReallyLongParameterName,\n"
8849                "    const SomeType<string, SomeOtherTemplateParameter>\n"
8850                "        &AnotherLongParameterName) {}");
8851   verifyFormat("template <typename A>\n"
8852                "SomeLoooooooooooooooooooooongType<\n"
8853                "    typename some_namespace::SomeOtherType<A>::Type>\n"
8854                "Function() {}");
8855 
8856   verifyGoogleFormat(
8857       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
8858       "    aaaaaaaaaaaaaaaaaaaaaaa;");
8859   verifyGoogleFormat(
8860       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
8861       "                                   SourceLocation L) {}");
8862   verifyGoogleFormat(
8863       "some_namespace::LongReturnType\n"
8864       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
8865       "    int first_long_parameter, int second_parameter) {}");
8866 
8867   verifyGoogleFormat("template <typename T>\n"
8868                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8869                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
8870   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8871                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
8872 
8873   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
8874                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8875                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8876   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8877                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
8878                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
8879   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8880                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
8881                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
8882                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8883 
8884   verifyFormat("template <typename T> // Templates on own line.\n"
8885                "static int            // Some comment.\n"
8886                "MyFunction(int a);",
8887                getLLVMStyle());
8888 }
8889 
8890 TEST_F(FormatTest, FormatsAccessModifiers) {
8891   FormatStyle Style = getLLVMStyle();
8892   EXPECT_EQ(Style.EmptyLineBeforeAccessModifier,
8893             FormatStyle::ELBAMS_LogicalBlock);
8894   verifyFormat("struct foo {\n"
8895                "private:\n"
8896                "  void f() {}\n"
8897                "\n"
8898                "private:\n"
8899                "  int i;\n"
8900                "\n"
8901                "protected:\n"
8902                "  int j;\n"
8903                "};\n",
8904                Style);
8905   verifyFormat("struct foo {\n"
8906                "private:\n"
8907                "  void f() {}\n"
8908                "\n"
8909                "private:\n"
8910                "  int i;\n"
8911                "\n"
8912                "protected:\n"
8913                "  int j;\n"
8914                "};\n",
8915                "struct foo {\n"
8916                "private:\n"
8917                "  void f() {}\n"
8918                "private:\n"
8919                "  int i;\n"
8920                "protected:\n"
8921                "  int j;\n"
8922                "};\n",
8923                Style);
8924   verifyFormat("struct foo { /* comment */\n"
8925                "private:\n"
8926                "  int i;\n"
8927                "  // comment\n"
8928                "private:\n"
8929                "  int j;\n"
8930                "};\n",
8931                Style);
8932   verifyFormat("struct foo {\n"
8933                "#ifdef FOO\n"
8934                "#endif\n"
8935                "private:\n"
8936                "  int i;\n"
8937                "#ifdef FOO\n"
8938                "private:\n"
8939                "#endif\n"
8940                "  int j;\n"
8941                "};\n",
8942                Style);
8943   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
8944   verifyFormat("struct foo {\n"
8945                "private:\n"
8946                "  void f() {}\n"
8947                "private:\n"
8948                "  int i;\n"
8949                "protected:\n"
8950                "  int j;\n"
8951                "};\n",
8952                Style);
8953   verifyFormat("struct foo {\n"
8954                "private:\n"
8955                "  void f() {}\n"
8956                "private:\n"
8957                "  int i;\n"
8958                "protected:\n"
8959                "  int j;\n"
8960                "};\n",
8961                "struct foo {\n"
8962                "\n"
8963                "private:\n"
8964                "  void f() {}\n"
8965                "\n"
8966                "private:\n"
8967                "  int i;\n"
8968                "\n"
8969                "protected:\n"
8970                "  int j;\n"
8971                "};\n",
8972                Style);
8973   verifyFormat("struct foo { /* comment */\n"
8974                "private:\n"
8975                "  int i;\n"
8976                "  // comment\n"
8977                "private:\n"
8978                "  int j;\n"
8979                "};\n",
8980                "struct foo { /* comment */\n"
8981                "\n"
8982                "private:\n"
8983                "  int i;\n"
8984                "  // comment\n"
8985                "\n"
8986                "private:\n"
8987                "  int j;\n"
8988                "};\n",
8989                Style);
8990   verifyFormat("struct foo {\n"
8991                "#ifdef FOO\n"
8992                "#endif\n"
8993                "private:\n"
8994                "  int i;\n"
8995                "#ifdef FOO\n"
8996                "private:\n"
8997                "#endif\n"
8998                "  int j;\n"
8999                "};\n",
9000                "struct foo {\n"
9001                "#ifdef FOO\n"
9002                "#endif\n"
9003                "\n"
9004                "private:\n"
9005                "  int i;\n"
9006                "#ifdef FOO\n"
9007                "\n"
9008                "private:\n"
9009                "#endif\n"
9010                "  int j;\n"
9011                "};\n",
9012                Style);
9013   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
9014   verifyFormat("struct foo {\n"
9015                "private:\n"
9016                "  void f() {}\n"
9017                "\n"
9018                "private:\n"
9019                "  int i;\n"
9020                "\n"
9021                "protected:\n"
9022                "  int j;\n"
9023                "};\n",
9024                Style);
9025   verifyFormat("struct foo {\n"
9026                "private:\n"
9027                "  void f() {}\n"
9028                "\n"
9029                "private:\n"
9030                "  int i;\n"
9031                "\n"
9032                "protected:\n"
9033                "  int j;\n"
9034                "};\n",
9035                "struct foo {\n"
9036                "private:\n"
9037                "  void f() {}\n"
9038                "private:\n"
9039                "  int i;\n"
9040                "protected:\n"
9041                "  int j;\n"
9042                "};\n",
9043                Style);
9044   verifyFormat("struct foo { /* comment */\n"
9045                "private:\n"
9046                "  int i;\n"
9047                "  // comment\n"
9048                "\n"
9049                "private:\n"
9050                "  int j;\n"
9051                "};\n",
9052                "struct foo { /* comment */\n"
9053                "private:\n"
9054                "  int i;\n"
9055                "  // comment\n"
9056                "\n"
9057                "private:\n"
9058                "  int j;\n"
9059                "};\n",
9060                Style);
9061   verifyFormat("struct foo {\n"
9062                "#ifdef FOO\n"
9063                "#endif\n"
9064                "\n"
9065                "private:\n"
9066                "  int i;\n"
9067                "#ifdef FOO\n"
9068                "\n"
9069                "private:\n"
9070                "#endif\n"
9071                "  int j;\n"
9072                "};\n",
9073                "struct foo {\n"
9074                "#ifdef FOO\n"
9075                "#endif\n"
9076                "private:\n"
9077                "  int i;\n"
9078                "#ifdef FOO\n"
9079                "private:\n"
9080                "#endif\n"
9081                "  int j;\n"
9082                "};\n",
9083                Style);
9084   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;
9085   EXPECT_EQ("struct foo {\n"
9086             "\n"
9087             "private:\n"
9088             "  void f() {}\n"
9089             "\n"
9090             "private:\n"
9091             "  int i;\n"
9092             "\n"
9093             "protected:\n"
9094             "  int j;\n"
9095             "};\n",
9096             format("struct foo {\n"
9097                    "\n"
9098                    "private:\n"
9099                    "  void f() {}\n"
9100                    "\n"
9101                    "private:\n"
9102                    "  int i;\n"
9103                    "\n"
9104                    "protected:\n"
9105                    "  int j;\n"
9106                    "};\n",
9107                    Style));
9108   verifyFormat("struct foo {\n"
9109                "private:\n"
9110                "  void f() {}\n"
9111                "private:\n"
9112                "  int i;\n"
9113                "protected:\n"
9114                "  int j;\n"
9115                "};\n",
9116                Style);
9117   EXPECT_EQ("struct foo { /* comment */\n"
9118             "\n"
9119             "private:\n"
9120             "  int i;\n"
9121             "  // comment\n"
9122             "\n"
9123             "private:\n"
9124             "  int j;\n"
9125             "};\n",
9126             format("struct foo { /* comment */\n"
9127                    "\n"
9128                    "private:\n"
9129                    "  int i;\n"
9130                    "  // comment\n"
9131                    "\n"
9132                    "private:\n"
9133                    "  int j;\n"
9134                    "};\n",
9135                    Style));
9136   verifyFormat("struct foo { /* comment */\n"
9137                "private:\n"
9138                "  int i;\n"
9139                "  // comment\n"
9140                "private:\n"
9141                "  int j;\n"
9142                "};\n",
9143                Style);
9144   EXPECT_EQ("struct foo {\n"
9145             "#ifdef FOO\n"
9146             "#endif\n"
9147             "\n"
9148             "private:\n"
9149             "  int i;\n"
9150             "#ifdef FOO\n"
9151             "\n"
9152             "private:\n"
9153             "#endif\n"
9154             "  int j;\n"
9155             "};\n",
9156             format("struct foo {\n"
9157                    "#ifdef FOO\n"
9158                    "#endif\n"
9159                    "\n"
9160                    "private:\n"
9161                    "  int i;\n"
9162                    "#ifdef FOO\n"
9163                    "\n"
9164                    "private:\n"
9165                    "#endif\n"
9166                    "  int j;\n"
9167                    "};\n",
9168                    Style));
9169   verifyFormat("struct foo {\n"
9170                "#ifdef FOO\n"
9171                "#endif\n"
9172                "private:\n"
9173                "  int i;\n"
9174                "#ifdef FOO\n"
9175                "private:\n"
9176                "#endif\n"
9177                "  int j;\n"
9178                "};\n",
9179                Style);
9180 }
9181 
9182 TEST_F(FormatTest, FormatsArrays) {
9183   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
9184                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
9185   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
9186                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
9187   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
9188                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
9189   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9190                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
9191   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9192                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
9193   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9194                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
9195                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
9196   verifyFormat(
9197       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
9198       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
9199       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
9200   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
9201                "    .aaaaaaaaaaaaaaaaaaaaaa();");
9202 
9203   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
9204                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
9205   verifyFormat(
9206       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
9207       "                                  .aaaaaaa[0]\n"
9208       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
9209   verifyFormat("a[::b::c];");
9210 
9211   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
9212 
9213   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
9214   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
9215 }
9216 
9217 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
9218   verifyFormat("(a)->b();");
9219   verifyFormat("--a;");
9220 }
9221 
9222 TEST_F(FormatTest, HandlesIncludeDirectives) {
9223   verifyFormat("#include <string>\n"
9224                "#include <a/b/c.h>\n"
9225                "#include \"a/b/string\"\n"
9226                "#include \"string.h\"\n"
9227                "#include \"string.h\"\n"
9228                "#include <a-a>\n"
9229                "#include < path with space >\n"
9230                "#include_next <test.h>"
9231                "#include \"abc.h\" // this is included for ABC\n"
9232                "#include \"some long include\" // with a comment\n"
9233                "#include \"some very long include path\"\n"
9234                "#include <some/very/long/include/path>\n",
9235                getLLVMStyleWithColumns(35));
9236   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
9237   EXPECT_EQ("#include <a>", format("#include<a>"));
9238 
9239   verifyFormat("#import <string>");
9240   verifyFormat("#import <a/b/c.h>");
9241   verifyFormat("#import \"a/b/string\"");
9242   verifyFormat("#import \"string.h\"");
9243   verifyFormat("#import \"string.h\"");
9244   verifyFormat("#if __has_include(<strstream>)\n"
9245                "#include <strstream>\n"
9246                "#endif");
9247 
9248   verifyFormat("#define MY_IMPORT <a/b>");
9249 
9250   verifyFormat("#if __has_include(<a/b>)");
9251   verifyFormat("#if __has_include_next(<a/b>)");
9252   verifyFormat("#define F __has_include(<a/b>)");
9253   verifyFormat("#define F __has_include_next(<a/b>)");
9254 
9255   // Protocol buffer definition or missing "#".
9256   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
9257                getLLVMStyleWithColumns(30));
9258 
9259   FormatStyle Style = getLLVMStyle();
9260   Style.AlwaysBreakBeforeMultilineStrings = true;
9261   Style.ColumnLimit = 0;
9262   verifyFormat("#import \"abc.h\"", Style);
9263 
9264   // But 'import' might also be a regular C++ namespace.
9265   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9266                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
9267 }
9268 
9269 //===----------------------------------------------------------------------===//
9270 // Error recovery tests.
9271 //===----------------------------------------------------------------------===//
9272 
9273 TEST_F(FormatTest, IncompleteParameterLists) {
9274   FormatStyle NoBinPacking = getLLVMStyle();
9275   NoBinPacking.BinPackParameters = false;
9276   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
9277                "                        double *min_x,\n"
9278                "                        double *max_x,\n"
9279                "                        double *min_y,\n"
9280                "                        double *max_y,\n"
9281                "                        double *min_z,\n"
9282                "                        double *max_z, ) {}",
9283                NoBinPacking);
9284 }
9285 
9286 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
9287   verifyFormat("void f() { return; }\n42");
9288   verifyFormat("void f() {\n"
9289                "  if (0)\n"
9290                "    return;\n"
9291                "}\n"
9292                "42");
9293   verifyFormat("void f() { return }\n42");
9294   verifyFormat("void f() {\n"
9295                "  if (0)\n"
9296                "    return\n"
9297                "}\n"
9298                "42");
9299 }
9300 
9301 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
9302   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
9303   EXPECT_EQ("void f() {\n"
9304             "  if (a)\n"
9305             "    return\n"
9306             "}",
9307             format("void  f  (  )  {  if  ( a )  return  }"));
9308   EXPECT_EQ("namespace N {\n"
9309             "void f()\n"
9310             "}",
9311             format("namespace  N  {  void f()  }"));
9312   EXPECT_EQ("namespace N {\n"
9313             "void f() {}\n"
9314             "void g()\n"
9315             "} // namespace N",
9316             format("namespace N  { void f( ) { } void g( ) }"));
9317 }
9318 
9319 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
9320   verifyFormat("int aaaaaaaa =\n"
9321                "    // Overlylongcomment\n"
9322                "    b;",
9323                getLLVMStyleWithColumns(20));
9324   verifyFormat("function(\n"
9325                "    ShortArgument,\n"
9326                "    LoooooooooooongArgument);\n",
9327                getLLVMStyleWithColumns(20));
9328 }
9329 
9330 TEST_F(FormatTest, IncorrectAccessSpecifier) {
9331   verifyFormat("public:");
9332   verifyFormat("class A {\n"
9333                "public\n"
9334                "  void f() {}\n"
9335                "};");
9336   verifyFormat("public\n"
9337                "int qwerty;");
9338   verifyFormat("public\n"
9339                "B {}");
9340   verifyFormat("public\n"
9341                "{}");
9342   verifyFormat("public\n"
9343                "B { int x; }");
9344 }
9345 
9346 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
9347   verifyFormat("{");
9348   verifyFormat("#})");
9349   verifyNoCrash("(/**/[:!] ?[).");
9350 }
9351 
9352 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
9353   // Found by oss-fuzz:
9354   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
9355   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
9356   Style.ColumnLimit = 60;
9357   verifyNoCrash(
9358       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
9359       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
9360       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
9361       Style);
9362 }
9363 
9364 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
9365   verifyFormat("do {\n}");
9366   verifyFormat("do {\n}\n"
9367                "f();");
9368   verifyFormat("do {\n}\n"
9369                "wheeee(fun);");
9370   verifyFormat("do {\n"
9371                "  f();\n"
9372                "}");
9373 }
9374 
9375 TEST_F(FormatTest, IncorrectCodeMissingParens) {
9376   verifyFormat("if {\n  foo;\n  foo();\n}");
9377   verifyFormat("switch {\n  foo;\n  foo();\n}");
9378   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
9379   verifyFormat("while {\n  foo;\n  foo();\n}");
9380   verifyFormat("do {\n  foo;\n  foo();\n} while;");
9381 }
9382 
9383 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
9384   verifyIncompleteFormat("namespace {\n"
9385                          "class Foo { Foo (\n"
9386                          "};\n"
9387                          "} // namespace");
9388 }
9389 
9390 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
9391   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
9392   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
9393   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
9394   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
9395 
9396   EXPECT_EQ("{\n"
9397             "  {\n"
9398             "    breakme(\n"
9399             "        qwe);\n"
9400             "  }\n",
9401             format("{\n"
9402                    "    {\n"
9403                    " breakme(qwe);\n"
9404                    "}\n",
9405                    getLLVMStyleWithColumns(10)));
9406 }
9407 
9408 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
9409   verifyFormat("int x = {\n"
9410                "    avariable,\n"
9411                "    b(alongervariable)};",
9412                getLLVMStyleWithColumns(25));
9413 }
9414 
9415 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
9416   verifyFormat("return (a)(b){1, 2, 3};");
9417 }
9418 
9419 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
9420   verifyFormat("vector<int> x{1, 2, 3, 4};");
9421   verifyFormat("vector<int> x{\n"
9422                "    1,\n"
9423                "    2,\n"
9424                "    3,\n"
9425                "    4,\n"
9426                "};");
9427   verifyFormat("vector<T> x{{}, {}, {}, {}};");
9428   verifyFormat("f({1, 2});");
9429   verifyFormat("auto v = Foo{-1};");
9430   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
9431   verifyFormat("Class::Class : member{1, 2, 3} {}");
9432   verifyFormat("new vector<int>{1, 2, 3};");
9433   verifyFormat("new int[3]{1, 2, 3};");
9434   verifyFormat("new int{1};");
9435   verifyFormat("return {arg1, arg2};");
9436   verifyFormat("return {arg1, SomeType{parameter}};");
9437   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
9438   verifyFormat("new T{arg1, arg2};");
9439   verifyFormat("f(MyMap[{composite, key}]);");
9440   verifyFormat("class Class {\n"
9441                "  T member = {arg1, arg2};\n"
9442                "};");
9443   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
9444   verifyFormat("const struct A a = {.a = 1, .b = 2};");
9445   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
9446   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
9447   verifyFormat("int a = std::is_integral<int>{} + 0;");
9448 
9449   verifyFormat("int foo(int i) { return fo1{}(i); }");
9450   verifyFormat("int foo(int i) { return fo1{}(i); }");
9451   verifyFormat("auto i = decltype(x){};");
9452   verifyFormat("auto i = typeof(x){};");
9453   verifyFormat("auto i = _Atomic(x){};");
9454   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
9455   verifyFormat("Node n{1, Node{1000}, //\n"
9456                "       2};");
9457   verifyFormat("Aaaa aaaaaaa{\n"
9458                "    {\n"
9459                "        aaaa,\n"
9460                "    },\n"
9461                "};");
9462   verifyFormat("class C : public D {\n"
9463                "  SomeClass SC{2};\n"
9464                "};");
9465   verifyFormat("class C : public A {\n"
9466                "  class D : public B {\n"
9467                "    void f() { int i{2}; }\n"
9468                "  };\n"
9469                "};");
9470   verifyFormat("#define A {a, a},");
9471 
9472   // Avoid breaking between equal sign and opening brace
9473   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
9474   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
9475   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
9476                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
9477                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
9478                "     {\"ccccccccccccccccccccc\", 2}};",
9479                AvoidBreakingFirstArgument);
9480 
9481   // Binpacking only if there is no trailing comma
9482   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
9483                "                      cccccccccc, dddddddddd};",
9484                getLLVMStyleWithColumns(50));
9485   verifyFormat("const Aaaaaa aaaaa = {\n"
9486                "    aaaaaaaaaaa,\n"
9487                "    bbbbbbbbbbb,\n"
9488                "    ccccccccccc,\n"
9489                "    ddddddddddd,\n"
9490                "};",
9491                getLLVMStyleWithColumns(50));
9492 
9493   // Cases where distinguising braced lists and blocks is hard.
9494   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
9495   verifyFormat("void f() {\n"
9496                "  return; // comment\n"
9497                "}\n"
9498                "SomeType t;");
9499   verifyFormat("void f() {\n"
9500                "  if (a) {\n"
9501                "    f();\n"
9502                "  }\n"
9503                "}\n"
9504                "SomeType t;");
9505 
9506   // In combination with BinPackArguments = false.
9507   FormatStyle NoBinPacking = getLLVMStyle();
9508   NoBinPacking.BinPackArguments = false;
9509   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
9510                "                      bbbbb,\n"
9511                "                      ccccc,\n"
9512                "                      ddddd,\n"
9513                "                      eeeee,\n"
9514                "                      ffffff,\n"
9515                "                      ggggg,\n"
9516                "                      hhhhhh,\n"
9517                "                      iiiiii,\n"
9518                "                      jjjjjj,\n"
9519                "                      kkkkkk};",
9520                NoBinPacking);
9521   verifyFormat("const Aaaaaa aaaaa = {\n"
9522                "    aaaaa,\n"
9523                "    bbbbb,\n"
9524                "    ccccc,\n"
9525                "    ddddd,\n"
9526                "    eeeee,\n"
9527                "    ffffff,\n"
9528                "    ggggg,\n"
9529                "    hhhhhh,\n"
9530                "    iiiiii,\n"
9531                "    jjjjjj,\n"
9532                "    kkkkkk,\n"
9533                "};",
9534                NoBinPacking);
9535   verifyFormat(
9536       "const Aaaaaa aaaaa = {\n"
9537       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
9538       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
9539       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
9540       "};",
9541       NoBinPacking);
9542 
9543   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
9544   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
9545             "    CDDDP83848_BMCR_REGISTER,\n"
9546             "    CDDDP83848_BMSR_REGISTER,\n"
9547             "    CDDDP83848_RBR_REGISTER};",
9548             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
9549                    "                                CDDDP83848_BMSR_REGISTER,\n"
9550                    "                                CDDDP83848_RBR_REGISTER};",
9551                    NoBinPacking));
9552 
9553   // FIXME: The alignment of these trailing comments might be bad. Then again,
9554   // this might be utterly useless in real code.
9555   verifyFormat("Constructor::Constructor()\n"
9556                "    : some_value{         //\n"
9557                "                 aaaaaaa, //\n"
9558                "                 bbbbbbb} {}");
9559 
9560   // In braced lists, the first comment is always assumed to belong to the
9561   // first element. Thus, it can be moved to the next or previous line as
9562   // appropriate.
9563   EXPECT_EQ("function({// First element:\n"
9564             "          1,\n"
9565             "          // Second element:\n"
9566             "          2});",
9567             format("function({\n"
9568                    "    // First element:\n"
9569                    "    1,\n"
9570                    "    // Second element:\n"
9571                    "    2});"));
9572   EXPECT_EQ("std::vector<int> MyNumbers{\n"
9573             "    // First element:\n"
9574             "    1,\n"
9575             "    // Second element:\n"
9576             "    2};",
9577             format("std::vector<int> MyNumbers{// First element:\n"
9578                    "                           1,\n"
9579                    "                           // Second element:\n"
9580                    "                           2};",
9581                    getLLVMStyleWithColumns(30)));
9582   // A trailing comma should still lead to an enforced line break and no
9583   // binpacking.
9584   EXPECT_EQ("vector<int> SomeVector = {\n"
9585             "    // aaa\n"
9586             "    1,\n"
9587             "    2,\n"
9588             "};",
9589             format("vector<int> SomeVector = { // aaa\n"
9590                    "    1, 2, };"));
9591 
9592   // C++11 brace initializer list l-braces should not be treated any differently
9593   // when breaking before lambda bodies is enabled
9594   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
9595   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
9596   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
9597   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
9598   verifyFormat(
9599       "std::runtime_error{\n"
9600       "    \"Long string which will force a break onto the next line...\"};",
9601       BreakBeforeLambdaBody);
9602 
9603   FormatStyle ExtraSpaces = getLLVMStyle();
9604   ExtraSpaces.Cpp11BracedListStyle = false;
9605   ExtraSpaces.ColumnLimit = 75;
9606   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
9607   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
9608   verifyFormat("f({ 1, 2 });", ExtraSpaces);
9609   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
9610   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
9611   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
9612   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
9613   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
9614   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
9615   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
9616   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
9617   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
9618   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
9619   verifyFormat("class Class {\n"
9620                "  T member = { arg1, arg2 };\n"
9621                "};",
9622                ExtraSpaces);
9623   verifyFormat(
9624       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9625       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
9626       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
9627       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
9628       ExtraSpaces);
9629   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
9630   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
9631                ExtraSpaces);
9632   verifyFormat(
9633       "someFunction(OtherParam,\n"
9634       "             BracedList{ // comment 1 (Forcing interesting break)\n"
9635       "                         param1, param2,\n"
9636       "                         // comment 2\n"
9637       "                         param3, param4 });",
9638       ExtraSpaces);
9639   verifyFormat(
9640       "std::this_thread::sleep_for(\n"
9641       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
9642       ExtraSpaces);
9643   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
9644                "    aaaaaaa,\n"
9645                "    aaaaaaaaaa,\n"
9646                "    aaaaa,\n"
9647                "    aaaaaaaaaaaaaaa,\n"
9648                "    aaa,\n"
9649                "    aaaaaaaaaa,\n"
9650                "    a,\n"
9651                "    aaaaaaaaaaaaaaaaaaaaa,\n"
9652                "    aaaaaaaaaaaa,\n"
9653                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
9654                "    aaaaaaa,\n"
9655                "    a};");
9656   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
9657   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
9658   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
9659 
9660   // Avoid breaking between initializer/equal sign and opening brace
9661   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
9662   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
9663                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9664                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9665                "  { \"ccccccccccccccccccccc\", 2 }\n"
9666                "};",
9667                ExtraSpaces);
9668   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
9669                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9670                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9671                "  { \"ccccccccccccccccccccc\", 2 }\n"
9672                "};",
9673                ExtraSpaces);
9674 
9675   FormatStyle SpaceBeforeBrace = getLLVMStyle();
9676   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9677   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9678   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9679 
9680   FormatStyle SpaceBetweenBraces = getLLVMStyle();
9681   SpaceBetweenBraces.SpacesInAngles = true;
9682   SpaceBetweenBraces.SpacesInParentheses = true;
9683   SpaceBetweenBraces.SpacesInSquareBrackets = true;
9684   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9685   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9686   verifyFormat("vector< int > x{ // comment 1\n"
9687                "                 1, 2, 3, 4 };",
9688                SpaceBetweenBraces);
9689   SpaceBetweenBraces.ColumnLimit = 20;
9690   EXPECT_EQ("vector< int > x{\n"
9691             "    1, 2, 3, 4 };",
9692             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9693   SpaceBetweenBraces.ColumnLimit = 24;
9694   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9695             "                 3, 4 };",
9696             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9697   EXPECT_EQ("vector< int > x{\n"
9698             "    1,\n"
9699             "    2,\n"
9700             "    3,\n"
9701             "    4,\n"
9702             "};",
9703             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9704   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9705   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9706   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9707 }
9708 
9709 TEST_F(FormatTest, FormatSpacesInAngles) {
9710   FormatStyle SpaceInAngles = getLLVMStyle();
9711   SpaceInAngles.SpacesInAngles = true;
9712   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9713   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9714   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9715 
9716   SpaceInAngles.SpacesInAngles = false;
9717   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9718   verifyFormat("vector<int> x5;", SpaceInAngles);
9719   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9720   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9721 }
9722 
9723 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9724   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9725                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9726                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9727                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9728                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9729                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9730   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9731                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9732                "                 1, 22, 333, 4444, 55555, //\n"
9733                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9734                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9735   verifyFormat(
9736       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9737       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9738       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9739       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9740       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9741       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9742       "                 7777777};");
9743   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9744                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9745                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9746   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9747                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9748                "    // Separating comment.\n"
9749                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9750   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9751                "    // Leading comment\n"
9752                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9753                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9754   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9755                "                 1, 1, 1, 1};",
9756                getLLVMStyleWithColumns(39));
9757   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9758                "                 1, 1, 1, 1};",
9759                getLLVMStyleWithColumns(38));
9760   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9761                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9762                getLLVMStyleWithColumns(43));
9763   verifyFormat(
9764       "static unsigned SomeValues[10][3] = {\n"
9765       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9766       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9767   verifyFormat("static auto fields = new vector<string>{\n"
9768                "    \"aaaaaaaaaaaaa\",\n"
9769                "    \"aaaaaaaaaaaaa\",\n"
9770                "    \"aaaaaaaaaaaa\",\n"
9771                "    \"aaaaaaaaaaaaaa\",\n"
9772                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9773                "    \"aaaaaaaaaaaa\",\n"
9774                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9775                "};");
9776   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9777   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9778                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9779                "                 3, cccccccccccccccccccccc};",
9780                getLLVMStyleWithColumns(60));
9781 
9782   // Trailing commas.
9783   verifyFormat("vector<int> x = {\n"
9784                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9785                "};",
9786                getLLVMStyleWithColumns(39));
9787   verifyFormat("vector<int> x = {\n"
9788                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9789                "};",
9790                getLLVMStyleWithColumns(39));
9791   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9792                "                 1, 1, 1, 1,\n"
9793                "                 /**/ /**/};",
9794                getLLVMStyleWithColumns(39));
9795 
9796   // Trailing comment in the first line.
9797   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9798                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9799                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9800                "    11111111,   22222222,   333333333,   44444444};");
9801   // Trailing comment in the last line.
9802   verifyFormat("int aaaaa[] = {\n"
9803                "    1, 2, 3, // comment\n"
9804                "    4, 5, 6  // comment\n"
9805                "};");
9806 
9807   // With nested lists, we should either format one item per line or all nested
9808   // lists one on line.
9809   // FIXME: For some nested lists, we can do better.
9810   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9811                "        {aaaaaaaaaaaaaaaaaaa},\n"
9812                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9813                "        {aaaaaaaaaaaaaaaaa}};",
9814                getLLVMStyleWithColumns(60));
9815   verifyFormat(
9816       "SomeStruct my_struct_array = {\n"
9817       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9818       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9819       "    {aaa, aaa},\n"
9820       "    {aaa, aaa},\n"
9821       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9822       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9823       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9824 
9825   // No column layout should be used here.
9826   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9827                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9828 
9829   verifyNoCrash("a<,");
9830 
9831   // No braced initializer here.
9832   verifyFormat("void f() {\n"
9833                "  struct Dummy {};\n"
9834                "  f(v);\n"
9835                "}");
9836 
9837   // Long lists should be formatted in columns even if they are nested.
9838   verifyFormat(
9839       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9840       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9841       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9842       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9843       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9844       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9845 
9846   // Allow "single-column" layout even if that violates the column limit. There
9847   // isn't going to be a better way.
9848   verifyFormat("std::vector<int> a = {\n"
9849                "    aaaaaaaa,\n"
9850                "    aaaaaaaa,\n"
9851                "    aaaaaaaa,\n"
9852                "    aaaaaaaa,\n"
9853                "    aaaaaaaaaa,\n"
9854                "    aaaaaaaa,\n"
9855                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9856                getLLVMStyleWithColumns(30));
9857   verifyFormat("vector<int> aaaa = {\n"
9858                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9859                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9860                "    aaaaaa.aaaaaaa,\n"
9861                "    aaaaaa.aaaaaaa,\n"
9862                "    aaaaaa.aaaaaaa,\n"
9863                "    aaaaaa.aaaaaaa,\n"
9864                "};");
9865 
9866   // Don't create hanging lists.
9867   verifyFormat("someFunction(Param, {List1, List2,\n"
9868                "                     List3});",
9869                getLLVMStyleWithColumns(35));
9870   verifyFormat("someFunction(Param, Param,\n"
9871                "             {List1, List2,\n"
9872                "              List3});",
9873                getLLVMStyleWithColumns(35));
9874   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9875                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9876 }
9877 
9878 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9879   FormatStyle DoNotMerge = getLLVMStyle();
9880   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9881 
9882   verifyFormat("void f() { return 42; }");
9883   verifyFormat("void f() {\n"
9884                "  return 42;\n"
9885                "}",
9886                DoNotMerge);
9887   verifyFormat("void f() {\n"
9888                "  // Comment\n"
9889                "}");
9890   verifyFormat("{\n"
9891                "#error {\n"
9892                "  int a;\n"
9893                "}");
9894   verifyFormat("{\n"
9895                "  int a;\n"
9896                "#error {\n"
9897                "}");
9898   verifyFormat("void f() {} // comment");
9899   verifyFormat("void f() { int a; } // comment");
9900   verifyFormat("void f() {\n"
9901                "} // comment",
9902                DoNotMerge);
9903   verifyFormat("void f() {\n"
9904                "  int a;\n"
9905                "} // comment",
9906                DoNotMerge);
9907   verifyFormat("void f() {\n"
9908                "} // comment",
9909                getLLVMStyleWithColumns(15));
9910 
9911   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9912   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9913 
9914   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9915   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9916   verifyFormat("class C {\n"
9917                "  C()\n"
9918                "      : iiiiiiii(nullptr),\n"
9919                "        kkkkkkk(nullptr),\n"
9920                "        mmmmmmm(nullptr),\n"
9921                "        nnnnnnn(nullptr) {}\n"
9922                "};",
9923                getGoogleStyle());
9924 
9925   FormatStyle NoColumnLimit = getLLVMStyle();
9926   NoColumnLimit.ColumnLimit = 0;
9927   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9928   EXPECT_EQ("class C {\n"
9929             "  A() : b(0) {}\n"
9930             "};",
9931             format("class C{A():b(0){}};", NoColumnLimit));
9932   EXPECT_EQ("A()\n"
9933             "    : b(0) {\n"
9934             "}",
9935             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9936 
9937   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9938   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9939       FormatStyle::SFS_None;
9940   EXPECT_EQ("A()\n"
9941             "    : b(0) {\n"
9942             "}",
9943             format("A():b(0){}", DoNotMergeNoColumnLimit));
9944   EXPECT_EQ("A()\n"
9945             "    : b(0) {\n"
9946             "}",
9947             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9948 
9949   verifyFormat("#define A          \\\n"
9950                "  void f() {       \\\n"
9951                "    int i;         \\\n"
9952                "  }",
9953                getLLVMStyleWithColumns(20));
9954   verifyFormat("#define A           \\\n"
9955                "  void f() { int i; }",
9956                getLLVMStyleWithColumns(21));
9957   verifyFormat("#define A            \\\n"
9958                "  void f() {         \\\n"
9959                "    int i;           \\\n"
9960                "  }                  \\\n"
9961                "  int j;",
9962                getLLVMStyleWithColumns(22));
9963   verifyFormat("#define A             \\\n"
9964                "  void f() { int i; } \\\n"
9965                "  int j;",
9966                getLLVMStyleWithColumns(23));
9967 }
9968 
9969 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9970   FormatStyle MergeEmptyOnly = getLLVMStyle();
9971   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9972   verifyFormat("class C {\n"
9973                "  int f() {}\n"
9974                "};",
9975                MergeEmptyOnly);
9976   verifyFormat("class C {\n"
9977                "  int f() {\n"
9978                "    return 42;\n"
9979                "  }\n"
9980                "};",
9981                MergeEmptyOnly);
9982   verifyFormat("int f() {}", MergeEmptyOnly);
9983   verifyFormat("int f() {\n"
9984                "  return 42;\n"
9985                "}",
9986                MergeEmptyOnly);
9987 
9988   // Also verify behavior when BraceWrapping.AfterFunction = true
9989   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9990   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9991   verifyFormat("int f() {}", MergeEmptyOnly);
9992   verifyFormat("class C {\n"
9993                "  int f() {}\n"
9994                "};",
9995                MergeEmptyOnly);
9996 }
9997 
9998 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9999   FormatStyle MergeInlineOnly = getLLVMStyle();
10000   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
10001   verifyFormat("class C {\n"
10002                "  int f() { return 42; }\n"
10003                "};",
10004                MergeInlineOnly);
10005   verifyFormat("int f() {\n"
10006                "  return 42;\n"
10007                "}",
10008                MergeInlineOnly);
10009 
10010   // SFS_Inline implies SFS_Empty
10011   verifyFormat("class C {\n"
10012                "  int f() {}\n"
10013                "};",
10014                MergeInlineOnly);
10015   verifyFormat("int f() {}", MergeInlineOnly);
10016 
10017   // Also verify behavior when BraceWrapping.AfterFunction = true
10018   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
10019   MergeInlineOnly.BraceWrapping.AfterFunction = true;
10020   verifyFormat("class C {\n"
10021                "  int f() { return 42; }\n"
10022                "};",
10023                MergeInlineOnly);
10024   verifyFormat("int f()\n"
10025                "{\n"
10026                "  return 42;\n"
10027                "}",
10028                MergeInlineOnly);
10029 
10030   // SFS_Inline implies SFS_Empty
10031   verifyFormat("int f() {}", MergeInlineOnly);
10032   verifyFormat("class C {\n"
10033                "  int f() {}\n"
10034                "};",
10035                MergeInlineOnly);
10036 }
10037 
10038 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
10039   FormatStyle MergeInlineOnly = getLLVMStyle();
10040   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
10041       FormatStyle::SFS_InlineOnly;
10042   verifyFormat("class C {\n"
10043                "  int f() { return 42; }\n"
10044                "};",
10045                MergeInlineOnly);
10046   verifyFormat("int f() {\n"
10047                "  return 42;\n"
10048                "}",
10049                MergeInlineOnly);
10050 
10051   // SFS_InlineOnly does not imply SFS_Empty
10052   verifyFormat("class C {\n"
10053                "  int f() {}\n"
10054                "};",
10055                MergeInlineOnly);
10056   verifyFormat("int f() {\n"
10057                "}",
10058                MergeInlineOnly);
10059 
10060   // Also verify behavior when BraceWrapping.AfterFunction = true
10061   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
10062   MergeInlineOnly.BraceWrapping.AfterFunction = true;
10063   verifyFormat("class C {\n"
10064                "  int f() { return 42; }\n"
10065                "};",
10066                MergeInlineOnly);
10067   verifyFormat("int f()\n"
10068                "{\n"
10069                "  return 42;\n"
10070                "}",
10071                MergeInlineOnly);
10072 
10073   // SFS_InlineOnly does not imply SFS_Empty
10074   verifyFormat("int f()\n"
10075                "{\n"
10076                "}",
10077                MergeInlineOnly);
10078   verifyFormat("class C {\n"
10079                "  int f() {}\n"
10080                "};",
10081                MergeInlineOnly);
10082 }
10083 
10084 TEST_F(FormatTest, SplitEmptyFunction) {
10085   FormatStyle Style = getLLVMStyle();
10086   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
10087   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10088   Style.BraceWrapping.AfterFunction = true;
10089   Style.BraceWrapping.SplitEmptyFunction = false;
10090   Style.ColumnLimit = 40;
10091 
10092   verifyFormat("int f()\n"
10093                "{}",
10094                Style);
10095   verifyFormat("int f()\n"
10096                "{\n"
10097                "  return 42;\n"
10098                "}",
10099                Style);
10100   verifyFormat("int f()\n"
10101                "{\n"
10102                "  // some comment\n"
10103                "}",
10104                Style);
10105 
10106   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
10107   verifyFormat("int f() {}", Style);
10108   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
10109                "{}",
10110                Style);
10111   verifyFormat("int f()\n"
10112                "{\n"
10113                "  return 0;\n"
10114                "}",
10115                Style);
10116 
10117   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
10118   verifyFormat("class Foo {\n"
10119                "  int f() {}\n"
10120                "};\n",
10121                Style);
10122   verifyFormat("class Foo {\n"
10123                "  int f() { return 0; }\n"
10124                "};\n",
10125                Style);
10126   verifyFormat("class Foo {\n"
10127                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
10128                "  {}\n"
10129                "};\n",
10130                Style);
10131   verifyFormat("class Foo {\n"
10132                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
10133                "  {\n"
10134                "    return 0;\n"
10135                "  }\n"
10136                "};\n",
10137                Style);
10138 
10139   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
10140   verifyFormat("int f() {}", Style);
10141   verifyFormat("int f() { return 0; }", Style);
10142   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
10143                "{}",
10144                Style);
10145   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
10146                "{\n"
10147                "  return 0;\n"
10148                "}",
10149                Style);
10150 }
10151 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
10152   FormatStyle Style = getLLVMStyle();
10153   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
10154   verifyFormat("#ifdef A\n"
10155                "int f() {}\n"
10156                "#else\n"
10157                "int g() {}\n"
10158                "#endif",
10159                Style);
10160 }
10161 
10162 TEST_F(FormatTest, SplitEmptyClass) {
10163   FormatStyle Style = getLLVMStyle();
10164   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10165   Style.BraceWrapping.AfterClass = true;
10166   Style.BraceWrapping.SplitEmptyRecord = false;
10167 
10168   verifyFormat("class Foo\n"
10169                "{};",
10170                Style);
10171   verifyFormat("/* something */ class Foo\n"
10172                "{};",
10173                Style);
10174   verifyFormat("template <typename X> class Foo\n"
10175                "{};",
10176                Style);
10177   verifyFormat("class Foo\n"
10178                "{\n"
10179                "  Foo();\n"
10180                "};",
10181                Style);
10182   verifyFormat("typedef class Foo\n"
10183                "{\n"
10184                "} Foo_t;",
10185                Style);
10186 
10187   Style.BraceWrapping.SplitEmptyRecord = true;
10188   Style.BraceWrapping.AfterStruct = true;
10189   verifyFormat("class rep\n"
10190                "{\n"
10191                "};",
10192                Style);
10193   verifyFormat("struct rep\n"
10194                "{\n"
10195                "};",
10196                Style);
10197   verifyFormat("template <typename T> class rep\n"
10198                "{\n"
10199                "};",
10200                Style);
10201   verifyFormat("template <typename T> struct rep\n"
10202                "{\n"
10203                "};",
10204                Style);
10205   verifyFormat("class rep\n"
10206                "{\n"
10207                "  int x;\n"
10208                "};",
10209                Style);
10210   verifyFormat("struct rep\n"
10211                "{\n"
10212                "  int x;\n"
10213                "};",
10214                Style);
10215   verifyFormat("template <typename T> class rep\n"
10216                "{\n"
10217                "  int x;\n"
10218                "};",
10219                Style);
10220   verifyFormat("template <typename T> struct rep\n"
10221                "{\n"
10222                "  int x;\n"
10223                "};",
10224                Style);
10225   verifyFormat("template <typename T> class rep // Foo\n"
10226                "{\n"
10227                "  int x;\n"
10228                "};",
10229                Style);
10230   verifyFormat("template <typename T> struct rep // Bar\n"
10231                "{\n"
10232                "  int x;\n"
10233                "};",
10234                Style);
10235 
10236   verifyFormat("template <typename T> class rep<T>\n"
10237                "{\n"
10238                "  int x;\n"
10239                "};",
10240                Style);
10241 
10242   verifyFormat("template <typename T> class rep<std::complex<T>>\n"
10243                "{\n"
10244                "  int x;\n"
10245                "};",
10246                Style);
10247   verifyFormat("template <typename T> class rep<std::complex<T>>\n"
10248                "{\n"
10249                "};",
10250                Style);
10251 
10252   verifyFormat("#include \"stdint.h\"\n"
10253                "namespace rep {}",
10254                Style);
10255   verifyFormat("#include <stdint.h>\n"
10256                "namespace rep {}",
10257                Style);
10258   verifyFormat("#include <stdint.h>\n"
10259                "namespace rep {}",
10260                "#include <stdint.h>\n"
10261                "namespace rep {\n"
10262                "\n"
10263                "\n"
10264                "}",
10265                Style);
10266 }
10267 
10268 TEST_F(FormatTest, SplitEmptyStruct) {
10269   FormatStyle Style = getLLVMStyle();
10270   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10271   Style.BraceWrapping.AfterStruct = true;
10272   Style.BraceWrapping.SplitEmptyRecord = false;
10273 
10274   verifyFormat("struct Foo\n"
10275                "{};",
10276                Style);
10277   verifyFormat("/* something */ struct Foo\n"
10278                "{};",
10279                Style);
10280   verifyFormat("template <typename X> struct Foo\n"
10281                "{};",
10282                Style);
10283   verifyFormat("struct Foo\n"
10284                "{\n"
10285                "  Foo();\n"
10286                "};",
10287                Style);
10288   verifyFormat("typedef struct Foo\n"
10289                "{\n"
10290                "} Foo_t;",
10291                Style);
10292   // typedef struct Bar {} Bar_t;
10293 }
10294 
10295 TEST_F(FormatTest, SplitEmptyUnion) {
10296   FormatStyle Style = getLLVMStyle();
10297   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10298   Style.BraceWrapping.AfterUnion = true;
10299   Style.BraceWrapping.SplitEmptyRecord = false;
10300 
10301   verifyFormat("union Foo\n"
10302                "{};",
10303                Style);
10304   verifyFormat("/* something */ union Foo\n"
10305                "{};",
10306                Style);
10307   verifyFormat("union Foo\n"
10308                "{\n"
10309                "  A,\n"
10310                "};",
10311                Style);
10312   verifyFormat("typedef union Foo\n"
10313                "{\n"
10314                "} Foo_t;",
10315                Style);
10316 }
10317 
10318 TEST_F(FormatTest, SplitEmptyNamespace) {
10319   FormatStyle Style = getLLVMStyle();
10320   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10321   Style.BraceWrapping.AfterNamespace = true;
10322   Style.BraceWrapping.SplitEmptyNamespace = false;
10323 
10324   verifyFormat("namespace Foo\n"
10325                "{};",
10326                Style);
10327   verifyFormat("/* something */ namespace Foo\n"
10328                "{};",
10329                Style);
10330   verifyFormat("inline namespace Foo\n"
10331                "{};",
10332                Style);
10333   verifyFormat("/* something */ inline namespace Foo\n"
10334                "{};",
10335                Style);
10336   verifyFormat("export namespace Foo\n"
10337                "{};",
10338                Style);
10339   verifyFormat("namespace Foo\n"
10340                "{\n"
10341                "void Bar();\n"
10342                "};",
10343                Style);
10344 }
10345 
10346 TEST_F(FormatTest, NeverMergeShortRecords) {
10347   FormatStyle Style = getLLVMStyle();
10348 
10349   verifyFormat("class Foo {\n"
10350                "  Foo();\n"
10351                "};",
10352                Style);
10353   verifyFormat("typedef class Foo {\n"
10354                "  Foo();\n"
10355                "} Foo_t;",
10356                Style);
10357   verifyFormat("struct Foo {\n"
10358                "  Foo();\n"
10359                "};",
10360                Style);
10361   verifyFormat("typedef struct Foo {\n"
10362                "  Foo();\n"
10363                "} Foo_t;",
10364                Style);
10365   verifyFormat("union Foo {\n"
10366                "  A,\n"
10367                "};",
10368                Style);
10369   verifyFormat("typedef union Foo {\n"
10370                "  A,\n"
10371                "} Foo_t;",
10372                Style);
10373   verifyFormat("namespace Foo {\n"
10374                "void Bar();\n"
10375                "};",
10376                Style);
10377 
10378   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10379   Style.BraceWrapping.AfterClass = true;
10380   Style.BraceWrapping.AfterStruct = true;
10381   Style.BraceWrapping.AfterUnion = true;
10382   Style.BraceWrapping.AfterNamespace = true;
10383   verifyFormat("class Foo\n"
10384                "{\n"
10385                "  Foo();\n"
10386                "};",
10387                Style);
10388   verifyFormat("typedef class Foo\n"
10389                "{\n"
10390                "  Foo();\n"
10391                "} Foo_t;",
10392                Style);
10393   verifyFormat("struct Foo\n"
10394                "{\n"
10395                "  Foo();\n"
10396                "};",
10397                Style);
10398   verifyFormat("typedef struct Foo\n"
10399                "{\n"
10400                "  Foo();\n"
10401                "} Foo_t;",
10402                Style);
10403   verifyFormat("union Foo\n"
10404                "{\n"
10405                "  A,\n"
10406                "};",
10407                Style);
10408   verifyFormat("typedef union Foo\n"
10409                "{\n"
10410                "  A,\n"
10411                "} Foo_t;",
10412                Style);
10413   verifyFormat("namespace Foo\n"
10414                "{\n"
10415                "void Bar();\n"
10416                "};",
10417                Style);
10418 }
10419 
10420 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
10421   // Elaborate type variable declarations.
10422   verifyFormat("struct foo a = {bar};\nint n;");
10423   verifyFormat("class foo a = {bar};\nint n;");
10424   verifyFormat("union foo a = {bar};\nint n;");
10425 
10426   // Elaborate types inside function definitions.
10427   verifyFormat("struct foo f() {}\nint n;");
10428   verifyFormat("class foo f() {}\nint n;");
10429   verifyFormat("union foo f() {}\nint n;");
10430 
10431   // Templates.
10432   verifyFormat("template <class X> void f() {}\nint n;");
10433   verifyFormat("template <struct X> void f() {}\nint n;");
10434   verifyFormat("template <union X> void f() {}\nint n;");
10435 
10436   // Actual definitions...
10437   verifyFormat("struct {\n} n;");
10438   verifyFormat(
10439       "template <template <class T, class Y>, class Z> class X {\n} n;");
10440   verifyFormat("union Z {\n  int n;\n} x;");
10441   verifyFormat("class MACRO Z {\n} n;");
10442   verifyFormat("class MACRO(X) Z {\n} n;");
10443   verifyFormat("class __attribute__(X) Z {\n} n;");
10444   verifyFormat("class __declspec(X) Z {\n} n;");
10445   verifyFormat("class A##B##C {\n} n;");
10446   verifyFormat("class alignas(16) Z {\n} n;");
10447   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
10448   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
10449 
10450   // Redefinition from nested context:
10451   verifyFormat("class A::B::C {\n} n;");
10452 
10453   // Template definitions.
10454   verifyFormat(
10455       "template <typename F>\n"
10456       "Matcher(const Matcher<F> &Other,\n"
10457       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
10458       "                             !is_same<F, T>::value>::type * = 0)\n"
10459       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
10460 
10461   // FIXME: This is still incorrectly handled at the formatter side.
10462   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
10463   verifyFormat("int i = SomeFunction(a<b, a> b);");
10464 
10465   // FIXME:
10466   // This now gets parsed incorrectly as class definition.
10467   // verifyFormat("class A<int> f() {\n}\nint n;");
10468 
10469   // Elaborate types where incorrectly parsing the structural element would
10470   // break the indent.
10471   verifyFormat("if (true)\n"
10472                "  class X x;\n"
10473                "else\n"
10474                "  f();\n");
10475 
10476   // This is simply incomplete. Formatting is not important, but must not crash.
10477   verifyFormat("class A:");
10478 }
10479 
10480 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
10481   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
10482             format("#error Leave     all         white!!!!! space* alone!\n"));
10483   EXPECT_EQ(
10484       "#warning Leave     all         white!!!!! space* alone!\n",
10485       format("#warning Leave     all         white!!!!! space* alone!\n"));
10486   EXPECT_EQ("#error 1", format("  #  error   1"));
10487   EXPECT_EQ("#warning 1", format("  #  warning 1"));
10488 }
10489 
10490 TEST_F(FormatTest, FormatHashIfExpressions) {
10491   verifyFormat("#if AAAA && BBBB");
10492   verifyFormat("#if (AAAA && BBBB)");
10493   verifyFormat("#elif (AAAA && BBBB)");
10494   // FIXME: Come up with a better indentation for #elif.
10495   verifyFormat(
10496       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
10497       "    defined(BBBBBBBB)\n"
10498       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
10499       "    defined(BBBBBBBB)\n"
10500       "#endif",
10501       getLLVMStyleWithColumns(65));
10502 }
10503 
10504 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
10505   FormatStyle AllowsMergedIf = getGoogleStyle();
10506   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
10507       FormatStyle::SIS_WithoutElse;
10508   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
10509   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
10510   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
10511   EXPECT_EQ("if (true) return 42;",
10512             format("if (true)\nreturn 42;", AllowsMergedIf));
10513   FormatStyle ShortMergedIf = AllowsMergedIf;
10514   ShortMergedIf.ColumnLimit = 25;
10515   verifyFormat("#define A \\\n"
10516                "  if (true) return 42;",
10517                ShortMergedIf);
10518   verifyFormat("#define A \\\n"
10519                "  f();    \\\n"
10520                "  if (true)\n"
10521                "#define B",
10522                ShortMergedIf);
10523   verifyFormat("#define A \\\n"
10524                "  f();    \\\n"
10525                "  if (true)\n"
10526                "g();",
10527                ShortMergedIf);
10528   verifyFormat("{\n"
10529                "#ifdef A\n"
10530                "  // Comment\n"
10531                "  if (true) continue;\n"
10532                "#endif\n"
10533                "  // Comment\n"
10534                "  if (true) continue;\n"
10535                "}",
10536                ShortMergedIf);
10537   ShortMergedIf.ColumnLimit = 33;
10538   verifyFormat("#define A \\\n"
10539                "  if constexpr (true) return 42;",
10540                ShortMergedIf);
10541   verifyFormat("#define A \\\n"
10542                "  if CONSTEXPR (true) return 42;",
10543                ShortMergedIf);
10544   ShortMergedIf.ColumnLimit = 29;
10545   verifyFormat("#define A                   \\\n"
10546                "  if (aaaaaaaaaa) return 1; \\\n"
10547                "  return 2;",
10548                ShortMergedIf);
10549   ShortMergedIf.ColumnLimit = 28;
10550   verifyFormat("#define A         \\\n"
10551                "  if (aaaaaaaaaa) \\\n"
10552                "    return 1;     \\\n"
10553                "  return 2;",
10554                ShortMergedIf);
10555   verifyFormat("#define A                \\\n"
10556                "  if constexpr (aaaaaaa) \\\n"
10557                "    return 1;            \\\n"
10558                "  return 2;",
10559                ShortMergedIf);
10560   verifyFormat("#define A                \\\n"
10561                "  if CONSTEXPR (aaaaaaa) \\\n"
10562                "    return 1;            \\\n"
10563                "  return 2;",
10564                ShortMergedIf);
10565 }
10566 
10567 TEST_F(FormatTest, FormatStarDependingOnContext) {
10568   verifyFormat("void f(int *a);");
10569   verifyFormat("void f() { f(fint * b); }");
10570   verifyFormat("class A {\n  void f(int *a);\n};");
10571   verifyFormat("class A {\n  int *a;\n};");
10572   verifyFormat("namespace a {\n"
10573                "namespace b {\n"
10574                "class A {\n"
10575                "  void f() {}\n"
10576                "  int *a;\n"
10577                "};\n"
10578                "} // namespace b\n"
10579                "} // namespace a");
10580 }
10581 
10582 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
10583   verifyFormat("while");
10584   verifyFormat("operator");
10585 }
10586 
10587 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
10588   // This code would be painfully slow to format if we didn't skip it.
10589   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
10590                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10591                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10592                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10593                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10594                    "A(1, 1)\n"
10595                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
10596                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10597                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10598                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10599                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10600                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10601                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10602                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10603                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10604                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
10605   // Deeply nested part is untouched, rest is formatted.
10606   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
10607             format(std::string("int    i;\n") + Code + "int    j;\n",
10608                    getLLVMStyle(), SC_ExpectIncomplete));
10609 }
10610 
10611 //===----------------------------------------------------------------------===//
10612 // Objective-C tests.
10613 //===----------------------------------------------------------------------===//
10614 
10615 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
10616   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
10617   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
10618             format("-(NSUInteger)indexOfObject:(id)anObject;"));
10619   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
10620   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
10621   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
10622             format("-(NSInteger)Method3:(id)anObject;"));
10623   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
10624             format("-(NSInteger)Method4:(id)anObject;"));
10625   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
10626             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
10627   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
10628             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
10629   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10630             "forAllCells:(BOOL)flag;",
10631             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10632                    "forAllCells:(BOOL)flag;"));
10633 
10634   // Very long objectiveC method declaration.
10635   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
10636                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
10637   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
10638                "                    inRange:(NSRange)range\n"
10639                "                   outRange:(NSRange)out_range\n"
10640                "                  outRange1:(NSRange)out_range1\n"
10641                "                  outRange2:(NSRange)out_range2\n"
10642                "                  outRange3:(NSRange)out_range3\n"
10643                "                  outRange4:(NSRange)out_range4\n"
10644                "                  outRange5:(NSRange)out_range5\n"
10645                "                  outRange6:(NSRange)out_range6\n"
10646                "                  outRange7:(NSRange)out_range7\n"
10647                "                  outRange8:(NSRange)out_range8\n"
10648                "                  outRange9:(NSRange)out_range9;");
10649 
10650   // When the function name has to be wrapped.
10651   FormatStyle Style = getLLVMStyle();
10652   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
10653   // and always indents instead.
10654   Style.IndentWrappedFunctionNames = false;
10655   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10656                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
10657                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
10658                "}",
10659                Style);
10660   Style.IndentWrappedFunctionNames = true;
10661   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10662                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
10663                "               anotherName:(NSString)dddddddddddddd {\n"
10664                "}",
10665                Style);
10666 
10667   verifyFormat("- (int)sum:(vector<int>)numbers;");
10668   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
10669   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
10670   // protocol lists (but not for template classes):
10671   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
10672 
10673   verifyFormat("- (int (*)())foo:(int (*)())f;");
10674   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
10675 
10676   // If there's no return type (very rare in practice!), LLVM and Google style
10677   // agree.
10678   verifyFormat("- foo;");
10679   verifyFormat("- foo:(int)f;");
10680   verifyGoogleFormat("- foo:(int)foo;");
10681 }
10682 
10683 TEST_F(FormatTest, BreaksStringLiterals) {
10684   EXPECT_EQ("\"some text \"\n"
10685             "\"other\";",
10686             format("\"some text other\";", getLLVMStyleWithColumns(12)));
10687   EXPECT_EQ("\"some text \"\n"
10688             "\"other\";",
10689             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
10690   EXPECT_EQ(
10691       "#define A  \\\n"
10692       "  \"some \"  \\\n"
10693       "  \"text \"  \\\n"
10694       "  \"other\";",
10695       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
10696   EXPECT_EQ(
10697       "#define A  \\\n"
10698       "  \"so \"    \\\n"
10699       "  \"text \"  \\\n"
10700       "  \"other\";",
10701       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
10702 
10703   EXPECT_EQ("\"some text\"",
10704             format("\"some text\"", getLLVMStyleWithColumns(1)));
10705   EXPECT_EQ("\"some text\"",
10706             format("\"some text\"", getLLVMStyleWithColumns(11)));
10707   EXPECT_EQ("\"some \"\n"
10708             "\"text\"",
10709             format("\"some text\"", getLLVMStyleWithColumns(10)));
10710   EXPECT_EQ("\"some \"\n"
10711             "\"text\"",
10712             format("\"some text\"", getLLVMStyleWithColumns(7)));
10713   EXPECT_EQ("\"some\"\n"
10714             "\" tex\"\n"
10715             "\"t\"",
10716             format("\"some text\"", getLLVMStyleWithColumns(6)));
10717   EXPECT_EQ("\"some\"\n"
10718             "\" tex\"\n"
10719             "\" and\"",
10720             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
10721   EXPECT_EQ("\"some\"\n"
10722             "\"/tex\"\n"
10723             "\"/and\"",
10724             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
10725 
10726   EXPECT_EQ("variable =\n"
10727             "    \"long string \"\n"
10728             "    \"literal\";",
10729             format("variable = \"long string literal\";",
10730                    getLLVMStyleWithColumns(20)));
10731 
10732   EXPECT_EQ("variable = f(\n"
10733             "    \"long string \"\n"
10734             "    \"literal\",\n"
10735             "    short,\n"
10736             "    loooooooooooooooooooong);",
10737             format("variable = f(\"long string literal\", short, "
10738                    "loooooooooooooooooooong);",
10739                    getLLVMStyleWithColumns(20)));
10740 
10741   EXPECT_EQ(
10742       "f(g(\"long string \"\n"
10743       "    \"literal\"),\n"
10744       "  b);",
10745       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
10746   EXPECT_EQ("f(g(\"long string \"\n"
10747             "    \"literal\",\n"
10748             "    a),\n"
10749             "  b);",
10750             format("f(g(\"long string literal\", a), b);",
10751                    getLLVMStyleWithColumns(20)));
10752   EXPECT_EQ(
10753       "f(\"one two\".split(\n"
10754       "    variable));",
10755       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10756   EXPECT_EQ("f(\"one two three four five six \"\n"
10757             "  \"seven\".split(\n"
10758             "      really_looooong_variable));",
10759             format("f(\"one two three four five six seven\"."
10760                    "split(really_looooong_variable));",
10761                    getLLVMStyleWithColumns(33)));
10762 
10763   EXPECT_EQ("f(\"some \"\n"
10764             "  \"text\",\n"
10765             "  other);",
10766             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10767 
10768   // Only break as a last resort.
10769   verifyFormat(
10770       "aaaaaaaaaaaaaaaaaaaa(\n"
10771       "    aaaaaaaaaaaaaaaaaaaa,\n"
10772       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10773 
10774   EXPECT_EQ("\"splitmea\"\n"
10775             "\"trandomp\"\n"
10776             "\"oint\"",
10777             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10778 
10779   EXPECT_EQ("\"split/\"\n"
10780             "\"pathat/\"\n"
10781             "\"slashes\"",
10782             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10783 
10784   EXPECT_EQ("\"split/\"\n"
10785             "\"pathat/\"\n"
10786             "\"slashes\"",
10787             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10788   EXPECT_EQ("\"split at \"\n"
10789             "\"spaces/at/\"\n"
10790             "\"slashes.at.any$\"\n"
10791             "\"non-alphanumeric%\"\n"
10792             "\"1111111111characte\"\n"
10793             "\"rs\"",
10794             format("\"split at "
10795                    "spaces/at/"
10796                    "slashes.at."
10797                    "any$non-"
10798                    "alphanumeric%"
10799                    "1111111111characte"
10800                    "rs\"",
10801                    getLLVMStyleWithColumns(20)));
10802 
10803   // Verify that splitting the strings understands
10804   // Style::AlwaysBreakBeforeMultilineStrings.
10805   EXPECT_EQ("aaaaaaaaaaaa(\n"
10806             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10807             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10808             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10809                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10810                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10811                    getGoogleStyle()));
10812   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10813             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10814             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10815                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10816                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10817                    getGoogleStyle()));
10818   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10819             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10820             format("llvm::outs() << "
10821                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10822                    "aaaaaaaaaaaaaaaaaaa\";"));
10823   EXPECT_EQ("ffff(\n"
10824             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10825             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10826             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10827                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10828                    getGoogleStyle()));
10829 
10830   FormatStyle Style = getLLVMStyleWithColumns(12);
10831   Style.BreakStringLiterals = false;
10832   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10833 
10834   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10835   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10836   EXPECT_EQ("#define A \\\n"
10837             "  \"some \" \\\n"
10838             "  \"text \" \\\n"
10839             "  \"other\";",
10840             format("#define A \"some text other\";", AlignLeft));
10841 }
10842 
10843 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10844   EXPECT_EQ("C a = \"some more \"\n"
10845             "      \"text\";",
10846             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10847 }
10848 
10849 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10850   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10851   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10852   EXPECT_EQ("int i = a(b());",
10853             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10854 }
10855 
10856 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10857   EXPECT_EQ(
10858       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10859       "(\n"
10860       "    \"x\t\");",
10861       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10862              "aaaaaaa("
10863              "\"x\t\");"));
10864 }
10865 
10866 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10867   EXPECT_EQ(
10868       "u8\"utf8 string \"\n"
10869       "u8\"literal\";",
10870       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10871   EXPECT_EQ(
10872       "u\"utf16 string \"\n"
10873       "u\"literal\";",
10874       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10875   EXPECT_EQ(
10876       "U\"utf32 string \"\n"
10877       "U\"literal\";",
10878       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10879   EXPECT_EQ("L\"wide string \"\n"
10880             "L\"literal\";",
10881             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10882   EXPECT_EQ("@\"NSString \"\n"
10883             "@\"literal\";",
10884             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10885   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10886 
10887   // This input makes clang-format try to split the incomplete unicode escape
10888   // sequence, which used to lead to a crasher.
10889   verifyNoCrash(
10890       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10891       getLLVMStyleWithColumns(60));
10892 }
10893 
10894 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10895   FormatStyle Style = getGoogleStyleWithColumns(15);
10896   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10897   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10898   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10899   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10900   EXPECT_EQ("u8R\"x(raw literal)x\";",
10901             format("u8R\"x(raw literal)x\";", Style));
10902 }
10903 
10904 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10905   FormatStyle Style = getLLVMStyleWithColumns(20);
10906   EXPECT_EQ(
10907       "_T(\"aaaaaaaaaaaaaa\")\n"
10908       "_T(\"aaaaaaaaaaaaaa\")\n"
10909       "_T(\"aaaaaaaaaaaa\")",
10910       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10911   EXPECT_EQ("f(x,\n"
10912             "  _T(\"aaaaaaaaaaaa\")\n"
10913             "  _T(\"aaa\"),\n"
10914             "  z);",
10915             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10916 
10917   // FIXME: Handle embedded spaces in one iteration.
10918   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10919   //            "_T(\"aaaaaaaaaaaaa\")\n"
10920   //            "_T(\"aaaaaaaaaaaaa\")\n"
10921   //            "_T(\"a\")",
10922   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10923   //                   getLLVMStyleWithColumns(20)));
10924   EXPECT_EQ(
10925       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10926       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10927   EXPECT_EQ("f(\n"
10928             "#if !TEST\n"
10929             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10930             "#endif\n"
10931             ");",
10932             format("f(\n"
10933                    "#if !TEST\n"
10934                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10935                    "#endif\n"
10936                    ");"));
10937   EXPECT_EQ("f(\n"
10938             "\n"
10939             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10940             format("f(\n"
10941                    "\n"
10942                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10943 }
10944 
10945 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10946   // In a function call with two operands, the second can be broken with no line
10947   // break before it.
10948   EXPECT_EQ(
10949       "func(a, \"long long \"\n"
10950       "        \"long long\");",
10951       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10952   // In a function call with three operands, the second must be broken with a
10953   // line break before it.
10954   EXPECT_EQ("func(a,\n"
10955             "     \"long long long \"\n"
10956             "     \"long\",\n"
10957             "     c);",
10958             format("func(a, \"long long long long\", c);",
10959                    getLLVMStyleWithColumns(24)));
10960   // In a function call with three operands, the third must be broken with a
10961   // line break before it.
10962   EXPECT_EQ("func(a, b,\n"
10963             "     \"long long long \"\n"
10964             "     \"long\");",
10965             format("func(a, b, \"long long long long\");",
10966                    getLLVMStyleWithColumns(24)));
10967   // In a function call with three operands, both the second and the third must
10968   // be broken with a line break before them.
10969   EXPECT_EQ("func(a,\n"
10970             "     \"long long long \"\n"
10971             "     \"long\",\n"
10972             "     \"long long long \"\n"
10973             "     \"long\");",
10974             format("func(a, \"long long long long\", \"long long long long\");",
10975                    getLLVMStyleWithColumns(24)));
10976   // In a chain of << with two operands, the second can be broken with no line
10977   // break before it.
10978   EXPECT_EQ("a << \"line line \"\n"
10979             "     \"line\";",
10980             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10981   // In a chain of << with three operands, the second can be broken with no line
10982   // break before it.
10983   EXPECT_EQ(
10984       "abcde << \"line \"\n"
10985       "         \"line line\"\n"
10986       "      << c;",
10987       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10988   // In a chain of << with three operands, the third must be broken with a line
10989   // break before it.
10990   EXPECT_EQ(
10991       "a << b\n"
10992       "  << \"line line \"\n"
10993       "     \"line\";",
10994       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10995   // In a chain of << with three operands, the second can be broken with no line
10996   // break before it and the third must be broken with a line break before it.
10997   EXPECT_EQ("abcd << \"line line \"\n"
10998             "        \"line\"\n"
10999             "     << \"line line \"\n"
11000             "        \"line\";",
11001             format("abcd << \"line line line\" << \"line line line\";",
11002                    getLLVMStyleWithColumns(20)));
11003   // In a chain of binary operators with two operands, the second can be broken
11004   // with no line break before it.
11005   EXPECT_EQ(
11006       "abcd + \"line line \"\n"
11007       "       \"line line\";",
11008       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
11009   // In a chain of binary operators with three operands, the second must be
11010   // broken with a line break before it.
11011   EXPECT_EQ("abcd +\n"
11012             "    \"line line \"\n"
11013             "    \"line line\" +\n"
11014             "    e;",
11015             format("abcd + \"line line line line\" + e;",
11016                    getLLVMStyleWithColumns(20)));
11017   // In a function call with two operands, with AlignAfterOpenBracket enabled,
11018   // the first must be broken with a line break before it.
11019   FormatStyle Style = getLLVMStyleWithColumns(25);
11020   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
11021   EXPECT_EQ("someFunction(\n"
11022             "    \"long long long \"\n"
11023             "    \"long\",\n"
11024             "    a);",
11025             format("someFunction(\"long long long long\", a);", Style));
11026 }
11027 
11028 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
11029   EXPECT_EQ(
11030       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
11031       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
11032       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
11033       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
11034              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
11035              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
11036 }
11037 
11038 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
11039   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
11040             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
11041   EXPECT_EQ("fffffffffff(g(R\"x(\n"
11042             "multiline raw string literal xxxxxxxxxxxxxx\n"
11043             ")x\",\n"
11044             "              a),\n"
11045             "            b);",
11046             format("fffffffffff(g(R\"x(\n"
11047                    "multiline raw string literal xxxxxxxxxxxxxx\n"
11048                    ")x\", a), b);",
11049                    getGoogleStyleWithColumns(20)));
11050   EXPECT_EQ("fffffffffff(\n"
11051             "    g(R\"x(qqq\n"
11052             "multiline raw string literal xxxxxxxxxxxxxx\n"
11053             ")x\",\n"
11054             "      a),\n"
11055             "    b);",
11056             format("fffffffffff(g(R\"x(qqq\n"
11057                    "multiline raw string literal xxxxxxxxxxxxxx\n"
11058                    ")x\", a), b);",
11059                    getGoogleStyleWithColumns(20)));
11060 
11061   EXPECT_EQ("fffffffffff(R\"x(\n"
11062             "multiline raw string literal xxxxxxxxxxxxxx\n"
11063             ")x\");",
11064             format("fffffffffff(R\"x(\n"
11065                    "multiline raw string literal xxxxxxxxxxxxxx\n"
11066                    ")x\");",
11067                    getGoogleStyleWithColumns(20)));
11068   EXPECT_EQ("fffffffffff(R\"x(\n"
11069             "multiline raw string literal xxxxxxxxxxxxxx\n"
11070             ")x\" + bbbbbb);",
11071             format("fffffffffff(R\"x(\n"
11072                    "multiline raw string literal xxxxxxxxxxxxxx\n"
11073                    ")x\" +   bbbbbb);",
11074                    getGoogleStyleWithColumns(20)));
11075   EXPECT_EQ("fffffffffff(\n"
11076             "    R\"x(\n"
11077             "multiline raw string literal xxxxxxxxxxxxxx\n"
11078             ")x\" +\n"
11079             "    bbbbbb);",
11080             format("fffffffffff(\n"
11081                    " R\"x(\n"
11082                    "multiline raw string literal xxxxxxxxxxxxxx\n"
11083                    ")x\" + bbbbbb);",
11084                    getGoogleStyleWithColumns(20)));
11085   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
11086             format("fffffffffff(\n"
11087                    " R\"(single line raw string)\" + bbbbbb);"));
11088 }
11089 
11090 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
11091   verifyFormat("string a = \"unterminated;");
11092   EXPECT_EQ("function(\"unterminated,\n"
11093             "         OtherParameter);",
11094             format("function(  \"unterminated,\n"
11095                    "    OtherParameter);"));
11096 }
11097 
11098 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
11099   FormatStyle Style = getLLVMStyle();
11100   Style.Standard = FormatStyle::LS_Cpp03;
11101   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
11102             format("#define x(_a) printf(\"foo\"_a);", Style));
11103 }
11104 
11105 TEST_F(FormatTest, CppLexVersion) {
11106   FormatStyle Style = getLLVMStyle();
11107   // Formatting of x * y differs if x is a type.
11108   verifyFormat("void foo() { MACRO(a * b); }", Style);
11109   verifyFormat("void foo() { MACRO(int *b); }", Style);
11110 
11111   // LLVM style uses latest lexer.
11112   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
11113   Style.Standard = FormatStyle::LS_Cpp17;
11114   // But in c++17, char8_t isn't a keyword.
11115   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
11116 }
11117 
11118 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
11119 
11120 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
11121   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
11122             "             \"ddeeefff\");",
11123             format("someFunction(\"aaabbbcccdddeeefff\");",
11124                    getLLVMStyleWithColumns(25)));
11125   EXPECT_EQ("someFunction1234567890(\n"
11126             "    \"aaabbbcccdddeeefff\");",
11127             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
11128                    getLLVMStyleWithColumns(26)));
11129   EXPECT_EQ("someFunction1234567890(\n"
11130             "    \"aaabbbcccdddeeeff\"\n"
11131             "    \"f\");",
11132             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
11133                    getLLVMStyleWithColumns(25)));
11134   EXPECT_EQ("someFunction1234567890(\n"
11135             "    \"aaabbbcccdddeeeff\"\n"
11136             "    \"f\");",
11137             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
11138                    getLLVMStyleWithColumns(24)));
11139   EXPECT_EQ("someFunction(\n"
11140             "    \"aaabbbcc ddde \"\n"
11141             "    \"efff\");",
11142             format("someFunction(\"aaabbbcc ddde efff\");",
11143                    getLLVMStyleWithColumns(25)));
11144   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
11145             "             \"ddeeefff\");",
11146             format("someFunction(\"aaabbbccc ddeeefff\");",
11147                    getLLVMStyleWithColumns(25)));
11148   EXPECT_EQ("someFunction1234567890(\n"
11149             "    \"aaabb \"\n"
11150             "    \"cccdddeeefff\");",
11151             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
11152                    getLLVMStyleWithColumns(25)));
11153   EXPECT_EQ("#define A          \\\n"
11154             "  string s =       \\\n"
11155             "      \"123456789\"  \\\n"
11156             "      \"0\";         \\\n"
11157             "  int i;",
11158             format("#define A string s = \"1234567890\"; int i;",
11159                    getLLVMStyleWithColumns(20)));
11160   EXPECT_EQ("someFunction(\n"
11161             "    \"aaabbbcc \"\n"
11162             "    \"dddeeefff\");",
11163             format("someFunction(\"aaabbbcc dddeeefff\");",
11164                    getLLVMStyleWithColumns(25)));
11165 }
11166 
11167 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
11168   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
11169   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
11170   EXPECT_EQ("\"test\"\n"
11171             "\"\\n\"",
11172             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
11173   EXPECT_EQ("\"tes\\\\\"\n"
11174             "\"n\"",
11175             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
11176   EXPECT_EQ("\"\\\\\\\\\"\n"
11177             "\"\\n\"",
11178             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
11179   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
11180   EXPECT_EQ("\"\\uff01\"\n"
11181             "\"test\"",
11182             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
11183   EXPECT_EQ("\"\\Uff01ff02\"",
11184             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
11185   EXPECT_EQ("\"\\x000000000001\"\n"
11186             "\"next\"",
11187             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
11188   EXPECT_EQ("\"\\x000000000001next\"",
11189             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
11190   EXPECT_EQ("\"\\x000000000001\"",
11191             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
11192   EXPECT_EQ("\"test\"\n"
11193             "\"\\000000\"\n"
11194             "\"000001\"",
11195             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
11196   EXPECT_EQ("\"test\\000\"\n"
11197             "\"00000000\"\n"
11198             "\"1\"",
11199             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
11200 }
11201 
11202 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
11203   verifyFormat("void f() {\n"
11204                "  return g() {}\n"
11205                "  void h() {}");
11206   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
11207                "g();\n"
11208                "}");
11209 }
11210 
11211 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
11212   verifyFormat(
11213       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
11214 }
11215 
11216 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
11217   verifyFormat("class X {\n"
11218                "  void f() {\n"
11219                "  }\n"
11220                "};",
11221                getLLVMStyleWithColumns(12));
11222 }
11223 
11224 TEST_F(FormatTest, ConfigurableIndentWidth) {
11225   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
11226   EightIndent.IndentWidth = 8;
11227   EightIndent.ContinuationIndentWidth = 8;
11228   verifyFormat("void f() {\n"
11229                "        someFunction();\n"
11230                "        if (true) {\n"
11231                "                f();\n"
11232                "        }\n"
11233                "}",
11234                EightIndent);
11235   verifyFormat("class X {\n"
11236                "        void f() {\n"
11237                "        }\n"
11238                "};",
11239                EightIndent);
11240   verifyFormat("int x[] = {\n"
11241                "        call(),\n"
11242                "        call()};",
11243                EightIndent);
11244 }
11245 
11246 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
11247   verifyFormat("double\n"
11248                "f();",
11249                getLLVMStyleWithColumns(8));
11250 }
11251 
11252 TEST_F(FormatTest, ConfigurableUseOfTab) {
11253   FormatStyle Tab = getLLVMStyleWithColumns(42);
11254   Tab.IndentWidth = 8;
11255   Tab.UseTab = FormatStyle::UT_Always;
11256   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
11257 
11258   EXPECT_EQ("if (aaaaaaaa && // q\n"
11259             "    bb)\t\t// 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 
11271   verifyFormat("class X {\n"
11272                "\tvoid f() {\n"
11273                "\t\tsomeFunction(parameter1,\n"
11274                "\t\t\t     parameter2);\n"
11275                "\t}\n"
11276                "};",
11277                Tab);
11278   verifyFormat("#define A                        \\\n"
11279                "\tvoid f() {               \\\n"
11280                "\t\tsomeFunction(    \\\n"
11281                "\t\t    parameter1,  \\\n"
11282                "\t\t    parameter2); \\\n"
11283                "\t}",
11284                Tab);
11285   verifyFormat("int a;\t      // x\n"
11286                "int bbbbbbbb; // x\n",
11287                Tab);
11288 
11289   Tab.TabWidth = 4;
11290   Tab.IndentWidth = 8;
11291   verifyFormat("class TabWidth4Indent8 {\n"
11292                "\t\tvoid f() {\n"
11293                "\t\t\t\tsomeFunction(parameter1,\n"
11294                "\t\t\t\t\t\t\t parameter2);\n"
11295                "\t\t}\n"
11296                "};",
11297                Tab);
11298 
11299   Tab.TabWidth = 4;
11300   Tab.IndentWidth = 4;
11301   verifyFormat("class TabWidth4Indent4 {\n"
11302                "\tvoid f() {\n"
11303                "\t\tsomeFunction(parameter1,\n"
11304                "\t\t\t\t\t parameter2);\n"
11305                "\t}\n"
11306                "};",
11307                Tab);
11308 
11309   Tab.TabWidth = 8;
11310   Tab.IndentWidth = 4;
11311   verifyFormat("class TabWidth8Indent4 {\n"
11312                "    void f() {\n"
11313                "\tsomeFunction(parameter1,\n"
11314                "\t\t     parameter2);\n"
11315                "    }\n"
11316                "};",
11317                Tab);
11318 
11319   Tab.TabWidth = 8;
11320   Tab.IndentWidth = 8;
11321   EXPECT_EQ("/*\n"
11322             "\t      a\t\tcomment\n"
11323             "\t      in multiple lines\n"
11324             "       */",
11325             format("   /*\t \t \n"
11326                    " \t \t a\t\tcomment\t \t\n"
11327                    " \t \t in multiple lines\t\n"
11328                    " \t  */",
11329                    Tab));
11330 
11331   Tab.UseTab = FormatStyle::UT_ForIndentation;
11332   verifyFormat("{\n"
11333                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11334                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11335                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11336                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11337                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11338                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11339                "};",
11340                Tab);
11341   verifyFormat("enum AA {\n"
11342                "\ta1, // Force multiple lines\n"
11343                "\ta2,\n"
11344                "\ta3\n"
11345                "};",
11346                Tab);
11347   EXPECT_EQ("if (aaaaaaaa && // q\n"
11348             "    bb)         // w\n"
11349             "\t;",
11350             format("if (aaaaaaaa &&// q\n"
11351                    "bb)// w\n"
11352                    ";",
11353                    Tab));
11354   verifyFormat("class X {\n"
11355                "\tvoid f() {\n"
11356                "\t\tsomeFunction(parameter1,\n"
11357                "\t\t             parameter2);\n"
11358                "\t}\n"
11359                "};",
11360                Tab);
11361   verifyFormat("{\n"
11362                "\tQ(\n"
11363                "\t    {\n"
11364                "\t\t    int a;\n"
11365                "\t\t    someFunction(aaaaaaaa,\n"
11366                "\t\t                 bbbbbbb);\n"
11367                "\t    },\n"
11368                "\t    p);\n"
11369                "}",
11370                Tab);
11371   EXPECT_EQ("{\n"
11372             "\t/* aaaa\n"
11373             "\t   bbbb */\n"
11374             "}",
11375             format("{\n"
11376                    "/* aaaa\n"
11377                    "   bbbb */\n"
11378                    "}",
11379                    Tab));
11380   EXPECT_EQ("{\n"
11381             "\t/*\n"
11382             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11383             "\t  bbbbbbbbbbbbb\n"
11384             "\t*/\n"
11385             "}",
11386             format("{\n"
11387                    "/*\n"
11388                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11389                    "*/\n"
11390                    "}",
11391                    Tab));
11392   EXPECT_EQ("{\n"
11393             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11394             "\t// bbbbbbbbbbbbb\n"
11395             "}",
11396             format("{\n"
11397                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11398                    "}",
11399                    Tab));
11400   EXPECT_EQ("{\n"
11401             "\t/*\n"
11402             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11403             "\t  bbbbbbbbbbbbb\n"
11404             "\t*/\n"
11405             "}",
11406             format("{\n"
11407                    "\t/*\n"
11408                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11409                    "\t*/\n"
11410                    "}",
11411                    Tab));
11412   EXPECT_EQ("{\n"
11413             "\t/*\n"
11414             "\n"
11415             "\t*/\n"
11416             "}",
11417             format("{\n"
11418                    "\t/*\n"
11419                    "\n"
11420                    "\t*/\n"
11421                    "}",
11422                    Tab));
11423   EXPECT_EQ("{\n"
11424             "\t/*\n"
11425             " asdf\n"
11426             "\t*/\n"
11427             "}",
11428             format("{\n"
11429                    "\t/*\n"
11430                    " asdf\n"
11431                    "\t*/\n"
11432                    "}",
11433                    Tab));
11434 
11435   Tab.UseTab = FormatStyle::UT_Never;
11436   EXPECT_EQ("/*\n"
11437             "              a\t\tcomment\n"
11438             "              in multiple lines\n"
11439             "       */",
11440             format("   /*\t \t \n"
11441                    " \t \t a\t\tcomment\t \t\n"
11442                    " \t \t in multiple lines\t\n"
11443                    " \t  */",
11444                    Tab));
11445   EXPECT_EQ("/* some\n"
11446             "   comment */",
11447             format(" \t \t /* some\n"
11448                    " \t \t    comment */",
11449                    Tab));
11450   EXPECT_EQ("int a; /* some\n"
11451             "   comment */",
11452             format(" \t \t int a; /* some\n"
11453                    " \t \t    comment */",
11454                    Tab));
11455 
11456   EXPECT_EQ("int a; /* some\n"
11457             "comment */",
11458             format(" \t \t int\ta; /* some\n"
11459                    " \t \t    comment */",
11460                    Tab));
11461   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11462             "    comment */",
11463             format(" \t \t f(\"\t\t\"); /* some\n"
11464                    " \t \t    comment */",
11465                    Tab));
11466   EXPECT_EQ("{\n"
11467             "        /*\n"
11468             "         * Comment\n"
11469             "         */\n"
11470             "        int i;\n"
11471             "}",
11472             format("{\n"
11473                    "\t/*\n"
11474                    "\t * Comment\n"
11475                    "\t */\n"
11476                    "\t int i;\n"
11477                    "}",
11478                    Tab));
11479 
11480   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11481   Tab.TabWidth = 8;
11482   Tab.IndentWidth = 8;
11483   EXPECT_EQ("if (aaaaaaaa && // q\n"
11484             "    bb)         // w\n"
11485             "\t;",
11486             format("if (aaaaaaaa &&// q\n"
11487                    "bb)// w\n"
11488                    ";",
11489                    Tab));
11490   EXPECT_EQ("if (aaa && bbb) // w\n"
11491             "\t;",
11492             format("if(aaa&&bbb)// w\n"
11493                    ";",
11494                    Tab));
11495   verifyFormat("class X {\n"
11496                "\tvoid f() {\n"
11497                "\t\tsomeFunction(parameter1,\n"
11498                "\t\t\t     parameter2);\n"
11499                "\t}\n"
11500                "};",
11501                Tab);
11502   verifyFormat("#define A                        \\\n"
11503                "\tvoid f() {               \\\n"
11504                "\t\tsomeFunction(    \\\n"
11505                "\t\t    parameter1,  \\\n"
11506                "\t\t    parameter2); \\\n"
11507                "\t}",
11508                Tab);
11509   Tab.TabWidth = 4;
11510   Tab.IndentWidth = 8;
11511   verifyFormat("class TabWidth4Indent8 {\n"
11512                "\t\tvoid f() {\n"
11513                "\t\t\t\tsomeFunction(parameter1,\n"
11514                "\t\t\t\t\t\t\t parameter2);\n"
11515                "\t\t}\n"
11516                "};",
11517                Tab);
11518   Tab.TabWidth = 4;
11519   Tab.IndentWidth = 4;
11520   verifyFormat("class TabWidth4Indent4 {\n"
11521                "\tvoid f() {\n"
11522                "\t\tsomeFunction(parameter1,\n"
11523                "\t\t\t\t\t parameter2);\n"
11524                "\t}\n"
11525                "};",
11526                Tab);
11527   Tab.TabWidth = 8;
11528   Tab.IndentWidth = 4;
11529   verifyFormat("class TabWidth8Indent4 {\n"
11530                "    void f() {\n"
11531                "\tsomeFunction(parameter1,\n"
11532                "\t\t     parameter2);\n"
11533                "    }\n"
11534                "};",
11535                Tab);
11536   Tab.TabWidth = 8;
11537   Tab.IndentWidth = 8;
11538   EXPECT_EQ("/*\n"
11539             "\t      a\t\tcomment\n"
11540             "\t      in multiple lines\n"
11541             "       */",
11542             format("   /*\t \t \n"
11543                    " \t \t a\t\tcomment\t \t\n"
11544                    " \t \t in multiple lines\t\n"
11545                    " \t  */",
11546                    Tab));
11547   verifyFormat("{\n"
11548                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11549                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11550                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11551                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11552                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11553                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11554                "};",
11555                Tab);
11556   verifyFormat("enum AA {\n"
11557                "\ta1, // Force multiple lines\n"
11558                "\ta2,\n"
11559                "\ta3\n"
11560                "};",
11561                Tab);
11562   EXPECT_EQ("if (aaaaaaaa && // q\n"
11563             "    bb)         // w\n"
11564             "\t;",
11565             format("if (aaaaaaaa &&// q\n"
11566                    "bb)// w\n"
11567                    ";",
11568                    Tab));
11569   verifyFormat("class X {\n"
11570                "\tvoid f() {\n"
11571                "\t\tsomeFunction(parameter1,\n"
11572                "\t\t\t     parameter2);\n"
11573                "\t}\n"
11574                "};",
11575                Tab);
11576   verifyFormat("{\n"
11577                "\tQ(\n"
11578                "\t    {\n"
11579                "\t\t    int a;\n"
11580                "\t\t    someFunction(aaaaaaaa,\n"
11581                "\t\t\t\t bbbbbbb);\n"
11582                "\t    },\n"
11583                "\t    p);\n"
11584                "}",
11585                Tab);
11586   EXPECT_EQ("{\n"
11587             "\t/* aaaa\n"
11588             "\t   bbbb */\n"
11589             "}",
11590             format("{\n"
11591                    "/* aaaa\n"
11592                    "   bbbb */\n"
11593                    "}",
11594                    Tab));
11595   EXPECT_EQ("{\n"
11596             "\t/*\n"
11597             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11598             "\t  bbbbbbbbbbbbb\n"
11599             "\t*/\n"
11600             "}",
11601             format("{\n"
11602                    "/*\n"
11603                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11604                    "*/\n"
11605                    "}",
11606                    Tab));
11607   EXPECT_EQ("{\n"
11608             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11609             "\t// bbbbbbbbbbbbb\n"
11610             "}",
11611             format("{\n"
11612                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11613                    "}",
11614                    Tab));
11615   EXPECT_EQ("{\n"
11616             "\t/*\n"
11617             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11618             "\t  bbbbbbbbbbbbb\n"
11619             "\t*/\n"
11620             "}",
11621             format("{\n"
11622                    "\t/*\n"
11623                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11624                    "\t*/\n"
11625                    "}",
11626                    Tab));
11627   EXPECT_EQ("{\n"
11628             "\t/*\n"
11629             "\n"
11630             "\t*/\n"
11631             "}",
11632             format("{\n"
11633                    "\t/*\n"
11634                    "\n"
11635                    "\t*/\n"
11636                    "}",
11637                    Tab));
11638   EXPECT_EQ("{\n"
11639             "\t/*\n"
11640             " asdf\n"
11641             "\t*/\n"
11642             "}",
11643             format("{\n"
11644                    "\t/*\n"
11645                    " asdf\n"
11646                    "\t*/\n"
11647                    "}",
11648                    Tab));
11649   EXPECT_EQ("/* some\n"
11650             "   comment */",
11651             format(" \t \t /* some\n"
11652                    " \t \t    comment */",
11653                    Tab));
11654   EXPECT_EQ("int a; /* some\n"
11655             "   comment */",
11656             format(" \t \t int a; /* some\n"
11657                    " \t \t    comment */",
11658                    Tab));
11659   EXPECT_EQ("int a; /* some\n"
11660             "comment */",
11661             format(" \t \t int\ta; /* some\n"
11662                    " \t \t    comment */",
11663                    Tab));
11664   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11665             "    comment */",
11666             format(" \t \t f(\"\t\t\"); /* some\n"
11667                    " \t \t    comment */",
11668                    Tab));
11669   EXPECT_EQ("{\n"
11670             "\t/*\n"
11671             "\t * Comment\n"
11672             "\t */\n"
11673             "\tint i;\n"
11674             "}",
11675             format("{\n"
11676                    "\t/*\n"
11677                    "\t * Comment\n"
11678                    "\t */\n"
11679                    "\t int i;\n"
11680                    "}",
11681                    Tab));
11682   Tab.TabWidth = 2;
11683   Tab.IndentWidth = 2;
11684   EXPECT_EQ("{\n"
11685             "\t/* aaaa\n"
11686             "\t\t bbbb */\n"
11687             "}",
11688             format("{\n"
11689                    "/* aaaa\n"
11690                    "\t bbbb */\n"
11691                    "}",
11692                    Tab));
11693   EXPECT_EQ("{\n"
11694             "\t/*\n"
11695             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11696             "\t\tbbbbbbbbbbbbb\n"
11697             "\t*/\n"
11698             "}",
11699             format("{\n"
11700                    "/*\n"
11701                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11702                    "*/\n"
11703                    "}",
11704                    Tab));
11705   Tab.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
11706   Tab.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
11707   Tab.TabWidth = 4;
11708   Tab.IndentWidth = 4;
11709   verifyFormat("class Assign {\n"
11710                "\tvoid f() {\n"
11711                "\t\tint         x      = 123;\n"
11712                "\t\tint         random = 4;\n"
11713                "\t\tstd::string alphabet =\n"
11714                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11715                "\t}\n"
11716                "};",
11717                Tab);
11718 
11719   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11720   Tab.TabWidth = 8;
11721   Tab.IndentWidth = 8;
11722   EXPECT_EQ("if (aaaaaaaa && // q\n"
11723             "    bb)         // w\n"
11724             "\t;",
11725             format("if (aaaaaaaa &&// q\n"
11726                    "bb)// w\n"
11727                    ";",
11728                    Tab));
11729   EXPECT_EQ("if (aaa && bbb) // w\n"
11730             "\t;",
11731             format("if(aaa&&bbb)// w\n"
11732                    ";",
11733                    Tab));
11734   verifyFormat("class X {\n"
11735                "\tvoid f() {\n"
11736                "\t\tsomeFunction(parameter1,\n"
11737                "\t\t             parameter2);\n"
11738                "\t}\n"
11739                "};",
11740                Tab);
11741   verifyFormat("#define A                        \\\n"
11742                "\tvoid f() {               \\\n"
11743                "\t\tsomeFunction(    \\\n"
11744                "\t\t    parameter1,  \\\n"
11745                "\t\t    parameter2); \\\n"
11746                "\t}",
11747                Tab);
11748   Tab.TabWidth = 4;
11749   Tab.IndentWidth = 8;
11750   verifyFormat("class TabWidth4Indent8 {\n"
11751                "\t\tvoid f() {\n"
11752                "\t\t\t\tsomeFunction(parameter1,\n"
11753                "\t\t\t\t             parameter2);\n"
11754                "\t\t}\n"
11755                "};",
11756                Tab);
11757   Tab.TabWidth = 4;
11758   Tab.IndentWidth = 4;
11759   verifyFormat("class TabWidth4Indent4 {\n"
11760                "\tvoid f() {\n"
11761                "\t\tsomeFunction(parameter1,\n"
11762                "\t\t             parameter2);\n"
11763                "\t}\n"
11764                "};",
11765                Tab);
11766   Tab.TabWidth = 8;
11767   Tab.IndentWidth = 4;
11768   verifyFormat("class TabWidth8Indent4 {\n"
11769                "    void f() {\n"
11770                "\tsomeFunction(parameter1,\n"
11771                "\t             parameter2);\n"
11772                "    }\n"
11773                "};",
11774                Tab);
11775   Tab.TabWidth = 8;
11776   Tab.IndentWidth = 8;
11777   EXPECT_EQ("/*\n"
11778             "              a\t\tcomment\n"
11779             "              in multiple lines\n"
11780             "       */",
11781             format("   /*\t \t \n"
11782                    " \t \t a\t\tcomment\t \t\n"
11783                    " \t \t in multiple lines\t\n"
11784                    " \t  */",
11785                    Tab));
11786   verifyFormat("{\n"
11787                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11788                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11789                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11790                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11791                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11792                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11793                "};",
11794                Tab);
11795   verifyFormat("enum AA {\n"
11796                "\ta1, // Force multiple lines\n"
11797                "\ta2,\n"
11798                "\ta3\n"
11799                "};",
11800                Tab);
11801   EXPECT_EQ("if (aaaaaaaa && // q\n"
11802             "    bb)         // w\n"
11803             "\t;",
11804             format("if (aaaaaaaa &&// q\n"
11805                    "bb)// w\n"
11806                    ";",
11807                    Tab));
11808   verifyFormat("class X {\n"
11809                "\tvoid f() {\n"
11810                "\t\tsomeFunction(parameter1,\n"
11811                "\t\t             parameter2);\n"
11812                "\t}\n"
11813                "};",
11814                Tab);
11815   verifyFormat("{\n"
11816                "\tQ(\n"
11817                "\t    {\n"
11818                "\t\t    int a;\n"
11819                "\t\t    someFunction(aaaaaaaa,\n"
11820                "\t\t                 bbbbbbb);\n"
11821                "\t    },\n"
11822                "\t    p);\n"
11823                "}",
11824                Tab);
11825   EXPECT_EQ("{\n"
11826             "\t/* aaaa\n"
11827             "\t   bbbb */\n"
11828             "}",
11829             format("{\n"
11830                    "/* aaaa\n"
11831                    "   bbbb */\n"
11832                    "}",
11833                    Tab));
11834   EXPECT_EQ("{\n"
11835             "\t/*\n"
11836             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11837             "\t  bbbbbbbbbbbbb\n"
11838             "\t*/\n"
11839             "}",
11840             format("{\n"
11841                    "/*\n"
11842                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11843                    "*/\n"
11844                    "}",
11845                    Tab));
11846   EXPECT_EQ("{\n"
11847             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11848             "\t// bbbbbbbbbbbbb\n"
11849             "}",
11850             format("{\n"
11851                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11852                    "}",
11853                    Tab));
11854   EXPECT_EQ("{\n"
11855             "\t/*\n"
11856             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11857             "\t  bbbbbbbbbbbbb\n"
11858             "\t*/\n"
11859             "}",
11860             format("{\n"
11861                    "\t/*\n"
11862                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11863                    "\t*/\n"
11864                    "}",
11865                    Tab));
11866   EXPECT_EQ("{\n"
11867             "\t/*\n"
11868             "\n"
11869             "\t*/\n"
11870             "}",
11871             format("{\n"
11872                    "\t/*\n"
11873                    "\n"
11874                    "\t*/\n"
11875                    "}",
11876                    Tab));
11877   EXPECT_EQ("{\n"
11878             "\t/*\n"
11879             " asdf\n"
11880             "\t*/\n"
11881             "}",
11882             format("{\n"
11883                    "\t/*\n"
11884                    " asdf\n"
11885                    "\t*/\n"
11886                    "}",
11887                    Tab));
11888   EXPECT_EQ("/* some\n"
11889             "   comment */",
11890             format(" \t \t /* some\n"
11891                    " \t \t    comment */",
11892                    Tab));
11893   EXPECT_EQ("int a; /* some\n"
11894             "   comment */",
11895             format(" \t \t int a; /* some\n"
11896                    " \t \t    comment */",
11897                    Tab));
11898   EXPECT_EQ("int a; /* some\n"
11899             "comment */",
11900             format(" \t \t int\ta; /* some\n"
11901                    " \t \t    comment */",
11902                    Tab));
11903   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11904             "    comment */",
11905             format(" \t \t f(\"\t\t\"); /* some\n"
11906                    " \t \t    comment */",
11907                    Tab));
11908   EXPECT_EQ("{\n"
11909             "\t/*\n"
11910             "\t * Comment\n"
11911             "\t */\n"
11912             "\tint i;\n"
11913             "}",
11914             format("{\n"
11915                    "\t/*\n"
11916                    "\t * Comment\n"
11917                    "\t */\n"
11918                    "\t int i;\n"
11919                    "}",
11920                    Tab));
11921   Tab.TabWidth = 2;
11922   Tab.IndentWidth = 2;
11923   EXPECT_EQ("{\n"
11924             "\t/* aaaa\n"
11925             "\t   bbbb */\n"
11926             "}",
11927             format("{\n"
11928                    "/* aaaa\n"
11929                    "   bbbb */\n"
11930                    "}",
11931                    Tab));
11932   EXPECT_EQ("{\n"
11933             "\t/*\n"
11934             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11935             "\t  bbbbbbbbbbbbb\n"
11936             "\t*/\n"
11937             "}",
11938             format("{\n"
11939                    "/*\n"
11940                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11941                    "*/\n"
11942                    "}",
11943                    Tab));
11944   Tab.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
11945   Tab.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
11946   Tab.TabWidth = 4;
11947   Tab.IndentWidth = 4;
11948   verifyFormat("class Assign {\n"
11949                "\tvoid f() {\n"
11950                "\t\tint         x      = 123;\n"
11951                "\t\tint         random = 4;\n"
11952                "\t\tstd::string alphabet =\n"
11953                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11954                "\t}\n"
11955                "};",
11956                Tab);
11957   Tab.AlignOperands = FormatStyle::OAS_Align;
11958   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb +\n"
11959                "                 cccccccccccccccccccc;",
11960                Tab);
11961   // no alignment
11962   verifyFormat("int aaaaaaaaaa =\n"
11963                "\tbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
11964                Tab);
11965   verifyFormat("return aaaaaaaaaaaaaaaa ? 111111111111111\n"
11966                "       : bbbbbbbbbbbbbb ? 222222222222222\n"
11967                "                        : 333333333333333;",
11968                Tab);
11969   Tab.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
11970   Tab.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
11971   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb\n"
11972                "               + cccccccccccccccccccc;",
11973                Tab);
11974 }
11975 
11976 TEST_F(FormatTest, ZeroTabWidth) {
11977   FormatStyle Tab = getLLVMStyleWithColumns(42);
11978   Tab.IndentWidth = 8;
11979   Tab.UseTab = FormatStyle::UT_Never;
11980   Tab.TabWidth = 0;
11981   EXPECT_EQ("void a(){\n"
11982             "    // line starts with '\t'\n"
11983             "};",
11984             format("void a(){\n"
11985                    "\t// line starts with '\t'\n"
11986                    "};",
11987                    Tab));
11988 
11989   EXPECT_EQ("void a(){\n"
11990             "    // line starts with '\t'\n"
11991             "};",
11992             format("void a(){\n"
11993                    "\t\t// line starts with '\t'\n"
11994                    "};",
11995                    Tab));
11996 
11997   Tab.UseTab = FormatStyle::UT_ForIndentation;
11998   EXPECT_EQ("void a(){\n"
11999             "    // line starts with '\t'\n"
12000             "};",
12001             format("void a(){\n"
12002                    "\t// line starts with '\t'\n"
12003                    "};",
12004                    Tab));
12005 
12006   EXPECT_EQ("void a(){\n"
12007             "    // line starts with '\t'\n"
12008             "};",
12009             format("void a(){\n"
12010                    "\t\t// line starts with '\t'\n"
12011                    "};",
12012                    Tab));
12013 
12014   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
12015   EXPECT_EQ("void a(){\n"
12016             "    // line starts with '\t'\n"
12017             "};",
12018             format("void a(){\n"
12019                    "\t// line starts with '\t'\n"
12020                    "};",
12021                    Tab));
12022 
12023   EXPECT_EQ("void a(){\n"
12024             "    // line starts with '\t'\n"
12025             "};",
12026             format("void a(){\n"
12027                    "\t\t// line starts with '\t'\n"
12028                    "};",
12029                    Tab));
12030 
12031   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
12032   EXPECT_EQ("void a(){\n"
12033             "    // line starts with '\t'\n"
12034             "};",
12035             format("void a(){\n"
12036                    "\t// line starts with '\t'\n"
12037                    "};",
12038                    Tab));
12039 
12040   EXPECT_EQ("void a(){\n"
12041             "    // line starts with '\t'\n"
12042             "};",
12043             format("void a(){\n"
12044                    "\t\t// line starts with '\t'\n"
12045                    "};",
12046                    Tab));
12047 
12048   Tab.UseTab = FormatStyle::UT_Always;
12049   EXPECT_EQ("void a(){\n"
12050             "// line starts with '\t'\n"
12051             "};",
12052             format("void a(){\n"
12053                    "\t// line starts with '\t'\n"
12054                    "};",
12055                    Tab));
12056 
12057   EXPECT_EQ("void a(){\n"
12058             "// line starts with '\t'\n"
12059             "};",
12060             format("void a(){\n"
12061                    "\t\t// line starts with '\t'\n"
12062                    "};",
12063                    Tab));
12064 }
12065 
12066 TEST_F(FormatTest, CalculatesOriginalColumn) {
12067   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12068             "q\"; /* some\n"
12069             "       comment */",
12070             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12071                    "q\"; /* some\n"
12072                    "       comment */",
12073                    getLLVMStyle()));
12074   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
12075             "/* some\n"
12076             "   comment */",
12077             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
12078                    " /* some\n"
12079                    "    comment */",
12080                    getLLVMStyle()));
12081   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12082             "qqq\n"
12083             "/* some\n"
12084             "   comment */",
12085             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12086                    "qqq\n"
12087                    " /* some\n"
12088                    "    comment */",
12089                    getLLVMStyle()));
12090   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12091             "wwww; /* some\n"
12092             "         comment */",
12093             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
12094                    "wwww; /* some\n"
12095                    "         comment */",
12096                    getLLVMStyle()));
12097 }
12098 
12099 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
12100   FormatStyle NoSpace = getLLVMStyle();
12101   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
12102 
12103   verifyFormat("while(true)\n"
12104                "  continue;",
12105                NoSpace);
12106   verifyFormat("for(;;)\n"
12107                "  continue;",
12108                NoSpace);
12109   verifyFormat("if(true)\n"
12110                "  f();\n"
12111                "else if(true)\n"
12112                "  f();",
12113                NoSpace);
12114   verifyFormat("do {\n"
12115                "  do_something();\n"
12116                "} while(something());",
12117                NoSpace);
12118   verifyFormat("switch(x) {\n"
12119                "default:\n"
12120                "  break;\n"
12121                "}",
12122                NoSpace);
12123   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
12124   verifyFormat("size_t x = sizeof(x);", NoSpace);
12125   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
12126   verifyFormat("auto f(int x) -> typeof(x);", NoSpace);
12127   verifyFormat("auto f(int x) -> _Atomic(x);", NoSpace);
12128   verifyFormat("auto f(int x) -> __underlying_type(x);", NoSpace);
12129   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
12130   verifyFormat("alignas(128) char a[128];", NoSpace);
12131   verifyFormat("size_t x = alignof(MyType);", NoSpace);
12132   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
12133   verifyFormat("int f() throw(Deprecated);", NoSpace);
12134   verifyFormat("typedef void (*cb)(int);", NoSpace);
12135   verifyFormat("T A::operator()();", NoSpace);
12136   verifyFormat("X A::operator++(T);", NoSpace);
12137   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
12138 
12139   FormatStyle Space = getLLVMStyle();
12140   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
12141 
12142   verifyFormat("int f ();", Space);
12143   verifyFormat("void f (int a, T b) {\n"
12144                "  while (true)\n"
12145                "    continue;\n"
12146                "}",
12147                Space);
12148   verifyFormat("if (true)\n"
12149                "  f ();\n"
12150                "else if (true)\n"
12151                "  f ();",
12152                Space);
12153   verifyFormat("do {\n"
12154                "  do_something ();\n"
12155                "} while (something ());",
12156                Space);
12157   verifyFormat("switch (x) {\n"
12158                "default:\n"
12159                "  break;\n"
12160                "}",
12161                Space);
12162   verifyFormat("A::A () : a (1) {}", Space);
12163   verifyFormat("void f () __attribute__ ((asdf));", Space);
12164   verifyFormat("*(&a + 1);\n"
12165                "&((&a)[1]);\n"
12166                "a[(b + c) * d];\n"
12167                "(((a + 1) * 2) + 3) * 4;",
12168                Space);
12169   verifyFormat("#define A(x) x", Space);
12170   verifyFormat("#define A (x) x", Space);
12171   verifyFormat("#if defined(x)\n"
12172                "#endif",
12173                Space);
12174   verifyFormat("auto i = std::make_unique<int> (5);", Space);
12175   verifyFormat("size_t x = sizeof (x);", Space);
12176   verifyFormat("auto f (int x) -> decltype (x);", Space);
12177   verifyFormat("auto f (int x) -> typeof (x);", Space);
12178   verifyFormat("auto f (int x) -> _Atomic (x);", Space);
12179   verifyFormat("auto f (int x) -> __underlying_type (x);", Space);
12180   verifyFormat("int f (T x) noexcept (x.create ());", Space);
12181   verifyFormat("alignas (128) char a[128];", Space);
12182   verifyFormat("size_t x = alignof (MyType);", Space);
12183   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
12184   verifyFormat("int f () throw (Deprecated);", Space);
12185   verifyFormat("typedef void (*cb) (int);", Space);
12186   verifyFormat("T A::operator() ();", Space);
12187   verifyFormat("X A::operator++ (T);", Space);
12188   verifyFormat("auto lambda = [] () { return 0; };", Space);
12189   verifyFormat("int x = int (y);", Space);
12190 
12191   FormatStyle SomeSpace = getLLVMStyle();
12192   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
12193 
12194   verifyFormat("[]() -> float {}", SomeSpace);
12195   verifyFormat("[] (auto foo) {}", SomeSpace);
12196   verifyFormat("[foo]() -> int {}", SomeSpace);
12197   verifyFormat("int f();", SomeSpace);
12198   verifyFormat("void f (int a, T b) {\n"
12199                "  while (true)\n"
12200                "    continue;\n"
12201                "}",
12202                SomeSpace);
12203   verifyFormat("if (true)\n"
12204                "  f();\n"
12205                "else if (true)\n"
12206                "  f();",
12207                SomeSpace);
12208   verifyFormat("do {\n"
12209                "  do_something();\n"
12210                "} while (something());",
12211                SomeSpace);
12212   verifyFormat("switch (x) {\n"
12213                "default:\n"
12214                "  break;\n"
12215                "}",
12216                SomeSpace);
12217   verifyFormat("A::A() : a (1) {}", SomeSpace);
12218   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
12219   verifyFormat("*(&a + 1);\n"
12220                "&((&a)[1]);\n"
12221                "a[(b + c) * d];\n"
12222                "(((a + 1) * 2) + 3) * 4;",
12223                SomeSpace);
12224   verifyFormat("#define A(x) x", SomeSpace);
12225   verifyFormat("#define A (x) x", SomeSpace);
12226   verifyFormat("#if defined(x)\n"
12227                "#endif",
12228                SomeSpace);
12229   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
12230   verifyFormat("size_t x = sizeof (x);", SomeSpace);
12231   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
12232   verifyFormat("auto f (int x) -> typeof (x);", SomeSpace);
12233   verifyFormat("auto f (int x) -> _Atomic (x);", SomeSpace);
12234   verifyFormat("auto f (int x) -> __underlying_type (x);", SomeSpace);
12235   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
12236   verifyFormat("alignas (128) char a[128];", SomeSpace);
12237   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
12238   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
12239                SomeSpace);
12240   verifyFormat("int f() throw (Deprecated);", SomeSpace);
12241   verifyFormat("typedef void (*cb) (int);", SomeSpace);
12242   verifyFormat("T A::operator()();", SomeSpace);
12243   verifyFormat("X A::operator++ (T);", SomeSpace);
12244   verifyFormat("int x = int (y);", SomeSpace);
12245   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
12246 }
12247 
12248 TEST_F(FormatTest, SpaceAfterLogicalNot) {
12249   FormatStyle Spaces = getLLVMStyle();
12250   Spaces.SpaceAfterLogicalNot = true;
12251 
12252   verifyFormat("bool x = ! y", Spaces);
12253   verifyFormat("if (! isFailure())", Spaces);
12254   verifyFormat("if (! (a && b))", Spaces);
12255   verifyFormat("\"Error!\"", Spaces);
12256   verifyFormat("! ! x", Spaces);
12257 }
12258 
12259 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
12260   FormatStyle Spaces = getLLVMStyle();
12261 
12262   Spaces.SpacesInParentheses = true;
12263   verifyFormat("do_something( ::globalVar );", Spaces);
12264   verifyFormat("call( x, y, z );", Spaces);
12265   verifyFormat("call();", Spaces);
12266   verifyFormat("std::function<void( int, int )> callback;", Spaces);
12267   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
12268                Spaces);
12269   verifyFormat("while ( (bool)1 )\n"
12270                "  continue;",
12271                Spaces);
12272   verifyFormat("for ( ;; )\n"
12273                "  continue;",
12274                Spaces);
12275   verifyFormat("if ( true )\n"
12276                "  f();\n"
12277                "else if ( true )\n"
12278                "  f();",
12279                Spaces);
12280   verifyFormat("do {\n"
12281                "  do_something( (int)i );\n"
12282                "} while ( something() );",
12283                Spaces);
12284   verifyFormat("switch ( x ) {\n"
12285                "default:\n"
12286                "  break;\n"
12287                "}",
12288                Spaces);
12289 
12290   Spaces.SpacesInParentheses = false;
12291   Spaces.SpacesInCStyleCastParentheses = true;
12292   verifyFormat("Type *A = ( Type * )P;", Spaces);
12293   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
12294   verifyFormat("x = ( int32 )y;", Spaces);
12295   verifyFormat("int a = ( int )(2.0f);", Spaces);
12296   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
12297   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
12298   verifyFormat("#define x (( int )-1)", Spaces);
12299 
12300   // Run the first set of tests again with:
12301   Spaces.SpacesInParentheses = false;
12302   Spaces.SpaceInEmptyParentheses = true;
12303   Spaces.SpacesInCStyleCastParentheses = true;
12304   verifyFormat("call(x, y, z);", Spaces);
12305   verifyFormat("call( );", Spaces);
12306   verifyFormat("std::function<void(int, int)> callback;", Spaces);
12307   verifyFormat("while (( bool )1)\n"
12308                "  continue;",
12309                Spaces);
12310   verifyFormat("for (;;)\n"
12311                "  continue;",
12312                Spaces);
12313   verifyFormat("if (true)\n"
12314                "  f( );\n"
12315                "else if (true)\n"
12316                "  f( );",
12317                Spaces);
12318   verifyFormat("do {\n"
12319                "  do_something(( int )i);\n"
12320                "} while (something( ));",
12321                Spaces);
12322   verifyFormat("switch (x) {\n"
12323                "default:\n"
12324                "  break;\n"
12325                "}",
12326                Spaces);
12327 
12328   // Run the first set of tests again with:
12329   Spaces.SpaceAfterCStyleCast = true;
12330   verifyFormat("call(x, y, z);", Spaces);
12331   verifyFormat("call( );", Spaces);
12332   verifyFormat("std::function<void(int, int)> callback;", Spaces);
12333   verifyFormat("while (( bool ) 1)\n"
12334                "  continue;",
12335                Spaces);
12336   verifyFormat("for (;;)\n"
12337                "  continue;",
12338                Spaces);
12339   verifyFormat("if (true)\n"
12340                "  f( );\n"
12341                "else if (true)\n"
12342                "  f( );",
12343                Spaces);
12344   verifyFormat("do {\n"
12345                "  do_something(( int ) i);\n"
12346                "} while (something( ));",
12347                Spaces);
12348   verifyFormat("switch (x) {\n"
12349                "default:\n"
12350                "  break;\n"
12351                "}",
12352                Spaces);
12353 
12354   // Run subset of tests again with:
12355   Spaces.SpacesInCStyleCastParentheses = false;
12356   Spaces.SpaceAfterCStyleCast = true;
12357   verifyFormat("while ((bool) 1)\n"
12358                "  continue;",
12359                Spaces);
12360   verifyFormat("do {\n"
12361                "  do_something((int) i);\n"
12362                "} while (something( ));",
12363                Spaces);
12364 
12365   verifyFormat("size_t idx = (size_t) (ptr - ((char *) file));", Spaces);
12366   verifyFormat("size_t idx = (size_t) a;", Spaces);
12367   verifyFormat("size_t idx = (size_t) (a - 1);", Spaces);
12368   verifyFormat("size_t idx = (a->*foo)(a - 1);", Spaces);
12369   verifyFormat("size_t idx = (a->foo)(a - 1);", Spaces);
12370   verifyFormat("size_t idx = (*foo)(a - 1);", Spaces);
12371   Spaces.SpaceAfterCStyleCast = false;
12372   verifyFormat("size_t idx = (size_t)(ptr - ((char *)file));", Spaces);
12373   verifyFormat("size_t idx = (size_t)a;", Spaces);
12374   verifyFormat("size_t idx = (size_t)(a - 1);", Spaces);
12375   verifyFormat("size_t idx = (a->*foo)(a - 1);", Spaces);
12376   verifyFormat("size_t idx = (a->foo)(a - 1);", Spaces);
12377   verifyFormat("size_t idx = (*foo)(a - 1);", Spaces);
12378 }
12379 
12380 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
12381   verifyFormat("int a[5];");
12382   verifyFormat("a[3] += 42;");
12383 
12384   FormatStyle Spaces = getLLVMStyle();
12385   Spaces.SpacesInSquareBrackets = true;
12386   // Not lambdas.
12387   verifyFormat("int a[ 5 ];", Spaces);
12388   verifyFormat("a[ 3 ] += 42;", Spaces);
12389   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
12390   verifyFormat("double &operator[](int i) { return 0; }\n"
12391                "int i;",
12392                Spaces);
12393   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
12394   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
12395   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
12396   // Lambdas.
12397   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
12398   verifyFormat("return [ i, args... ] {};", Spaces);
12399   verifyFormat("int foo = [ &bar ]() {};", Spaces);
12400   verifyFormat("int foo = [ = ]() {};", Spaces);
12401   verifyFormat("int foo = [ & ]() {};", Spaces);
12402   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
12403   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
12404 }
12405 
12406 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
12407   FormatStyle NoSpaceStyle = getLLVMStyle();
12408   verifyFormat("int a[5];", NoSpaceStyle);
12409   verifyFormat("a[3] += 42;", NoSpaceStyle);
12410 
12411   verifyFormat("int a[1];", NoSpaceStyle);
12412   verifyFormat("int 1 [a];", NoSpaceStyle);
12413   verifyFormat("int a[1][2];", NoSpaceStyle);
12414   verifyFormat("a[7] = 5;", NoSpaceStyle);
12415   verifyFormat("int a = (f())[23];", NoSpaceStyle);
12416   verifyFormat("f([] {})", NoSpaceStyle);
12417 
12418   FormatStyle Space = getLLVMStyle();
12419   Space.SpaceBeforeSquareBrackets = true;
12420   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
12421   verifyFormat("return [i, args...] {};", Space);
12422 
12423   verifyFormat("int a [5];", Space);
12424   verifyFormat("a [3] += 42;", Space);
12425   verifyFormat("constexpr char hello []{\"hello\"};", Space);
12426   verifyFormat("double &operator[](int i) { return 0; }\n"
12427                "int i;",
12428                Space);
12429   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
12430   verifyFormat("int i = a [a][a]->f();", Space);
12431   verifyFormat("int i = (*b) [a]->f();", Space);
12432 
12433   verifyFormat("int a [1];", Space);
12434   verifyFormat("int 1 [a];", Space);
12435   verifyFormat("int a [1][2];", Space);
12436   verifyFormat("a [7] = 5;", Space);
12437   verifyFormat("int a = (f()) [23];", Space);
12438   verifyFormat("f([] {})", Space);
12439 }
12440 
12441 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
12442   verifyFormat("int a = 5;");
12443   verifyFormat("a += 42;");
12444   verifyFormat("a or_eq 8;");
12445 
12446   FormatStyle Spaces = getLLVMStyle();
12447   Spaces.SpaceBeforeAssignmentOperators = false;
12448   verifyFormat("int a= 5;", Spaces);
12449   verifyFormat("a+= 42;", Spaces);
12450   verifyFormat("a or_eq 8;", Spaces);
12451 }
12452 
12453 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
12454   verifyFormat("class Foo : public Bar {};");
12455   verifyFormat("Foo::Foo() : foo(1) {}");
12456   verifyFormat("for (auto a : b) {\n}");
12457   verifyFormat("int x = a ? b : c;");
12458   verifyFormat("{\n"
12459                "label0:\n"
12460                "  int x = 0;\n"
12461                "}");
12462   verifyFormat("switch (x) {\n"
12463                "case 1:\n"
12464                "default:\n"
12465                "}");
12466   verifyFormat("switch (allBraces) {\n"
12467                "case 1: {\n"
12468                "  break;\n"
12469                "}\n"
12470                "case 2: {\n"
12471                "  [[fallthrough]];\n"
12472                "}\n"
12473                "default: {\n"
12474                "  break;\n"
12475                "}\n"
12476                "}");
12477 
12478   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
12479   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
12480   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
12481   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
12482   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
12483   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
12484   verifyFormat("{\n"
12485                "label1:\n"
12486                "  int x = 0;\n"
12487                "}",
12488                CtorInitializerStyle);
12489   verifyFormat("switch (x) {\n"
12490                "case 1:\n"
12491                "default:\n"
12492                "}",
12493                CtorInitializerStyle);
12494   verifyFormat("switch (allBraces) {\n"
12495                "case 1: {\n"
12496                "  break;\n"
12497                "}\n"
12498                "case 2: {\n"
12499                "  [[fallthrough]];\n"
12500                "}\n"
12501                "default: {\n"
12502                "  break;\n"
12503                "}\n"
12504                "}",
12505                CtorInitializerStyle);
12506   CtorInitializerStyle.BreakConstructorInitializers =
12507       FormatStyle::BCIS_AfterColon;
12508   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
12509                "    aaaaaaaaaaaaaaaa(1),\n"
12510                "    bbbbbbbbbbbbbbbb(2) {}",
12511                CtorInitializerStyle);
12512   CtorInitializerStyle.BreakConstructorInitializers =
12513       FormatStyle::BCIS_BeforeComma;
12514   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12515                "    : aaaaaaaaaaaaaaaa(1)\n"
12516                "    , bbbbbbbbbbbbbbbb(2) {}",
12517                CtorInitializerStyle);
12518   CtorInitializerStyle.BreakConstructorInitializers =
12519       FormatStyle::BCIS_BeforeColon;
12520   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12521                "    : aaaaaaaaaaaaaaaa(1),\n"
12522                "      bbbbbbbbbbbbbbbb(2) {}",
12523                CtorInitializerStyle);
12524   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
12525   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12526                ": aaaaaaaaaaaaaaaa(1),\n"
12527                "  bbbbbbbbbbbbbbbb(2) {}",
12528                CtorInitializerStyle);
12529 
12530   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
12531   InheritanceStyle.SpaceBeforeInheritanceColon = false;
12532   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
12533   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
12534   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
12535   verifyFormat("int x = a ? b : c;", InheritanceStyle);
12536   verifyFormat("{\n"
12537                "label2:\n"
12538                "  int x = 0;\n"
12539                "}",
12540                InheritanceStyle);
12541   verifyFormat("switch (x) {\n"
12542                "case 1:\n"
12543                "default:\n"
12544                "}",
12545                InheritanceStyle);
12546   verifyFormat("switch (allBraces) {\n"
12547                "case 1: {\n"
12548                "  break;\n"
12549                "}\n"
12550                "case 2: {\n"
12551                "  [[fallthrough]];\n"
12552                "}\n"
12553                "default: {\n"
12554                "  break;\n"
12555                "}\n"
12556                "}",
12557                InheritanceStyle);
12558   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
12559   verifyFormat("class Foooooooooooooooooooooo:\n"
12560                "    public aaaaaaaaaaaaaaaaaa,\n"
12561                "    public bbbbbbbbbbbbbbbbbb {\n"
12562                "}",
12563                InheritanceStyle);
12564   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
12565   verifyFormat("class Foooooooooooooooooooooo\n"
12566                "    : public aaaaaaaaaaaaaaaaaa\n"
12567                "    , public bbbbbbbbbbbbbbbbbb {\n"
12568                "}",
12569                InheritanceStyle);
12570   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
12571   verifyFormat("class Foooooooooooooooooooooo\n"
12572                "    : public aaaaaaaaaaaaaaaaaa,\n"
12573                "      public bbbbbbbbbbbbbbbbbb {\n"
12574                "}",
12575                InheritanceStyle);
12576   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
12577   verifyFormat("class Foooooooooooooooooooooo\n"
12578                ": public aaaaaaaaaaaaaaaaaa,\n"
12579                "  public bbbbbbbbbbbbbbbbbb {}",
12580                InheritanceStyle);
12581 
12582   FormatStyle ForLoopStyle = getLLVMStyle();
12583   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
12584   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
12585   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
12586   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
12587   verifyFormat("int x = a ? b : c;", ForLoopStyle);
12588   verifyFormat("{\n"
12589                "label2:\n"
12590                "  int x = 0;\n"
12591                "}",
12592                ForLoopStyle);
12593   verifyFormat("switch (x) {\n"
12594                "case 1:\n"
12595                "default:\n"
12596                "}",
12597                ForLoopStyle);
12598   verifyFormat("switch (allBraces) {\n"
12599                "case 1: {\n"
12600                "  break;\n"
12601                "}\n"
12602                "case 2: {\n"
12603                "  [[fallthrough]];\n"
12604                "}\n"
12605                "default: {\n"
12606                "  break;\n"
12607                "}\n"
12608                "}",
12609                ForLoopStyle);
12610 
12611   FormatStyle CaseStyle = getLLVMStyle();
12612   CaseStyle.SpaceBeforeCaseColon = true;
12613   verifyFormat("class Foo : public Bar {};", CaseStyle);
12614   verifyFormat("Foo::Foo() : foo(1) {}", CaseStyle);
12615   verifyFormat("for (auto a : b) {\n}", CaseStyle);
12616   verifyFormat("int x = a ? b : c;", CaseStyle);
12617   verifyFormat("switch (x) {\n"
12618                "case 1 :\n"
12619                "default :\n"
12620                "}",
12621                CaseStyle);
12622   verifyFormat("switch (allBraces) {\n"
12623                "case 1 : {\n"
12624                "  break;\n"
12625                "}\n"
12626                "case 2 : {\n"
12627                "  [[fallthrough]];\n"
12628                "}\n"
12629                "default : {\n"
12630                "  break;\n"
12631                "}\n"
12632                "}",
12633                CaseStyle);
12634 
12635   FormatStyle NoSpaceStyle = getLLVMStyle();
12636   EXPECT_EQ(NoSpaceStyle.SpaceBeforeCaseColon, false);
12637   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
12638   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
12639   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
12640   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
12641   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
12642   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
12643   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
12644   verifyFormat("{\n"
12645                "label3:\n"
12646                "  int x = 0;\n"
12647                "}",
12648                NoSpaceStyle);
12649   verifyFormat("switch (x) {\n"
12650                "case 1:\n"
12651                "default:\n"
12652                "}",
12653                NoSpaceStyle);
12654   verifyFormat("switch (allBraces) {\n"
12655                "case 1: {\n"
12656                "  break;\n"
12657                "}\n"
12658                "case 2: {\n"
12659                "  [[fallthrough]];\n"
12660                "}\n"
12661                "default: {\n"
12662                "  break;\n"
12663                "}\n"
12664                "}",
12665                NoSpaceStyle);
12666 
12667   FormatStyle InvertedSpaceStyle = getLLVMStyle();
12668   InvertedSpaceStyle.SpaceBeforeCaseColon = true;
12669   InvertedSpaceStyle.SpaceBeforeCtorInitializerColon = false;
12670   InvertedSpaceStyle.SpaceBeforeInheritanceColon = false;
12671   InvertedSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
12672   verifyFormat("class Foo: public Bar {};", InvertedSpaceStyle);
12673   verifyFormat("Foo::Foo(): foo(1) {}", InvertedSpaceStyle);
12674   verifyFormat("for (auto a: b) {\n}", InvertedSpaceStyle);
12675   verifyFormat("int x = a ? b : c;", InvertedSpaceStyle);
12676   verifyFormat("{\n"
12677                "label3:\n"
12678                "  int x = 0;\n"
12679                "}",
12680                InvertedSpaceStyle);
12681   verifyFormat("switch (x) {\n"
12682                "case 1 :\n"
12683                "case 2 : {\n"
12684                "  break;\n"
12685                "}\n"
12686                "default :\n"
12687                "  break;\n"
12688                "}",
12689                InvertedSpaceStyle);
12690   verifyFormat("switch (allBraces) {\n"
12691                "case 1 : {\n"
12692                "  break;\n"
12693                "}\n"
12694                "case 2 : {\n"
12695                "  [[fallthrough]];\n"
12696                "}\n"
12697                "default : {\n"
12698                "  break;\n"
12699                "}\n"
12700                "}",
12701                InvertedSpaceStyle);
12702 }
12703 
12704 TEST_F(FormatTest, ConfigurableSpaceAroundPointerQualifiers) {
12705   FormatStyle Style = getLLVMStyle();
12706 
12707   Style.PointerAlignment = FormatStyle::PAS_Left;
12708   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
12709   verifyFormat("void* const* x = NULL;", Style);
12710 
12711 #define verifyQualifierSpaces(Code, Pointers, Qualifiers)                      \
12712   do {                                                                         \
12713     Style.PointerAlignment = FormatStyle::Pointers;                            \
12714     Style.SpaceAroundPointerQualifiers = FormatStyle::Qualifiers;              \
12715     verifyFormat(Code, Style);                                                 \
12716   } while (false)
12717 
12718   verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Default);
12719   verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_Default);
12720   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Default);
12721 
12722   verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Before);
12723   verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Before);
12724   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Before);
12725 
12726   verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_After);
12727   verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_After);
12728   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_After);
12729 
12730   verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_Both);
12731   verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Both);
12732   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Both);
12733 
12734   verifyQualifierSpaces("Foo::operator void const*();", PAS_Left, SAPQ_Default);
12735   verifyQualifierSpaces("Foo::operator void const *();", PAS_Right,
12736                         SAPQ_Default);
12737   verifyQualifierSpaces("Foo::operator void const *();", PAS_Middle,
12738                         SAPQ_Default);
12739 
12740   verifyQualifierSpaces("Foo::operator void const*();", PAS_Left, SAPQ_Before);
12741   verifyQualifierSpaces("Foo::operator void const *();", PAS_Right,
12742                         SAPQ_Before);
12743   verifyQualifierSpaces("Foo::operator void const *();", PAS_Middle,
12744                         SAPQ_Before);
12745 
12746   verifyQualifierSpaces("Foo::operator void const *();", PAS_Left, SAPQ_After);
12747   verifyQualifierSpaces("Foo::operator void const *();", PAS_Right, SAPQ_After);
12748   verifyQualifierSpaces("Foo::operator void const *();", PAS_Middle,
12749                         SAPQ_After);
12750 
12751   verifyQualifierSpaces("Foo::operator void const *();", PAS_Left, SAPQ_Both);
12752   verifyQualifierSpaces("Foo::operator void const *();", PAS_Right, SAPQ_Both);
12753   verifyQualifierSpaces("Foo::operator void const *();", PAS_Middle, SAPQ_Both);
12754 
12755 #undef verifyQualifierSpaces
12756 
12757   FormatStyle Spaces = getLLVMStyle();
12758   Spaces.AttributeMacros.push_back("qualified");
12759   Spaces.PointerAlignment = FormatStyle::PAS_Right;
12760   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
12761   verifyFormat("SomeType *volatile *a = NULL;", Spaces);
12762   verifyFormat("SomeType *__attribute__((attr)) *a = NULL;", Spaces);
12763   verifyFormat("std::vector<SomeType *const *> x;", Spaces);
12764   verifyFormat("std::vector<SomeType *qualified *> x;", Spaces);
12765   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12766   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
12767   verifyFormat("SomeType * volatile *a = NULL;", Spaces);
12768   verifyFormat("SomeType * __attribute__((attr)) *a = NULL;", Spaces);
12769   verifyFormat("std::vector<SomeType * const *> x;", Spaces);
12770   verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
12771   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12772 
12773   // Check that SAPQ_Before doesn't result in extra spaces for PAS_Left.
12774   Spaces.PointerAlignment = FormatStyle::PAS_Left;
12775   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
12776   verifyFormat("SomeType* volatile* a = NULL;", Spaces);
12777   verifyFormat("SomeType* __attribute__((attr))* a = NULL;", Spaces);
12778   verifyFormat("std::vector<SomeType* const*> x;", Spaces);
12779   verifyFormat("std::vector<SomeType* qualified*> x;", Spaces);
12780   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12781   // However, setting it to SAPQ_After should add spaces after __attribute, etc.
12782   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
12783   verifyFormat("SomeType* volatile * a = NULL;", Spaces);
12784   verifyFormat("SomeType* __attribute__((attr)) * a = NULL;", Spaces);
12785   verifyFormat("std::vector<SomeType* const *> x;", Spaces);
12786   verifyFormat("std::vector<SomeType* qualified *> x;", Spaces);
12787   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12788 
12789   // PAS_Middle should not have any noticeable changes even for SAPQ_Both
12790   Spaces.PointerAlignment = FormatStyle::PAS_Middle;
12791   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
12792   verifyFormat("SomeType * volatile * a = NULL;", Spaces);
12793   verifyFormat("SomeType * __attribute__((attr)) * a = NULL;", Spaces);
12794   verifyFormat("std::vector<SomeType * const *> x;", Spaces);
12795   verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
12796   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12797 }
12798 
12799 TEST_F(FormatTest, AlignConsecutiveMacros) {
12800   FormatStyle Style = getLLVMStyle();
12801   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
12802   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
12803   Style.AlignConsecutiveMacros = FormatStyle::ACS_None;
12804 
12805   verifyFormat("#define a 3\n"
12806                "#define bbbb 4\n"
12807                "#define ccc (5)",
12808                Style);
12809 
12810   verifyFormat("#define f(x) (x * x)\n"
12811                "#define fff(x, y, z) (x * y + z)\n"
12812                "#define ffff(x, y) (x - y)",
12813                Style);
12814 
12815   verifyFormat("#define foo(x, y) (x + y)\n"
12816                "#define bar (5, 6)(2 + 2)",
12817                Style);
12818 
12819   verifyFormat("#define a 3\n"
12820                "#define bbbb 4\n"
12821                "#define ccc (5)\n"
12822                "#define f(x) (x * x)\n"
12823                "#define fff(x, y, z) (x * y + z)\n"
12824                "#define ffff(x, y) (x - y)",
12825                Style);
12826 
12827   Style.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
12828   verifyFormat("#define a    3\n"
12829                "#define bbbb 4\n"
12830                "#define ccc  (5)",
12831                Style);
12832 
12833   verifyFormat("#define f(x)         (x * x)\n"
12834                "#define fff(x, y, z) (x * y + z)\n"
12835                "#define ffff(x, y)   (x - y)",
12836                Style);
12837 
12838   verifyFormat("#define foo(x, y) (x + y)\n"
12839                "#define bar       (5, 6)(2 + 2)",
12840                Style);
12841 
12842   verifyFormat("#define a            3\n"
12843                "#define bbbb         4\n"
12844                "#define ccc          (5)\n"
12845                "#define f(x)         (x * x)\n"
12846                "#define fff(x, y, z) (x * y + z)\n"
12847                "#define ffff(x, y)   (x - y)",
12848                Style);
12849 
12850   verifyFormat("#define a         5\n"
12851                "#define foo(x, y) (x + y)\n"
12852                "#define CCC       (6)\n"
12853                "auto lambda = []() {\n"
12854                "  auto  ii = 0;\n"
12855                "  float j  = 0;\n"
12856                "  return 0;\n"
12857                "};\n"
12858                "int   i  = 0;\n"
12859                "float i2 = 0;\n"
12860                "auto  v  = type{\n"
12861                "    i = 1,   //\n"
12862                "    (i = 2), //\n"
12863                "    i = 3    //\n"
12864                "};",
12865                Style);
12866 
12867   Style.AlignConsecutiveMacros = FormatStyle::ACS_None;
12868   Style.ColumnLimit = 20;
12869 
12870   verifyFormat("#define a          \\\n"
12871                "  \"aabbbbbbbbbbbb\"\n"
12872                "#define D          \\\n"
12873                "  \"aabbbbbbbbbbbb\" \\\n"
12874                "  \"ccddeeeeeeeee\"\n"
12875                "#define B          \\\n"
12876                "  \"QQQQQQQQQQQQQ\"  \\\n"
12877                "  \"FFFFFFFFFFFFF\"  \\\n"
12878                "  \"LLLLLLLL\"\n",
12879                Style);
12880 
12881   Style.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
12882   verifyFormat("#define a          \\\n"
12883                "  \"aabbbbbbbbbbbb\"\n"
12884                "#define D          \\\n"
12885                "  \"aabbbbbbbbbbbb\" \\\n"
12886                "  \"ccddeeeeeeeee\"\n"
12887                "#define B          \\\n"
12888                "  \"QQQQQQQQQQQQQ\"  \\\n"
12889                "  \"FFFFFFFFFFFFF\"  \\\n"
12890                "  \"LLLLLLLL\"\n",
12891                Style);
12892 
12893   // Test across comments
12894   Style.MaxEmptyLinesToKeep = 10;
12895   Style.ReflowComments = false;
12896   Style.AlignConsecutiveMacros = FormatStyle::ACS_AcrossComments;
12897   EXPECT_EQ("#define a    3\n"
12898             "// line comment\n"
12899             "#define bbbb 4\n"
12900             "#define ccc  (5)",
12901             format("#define a 3\n"
12902                    "// line comment\n"
12903                    "#define bbbb 4\n"
12904                    "#define ccc (5)",
12905                    Style));
12906 
12907   EXPECT_EQ("#define a    3\n"
12908             "/* block comment */\n"
12909             "#define bbbb 4\n"
12910             "#define ccc  (5)",
12911             format("#define a  3\n"
12912                    "/* block comment */\n"
12913                    "#define bbbb 4\n"
12914                    "#define ccc (5)",
12915                    Style));
12916 
12917   EXPECT_EQ("#define a    3\n"
12918             "/* multi-line *\n"
12919             " * block comment */\n"
12920             "#define bbbb 4\n"
12921             "#define ccc  (5)",
12922             format("#define a 3\n"
12923                    "/* multi-line *\n"
12924                    " * block comment */\n"
12925                    "#define bbbb 4\n"
12926                    "#define ccc (5)",
12927                    Style));
12928 
12929   EXPECT_EQ("#define a    3\n"
12930             "// multi-line line comment\n"
12931             "//\n"
12932             "#define bbbb 4\n"
12933             "#define ccc  (5)",
12934             format("#define a  3\n"
12935                    "// multi-line line comment\n"
12936                    "//\n"
12937                    "#define bbbb 4\n"
12938                    "#define ccc (5)",
12939                    Style));
12940 
12941   EXPECT_EQ("#define a 3\n"
12942             "// empty lines still break.\n"
12943             "\n"
12944             "#define bbbb 4\n"
12945             "#define ccc  (5)",
12946             format("#define a     3\n"
12947                    "// empty lines still break.\n"
12948                    "\n"
12949                    "#define bbbb     4\n"
12950                    "#define ccc  (5)",
12951                    Style));
12952 
12953   // Test across empty lines
12954   Style.AlignConsecutiveMacros = FormatStyle::ACS_AcrossEmptyLines;
12955   EXPECT_EQ("#define a    3\n"
12956             "\n"
12957             "#define bbbb 4\n"
12958             "#define ccc  (5)",
12959             format("#define a 3\n"
12960                    "\n"
12961                    "#define bbbb 4\n"
12962                    "#define ccc (5)",
12963                    Style));
12964 
12965   EXPECT_EQ("#define a    3\n"
12966             "\n"
12967             "\n"
12968             "\n"
12969             "#define bbbb 4\n"
12970             "#define ccc  (5)",
12971             format("#define a        3\n"
12972                    "\n"
12973                    "\n"
12974                    "\n"
12975                    "#define bbbb 4\n"
12976                    "#define ccc (5)",
12977                    Style));
12978 
12979   EXPECT_EQ("#define a 3\n"
12980             "// comments should break alignment\n"
12981             "//\n"
12982             "#define bbbb 4\n"
12983             "#define ccc  (5)",
12984             format("#define a        3\n"
12985                    "// comments should break alignment\n"
12986                    "//\n"
12987                    "#define bbbb 4\n"
12988                    "#define ccc (5)",
12989                    Style));
12990 
12991   // Test across empty lines and comments
12992   Style.AlignConsecutiveMacros = FormatStyle::ACS_AcrossEmptyLinesAndComments;
12993   verifyFormat("#define a    3\n"
12994                "\n"
12995                "// line comment\n"
12996                "#define bbbb 4\n"
12997                "#define ccc  (5)",
12998                Style);
12999 
13000   EXPECT_EQ("#define a    3\n"
13001             "\n"
13002             "\n"
13003             "/* multi-line *\n"
13004             " * block comment */\n"
13005             "\n"
13006             "\n"
13007             "#define bbbb 4\n"
13008             "#define ccc  (5)",
13009             format("#define a 3\n"
13010                    "\n"
13011                    "\n"
13012                    "/* multi-line *\n"
13013                    " * block comment */\n"
13014                    "\n"
13015                    "\n"
13016                    "#define bbbb 4\n"
13017                    "#define ccc (5)",
13018                    Style));
13019 
13020   EXPECT_EQ("#define a    3\n"
13021             "\n"
13022             "\n"
13023             "/* multi-line *\n"
13024             " * block comment */\n"
13025             "\n"
13026             "\n"
13027             "#define bbbb 4\n"
13028             "#define ccc  (5)",
13029             format("#define a 3\n"
13030                    "\n"
13031                    "\n"
13032                    "/* multi-line *\n"
13033                    " * block comment */\n"
13034                    "\n"
13035                    "\n"
13036                    "#define bbbb 4\n"
13037                    "#define ccc       (5)",
13038                    Style));
13039 }
13040 
13041 TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLines) {
13042   FormatStyle Alignment = getLLVMStyle();
13043   Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
13044   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_AcrossEmptyLines;
13045 
13046   Alignment.MaxEmptyLinesToKeep = 10;
13047   /* Test alignment across empty lines */
13048   EXPECT_EQ("int a           = 5;\n"
13049             "\n"
13050             "int oneTwoThree = 123;",
13051             format("int a       = 5;\n"
13052                    "\n"
13053                    "int oneTwoThree= 123;",
13054                    Alignment));
13055   EXPECT_EQ("int a           = 5;\n"
13056             "int one         = 1;\n"
13057             "\n"
13058             "int oneTwoThree = 123;",
13059             format("int a = 5;\n"
13060                    "int one = 1;\n"
13061                    "\n"
13062                    "int oneTwoThree = 123;",
13063                    Alignment));
13064   EXPECT_EQ("int a           = 5;\n"
13065             "int one         = 1;\n"
13066             "\n"
13067             "int oneTwoThree = 123;\n"
13068             "int oneTwo      = 12;",
13069             format("int a = 5;\n"
13070                    "int one = 1;\n"
13071                    "\n"
13072                    "int oneTwoThree = 123;\n"
13073                    "int oneTwo = 12;",
13074                    Alignment));
13075 
13076   /* Test across comments */
13077   EXPECT_EQ("int a = 5;\n"
13078             "/* block comment */\n"
13079             "int oneTwoThree = 123;",
13080             format("int a = 5;\n"
13081                    "/* block comment */\n"
13082                    "int oneTwoThree=123;",
13083                    Alignment));
13084 
13085   EXPECT_EQ("int a = 5;\n"
13086             "// line comment\n"
13087             "int oneTwoThree = 123;",
13088             format("int a = 5;\n"
13089                    "// line comment\n"
13090                    "int oneTwoThree=123;",
13091                    Alignment));
13092 
13093   /* Test across comments and newlines */
13094   EXPECT_EQ("int a = 5;\n"
13095             "\n"
13096             "/* block comment */\n"
13097             "int oneTwoThree = 123;",
13098             format("int a = 5;\n"
13099                    "\n"
13100                    "/* block comment */\n"
13101                    "int oneTwoThree=123;",
13102                    Alignment));
13103 
13104   EXPECT_EQ("int a = 5;\n"
13105             "\n"
13106             "// line comment\n"
13107             "int oneTwoThree = 123;",
13108             format("int a = 5;\n"
13109                    "\n"
13110                    "// line comment\n"
13111                    "int oneTwoThree=123;",
13112                    Alignment));
13113 }
13114 
13115 TEST_F(FormatTest, AlignConsecutiveDeclarationsAcrossEmptyLinesAndComments) {
13116   FormatStyle Alignment = getLLVMStyle();
13117   Alignment.AlignConsecutiveDeclarations =
13118       FormatStyle::ACS_AcrossEmptyLinesAndComments;
13119   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
13120 
13121   Alignment.MaxEmptyLinesToKeep = 10;
13122   /* Test alignment across empty lines */
13123   EXPECT_EQ("int         a = 5;\n"
13124             "\n"
13125             "float const oneTwoThree = 123;",
13126             format("int a = 5;\n"
13127                    "\n"
13128                    "float const oneTwoThree = 123;",
13129                    Alignment));
13130   EXPECT_EQ("int         a = 5;\n"
13131             "float const one = 1;\n"
13132             "\n"
13133             "int         oneTwoThree = 123;",
13134             format("int a = 5;\n"
13135                    "float const one = 1;\n"
13136                    "\n"
13137                    "int oneTwoThree = 123;",
13138                    Alignment));
13139 
13140   /* Test across comments */
13141   EXPECT_EQ("float const a = 5;\n"
13142             "/* block comment */\n"
13143             "int         oneTwoThree = 123;",
13144             format("float const a = 5;\n"
13145                    "/* block comment */\n"
13146                    "int oneTwoThree=123;",
13147                    Alignment));
13148 
13149   EXPECT_EQ("float const a = 5;\n"
13150             "// line comment\n"
13151             "int         oneTwoThree = 123;",
13152             format("float const a = 5;\n"
13153                    "// line comment\n"
13154                    "int oneTwoThree=123;",
13155                    Alignment));
13156 
13157   /* Test across comments and newlines */
13158   EXPECT_EQ("float const a = 5;\n"
13159             "\n"
13160             "/* block comment */\n"
13161             "int         oneTwoThree = 123;",
13162             format("float const a = 5;\n"
13163                    "\n"
13164                    "/* block comment */\n"
13165                    "int         oneTwoThree=123;",
13166                    Alignment));
13167 
13168   EXPECT_EQ("float const a = 5;\n"
13169             "\n"
13170             "// line comment\n"
13171             "int         oneTwoThree = 123;",
13172             format("float const a = 5;\n"
13173                    "\n"
13174                    "// line comment\n"
13175                    "int oneTwoThree=123;",
13176                    Alignment));
13177 }
13178 
13179 TEST_F(FormatTest, AlignConsecutiveBitFieldsAcrossEmptyLinesAndComments) {
13180   FormatStyle Alignment = getLLVMStyle();
13181   Alignment.AlignConsecutiveBitFields =
13182       FormatStyle::ACS_AcrossEmptyLinesAndComments;
13183 
13184   Alignment.MaxEmptyLinesToKeep = 10;
13185   /* Test alignment across empty lines */
13186   EXPECT_EQ("int a            : 5;\n"
13187             "\n"
13188             "int longbitfield : 6;",
13189             format("int a : 5;\n"
13190                    "\n"
13191                    "int longbitfield : 6;",
13192                    Alignment));
13193   EXPECT_EQ("int a            : 5;\n"
13194             "int one          : 1;\n"
13195             "\n"
13196             "int longbitfield : 6;",
13197             format("int a : 5;\n"
13198                    "int one : 1;\n"
13199                    "\n"
13200                    "int longbitfield : 6;",
13201                    Alignment));
13202 
13203   /* Test across comments */
13204   EXPECT_EQ("int a            : 5;\n"
13205             "/* block comment */\n"
13206             "int longbitfield : 6;",
13207             format("int a : 5;\n"
13208                    "/* block comment */\n"
13209                    "int longbitfield : 6;",
13210                    Alignment));
13211   EXPECT_EQ("int a            : 5;\n"
13212             "int one          : 1;\n"
13213             "// line comment\n"
13214             "int longbitfield : 6;",
13215             format("int a : 5;\n"
13216                    "int one : 1;\n"
13217                    "// line comment\n"
13218                    "int longbitfield : 6;",
13219                    Alignment));
13220 
13221   /* Test across comments and newlines */
13222   EXPECT_EQ("int a            : 5;\n"
13223             "/* block comment */\n"
13224             "\n"
13225             "int longbitfield : 6;",
13226             format("int a : 5;\n"
13227                    "/* block comment */\n"
13228                    "\n"
13229                    "int longbitfield : 6;",
13230                    Alignment));
13231   EXPECT_EQ("int a            : 5;\n"
13232             "int one          : 1;\n"
13233             "\n"
13234             "// line comment\n"
13235             "\n"
13236             "int longbitfield : 6;",
13237             format("int a : 5;\n"
13238                    "int one : 1;\n"
13239                    "\n"
13240                    "// line comment \n"
13241                    "\n"
13242                    "int longbitfield : 6;",
13243                    Alignment));
13244 }
13245 
13246 TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossComments) {
13247   FormatStyle Alignment = getLLVMStyle();
13248   Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
13249   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_AcrossComments;
13250 
13251   Alignment.MaxEmptyLinesToKeep = 10;
13252   /* Test alignment across empty lines */
13253   EXPECT_EQ("int a = 5;\n"
13254             "\n"
13255             "int oneTwoThree = 123;",
13256             format("int a       = 5;\n"
13257                    "\n"
13258                    "int oneTwoThree= 123;",
13259                    Alignment));
13260   EXPECT_EQ("int a   = 5;\n"
13261             "int one = 1;\n"
13262             "\n"
13263             "int oneTwoThree = 123;",
13264             format("int a = 5;\n"
13265                    "int one = 1;\n"
13266                    "\n"
13267                    "int oneTwoThree = 123;",
13268                    Alignment));
13269 
13270   /* Test across comments */
13271   EXPECT_EQ("int a           = 5;\n"
13272             "/* block comment */\n"
13273             "int oneTwoThree = 123;",
13274             format("int a = 5;\n"
13275                    "/* block comment */\n"
13276                    "int oneTwoThree=123;",
13277                    Alignment));
13278 
13279   EXPECT_EQ("int a           = 5;\n"
13280             "// line comment\n"
13281             "int oneTwoThree = 123;",
13282             format("int a = 5;\n"
13283                    "// line comment\n"
13284                    "int oneTwoThree=123;",
13285                    Alignment));
13286 
13287   EXPECT_EQ("int a           = 5;\n"
13288             "/*\n"
13289             " * multi-line block comment\n"
13290             " */\n"
13291             "int oneTwoThree = 123;",
13292             format("int a = 5;\n"
13293                    "/*\n"
13294                    " * multi-line block comment\n"
13295                    " */\n"
13296                    "int oneTwoThree=123;",
13297                    Alignment));
13298 
13299   EXPECT_EQ("int a           = 5;\n"
13300             "//\n"
13301             "// multi-line line comment\n"
13302             "//\n"
13303             "int oneTwoThree = 123;",
13304             format("int a = 5;\n"
13305                    "//\n"
13306                    "// multi-line line comment\n"
13307                    "//\n"
13308                    "int oneTwoThree=123;",
13309                    Alignment));
13310 
13311   /* Test across comments and newlines */
13312   EXPECT_EQ("int a = 5;\n"
13313             "\n"
13314             "/* block comment */\n"
13315             "int oneTwoThree = 123;",
13316             format("int a = 5;\n"
13317                    "\n"
13318                    "/* block comment */\n"
13319                    "int oneTwoThree=123;",
13320                    Alignment));
13321 
13322   EXPECT_EQ("int a = 5;\n"
13323             "\n"
13324             "// line comment\n"
13325             "int oneTwoThree = 123;",
13326             format("int a = 5;\n"
13327                    "\n"
13328                    "// line comment\n"
13329                    "int oneTwoThree=123;",
13330                    Alignment));
13331 }
13332 
13333 TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLinesAndComments) {
13334   FormatStyle Alignment = getLLVMStyle();
13335   Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
13336   Alignment.AlignConsecutiveAssignments =
13337       FormatStyle::ACS_AcrossEmptyLinesAndComments;
13338   verifyFormat("int a           = 5;\n"
13339                "int oneTwoThree = 123;",
13340                Alignment);
13341   verifyFormat("int a           = method();\n"
13342                "int oneTwoThree = 133;",
13343                Alignment);
13344   verifyFormat("a &= 5;\n"
13345                "bcd *= 5;\n"
13346                "ghtyf += 5;\n"
13347                "dvfvdb -= 5;\n"
13348                "a /= 5;\n"
13349                "vdsvsv %= 5;\n"
13350                "sfdbddfbdfbb ^= 5;\n"
13351                "dvsdsv |= 5;\n"
13352                "int dsvvdvsdvvv = 123;",
13353                Alignment);
13354   verifyFormat("int i = 1, j = 10;\n"
13355                "something = 2000;",
13356                Alignment);
13357   verifyFormat("something = 2000;\n"
13358                "int i = 1, j = 10;\n",
13359                Alignment);
13360   verifyFormat("something = 2000;\n"
13361                "another   = 911;\n"
13362                "int i = 1, j = 10;\n"
13363                "oneMore = 1;\n"
13364                "i       = 2;",
13365                Alignment);
13366   verifyFormat("int a   = 5;\n"
13367                "int one = 1;\n"
13368                "method();\n"
13369                "int oneTwoThree = 123;\n"
13370                "int oneTwo      = 12;",
13371                Alignment);
13372   verifyFormat("int oneTwoThree = 123;\n"
13373                "int oneTwo      = 12;\n"
13374                "method();\n",
13375                Alignment);
13376   verifyFormat("int oneTwoThree = 123; // comment\n"
13377                "int oneTwo      = 12;  // comment",
13378                Alignment);
13379 
13380   // Bug 25167
13381   /* Uncomment when fixed
13382     verifyFormat("#if A\n"
13383                  "#else\n"
13384                  "int aaaaaaaa = 12;\n"
13385                  "#endif\n"
13386                  "#if B\n"
13387                  "#else\n"
13388                  "int a = 12;\n"
13389                  "#endif\n",
13390                  Alignment);
13391     verifyFormat("enum foo {\n"
13392                  "#if A\n"
13393                  "#else\n"
13394                  "  aaaaaaaa = 12;\n"
13395                  "#endif\n"
13396                  "#if B\n"
13397                  "#else\n"
13398                  "  a = 12;\n"
13399                  "#endif\n"
13400                  "};\n",
13401                  Alignment);
13402   */
13403 
13404   Alignment.MaxEmptyLinesToKeep = 10;
13405   /* Test alignment across empty lines */
13406   EXPECT_EQ("int a           = 5;\n"
13407             "\n"
13408             "int oneTwoThree = 123;",
13409             format("int a       = 5;\n"
13410                    "\n"
13411                    "int oneTwoThree= 123;",
13412                    Alignment));
13413   EXPECT_EQ("int a           = 5;\n"
13414             "int one         = 1;\n"
13415             "\n"
13416             "int oneTwoThree = 123;",
13417             format("int a = 5;\n"
13418                    "int one = 1;\n"
13419                    "\n"
13420                    "int oneTwoThree = 123;",
13421                    Alignment));
13422   EXPECT_EQ("int a           = 5;\n"
13423             "int one         = 1;\n"
13424             "\n"
13425             "int oneTwoThree = 123;\n"
13426             "int oneTwo      = 12;",
13427             format("int a = 5;\n"
13428                    "int one = 1;\n"
13429                    "\n"
13430                    "int oneTwoThree = 123;\n"
13431                    "int oneTwo = 12;",
13432                    Alignment));
13433 
13434   /* Test across comments */
13435   EXPECT_EQ("int a           = 5;\n"
13436             "/* block comment */\n"
13437             "int oneTwoThree = 123;",
13438             format("int a = 5;\n"
13439                    "/* block comment */\n"
13440                    "int oneTwoThree=123;",
13441                    Alignment));
13442 
13443   EXPECT_EQ("int a           = 5;\n"
13444             "// line comment\n"
13445             "int oneTwoThree = 123;",
13446             format("int a = 5;\n"
13447                    "// line comment\n"
13448                    "int oneTwoThree=123;",
13449                    Alignment));
13450 
13451   /* Test across comments and newlines */
13452   EXPECT_EQ("int a           = 5;\n"
13453             "\n"
13454             "/* block comment */\n"
13455             "int oneTwoThree = 123;",
13456             format("int a = 5;\n"
13457                    "\n"
13458                    "/* block comment */\n"
13459                    "int oneTwoThree=123;",
13460                    Alignment));
13461 
13462   EXPECT_EQ("int a           = 5;\n"
13463             "\n"
13464             "// line comment\n"
13465             "int oneTwoThree = 123;",
13466             format("int a = 5;\n"
13467                    "\n"
13468                    "// line comment\n"
13469                    "int oneTwoThree=123;",
13470                    Alignment));
13471 
13472   EXPECT_EQ("int a           = 5;\n"
13473             "//\n"
13474             "// multi-line line comment\n"
13475             "//\n"
13476             "int oneTwoThree = 123;",
13477             format("int a = 5;\n"
13478                    "//\n"
13479                    "// multi-line line comment\n"
13480                    "//\n"
13481                    "int oneTwoThree=123;",
13482                    Alignment));
13483 
13484   EXPECT_EQ("int a           = 5;\n"
13485             "/*\n"
13486             " *  multi-line block comment\n"
13487             " */\n"
13488             "int oneTwoThree = 123;",
13489             format("int a = 5;\n"
13490                    "/*\n"
13491                    " *  multi-line block comment\n"
13492                    " */\n"
13493                    "int oneTwoThree=123;",
13494                    Alignment));
13495 
13496   EXPECT_EQ("int a           = 5;\n"
13497             "\n"
13498             "/* block comment */\n"
13499             "\n"
13500             "\n"
13501             "\n"
13502             "int oneTwoThree = 123;",
13503             format("int a = 5;\n"
13504                    "\n"
13505                    "/* block comment */\n"
13506                    "\n"
13507                    "\n"
13508                    "\n"
13509                    "int oneTwoThree=123;",
13510                    Alignment));
13511 
13512   EXPECT_EQ("int a           = 5;\n"
13513             "\n"
13514             "// line comment\n"
13515             "\n"
13516             "\n"
13517             "\n"
13518             "int oneTwoThree = 123;",
13519             format("int a = 5;\n"
13520                    "\n"
13521                    "// line comment\n"
13522                    "\n"
13523                    "\n"
13524                    "\n"
13525                    "int oneTwoThree=123;",
13526                    Alignment));
13527 
13528   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
13529   verifyFormat("#define A \\\n"
13530                "  int aaaa       = 12; \\\n"
13531                "  int b          = 23; \\\n"
13532                "  int ccc        = 234; \\\n"
13533                "  int dddddddddd = 2345;",
13534                Alignment);
13535   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13536   verifyFormat("#define A               \\\n"
13537                "  int aaaa       = 12;  \\\n"
13538                "  int b          = 23;  \\\n"
13539                "  int ccc        = 234; \\\n"
13540                "  int dddddddddd = 2345;",
13541                Alignment);
13542   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
13543   verifyFormat("#define A                                                      "
13544                "                \\\n"
13545                "  int aaaa       = 12;                                         "
13546                "                \\\n"
13547                "  int b          = 23;                                         "
13548                "                \\\n"
13549                "  int ccc        = 234;                                        "
13550                "                \\\n"
13551                "  int dddddddddd = 2345;",
13552                Alignment);
13553   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
13554                "k = 4, int l = 5,\n"
13555                "                  int m = 6) {\n"
13556                "  int j      = 10;\n"
13557                "  otherThing = 1;\n"
13558                "}",
13559                Alignment);
13560   verifyFormat("void SomeFunction(int parameter = 0) {\n"
13561                "  int i   = 1;\n"
13562                "  int j   = 2;\n"
13563                "  int big = 10000;\n"
13564                "}",
13565                Alignment);
13566   verifyFormat("class C {\n"
13567                "public:\n"
13568                "  int i            = 1;\n"
13569                "  virtual void f() = 0;\n"
13570                "};",
13571                Alignment);
13572   verifyFormat("int i = 1;\n"
13573                "if (SomeType t = getSomething()) {\n"
13574                "}\n"
13575                "int j   = 2;\n"
13576                "int big = 10000;",
13577                Alignment);
13578   verifyFormat("int j = 7;\n"
13579                "for (int k = 0; k < N; ++k) {\n"
13580                "}\n"
13581                "int j   = 2;\n"
13582                "int big = 10000;\n"
13583                "}",
13584                Alignment);
13585   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13586   verifyFormat("int i = 1;\n"
13587                "LooooooooooongType loooooooooooooooooooooongVariable\n"
13588                "    = someLooooooooooooooooongFunction();\n"
13589                "int j = 2;",
13590                Alignment);
13591   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
13592   verifyFormat("int i = 1;\n"
13593                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
13594                "    someLooooooooooooooooongFunction();\n"
13595                "int j = 2;",
13596                Alignment);
13597 
13598   verifyFormat("auto lambda = []() {\n"
13599                "  auto i = 0;\n"
13600                "  return 0;\n"
13601                "};\n"
13602                "int i  = 0;\n"
13603                "auto v = type{\n"
13604                "    i = 1,   //\n"
13605                "    (i = 2), //\n"
13606                "    i = 3    //\n"
13607                "};",
13608                Alignment);
13609 
13610   verifyFormat(
13611       "int i      = 1;\n"
13612       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
13613       "                          loooooooooooooooooooooongParameterB);\n"
13614       "int j      = 2;",
13615       Alignment);
13616 
13617   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
13618                "          typename B   = very_long_type_name_1,\n"
13619                "          typename T_2 = very_long_type_name_2>\n"
13620                "auto foo() {}\n",
13621                Alignment);
13622   verifyFormat("int a, b = 1;\n"
13623                "int c  = 2;\n"
13624                "int dd = 3;\n",
13625                Alignment);
13626   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
13627                "float b[1][] = {{3.f}};\n",
13628                Alignment);
13629   verifyFormat("for (int i = 0; i < 1; i++)\n"
13630                "  int x = 1;\n",
13631                Alignment);
13632   verifyFormat("for (i = 0; i < 1; i++)\n"
13633                "  x = 1;\n"
13634                "y = 1;\n",
13635                Alignment);
13636 
13637   Alignment.ReflowComments = true;
13638   Alignment.ColumnLimit = 50;
13639   EXPECT_EQ("int x   = 0;\n"
13640             "int yy  = 1; /// specificlennospace\n"
13641             "int zzz = 2;\n",
13642             format("int x   = 0;\n"
13643                    "int yy  = 1; ///specificlennospace\n"
13644                    "int zzz = 2;\n",
13645                    Alignment));
13646 }
13647 
13648 TEST_F(FormatTest, AlignConsecutiveAssignments) {
13649   FormatStyle Alignment = getLLVMStyle();
13650   Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
13651   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
13652   verifyFormat("int a = 5;\n"
13653                "int oneTwoThree = 123;",
13654                Alignment);
13655   verifyFormat("int a = 5;\n"
13656                "int oneTwoThree = 123;",
13657                Alignment);
13658 
13659   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
13660   verifyFormat("int a           = 5;\n"
13661                "int oneTwoThree = 123;",
13662                Alignment);
13663   verifyFormat("int a           = method();\n"
13664                "int oneTwoThree = 133;",
13665                Alignment);
13666   verifyFormat("a &= 5;\n"
13667                "bcd *= 5;\n"
13668                "ghtyf += 5;\n"
13669                "dvfvdb -= 5;\n"
13670                "a /= 5;\n"
13671                "vdsvsv %= 5;\n"
13672                "sfdbddfbdfbb ^= 5;\n"
13673                "dvsdsv |= 5;\n"
13674                "int dsvvdvsdvvv = 123;",
13675                Alignment);
13676   verifyFormat("int i = 1, j = 10;\n"
13677                "something = 2000;",
13678                Alignment);
13679   verifyFormat("something = 2000;\n"
13680                "int i = 1, j = 10;\n",
13681                Alignment);
13682   verifyFormat("something = 2000;\n"
13683                "another   = 911;\n"
13684                "int i = 1, j = 10;\n"
13685                "oneMore = 1;\n"
13686                "i       = 2;",
13687                Alignment);
13688   verifyFormat("int a   = 5;\n"
13689                "int one = 1;\n"
13690                "method();\n"
13691                "int oneTwoThree = 123;\n"
13692                "int oneTwo      = 12;",
13693                Alignment);
13694   verifyFormat("int oneTwoThree = 123;\n"
13695                "int oneTwo      = 12;\n"
13696                "method();\n",
13697                Alignment);
13698   verifyFormat("int oneTwoThree = 123; // comment\n"
13699                "int oneTwo      = 12;  // comment",
13700                Alignment);
13701 
13702   // Bug 25167
13703   /* Uncomment when fixed
13704     verifyFormat("#if A\n"
13705                  "#else\n"
13706                  "int aaaaaaaa = 12;\n"
13707                  "#endif\n"
13708                  "#if B\n"
13709                  "#else\n"
13710                  "int a = 12;\n"
13711                  "#endif\n",
13712                  Alignment);
13713     verifyFormat("enum foo {\n"
13714                  "#if A\n"
13715                  "#else\n"
13716                  "  aaaaaaaa = 12;\n"
13717                  "#endif\n"
13718                  "#if B\n"
13719                  "#else\n"
13720                  "  a = 12;\n"
13721                  "#endif\n"
13722                  "};\n",
13723                  Alignment);
13724   */
13725 
13726   EXPECT_EQ("int a = 5;\n"
13727             "\n"
13728             "int oneTwoThree = 123;",
13729             format("int a       = 5;\n"
13730                    "\n"
13731                    "int oneTwoThree= 123;",
13732                    Alignment));
13733   EXPECT_EQ("int a   = 5;\n"
13734             "int one = 1;\n"
13735             "\n"
13736             "int oneTwoThree = 123;",
13737             format("int a = 5;\n"
13738                    "int one = 1;\n"
13739                    "\n"
13740                    "int oneTwoThree = 123;",
13741                    Alignment));
13742   EXPECT_EQ("int a   = 5;\n"
13743             "int one = 1;\n"
13744             "\n"
13745             "int oneTwoThree = 123;\n"
13746             "int oneTwo      = 12;",
13747             format("int a = 5;\n"
13748                    "int one = 1;\n"
13749                    "\n"
13750                    "int oneTwoThree = 123;\n"
13751                    "int oneTwo = 12;",
13752                    Alignment));
13753   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
13754   verifyFormat("#define A \\\n"
13755                "  int aaaa       = 12; \\\n"
13756                "  int b          = 23; \\\n"
13757                "  int ccc        = 234; \\\n"
13758                "  int dddddddddd = 2345;",
13759                Alignment);
13760   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13761   verifyFormat("#define A               \\\n"
13762                "  int aaaa       = 12;  \\\n"
13763                "  int b          = 23;  \\\n"
13764                "  int ccc        = 234; \\\n"
13765                "  int dddddddddd = 2345;",
13766                Alignment);
13767   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
13768   verifyFormat("#define A                                                      "
13769                "                \\\n"
13770                "  int aaaa       = 12;                                         "
13771                "                \\\n"
13772                "  int b          = 23;                                         "
13773                "                \\\n"
13774                "  int ccc        = 234;                                        "
13775                "                \\\n"
13776                "  int dddddddddd = 2345;",
13777                Alignment);
13778   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
13779                "k = 4, int l = 5,\n"
13780                "                  int m = 6) {\n"
13781                "  int j      = 10;\n"
13782                "  otherThing = 1;\n"
13783                "}",
13784                Alignment);
13785   verifyFormat("void SomeFunction(int parameter = 0) {\n"
13786                "  int i   = 1;\n"
13787                "  int j   = 2;\n"
13788                "  int big = 10000;\n"
13789                "}",
13790                Alignment);
13791   verifyFormat("class C {\n"
13792                "public:\n"
13793                "  int i            = 1;\n"
13794                "  virtual void f() = 0;\n"
13795                "};",
13796                Alignment);
13797   verifyFormat("int i = 1;\n"
13798                "if (SomeType t = getSomething()) {\n"
13799                "}\n"
13800                "int j   = 2;\n"
13801                "int big = 10000;",
13802                Alignment);
13803   verifyFormat("int j = 7;\n"
13804                "for (int k = 0; k < N; ++k) {\n"
13805                "}\n"
13806                "int j   = 2;\n"
13807                "int big = 10000;\n"
13808                "}",
13809                Alignment);
13810   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13811   verifyFormat("int i = 1;\n"
13812                "LooooooooooongType loooooooooooooooooooooongVariable\n"
13813                "    = someLooooooooooooooooongFunction();\n"
13814                "int j = 2;",
13815                Alignment);
13816   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
13817   verifyFormat("int i = 1;\n"
13818                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
13819                "    someLooooooooooooooooongFunction();\n"
13820                "int j = 2;",
13821                Alignment);
13822 
13823   verifyFormat("auto lambda = []() {\n"
13824                "  auto i = 0;\n"
13825                "  return 0;\n"
13826                "};\n"
13827                "int i  = 0;\n"
13828                "auto v = type{\n"
13829                "    i = 1,   //\n"
13830                "    (i = 2), //\n"
13831                "    i = 3    //\n"
13832                "};",
13833                Alignment);
13834 
13835   verifyFormat(
13836       "int i      = 1;\n"
13837       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
13838       "                          loooooooooooooooooooooongParameterB);\n"
13839       "int j      = 2;",
13840       Alignment);
13841 
13842   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
13843                "          typename B   = very_long_type_name_1,\n"
13844                "          typename T_2 = very_long_type_name_2>\n"
13845                "auto foo() {}\n",
13846                Alignment);
13847   verifyFormat("int a, b = 1;\n"
13848                "int c  = 2;\n"
13849                "int dd = 3;\n",
13850                Alignment);
13851   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
13852                "float b[1][] = {{3.f}};\n",
13853                Alignment);
13854   verifyFormat("for (int i = 0; i < 1; i++)\n"
13855                "  int x = 1;\n",
13856                Alignment);
13857   verifyFormat("for (i = 0; i < 1; i++)\n"
13858                "  x = 1;\n"
13859                "y = 1;\n",
13860                Alignment);
13861 
13862   Alignment.ReflowComments = true;
13863   Alignment.ColumnLimit = 50;
13864   EXPECT_EQ("int x   = 0;\n"
13865             "int yy  = 1; /// specificlennospace\n"
13866             "int zzz = 2;\n",
13867             format("int x   = 0;\n"
13868                    "int yy  = 1; ///specificlennospace\n"
13869                    "int zzz = 2;\n",
13870                    Alignment));
13871 }
13872 
13873 TEST_F(FormatTest, AlignConsecutiveBitFields) {
13874   FormatStyle Alignment = getLLVMStyle();
13875   Alignment.AlignConsecutiveBitFields = FormatStyle::ACS_Consecutive;
13876   verifyFormat("int const a     : 5;\n"
13877                "int oneTwoThree : 23;",
13878                Alignment);
13879 
13880   // Initializers are allowed starting with c++2a
13881   verifyFormat("int const a     : 5 = 1;\n"
13882                "int oneTwoThree : 23 = 0;",
13883                Alignment);
13884 
13885   Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
13886   verifyFormat("int const a           : 5;\n"
13887                "int       oneTwoThree : 23;",
13888                Alignment);
13889 
13890   verifyFormat("int const a           : 5;  // comment\n"
13891                "int       oneTwoThree : 23; // comment",
13892                Alignment);
13893 
13894   verifyFormat("int const a           : 5 = 1;\n"
13895                "int       oneTwoThree : 23 = 0;",
13896                Alignment);
13897 
13898   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
13899   verifyFormat("int const a           : 5  = 1;\n"
13900                "int       oneTwoThree : 23 = 0;",
13901                Alignment);
13902   verifyFormat("int const a           : 5  = {1};\n"
13903                "int       oneTwoThree : 23 = 0;",
13904                Alignment);
13905 
13906   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_None;
13907   verifyFormat("int const a          :5;\n"
13908                "int       oneTwoThree:23;",
13909                Alignment);
13910 
13911   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_Before;
13912   verifyFormat("int const a           :5;\n"
13913                "int       oneTwoThree :23;",
13914                Alignment);
13915 
13916   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_After;
13917   verifyFormat("int const a          : 5;\n"
13918                "int       oneTwoThree: 23;",
13919                Alignment);
13920 
13921   // Known limitations: ':' is only recognized as a bitfield colon when
13922   // followed by a number.
13923   /*
13924   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
13925                "int a           : 5;",
13926                Alignment);
13927   */
13928 }
13929 
13930 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
13931   FormatStyle Alignment = getLLVMStyle();
13932   Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
13933   Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_None;
13934   verifyFormat("float const a = 5;\n"
13935                "int oneTwoThree = 123;",
13936                Alignment);
13937   verifyFormat("int a = 5;\n"
13938                "float const oneTwoThree = 123;",
13939                Alignment);
13940 
13941   Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
13942   verifyFormat("float const a = 5;\n"
13943                "int         oneTwoThree = 123;",
13944                Alignment);
13945   verifyFormat("int         a = method();\n"
13946                "float const oneTwoThree = 133;",
13947                Alignment);
13948   verifyFormat("int i = 1, j = 10;\n"
13949                "something = 2000;",
13950                Alignment);
13951   verifyFormat("something = 2000;\n"
13952                "int i = 1, j = 10;\n",
13953                Alignment);
13954   verifyFormat("float      something = 2000;\n"
13955                "double     another = 911;\n"
13956                "int        i = 1, j = 10;\n"
13957                "const int *oneMore = 1;\n"
13958                "unsigned   i = 2;",
13959                Alignment);
13960   verifyFormat("float a = 5;\n"
13961                "int   one = 1;\n"
13962                "method();\n"
13963                "const double       oneTwoThree = 123;\n"
13964                "const unsigned int oneTwo = 12;",
13965                Alignment);
13966   verifyFormat("int      oneTwoThree{0}; // comment\n"
13967                "unsigned oneTwo;         // comment",
13968                Alignment);
13969   verifyFormat("unsigned int *      a;\n"
13970                "int *               b;\n"
13971                "unsigned int Const *c;\n"
13972                "unsigned int const *d;\n"
13973                "unsigned int Const &e;\n"
13974                "unsigned int const &f;",
13975                Alignment);
13976   verifyFormat("Const unsigned int *c;\n"
13977                "const unsigned int *d;\n"
13978                "Const unsigned int &e;\n"
13979                "const unsigned int &f;\n"
13980                "const unsigned      g;\n"
13981                "Const unsigned      h;",
13982                Alignment);
13983   EXPECT_EQ("float const a = 5;\n"
13984             "\n"
13985             "int oneTwoThree = 123;",
13986             format("float const   a = 5;\n"
13987                    "\n"
13988                    "int           oneTwoThree= 123;",
13989                    Alignment));
13990   EXPECT_EQ("float a = 5;\n"
13991             "int   one = 1;\n"
13992             "\n"
13993             "unsigned oneTwoThree = 123;",
13994             format("float    a = 5;\n"
13995                    "int      one = 1;\n"
13996                    "\n"
13997                    "unsigned oneTwoThree = 123;",
13998                    Alignment));
13999   EXPECT_EQ("float a = 5;\n"
14000             "int   one = 1;\n"
14001             "\n"
14002             "unsigned oneTwoThree = 123;\n"
14003             "int      oneTwo = 12;",
14004             format("float    a = 5;\n"
14005                    "int one = 1;\n"
14006                    "\n"
14007                    "unsigned oneTwoThree = 123;\n"
14008                    "int oneTwo = 12;",
14009                    Alignment));
14010   // Function prototype alignment
14011   verifyFormat("int    a();\n"
14012                "double b();",
14013                Alignment);
14014   verifyFormat("int    a(int x);\n"
14015                "double b();",
14016                Alignment);
14017   unsigned OldColumnLimit = Alignment.ColumnLimit;
14018   // We need to set ColumnLimit to zero, in order to stress nested alignments,
14019   // otherwise the function parameters will be re-flowed onto a single line.
14020   Alignment.ColumnLimit = 0;
14021   EXPECT_EQ("int    a(int   x,\n"
14022             "         float y);\n"
14023             "double b(int    x,\n"
14024             "         double y);",
14025             format("int a(int x,\n"
14026                    " float y);\n"
14027                    "double b(int x,\n"
14028                    " double y);",
14029                    Alignment));
14030   // This ensures that function parameters of function declarations are
14031   // correctly indented when their owning functions are indented.
14032   // The failure case here is for 'double y' to not be indented enough.
14033   EXPECT_EQ("double a(int x);\n"
14034             "int    b(int    y,\n"
14035             "         double z);",
14036             format("double a(int x);\n"
14037                    "int b(int y,\n"
14038                    " double z);",
14039                    Alignment));
14040   // Set ColumnLimit low so that we induce wrapping immediately after
14041   // the function name and opening paren.
14042   Alignment.ColumnLimit = 13;
14043   verifyFormat("int function(\n"
14044                "    int  x,\n"
14045                "    bool y);",
14046                Alignment);
14047   Alignment.ColumnLimit = OldColumnLimit;
14048   // Ensure function pointers don't screw up recursive alignment
14049   verifyFormat("int    a(int x, void (*fp)(int y));\n"
14050                "double b();",
14051                Alignment);
14052   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
14053   // Ensure recursive alignment is broken by function braces, so that the
14054   // "a = 1" does not align with subsequent assignments inside the function
14055   // body.
14056   verifyFormat("int func(int a = 1) {\n"
14057                "  int b  = 2;\n"
14058                "  int cc = 3;\n"
14059                "}",
14060                Alignment);
14061   verifyFormat("float      something = 2000;\n"
14062                "double     another   = 911;\n"
14063                "int        i = 1, j = 10;\n"
14064                "const int *oneMore = 1;\n"
14065                "unsigned   i       = 2;",
14066                Alignment);
14067   verifyFormat("int      oneTwoThree = {0}; // comment\n"
14068                "unsigned oneTwo      = 0;   // comment",
14069                Alignment);
14070   // Make sure that scope is correctly tracked, in the absence of braces
14071   verifyFormat("for (int i = 0; i < n; i++)\n"
14072                "  j = i;\n"
14073                "double x = 1;\n",
14074                Alignment);
14075   verifyFormat("if (int i = 0)\n"
14076                "  j = i;\n"
14077                "double x = 1;\n",
14078                Alignment);
14079   // Ensure operator[] and operator() are comprehended
14080   verifyFormat("struct test {\n"
14081                "  long long int foo();\n"
14082                "  int           operator[](int a);\n"
14083                "  double        bar();\n"
14084                "};\n",
14085                Alignment);
14086   verifyFormat("struct test {\n"
14087                "  long long int foo();\n"
14088                "  int           operator()(int a);\n"
14089                "  double        bar();\n"
14090                "};\n",
14091                Alignment);
14092   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
14093             "  int const i   = 1;\n"
14094             "  int *     j   = 2;\n"
14095             "  int       big = 10000;\n"
14096             "\n"
14097             "  unsigned oneTwoThree = 123;\n"
14098             "  int      oneTwo      = 12;\n"
14099             "  method();\n"
14100             "  float k  = 2;\n"
14101             "  int   ll = 10000;\n"
14102             "}",
14103             format("void SomeFunction(int parameter= 0) {\n"
14104                    " int const  i= 1;\n"
14105                    "  int *j=2;\n"
14106                    " int big  =  10000;\n"
14107                    "\n"
14108                    "unsigned oneTwoThree  =123;\n"
14109                    "int oneTwo = 12;\n"
14110                    "  method();\n"
14111                    "float k= 2;\n"
14112                    "int ll=10000;\n"
14113                    "}",
14114                    Alignment));
14115   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
14116   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
14117   verifyFormat("#define A \\\n"
14118                "  int       aaaa = 12; \\\n"
14119                "  float     b = 23; \\\n"
14120                "  const int ccc = 234; \\\n"
14121                "  unsigned  dddddddddd = 2345;",
14122                Alignment);
14123   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
14124   verifyFormat("#define A              \\\n"
14125                "  int       aaaa = 12; \\\n"
14126                "  float     b = 23;    \\\n"
14127                "  const int ccc = 234; \\\n"
14128                "  unsigned  dddddddddd = 2345;",
14129                Alignment);
14130   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
14131   Alignment.ColumnLimit = 30;
14132   verifyFormat("#define A                    \\\n"
14133                "  int       aaaa = 12;       \\\n"
14134                "  float     b = 23;          \\\n"
14135                "  const int ccc = 234;       \\\n"
14136                "  int       dddddddddd = 2345;",
14137                Alignment);
14138   Alignment.ColumnLimit = 80;
14139   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
14140                "k = 4, int l = 5,\n"
14141                "                  int m = 6) {\n"
14142                "  const int j = 10;\n"
14143                "  otherThing = 1;\n"
14144                "}",
14145                Alignment);
14146   verifyFormat("void SomeFunction(int parameter = 0) {\n"
14147                "  int const i = 1;\n"
14148                "  int *     j = 2;\n"
14149                "  int       big = 10000;\n"
14150                "}",
14151                Alignment);
14152   verifyFormat("class C {\n"
14153                "public:\n"
14154                "  int          i = 1;\n"
14155                "  virtual void f() = 0;\n"
14156                "};",
14157                Alignment);
14158   verifyFormat("float i = 1;\n"
14159                "if (SomeType t = getSomething()) {\n"
14160                "}\n"
14161                "const unsigned j = 2;\n"
14162                "int            big = 10000;",
14163                Alignment);
14164   verifyFormat("float j = 7;\n"
14165                "for (int k = 0; k < N; ++k) {\n"
14166                "}\n"
14167                "unsigned j = 2;\n"
14168                "int      big = 10000;\n"
14169                "}",
14170                Alignment);
14171   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
14172   verifyFormat("float              i = 1;\n"
14173                "LooooooooooongType loooooooooooooooooooooongVariable\n"
14174                "    = someLooooooooooooooooongFunction();\n"
14175                "int j = 2;",
14176                Alignment);
14177   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
14178   verifyFormat("int                i = 1;\n"
14179                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
14180                "    someLooooooooooooooooongFunction();\n"
14181                "int j = 2;",
14182                Alignment);
14183 
14184   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
14185   verifyFormat("auto lambda = []() {\n"
14186                "  auto  ii = 0;\n"
14187                "  float j  = 0;\n"
14188                "  return 0;\n"
14189                "};\n"
14190                "int   i  = 0;\n"
14191                "float i2 = 0;\n"
14192                "auto  v  = type{\n"
14193                "    i = 1,   //\n"
14194                "    (i = 2), //\n"
14195                "    i = 3    //\n"
14196                "};",
14197                Alignment);
14198   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
14199 
14200   verifyFormat(
14201       "int      i = 1;\n"
14202       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
14203       "                          loooooooooooooooooooooongParameterB);\n"
14204       "int      j = 2;",
14205       Alignment);
14206 
14207   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
14208   // We expect declarations and assignments to align, as long as it doesn't
14209   // exceed the column limit, starting a new alignment sequence whenever it
14210   // happens.
14211   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
14212   Alignment.ColumnLimit = 30;
14213   verifyFormat("float    ii              = 1;\n"
14214                "unsigned j               = 2;\n"
14215                "int someVerylongVariable = 1;\n"
14216                "AnotherLongType  ll = 123456;\n"
14217                "VeryVeryLongType k  = 2;\n"
14218                "int              myvar = 1;",
14219                Alignment);
14220   Alignment.ColumnLimit = 80;
14221   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
14222 
14223   verifyFormat(
14224       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
14225       "          typename LongType, typename B>\n"
14226       "auto foo() {}\n",
14227       Alignment);
14228   verifyFormat("float a, b = 1;\n"
14229                "int   c = 2;\n"
14230                "int   dd = 3;\n",
14231                Alignment);
14232   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
14233                "float b[1][] = {{3.f}};\n",
14234                Alignment);
14235   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
14236   verifyFormat("float a, b = 1;\n"
14237                "int   c  = 2;\n"
14238                "int   dd = 3;\n",
14239                Alignment);
14240   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
14241                "float b[1][] = {{3.f}};\n",
14242                Alignment);
14243   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
14244 
14245   Alignment.ColumnLimit = 30;
14246   Alignment.BinPackParameters = false;
14247   verifyFormat("void foo(float     a,\n"
14248                "         float     b,\n"
14249                "         int       c,\n"
14250                "         uint32_t *d) {\n"
14251                "  int *  e = 0;\n"
14252                "  float  f = 0;\n"
14253                "  double g = 0;\n"
14254                "}\n"
14255                "void bar(ino_t     a,\n"
14256                "         int       b,\n"
14257                "         uint32_t *c,\n"
14258                "         bool      d) {}\n",
14259                Alignment);
14260   Alignment.BinPackParameters = true;
14261   Alignment.ColumnLimit = 80;
14262 
14263   // Bug 33507
14264   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
14265   verifyFormat(
14266       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
14267       "  static const Version verVs2017;\n"
14268       "  return true;\n"
14269       "});\n",
14270       Alignment);
14271   Alignment.PointerAlignment = FormatStyle::PAS_Right;
14272 
14273   // See llvm.org/PR35641
14274   Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
14275   verifyFormat("int func() { //\n"
14276                "  int      b;\n"
14277                "  unsigned c;\n"
14278                "}",
14279                Alignment);
14280 
14281   // See PR37175
14282   FormatStyle Style = getMozillaStyle();
14283   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
14284   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
14285             "foo(int a);",
14286             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
14287 
14288   Alignment.PointerAlignment = FormatStyle::PAS_Left;
14289   verifyFormat("unsigned int*       a;\n"
14290                "int*                b;\n"
14291                "unsigned int Const* c;\n"
14292                "unsigned int const* d;\n"
14293                "unsigned int Const& e;\n"
14294                "unsigned int const& f;",
14295                Alignment);
14296   verifyFormat("Const unsigned int* c;\n"
14297                "const unsigned int* d;\n"
14298                "Const unsigned int& e;\n"
14299                "const unsigned int& f;\n"
14300                "const unsigned      g;\n"
14301                "Const unsigned      h;",
14302                Alignment);
14303 
14304   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
14305   verifyFormat("unsigned int *       a;\n"
14306                "int *                b;\n"
14307                "unsigned int Const * c;\n"
14308                "unsigned int const * d;\n"
14309                "unsigned int Const & e;\n"
14310                "unsigned int const & f;",
14311                Alignment);
14312   verifyFormat("Const unsigned int * c;\n"
14313                "const unsigned int * d;\n"
14314                "Const unsigned int & e;\n"
14315                "const unsigned int & f;\n"
14316                "const unsigned       g;\n"
14317                "Const unsigned       h;",
14318                Alignment);
14319 }
14320 
14321 TEST_F(FormatTest, AlignWithLineBreaks) {
14322   auto Style = getLLVMStyleWithColumns(120);
14323 
14324   EXPECT_EQ(Style.AlignConsecutiveAssignments, FormatStyle::ACS_None);
14325   EXPECT_EQ(Style.AlignConsecutiveDeclarations, FormatStyle::ACS_None);
14326   verifyFormat("void foo() {\n"
14327                "  int myVar = 5;\n"
14328                "  double x = 3.14;\n"
14329                "  auto str = \"Hello \"\n"
14330                "             \"World\";\n"
14331                "  auto s = \"Hello \"\n"
14332                "           \"Again\";\n"
14333                "}",
14334                Style);
14335 
14336   // clang-format off
14337   verifyFormat("void foo() {\n"
14338                "  const int capacityBefore = Entries.capacity();\n"
14339                "  const auto newEntry = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
14340                "                                            std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
14341                "  const X newEntry2 = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
14342                "                                          std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
14343                "}",
14344                Style);
14345   // clang-format on
14346 
14347   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
14348   verifyFormat("void foo() {\n"
14349                "  int myVar = 5;\n"
14350                "  double x  = 3.14;\n"
14351                "  auto str  = \"Hello \"\n"
14352                "              \"World\";\n"
14353                "  auto s    = \"Hello \"\n"
14354                "              \"Again\";\n"
14355                "}",
14356                Style);
14357 
14358   // clang-format off
14359   verifyFormat("void foo() {\n"
14360                "  const int capacityBefore = Entries.capacity();\n"
14361                "  const auto newEntry      = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
14362                "                                                 std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
14363                "  const X newEntry2        = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
14364                "                                                 std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
14365                "}",
14366                Style);
14367   // clang-format on
14368 
14369   Style.AlignConsecutiveAssignments = FormatStyle::ACS_None;
14370   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
14371   verifyFormat("void foo() {\n"
14372                "  int    myVar = 5;\n"
14373                "  double x = 3.14;\n"
14374                "  auto   str = \"Hello \"\n"
14375                "               \"World\";\n"
14376                "  auto   s = \"Hello \"\n"
14377                "             \"Again\";\n"
14378                "}",
14379                Style);
14380 
14381   // clang-format off
14382   verifyFormat("void foo() {\n"
14383                "  const int  capacityBefore = Entries.capacity();\n"
14384                "  const auto newEntry = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
14385                "                                            std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
14386                "  const X    newEntry2 = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
14387                "                                             std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
14388                "}",
14389                Style);
14390   // clang-format on
14391 
14392   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
14393   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
14394 
14395   verifyFormat("void foo() {\n"
14396                "  int    myVar = 5;\n"
14397                "  double x     = 3.14;\n"
14398                "  auto   str   = \"Hello \"\n"
14399                "                 \"World\";\n"
14400                "  auto   s     = \"Hello \"\n"
14401                "                 \"Again\";\n"
14402                "}",
14403                Style);
14404 
14405   // clang-format off
14406   verifyFormat("void foo() {\n"
14407                "  const int  capacityBefore = Entries.capacity();\n"
14408                "  const auto newEntry       = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
14409                "                                                  std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
14410                "  const X    newEntry2      = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
14411                "                                                  std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
14412                "}",
14413                Style);
14414   // clang-format on
14415 }
14416 
14417 TEST_F(FormatTest, LinuxBraceBreaking) {
14418   FormatStyle LinuxBraceStyle = getLLVMStyle();
14419   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
14420   verifyFormat("namespace a\n"
14421                "{\n"
14422                "class A\n"
14423                "{\n"
14424                "  void f()\n"
14425                "  {\n"
14426                "    if (true) {\n"
14427                "      a();\n"
14428                "      b();\n"
14429                "    } else {\n"
14430                "      a();\n"
14431                "    }\n"
14432                "  }\n"
14433                "  void g() { return; }\n"
14434                "};\n"
14435                "struct B {\n"
14436                "  int x;\n"
14437                "};\n"
14438                "} // namespace a\n",
14439                LinuxBraceStyle);
14440   verifyFormat("enum X {\n"
14441                "  Y = 0,\n"
14442                "}\n",
14443                LinuxBraceStyle);
14444   verifyFormat("struct S {\n"
14445                "  int Type;\n"
14446                "  union {\n"
14447                "    int x;\n"
14448                "    double y;\n"
14449                "  } Value;\n"
14450                "  class C\n"
14451                "  {\n"
14452                "    MyFavoriteType Value;\n"
14453                "  } Class;\n"
14454                "}\n",
14455                LinuxBraceStyle);
14456 }
14457 
14458 TEST_F(FormatTest, MozillaBraceBreaking) {
14459   FormatStyle MozillaBraceStyle = getLLVMStyle();
14460   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
14461   MozillaBraceStyle.FixNamespaceComments = false;
14462   verifyFormat("namespace a {\n"
14463                "class A\n"
14464                "{\n"
14465                "  void f()\n"
14466                "  {\n"
14467                "    if (true) {\n"
14468                "      a();\n"
14469                "      b();\n"
14470                "    }\n"
14471                "  }\n"
14472                "  void g() { return; }\n"
14473                "};\n"
14474                "enum E\n"
14475                "{\n"
14476                "  A,\n"
14477                "  // foo\n"
14478                "  B,\n"
14479                "  C\n"
14480                "};\n"
14481                "struct B\n"
14482                "{\n"
14483                "  int x;\n"
14484                "};\n"
14485                "}\n",
14486                MozillaBraceStyle);
14487   verifyFormat("struct S\n"
14488                "{\n"
14489                "  int Type;\n"
14490                "  union\n"
14491                "  {\n"
14492                "    int x;\n"
14493                "    double y;\n"
14494                "  } Value;\n"
14495                "  class C\n"
14496                "  {\n"
14497                "    MyFavoriteType Value;\n"
14498                "  } Class;\n"
14499                "}\n",
14500                MozillaBraceStyle);
14501 }
14502 
14503 TEST_F(FormatTest, StroustrupBraceBreaking) {
14504   FormatStyle StroustrupBraceStyle = getLLVMStyle();
14505   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
14506   verifyFormat("namespace a {\n"
14507                "class A {\n"
14508                "  void f()\n"
14509                "  {\n"
14510                "    if (true) {\n"
14511                "      a();\n"
14512                "      b();\n"
14513                "    }\n"
14514                "  }\n"
14515                "  void g() { return; }\n"
14516                "};\n"
14517                "struct B {\n"
14518                "  int x;\n"
14519                "};\n"
14520                "} // namespace a\n",
14521                StroustrupBraceStyle);
14522 
14523   verifyFormat("void foo()\n"
14524                "{\n"
14525                "  if (a) {\n"
14526                "    a();\n"
14527                "  }\n"
14528                "  else {\n"
14529                "    b();\n"
14530                "  }\n"
14531                "}\n",
14532                StroustrupBraceStyle);
14533 
14534   verifyFormat("#ifdef _DEBUG\n"
14535                "int foo(int i = 0)\n"
14536                "#else\n"
14537                "int foo(int i = 5)\n"
14538                "#endif\n"
14539                "{\n"
14540                "  return i;\n"
14541                "}",
14542                StroustrupBraceStyle);
14543 
14544   verifyFormat("void foo() {}\n"
14545                "void bar()\n"
14546                "#ifdef _DEBUG\n"
14547                "{\n"
14548                "  foo();\n"
14549                "}\n"
14550                "#else\n"
14551                "{\n"
14552                "}\n"
14553                "#endif",
14554                StroustrupBraceStyle);
14555 
14556   verifyFormat("void foobar() { int i = 5; }\n"
14557                "#ifdef _DEBUG\n"
14558                "void bar() {}\n"
14559                "#else\n"
14560                "void bar() { foobar(); }\n"
14561                "#endif",
14562                StroustrupBraceStyle);
14563 }
14564 
14565 TEST_F(FormatTest, AllmanBraceBreaking) {
14566   FormatStyle AllmanBraceStyle = getLLVMStyle();
14567   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
14568 
14569   EXPECT_EQ("namespace a\n"
14570             "{\n"
14571             "void f();\n"
14572             "void g();\n"
14573             "} // namespace a\n",
14574             format("namespace a\n"
14575                    "{\n"
14576                    "void f();\n"
14577                    "void g();\n"
14578                    "}\n",
14579                    AllmanBraceStyle));
14580 
14581   verifyFormat("namespace a\n"
14582                "{\n"
14583                "class A\n"
14584                "{\n"
14585                "  void f()\n"
14586                "  {\n"
14587                "    if (true)\n"
14588                "    {\n"
14589                "      a();\n"
14590                "      b();\n"
14591                "    }\n"
14592                "  }\n"
14593                "  void g() { return; }\n"
14594                "};\n"
14595                "struct B\n"
14596                "{\n"
14597                "  int x;\n"
14598                "};\n"
14599                "union C\n"
14600                "{\n"
14601                "};\n"
14602                "} // namespace a",
14603                AllmanBraceStyle);
14604 
14605   verifyFormat("void f()\n"
14606                "{\n"
14607                "  if (true)\n"
14608                "  {\n"
14609                "    a();\n"
14610                "  }\n"
14611                "  else if (false)\n"
14612                "  {\n"
14613                "    b();\n"
14614                "  }\n"
14615                "  else\n"
14616                "  {\n"
14617                "    c();\n"
14618                "  }\n"
14619                "}\n",
14620                AllmanBraceStyle);
14621 
14622   verifyFormat("void f()\n"
14623                "{\n"
14624                "  for (int i = 0; i < 10; ++i)\n"
14625                "  {\n"
14626                "    a();\n"
14627                "  }\n"
14628                "  while (false)\n"
14629                "  {\n"
14630                "    b();\n"
14631                "  }\n"
14632                "  do\n"
14633                "  {\n"
14634                "    c();\n"
14635                "  } while (false)\n"
14636                "}\n",
14637                AllmanBraceStyle);
14638 
14639   verifyFormat("void f(int a)\n"
14640                "{\n"
14641                "  switch (a)\n"
14642                "  {\n"
14643                "  case 0:\n"
14644                "    break;\n"
14645                "  case 1:\n"
14646                "  {\n"
14647                "    break;\n"
14648                "  }\n"
14649                "  case 2:\n"
14650                "  {\n"
14651                "  }\n"
14652                "  break;\n"
14653                "  default:\n"
14654                "    break;\n"
14655                "  }\n"
14656                "}\n",
14657                AllmanBraceStyle);
14658 
14659   verifyFormat("enum X\n"
14660                "{\n"
14661                "  Y = 0,\n"
14662                "}\n",
14663                AllmanBraceStyle);
14664   verifyFormat("enum X\n"
14665                "{\n"
14666                "  Y = 0\n"
14667                "}\n",
14668                AllmanBraceStyle);
14669 
14670   verifyFormat("@interface BSApplicationController ()\n"
14671                "{\n"
14672                "@private\n"
14673                "  id _extraIvar;\n"
14674                "}\n"
14675                "@end\n",
14676                AllmanBraceStyle);
14677 
14678   verifyFormat("#ifdef _DEBUG\n"
14679                "int foo(int i = 0)\n"
14680                "#else\n"
14681                "int foo(int i = 5)\n"
14682                "#endif\n"
14683                "{\n"
14684                "  return i;\n"
14685                "}",
14686                AllmanBraceStyle);
14687 
14688   verifyFormat("void foo() {}\n"
14689                "void bar()\n"
14690                "#ifdef _DEBUG\n"
14691                "{\n"
14692                "  foo();\n"
14693                "}\n"
14694                "#else\n"
14695                "{\n"
14696                "}\n"
14697                "#endif",
14698                AllmanBraceStyle);
14699 
14700   verifyFormat("void foobar() { int i = 5; }\n"
14701                "#ifdef _DEBUG\n"
14702                "void bar() {}\n"
14703                "#else\n"
14704                "void bar() { foobar(); }\n"
14705                "#endif",
14706                AllmanBraceStyle);
14707 
14708   EXPECT_EQ(AllmanBraceStyle.AllowShortLambdasOnASingleLine,
14709             FormatStyle::SLS_All);
14710 
14711   verifyFormat("[](int i) { return i + 2; };\n"
14712                "[](int i, int j)\n"
14713                "{\n"
14714                "  auto x = i + j;\n"
14715                "  auto y = i * j;\n"
14716                "  return x ^ y;\n"
14717                "};\n"
14718                "void foo()\n"
14719                "{\n"
14720                "  auto shortLambda = [](int i) { return i + 2; };\n"
14721                "  auto longLambda = [](int i, int j)\n"
14722                "  {\n"
14723                "    auto x = i + j;\n"
14724                "    auto y = i * j;\n"
14725                "    return x ^ y;\n"
14726                "  };\n"
14727                "}",
14728                AllmanBraceStyle);
14729 
14730   AllmanBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
14731 
14732   verifyFormat("[](int i)\n"
14733                "{\n"
14734                "  return i + 2;\n"
14735                "};\n"
14736                "[](int i, int j)\n"
14737                "{\n"
14738                "  auto x = i + j;\n"
14739                "  auto y = i * j;\n"
14740                "  return x ^ y;\n"
14741                "};\n"
14742                "void foo()\n"
14743                "{\n"
14744                "  auto shortLambda = [](int i)\n"
14745                "  {\n"
14746                "    return i + 2;\n"
14747                "  };\n"
14748                "  auto longLambda = [](int i, int j)\n"
14749                "  {\n"
14750                "    auto x = i + j;\n"
14751                "    auto y = i * j;\n"
14752                "    return x ^ y;\n"
14753                "  };\n"
14754                "}",
14755                AllmanBraceStyle);
14756 
14757   // Reset
14758   AllmanBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_All;
14759 
14760   // This shouldn't affect ObjC blocks..
14761   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
14762                "  // ...\n"
14763                "  int i;\n"
14764                "}];",
14765                AllmanBraceStyle);
14766   verifyFormat("void (^block)(void) = ^{\n"
14767                "  // ...\n"
14768                "  int i;\n"
14769                "};",
14770                AllmanBraceStyle);
14771   // .. or dict literals.
14772   verifyFormat("void f()\n"
14773                "{\n"
14774                "  // ...\n"
14775                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
14776                "}",
14777                AllmanBraceStyle);
14778   verifyFormat("void f()\n"
14779                "{\n"
14780                "  // ...\n"
14781                "  [object someMethod:@{a : @\"b\"}];\n"
14782                "}",
14783                AllmanBraceStyle);
14784   verifyFormat("int f()\n"
14785                "{ // comment\n"
14786                "  return 42;\n"
14787                "}",
14788                AllmanBraceStyle);
14789 
14790   AllmanBraceStyle.ColumnLimit = 19;
14791   verifyFormat("void f() { int i; }", AllmanBraceStyle);
14792   AllmanBraceStyle.ColumnLimit = 18;
14793   verifyFormat("void f()\n"
14794                "{\n"
14795                "  int i;\n"
14796                "}",
14797                AllmanBraceStyle);
14798   AllmanBraceStyle.ColumnLimit = 80;
14799 
14800   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
14801   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
14802       FormatStyle::SIS_WithoutElse;
14803   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
14804   verifyFormat("void f(bool b)\n"
14805                "{\n"
14806                "  if (b)\n"
14807                "  {\n"
14808                "    return;\n"
14809                "  }\n"
14810                "}\n",
14811                BreakBeforeBraceShortIfs);
14812   verifyFormat("void f(bool b)\n"
14813                "{\n"
14814                "  if constexpr (b)\n"
14815                "  {\n"
14816                "    return;\n"
14817                "  }\n"
14818                "}\n",
14819                BreakBeforeBraceShortIfs);
14820   verifyFormat("void f(bool b)\n"
14821                "{\n"
14822                "  if CONSTEXPR (b)\n"
14823                "  {\n"
14824                "    return;\n"
14825                "  }\n"
14826                "}\n",
14827                BreakBeforeBraceShortIfs);
14828   verifyFormat("void f(bool b)\n"
14829                "{\n"
14830                "  if (b) return;\n"
14831                "}\n",
14832                BreakBeforeBraceShortIfs);
14833   verifyFormat("void f(bool b)\n"
14834                "{\n"
14835                "  if constexpr (b) return;\n"
14836                "}\n",
14837                BreakBeforeBraceShortIfs);
14838   verifyFormat("void f(bool b)\n"
14839                "{\n"
14840                "  if CONSTEXPR (b) return;\n"
14841                "}\n",
14842                BreakBeforeBraceShortIfs);
14843   verifyFormat("void f(bool b)\n"
14844                "{\n"
14845                "  while (b)\n"
14846                "  {\n"
14847                "    return;\n"
14848                "  }\n"
14849                "}\n",
14850                BreakBeforeBraceShortIfs);
14851 }
14852 
14853 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
14854   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
14855   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
14856 
14857   // Make a few changes to the style for testing purposes
14858   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
14859       FormatStyle::SFS_Empty;
14860   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
14861   WhitesmithsBraceStyle.ColumnLimit = 0;
14862 
14863   // FIXME: this test case can't decide whether there should be a blank line
14864   // after the ~D() line or not. It adds one if one doesn't exist in the test
14865   // and it removes the line if one exists.
14866   /*
14867   verifyFormat("class A;\n"
14868                "namespace B\n"
14869                "  {\n"
14870                "class C;\n"
14871                "// Comment\n"
14872                "class D\n"
14873                "  {\n"
14874                "public:\n"
14875                "  D();\n"
14876                "  ~D() {}\n"
14877                "private:\n"
14878                "  enum E\n"
14879                "    {\n"
14880                "    F\n"
14881                "    }\n"
14882                "  };\n"
14883                "  } // namespace B\n",
14884                WhitesmithsBraceStyle);
14885   */
14886 
14887   WhitesmithsBraceStyle.NamespaceIndentation = FormatStyle::NI_None;
14888   verifyFormat("namespace a\n"
14889                "  {\n"
14890                "class A\n"
14891                "  {\n"
14892                "  void f()\n"
14893                "    {\n"
14894                "    if (true)\n"
14895                "      {\n"
14896                "      a();\n"
14897                "      b();\n"
14898                "      }\n"
14899                "    }\n"
14900                "  void g()\n"
14901                "    {\n"
14902                "    return;\n"
14903                "    }\n"
14904                "  };\n"
14905                "struct B\n"
14906                "  {\n"
14907                "  int x;\n"
14908                "  };\n"
14909                "  } // namespace a",
14910                WhitesmithsBraceStyle);
14911 
14912   verifyFormat("namespace a\n"
14913                "  {\n"
14914                "namespace b\n"
14915                "  {\n"
14916                "class A\n"
14917                "  {\n"
14918                "  void f()\n"
14919                "    {\n"
14920                "    if (true)\n"
14921                "      {\n"
14922                "      a();\n"
14923                "      b();\n"
14924                "      }\n"
14925                "    }\n"
14926                "  void g()\n"
14927                "    {\n"
14928                "    return;\n"
14929                "    }\n"
14930                "  };\n"
14931                "struct B\n"
14932                "  {\n"
14933                "  int x;\n"
14934                "  };\n"
14935                "  } // namespace b\n"
14936                "  } // namespace a",
14937                WhitesmithsBraceStyle);
14938 
14939   WhitesmithsBraceStyle.NamespaceIndentation = FormatStyle::NI_Inner;
14940   verifyFormat("namespace a\n"
14941                "  {\n"
14942                "namespace b\n"
14943                "  {\n"
14944                "  class A\n"
14945                "    {\n"
14946                "    void f()\n"
14947                "      {\n"
14948                "      if (true)\n"
14949                "        {\n"
14950                "        a();\n"
14951                "        b();\n"
14952                "        }\n"
14953                "      }\n"
14954                "    void g()\n"
14955                "      {\n"
14956                "      return;\n"
14957                "      }\n"
14958                "    };\n"
14959                "  struct B\n"
14960                "    {\n"
14961                "    int x;\n"
14962                "    };\n"
14963                "  } // namespace b\n"
14964                "  } // namespace a",
14965                WhitesmithsBraceStyle);
14966 
14967   WhitesmithsBraceStyle.NamespaceIndentation = FormatStyle::NI_All;
14968   verifyFormat("namespace a\n"
14969                "  {\n"
14970                "  namespace b\n"
14971                "    {\n"
14972                "    class A\n"
14973                "      {\n"
14974                "      void f()\n"
14975                "        {\n"
14976                "        if (true)\n"
14977                "          {\n"
14978                "          a();\n"
14979                "          b();\n"
14980                "          }\n"
14981                "        }\n"
14982                "      void g()\n"
14983                "        {\n"
14984                "        return;\n"
14985                "        }\n"
14986                "      };\n"
14987                "    struct B\n"
14988                "      {\n"
14989                "      int x;\n"
14990                "      };\n"
14991                "    } // namespace b\n"
14992                "  }   // namespace a",
14993                WhitesmithsBraceStyle);
14994 
14995   verifyFormat("void f()\n"
14996                "  {\n"
14997                "  if (true)\n"
14998                "    {\n"
14999                "    a();\n"
15000                "    }\n"
15001                "  else if (false)\n"
15002                "    {\n"
15003                "    b();\n"
15004                "    }\n"
15005                "  else\n"
15006                "    {\n"
15007                "    c();\n"
15008                "    }\n"
15009                "  }\n",
15010                WhitesmithsBraceStyle);
15011 
15012   verifyFormat("void f()\n"
15013                "  {\n"
15014                "  for (int i = 0; i < 10; ++i)\n"
15015                "    {\n"
15016                "    a();\n"
15017                "    }\n"
15018                "  while (false)\n"
15019                "    {\n"
15020                "    b();\n"
15021                "    }\n"
15022                "  do\n"
15023                "    {\n"
15024                "    c();\n"
15025                "    } while (false)\n"
15026                "  }\n",
15027                WhitesmithsBraceStyle);
15028 
15029   WhitesmithsBraceStyle.IndentCaseLabels = true;
15030   verifyFormat("void switchTest1(int a)\n"
15031                "  {\n"
15032                "  switch (a)\n"
15033                "    {\n"
15034                "    case 2:\n"
15035                "      {\n"
15036                "      }\n"
15037                "      break;\n"
15038                "    }\n"
15039                "  }\n",
15040                WhitesmithsBraceStyle);
15041 
15042   verifyFormat("void switchTest2(int a)\n"
15043                "  {\n"
15044                "  switch (a)\n"
15045                "    {\n"
15046                "    case 0:\n"
15047                "      break;\n"
15048                "    case 1:\n"
15049                "      {\n"
15050                "      break;\n"
15051                "      }\n"
15052                "    case 2:\n"
15053                "      {\n"
15054                "      }\n"
15055                "      break;\n"
15056                "    default:\n"
15057                "      break;\n"
15058                "    }\n"
15059                "  }\n",
15060                WhitesmithsBraceStyle);
15061 
15062   verifyFormat("void switchTest3(int a)\n"
15063                "  {\n"
15064                "  switch (a)\n"
15065                "    {\n"
15066                "    case 0:\n"
15067                "      {\n"
15068                "      foo(x);\n"
15069                "      }\n"
15070                "      break;\n"
15071                "    default:\n"
15072                "      {\n"
15073                "      foo(1);\n"
15074                "      }\n"
15075                "      break;\n"
15076                "    }\n"
15077                "  }\n",
15078                WhitesmithsBraceStyle);
15079 
15080   WhitesmithsBraceStyle.IndentCaseLabels = false;
15081 
15082   verifyFormat("void switchTest4(int a)\n"
15083                "  {\n"
15084                "  switch (a)\n"
15085                "    {\n"
15086                "  case 2:\n"
15087                "    {\n"
15088                "    }\n"
15089                "    break;\n"
15090                "    }\n"
15091                "  }\n",
15092                WhitesmithsBraceStyle);
15093 
15094   verifyFormat("void switchTest5(int a)\n"
15095                "  {\n"
15096                "  switch (a)\n"
15097                "    {\n"
15098                "  case 0:\n"
15099                "    break;\n"
15100                "  case 1:\n"
15101                "    {\n"
15102                "    foo();\n"
15103                "    break;\n"
15104                "    }\n"
15105                "  case 2:\n"
15106                "    {\n"
15107                "    }\n"
15108                "    break;\n"
15109                "  default:\n"
15110                "    break;\n"
15111                "    }\n"
15112                "  }\n",
15113                WhitesmithsBraceStyle);
15114 
15115   verifyFormat("void switchTest6(int a)\n"
15116                "  {\n"
15117                "  switch (a)\n"
15118                "    {\n"
15119                "  case 0:\n"
15120                "    {\n"
15121                "    foo(x);\n"
15122                "    }\n"
15123                "    break;\n"
15124                "  default:\n"
15125                "    {\n"
15126                "    foo(1);\n"
15127                "    }\n"
15128                "    break;\n"
15129                "    }\n"
15130                "  }\n",
15131                WhitesmithsBraceStyle);
15132 
15133   verifyFormat("enum X\n"
15134                "  {\n"
15135                "  Y = 0, // testing\n"
15136                "  }\n",
15137                WhitesmithsBraceStyle);
15138 
15139   verifyFormat("enum X\n"
15140                "  {\n"
15141                "  Y = 0\n"
15142                "  }\n",
15143                WhitesmithsBraceStyle);
15144   verifyFormat("enum X\n"
15145                "  {\n"
15146                "  Y = 0,\n"
15147                "  Z = 1\n"
15148                "  };\n",
15149                WhitesmithsBraceStyle);
15150 
15151   verifyFormat("@interface BSApplicationController ()\n"
15152                "  {\n"
15153                "@private\n"
15154                "  id _extraIvar;\n"
15155                "  }\n"
15156                "@end\n",
15157                WhitesmithsBraceStyle);
15158 
15159   verifyFormat("#ifdef _DEBUG\n"
15160                "int foo(int i = 0)\n"
15161                "#else\n"
15162                "int foo(int i = 5)\n"
15163                "#endif\n"
15164                "  {\n"
15165                "  return i;\n"
15166                "  }",
15167                WhitesmithsBraceStyle);
15168 
15169   verifyFormat("void foo() {}\n"
15170                "void bar()\n"
15171                "#ifdef _DEBUG\n"
15172                "  {\n"
15173                "  foo();\n"
15174                "  }\n"
15175                "#else\n"
15176                "  {\n"
15177                "  }\n"
15178                "#endif",
15179                WhitesmithsBraceStyle);
15180 
15181   verifyFormat("void foobar()\n"
15182                "  {\n"
15183                "  int i = 5;\n"
15184                "  }\n"
15185                "#ifdef _DEBUG\n"
15186                "void bar()\n"
15187                "  {\n"
15188                "  }\n"
15189                "#else\n"
15190                "void bar()\n"
15191                "  {\n"
15192                "  foobar();\n"
15193                "  }\n"
15194                "#endif",
15195                WhitesmithsBraceStyle);
15196 
15197   // This shouldn't affect ObjC blocks..
15198   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
15199                "  // ...\n"
15200                "  int i;\n"
15201                "}];",
15202                WhitesmithsBraceStyle);
15203   verifyFormat("void (^block)(void) = ^{\n"
15204                "  // ...\n"
15205                "  int i;\n"
15206                "};",
15207                WhitesmithsBraceStyle);
15208   // .. or dict literals.
15209   verifyFormat("void f()\n"
15210                "  {\n"
15211                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
15212                "  }",
15213                WhitesmithsBraceStyle);
15214 
15215   verifyFormat("int f()\n"
15216                "  { // comment\n"
15217                "  return 42;\n"
15218                "  }",
15219                WhitesmithsBraceStyle);
15220 
15221   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
15222   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
15223       FormatStyle::SIS_Always;
15224   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
15225   verifyFormat("void f(bool b)\n"
15226                "  {\n"
15227                "  if (b)\n"
15228                "    {\n"
15229                "    return;\n"
15230                "    }\n"
15231                "  }\n",
15232                BreakBeforeBraceShortIfs);
15233   verifyFormat("void f(bool b)\n"
15234                "  {\n"
15235                "  if (b) return;\n"
15236                "  }\n",
15237                BreakBeforeBraceShortIfs);
15238   verifyFormat("void f(bool b)\n"
15239                "  {\n"
15240                "  while (b)\n"
15241                "    {\n"
15242                "    return;\n"
15243                "    }\n"
15244                "  }\n",
15245                BreakBeforeBraceShortIfs);
15246 }
15247 
15248 TEST_F(FormatTest, GNUBraceBreaking) {
15249   FormatStyle GNUBraceStyle = getLLVMStyle();
15250   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
15251   verifyFormat("namespace a\n"
15252                "{\n"
15253                "class A\n"
15254                "{\n"
15255                "  void f()\n"
15256                "  {\n"
15257                "    int a;\n"
15258                "    {\n"
15259                "      int b;\n"
15260                "    }\n"
15261                "    if (true)\n"
15262                "      {\n"
15263                "        a();\n"
15264                "        b();\n"
15265                "      }\n"
15266                "  }\n"
15267                "  void g() { return; }\n"
15268                "}\n"
15269                "} // namespace a",
15270                GNUBraceStyle);
15271 
15272   verifyFormat("void f()\n"
15273                "{\n"
15274                "  if (true)\n"
15275                "    {\n"
15276                "      a();\n"
15277                "    }\n"
15278                "  else if (false)\n"
15279                "    {\n"
15280                "      b();\n"
15281                "    }\n"
15282                "  else\n"
15283                "    {\n"
15284                "      c();\n"
15285                "    }\n"
15286                "}\n",
15287                GNUBraceStyle);
15288 
15289   verifyFormat("void f()\n"
15290                "{\n"
15291                "  for (int i = 0; i < 10; ++i)\n"
15292                "    {\n"
15293                "      a();\n"
15294                "    }\n"
15295                "  while (false)\n"
15296                "    {\n"
15297                "      b();\n"
15298                "    }\n"
15299                "  do\n"
15300                "    {\n"
15301                "      c();\n"
15302                "    }\n"
15303                "  while (false);\n"
15304                "}\n",
15305                GNUBraceStyle);
15306 
15307   verifyFormat("void f(int a)\n"
15308                "{\n"
15309                "  switch (a)\n"
15310                "    {\n"
15311                "    case 0:\n"
15312                "      break;\n"
15313                "    case 1:\n"
15314                "      {\n"
15315                "        break;\n"
15316                "      }\n"
15317                "    case 2:\n"
15318                "      {\n"
15319                "      }\n"
15320                "      break;\n"
15321                "    default:\n"
15322                "      break;\n"
15323                "    }\n"
15324                "}\n",
15325                GNUBraceStyle);
15326 
15327   verifyFormat("enum X\n"
15328                "{\n"
15329                "  Y = 0,\n"
15330                "}\n",
15331                GNUBraceStyle);
15332 
15333   verifyFormat("@interface BSApplicationController ()\n"
15334                "{\n"
15335                "@private\n"
15336                "  id _extraIvar;\n"
15337                "}\n"
15338                "@end\n",
15339                GNUBraceStyle);
15340 
15341   verifyFormat("#ifdef _DEBUG\n"
15342                "int foo(int i = 0)\n"
15343                "#else\n"
15344                "int foo(int i = 5)\n"
15345                "#endif\n"
15346                "{\n"
15347                "  return i;\n"
15348                "}",
15349                GNUBraceStyle);
15350 
15351   verifyFormat("void foo() {}\n"
15352                "void bar()\n"
15353                "#ifdef _DEBUG\n"
15354                "{\n"
15355                "  foo();\n"
15356                "}\n"
15357                "#else\n"
15358                "{\n"
15359                "}\n"
15360                "#endif",
15361                GNUBraceStyle);
15362 
15363   verifyFormat("void foobar() { int i = 5; }\n"
15364                "#ifdef _DEBUG\n"
15365                "void bar() {}\n"
15366                "#else\n"
15367                "void bar() { foobar(); }\n"
15368                "#endif",
15369                GNUBraceStyle);
15370 }
15371 
15372 TEST_F(FormatTest, WebKitBraceBreaking) {
15373   FormatStyle WebKitBraceStyle = getLLVMStyle();
15374   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
15375   WebKitBraceStyle.FixNamespaceComments = false;
15376   verifyFormat("namespace a {\n"
15377                "class A {\n"
15378                "  void f()\n"
15379                "  {\n"
15380                "    if (true) {\n"
15381                "      a();\n"
15382                "      b();\n"
15383                "    }\n"
15384                "  }\n"
15385                "  void g() { return; }\n"
15386                "};\n"
15387                "enum E {\n"
15388                "  A,\n"
15389                "  // foo\n"
15390                "  B,\n"
15391                "  C\n"
15392                "};\n"
15393                "struct B {\n"
15394                "  int x;\n"
15395                "};\n"
15396                "}\n",
15397                WebKitBraceStyle);
15398   verifyFormat("struct S {\n"
15399                "  int Type;\n"
15400                "  union {\n"
15401                "    int x;\n"
15402                "    double y;\n"
15403                "  } Value;\n"
15404                "  class C {\n"
15405                "    MyFavoriteType Value;\n"
15406                "  } Class;\n"
15407                "};\n",
15408                WebKitBraceStyle);
15409 }
15410 
15411 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
15412   verifyFormat("void f() {\n"
15413                "  try {\n"
15414                "  } catch (const Exception &e) {\n"
15415                "  }\n"
15416                "}\n",
15417                getLLVMStyle());
15418 }
15419 
15420 TEST_F(FormatTest, UnderstandsPragmas) {
15421   verifyFormat("#pragma omp reduction(| : var)");
15422   verifyFormat("#pragma omp reduction(+ : var)");
15423 
15424   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
15425             "(including parentheses).",
15426             format("#pragma    mark   Any non-hyphenated or hyphenated string "
15427                    "(including parentheses)."));
15428 }
15429 
15430 TEST_F(FormatTest, UnderstandPragmaOption) {
15431   verifyFormat("#pragma option -C -A");
15432 
15433   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
15434 }
15435 
15436 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
15437   FormatStyle Style = getLLVMStyle();
15438   Style.ColumnLimit = 20;
15439 
15440   // See PR41213
15441   EXPECT_EQ("/*\n"
15442             " *\t9012345\n"
15443             " * /8901\n"
15444             " */",
15445             format("/*\n"
15446                    " *\t9012345 /8901\n"
15447                    " */",
15448                    Style));
15449   EXPECT_EQ("/*\n"
15450             " *345678\n"
15451             " *\t/8901\n"
15452             " */",
15453             format("/*\n"
15454                    " *345678\t/8901\n"
15455                    " */",
15456                    Style));
15457 
15458   verifyFormat("int a; // the\n"
15459                "       // comment",
15460                Style);
15461   EXPECT_EQ("int a; /* first line\n"
15462             "        * second\n"
15463             "        * line third\n"
15464             "        * line\n"
15465             "        */",
15466             format("int a; /* first line\n"
15467                    "        * second\n"
15468                    "        * line third\n"
15469                    "        * line\n"
15470                    "        */",
15471                    Style));
15472   EXPECT_EQ("int a; // first line\n"
15473             "       // second\n"
15474             "       // line third\n"
15475             "       // line",
15476             format("int a; // first line\n"
15477                    "       // second line\n"
15478                    "       // third line",
15479                    Style));
15480 
15481   Style.PenaltyExcessCharacter = 90;
15482   verifyFormat("int a; // the comment", Style);
15483   EXPECT_EQ("int a; // the comment\n"
15484             "       // aaa",
15485             format("int a; // the comment aaa", Style));
15486   EXPECT_EQ("int a; /* first line\n"
15487             "        * second line\n"
15488             "        * third line\n"
15489             "        */",
15490             format("int a; /* first line\n"
15491                    "        * second line\n"
15492                    "        * third line\n"
15493                    "        */",
15494                    Style));
15495   EXPECT_EQ("int a; // first line\n"
15496             "       // second line\n"
15497             "       // third line",
15498             format("int a; // first line\n"
15499                    "       // second line\n"
15500                    "       // third line",
15501                    Style));
15502   // FIXME: Investigate why this is not getting the same layout as the test
15503   // above.
15504   EXPECT_EQ("int a; /* first line\n"
15505             "        * second line\n"
15506             "        * third line\n"
15507             "        */",
15508             format("int a; /* first line second line third line"
15509                    "\n*/",
15510                    Style));
15511 
15512   EXPECT_EQ("// foo bar baz bazfoo\n"
15513             "// foo bar foo bar\n",
15514             format("// foo bar baz bazfoo\n"
15515                    "// foo bar foo           bar\n",
15516                    Style));
15517   EXPECT_EQ("// foo bar baz bazfoo\n"
15518             "// foo bar foo bar\n",
15519             format("// foo bar baz      bazfoo\n"
15520                    "// foo            bar foo bar\n",
15521                    Style));
15522 
15523   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
15524   // next one.
15525   EXPECT_EQ("// foo bar baz bazfoo\n"
15526             "// bar foo bar\n",
15527             format("// foo bar baz      bazfoo bar\n"
15528                    "// foo            bar\n",
15529                    Style));
15530 
15531   EXPECT_EQ("// foo bar baz bazfoo\n"
15532             "// foo bar baz bazfoo\n"
15533             "// bar foo bar\n",
15534             format("// foo bar baz      bazfoo\n"
15535                    "// foo bar baz      bazfoo bar\n"
15536                    "// foo bar\n",
15537                    Style));
15538 
15539   EXPECT_EQ("// foo bar baz bazfoo\n"
15540             "// foo bar baz bazfoo\n"
15541             "// bar foo bar\n",
15542             format("// foo bar baz      bazfoo\n"
15543                    "// foo bar baz      bazfoo bar\n"
15544                    "// foo           bar\n",
15545                    Style));
15546 
15547   // Make sure we do not keep protruding characters if strict mode reflow is
15548   // cheaper than keeping protruding characters.
15549   Style.ColumnLimit = 21;
15550   EXPECT_EQ(
15551       "// foo foo foo foo\n"
15552       "// foo foo foo foo\n"
15553       "// foo foo foo foo\n",
15554       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
15555 
15556   EXPECT_EQ("int a = /* long block\n"
15557             "           comment */\n"
15558             "    42;",
15559             format("int a = /* long block comment */ 42;", Style));
15560 }
15561 
15562 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
15563   for (size_t i = 1; i < Styles.size(); ++i)                                   \
15564   EXPECT_EQ(Styles[0], Styles[i])                                              \
15565       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
15566 
15567 TEST_F(FormatTest, GetsPredefinedStyleByName) {
15568   SmallVector<FormatStyle, 3> Styles;
15569   Styles.resize(3);
15570 
15571   Styles[0] = getLLVMStyle();
15572   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
15573   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
15574   EXPECT_ALL_STYLES_EQUAL(Styles);
15575 
15576   Styles[0] = getGoogleStyle();
15577   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
15578   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
15579   EXPECT_ALL_STYLES_EQUAL(Styles);
15580 
15581   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
15582   EXPECT_TRUE(
15583       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
15584   EXPECT_TRUE(
15585       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
15586   EXPECT_ALL_STYLES_EQUAL(Styles);
15587 
15588   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
15589   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
15590   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
15591   EXPECT_ALL_STYLES_EQUAL(Styles);
15592 
15593   Styles[0] = getMozillaStyle();
15594   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
15595   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
15596   EXPECT_ALL_STYLES_EQUAL(Styles);
15597 
15598   Styles[0] = getWebKitStyle();
15599   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
15600   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
15601   EXPECT_ALL_STYLES_EQUAL(Styles);
15602 
15603   Styles[0] = getGNUStyle();
15604   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
15605   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
15606   EXPECT_ALL_STYLES_EQUAL(Styles);
15607 
15608   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
15609 }
15610 
15611 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
15612   SmallVector<FormatStyle, 8> Styles;
15613   Styles.resize(2);
15614 
15615   Styles[0] = getGoogleStyle();
15616   Styles[1] = getLLVMStyle();
15617   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
15618   EXPECT_ALL_STYLES_EQUAL(Styles);
15619 
15620   Styles.resize(5);
15621   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
15622   Styles[1] = getLLVMStyle();
15623   Styles[1].Language = FormatStyle::LK_JavaScript;
15624   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
15625 
15626   Styles[2] = getLLVMStyle();
15627   Styles[2].Language = FormatStyle::LK_JavaScript;
15628   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
15629                                   "BasedOnStyle: Google",
15630                                   &Styles[2])
15631                    .value());
15632 
15633   Styles[3] = getLLVMStyle();
15634   Styles[3].Language = FormatStyle::LK_JavaScript;
15635   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
15636                                   "Language: JavaScript",
15637                                   &Styles[3])
15638                    .value());
15639 
15640   Styles[4] = getLLVMStyle();
15641   Styles[4].Language = FormatStyle::LK_JavaScript;
15642   EXPECT_EQ(0, parseConfiguration("---\n"
15643                                   "BasedOnStyle: LLVM\n"
15644                                   "IndentWidth: 123\n"
15645                                   "---\n"
15646                                   "BasedOnStyle: Google\n"
15647                                   "Language: JavaScript",
15648                                   &Styles[4])
15649                    .value());
15650   EXPECT_ALL_STYLES_EQUAL(Styles);
15651 }
15652 
15653 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
15654   Style.FIELD = false;                                                         \
15655   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
15656   EXPECT_TRUE(Style.FIELD);                                                    \
15657   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
15658   EXPECT_FALSE(Style.FIELD);
15659 
15660 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
15661 
15662 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
15663   Style.STRUCT.FIELD = false;                                                  \
15664   EXPECT_EQ(0,                                                                 \
15665             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
15666                 .value());                                                     \
15667   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
15668   EXPECT_EQ(0,                                                                 \
15669             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
15670                 .value());                                                     \
15671   EXPECT_FALSE(Style.STRUCT.FIELD);
15672 
15673 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
15674   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
15675 
15676 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
15677   EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!";          \
15678   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
15679   EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
15680 
15681 TEST_F(FormatTest, ParsesConfigurationBools) {
15682   FormatStyle Style = {};
15683   Style.Language = FormatStyle::LK_Cpp;
15684   CHECK_PARSE_BOOL(AlignTrailingComments);
15685   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
15686   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
15687   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
15688   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
15689   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
15690   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
15691   CHECK_PARSE_BOOL(BinPackArguments);
15692   CHECK_PARSE_BOOL(BinPackParameters);
15693   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
15694   CHECK_PARSE_BOOL(BreakBeforeConceptDeclarations);
15695   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
15696   CHECK_PARSE_BOOL(BreakStringLiterals);
15697   CHECK_PARSE_BOOL(CompactNamespaces);
15698   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
15699   CHECK_PARSE_BOOL(DeriveLineEnding);
15700   CHECK_PARSE_BOOL(DerivePointerAlignment);
15701   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
15702   CHECK_PARSE_BOOL(DisableFormat);
15703   CHECK_PARSE_BOOL(IndentAccessModifiers);
15704   CHECK_PARSE_BOOL(IndentCaseLabels);
15705   CHECK_PARSE_BOOL(IndentCaseBlocks);
15706   CHECK_PARSE_BOOL(IndentGotoLabels);
15707   CHECK_PARSE_BOOL(IndentRequires);
15708   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
15709   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
15710   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
15711   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
15712   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
15713   CHECK_PARSE_BOOL(ReflowComments);
15714   CHECK_PARSE_BOOL(SortUsingDeclarations);
15715   CHECK_PARSE_BOOL(SpacesInParentheses);
15716   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
15717   CHECK_PARSE_BOOL(SpacesInAngles);
15718   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
15719   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
15720   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
15721   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
15722   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
15723   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
15724   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
15725   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
15726   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
15727   CHECK_PARSE_BOOL(SpaceBeforeCaseColon);
15728   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
15729   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
15730   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
15731   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
15732   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
15733   CHECK_PARSE_BOOL(UseCRLF);
15734 
15735   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
15736   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
15737   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
15738   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
15739   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
15740   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
15741   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
15742   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
15743   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
15744   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
15745   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
15746   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
15747   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
15748   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
15749   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
15750   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
15751   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
15752 }
15753 
15754 #undef CHECK_PARSE_BOOL
15755 
15756 TEST_F(FormatTest, ParsesConfiguration) {
15757   FormatStyle Style = {};
15758   Style.Language = FormatStyle::LK_Cpp;
15759   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
15760   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
15761               ConstructorInitializerIndentWidth, 1234u);
15762   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
15763   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
15764   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
15765   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
15766   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
15767               PenaltyBreakBeforeFirstCallParameter, 1234u);
15768   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
15769               PenaltyBreakTemplateDeclaration, 1234u);
15770   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
15771   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
15772               PenaltyReturnTypeOnItsOwnLine, 1234u);
15773   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
15774               SpacesBeforeTrailingComments, 1234u);
15775   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
15776   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
15777   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
15778 
15779   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
15780   CHECK_PARSE("AlignConsecutiveAssignments: None", AlignConsecutiveAssignments,
15781               FormatStyle::ACS_None);
15782   CHECK_PARSE("AlignConsecutiveAssignments: Consecutive",
15783               AlignConsecutiveAssignments, FormatStyle::ACS_Consecutive);
15784   CHECK_PARSE("AlignConsecutiveAssignments: AcrossEmptyLines",
15785               AlignConsecutiveAssignments, FormatStyle::ACS_AcrossEmptyLines);
15786   CHECK_PARSE("AlignConsecutiveAssignments: AcrossEmptyLinesAndComments",
15787               AlignConsecutiveAssignments,
15788               FormatStyle::ACS_AcrossEmptyLinesAndComments);
15789   // For backwards compability, false / true should still parse
15790   CHECK_PARSE("AlignConsecutiveAssignments: false", AlignConsecutiveAssignments,
15791               FormatStyle::ACS_None);
15792   CHECK_PARSE("AlignConsecutiveAssignments: true", AlignConsecutiveAssignments,
15793               FormatStyle::ACS_Consecutive);
15794 
15795   Style.AlignConsecutiveBitFields = FormatStyle::ACS_Consecutive;
15796   CHECK_PARSE("AlignConsecutiveBitFields: None", AlignConsecutiveBitFields,
15797               FormatStyle::ACS_None);
15798   CHECK_PARSE("AlignConsecutiveBitFields: Consecutive",
15799               AlignConsecutiveBitFields, FormatStyle::ACS_Consecutive);
15800   CHECK_PARSE("AlignConsecutiveBitFields: AcrossEmptyLines",
15801               AlignConsecutiveBitFields, FormatStyle::ACS_AcrossEmptyLines);
15802   CHECK_PARSE("AlignConsecutiveBitFields: AcrossEmptyLinesAndComments",
15803               AlignConsecutiveBitFields,
15804               FormatStyle::ACS_AcrossEmptyLinesAndComments);
15805   // For backwards compability, false / true should still parse
15806   CHECK_PARSE("AlignConsecutiveBitFields: false", AlignConsecutiveBitFields,
15807               FormatStyle::ACS_None);
15808   CHECK_PARSE("AlignConsecutiveBitFields: true", AlignConsecutiveBitFields,
15809               FormatStyle::ACS_Consecutive);
15810 
15811   Style.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
15812   CHECK_PARSE("AlignConsecutiveMacros: None", AlignConsecutiveMacros,
15813               FormatStyle::ACS_None);
15814   CHECK_PARSE("AlignConsecutiveMacros: Consecutive", AlignConsecutiveMacros,
15815               FormatStyle::ACS_Consecutive);
15816   CHECK_PARSE("AlignConsecutiveMacros: AcrossEmptyLines",
15817               AlignConsecutiveMacros, FormatStyle::ACS_AcrossEmptyLines);
15818   CHECK_PARSE("AlignConsecutiveMacros: AcrossEmptyLinesAndComments",
15819               AlignConsecutiveMacros,
15820               FormatStyle::ACS_AcrossEmptyLinesAndComments);
15821   // For backwards compability, false / true should still parse
15822   CHECK_PARSE("AlignConsecutiveMacros: false", AlignConsecutiveMacros,
15823               FormatStyle::ACS_None);
15824   CHECK_PARSE("AlignConsecutiveMacros: true", AlignConsecutiveMacros,
15825               FormatStyle::ACS_Consecutive);
15826 
15827   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
15828   CHECK_PARSE("AlignConsecutiveDeclarations: None",
15829               AlignConsecutiveDeclarations, FormatStyle::ACS_None);
15830   CHECK_PARSE("AlignConsecutiveDeclarations: Consecutive",
15831               AlignConsecutiveDeclarations, FormatStyle::ACS_Consecutive);
15832   CHECK_PARSE("AlignConsecutiveDeclarations: AcrossEmptyLines",
15833               AlignConsecutiveDeclarations, FormatStyle::ACS_AcrossEmptyLines);
15834   CHECK_PARSE("AlignConsecutiveDeclarations: AcrossEmptyLinesAndComments",
15835               AlignConsecutiveDeclarations,
15836               FormatStyle::ACS_AcrossEmptyLinesAndComments);
15837   // For backwards compability, false / true should still parse
15838   CHECK_PARSE("AlignConsecutiveDeclarations: false",
15839               AlignConsecutiveDeclarations, FormatStyle::ACS_None);
15840   CHECK_PARSE("AlignConsecutiveDeclarations: true",
15841               AlignConsecutiveDeclarations, FormatStyle::ACS_Consecutive);
15842 
15843   Style.PointerAlignment = FormatStyle::PAS_Middle;
15844   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
15845               FormatStyle::PAS_Left);
15846   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
15847               FormatStyle::PAS_Right);
15848   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
15849               FormatStyle::PAS_Middle);
15850   // For backward compatibility:
15851   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
15852               FormatStyle::PAS_Left);
15853   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
15854               FormatStyle::PAS_Right);
15855   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
15856               FormatStyle::PAS_Middle);
15857 
15858   Style.Standard = FormatStyle::LS_Auto;
15859   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
15860   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
15861   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
15862   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
15863   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
15864   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
15865   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
15866   // Legacy aliases:
15867   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
15868   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
15869   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
15870   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
15871 
15872   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
15873   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
15874               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
15875   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
15876               FormatStyle::BOS_None);
15877   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
15878               FormatStyle::BOS_All);
15879   // For backward compatibility:
15880   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
15881               FormatStyle::BOS_None);
15882   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
15883               FormatStyle::BOS_All);
15884 
15885   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
15886   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
15887               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
15888   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
15889               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
15890   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
15891               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
15892   // For backward compatibility:
15893   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
15894               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
15895 
15896   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
15897   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
15898               FormatStyle::BILS_BeforeComma);
15899   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
15900               FormatStyle::BILS_AfterColon);
15901   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
15902               FormatStyle::BILS_BeforeColon);
15903   // For backward compatibility:
15904   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
15905               FormatStyle::BILS_BeforeComma);
15906 
15907   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
15908   CHECK_PARSE("EmptyLineBeforeAccessModifier: Never",
15909               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Never);
15910   CHECK_PARSE("EmptyLineBeforeAccessModifier: Leave",
15911               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Leave);
15912   CHECK_PARSE("EmptyLineBeforeAccessModifier: LogicalBlock",
15913               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_LogicalBlock);
15914   CHECK_PARSE("EmptyLineBeforeAccessModifier: Always",
15915               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Always);
15916 
15917   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
15918   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
15919               FormatStyle::BAS_Align);
15920   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
15921               FormatStyle::BAS_DontAlign);
15922   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
15923               FormatStyle::BAS_AlwaysBreak);
15924   // For backward compatibility:
15925   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
15926               FormatStyle::BAS_DontAlign);
15927   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
15928               FormatStyle::BAS_Align);
15929 
15930   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
15931   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
15932               FormatStyle::ENAS_DontAlign);
15933   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
15934               FormatStyle::ENAS_Left);
15935   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
15936               FormatStyle::ENAS_Right);
15937   // For backward compatibility:
15938   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
15939               FormatStyle::ENAS_Left);
15940   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
15941               FormatStyle::ENAS_Right);
15942 
15943   Style.AlignOperands = FormatStyle::OAS_Align;
15944   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
15945               FormatStyle::OAS_DontAlign);
15946   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
15947   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
15948               FormatStyle::OAS_AlignAfterOperator);
15949   // For backward compatibility:
15950   CHECK_PARSE("AlignOperands: false", AlignOperands,
15951               FormatStyle::OAS_DontAlign);
15952   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
15953 
15954   Style.UseTab = FormatStyle::UT_ForIndentation;
15955   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
15956   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
15957   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
15958   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
15959               FormatStyle::UT_ForContinuationAndIndentation);
15960   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
15961               FormatStyle::UT_AlignWithSpaces);
15962   // For backward compatibility:
15963   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
15964   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
15965 
15966   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
15967   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
15968               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
15969   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
15970               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
15971   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
15972               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
15973   // For backward compatibility:
15974   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
15975               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
15976   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
15977               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
15978 
15979   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
15980   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
15981               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
15982   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
15983               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
15984   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
15985               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
15986   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
15987               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
15988   // For backward compatibility:
15989   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
15990               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
15991   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
15992               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
15993 
15994   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Both;
15995   CHECK_PARSE("SpaceAroundPointerQualifiers: Default",
15996               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Default);
15997   CHECK_PARSE("SpaceAroundPointerQualifiers: Before",
15998               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Before);
15999   CHECK_PARSE("SpaceAroundPointerQualifiers: After",
16000               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_After);
16001   CHECK_PARSE("SpaceAroundPointerQualifiers: Both",
16002               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Both);
16003 
16004   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
16005   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
16006               FormatStyle::SBPO_Never);
16007   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
16008               FormatStyle::SBPO_Always);
16009   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
16010               FormatStyle::SBPO_ControlStatements);
16011   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
16012               FormatStyle::SBPO_NonEmptyParentheses);
16013   // For backward compatibility:
16014   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
16015               FormatStyle::SBPO_Never);
16016   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
16017               FormatStyle::SBPO_ControlStatements);
16018 
16019   Style.ColumnLimit = 123;
16020   FormatStyle BaseStyle = getLLVMStyle();
16021   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
16022   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
16023 
16024   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
16025   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
16026               FormatStyle::BS_Attach);
16027   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
16028               FormatStyle::BS_Linux);
16029   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
16030               FormatStyle::BS_Mozilla);
16031   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
16032               FormatStyle::BS_Stroustrup);
16033   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
16034               FormatStyle::BS_Allman);
16035   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
16036               FormatStyle::BS_Whitesmiths);
16037   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
16038   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
16039               FormatStyle::BS_WebKit);
16040   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
16041               FormatStyle::BS_Custom);
16042 
16043   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
16044   CHECK_PARSE("BraceWrapping:\n"
16045               "  AfterControlStatement: MultiLine",
16046               BraceWrapping.AfterControlStatement,
16047               FormatStyle::BWACS_MultiLine);
16048   CHECK_PARSE("BraceWrapping:\n"
16049               "  AfterControlStatement: Always",
16050               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
16051   CHECK_PARSE("BraceWrapping:\n"
16052               "  AfterControlStatement: Never",
16053               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
16054   // For backward compatibility:
16055   CHECK_PARSE("BraceWrapping:\n"
16056               "  AfterControlStatement: true",
16057               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
16058   CHECK_PARSE("BraceWrapping:\n"
16059               "  AfterControlStatement: false",
16060               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
16061 
16062   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
16063   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
16064               FormatStyle::RTBS_None);
16065   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
16066               FormatStyle::RTBS_All);
16067   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
16068               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
16069   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
16070               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
16071   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
16072               AlwaysBreakAfterReturnType,
16073               FormatStyle::RTBS_TopLevelDefinitions);
16074 
16075   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
16076   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
16077               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
16078   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
16079               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
16080   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
16081               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
16082   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
16083               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
16084   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
16085               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
16086 
16087   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
16088   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
16089               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
16090   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
16091               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
16092   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
16093               AlwaysBreakAfterDefinitionReturnType,
16094               FormatStyle::DRTBS_TopLevel);
16095 
16096   Style.NamespaceIndentation = FormatStyle::NI_All;
16097   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
16098               FormatStyle::NI_None);
16099   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
16100               FormatStyle::NI_Inner);
16101   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
16102               FormatStyle::NI_All);
16103 
16104   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
16105   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
16106               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
16107   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
16108               AllowShortIfStatementsOnASingleLine,
16109               FormatStyle::SIS_WithoutElse);
16110   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
16111               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
16112   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
16113               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
16114   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
16115               AllowShortIfStatementsOnASingleLine,
16116               FormatStyle::SIS_WithoutElse);
16117 
16118   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
16119   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
16120               FormatStyle::IEBS_AfterExternBlock);
16121   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
16122               FormatStyle::IEBS_Indent);
16123   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
16124               FormatStyle::IEBS_NoIndent);
16125   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
16126               FormatStyle::IEBS_Indent);
16127   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
16128               FormatStyle::IEBS_NoIndent);
16129 
16130   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
16131   CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
16132               FormatStyle::BFCS_Both);
16133   CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
16134               FormatStyle::BFCS_None);
16135   CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
16136               FormatStyle::BFCS_Before);
16137   CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
16138               FormatStyle::BFCS_After);
16139 
16140   Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
16141   CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
16142               FormatStyle::SJSIO_After);
16143   CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
16144               FormatStyle::SJSIO_Before);
16145 
16146   // FIXME: This is required because parsing a configuration simply overwrites
16147   // the first N elements of the list instead of resetting it.
16148   Style.ForEachMacros.clear();
16149   std::vector<std::string> BoostForeach;
16150   BoostForeach.push_back("BOOST_FOREACH");
16151   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
16152   std::vector<std::string> BoostAndQForeach;
16153   BoostAndQForeach.push_back("BOOST_FOREACH");
16154   BoostAndQForeach.push_back("Q_FOREACH");
16155   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
16156               BoostAndQForeach);
16157 
16158   Style.AttributeMacros.clear();
16159   CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
16160               std::vector<std::string>{"__capability"});
16161   CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
16162               std::vector<std::string>({"attr1", "attr2"}));
16163 
16164   Style.StatementAttributeLikeMacros.clear();
16165   CHECK_PARSE("StatementAttributeLikeMacros: [emit,Q_EMIT]",
16166               StatementAttributeLikeMacros,
16167               std::vector<std::string>({"emit", "Q_EMIT"}));
16168 
16169   Style.StatementMacros.clear();
16170   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
16171               std::vector<std::string>{"QUNUSED"});
16172   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
16173               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
16174 
16175   Style.NamespaceMacros.clear();
16176   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
16177               std::vector<std::string>{"TESTSUITE"});
16178   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
16179               std::vector<std::string>({"TESTSUITE", "SUITE"}));
16180 
16181   Style.WhitespaceSensitiveMacros.clear();
16182   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
16183               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
16184   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
16185               WhitespaceSensitiveMacros,
16186               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
16187   Style.WhitespaceSensitiveMacros.clear();
16188   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
16189               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
16190   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
16191               WhitespaceSensitiveMacros,
16192               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
16193 
16194   Style.IncludeStyle.IncludeCategories.clear();
16195   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
16196       {"abc/.*", 2, 0, false}, {".*", 1, 0, true}};
16197   CHECK_PARSE("IncludeCategories:\n"
16198               "  - Regex: abc/.*\n"
16199               "    Priority: 2\n"
16200               "  - Regex: .*\n"
16201               "    Priority: 1\n"
16202               "    CaseSensitive: true\n",
16203               IncludeStyle.IncludeCategories, ExpectedCategories);
16204   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
16205               "abc$");
16206   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
16207               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
16208 
16209   Style.SortIncludes = FormatStyle::SI_Never;
16210   CHECK_PARSE("SortIncludes: true", SortIncludes,
16211               FormatStyle::SI_CaseSensitive);
16212   CHECK_PARSE("SortIncludes: false", SortIncludes, FormatStyle::SI_Never);
16213   CHECK_PARSE("SortIncludes: CaseInsensitive", SortIncludes,
16214               FormatStyle::SI_CaseInsensitive);
16215   CHECK_PARSE("SortIncludes: CaseSensitive", SortIncludes,
16216               FormatStyle::SI_CaseSensitive);
16217   CHECK_PARSE("SortIncludes: Never", SortIncludes, FormatStyle::SI_Never);
16218 
16219   Style.RawStringFormats.clear();
16220   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
16221       {
16222           FormatStyle::LK_TextProto,
16223           {"pb", "proto"},
16224           {"PARSE_TEXT_PROTO"},
16225           /*CanonicalDelimiter=*/"",
16226           "llvm",
16227       },
16228       {
16229           FormatStyle::LK_Cpp,
16230           {"cc", "cpp"},
16231           {"C_CODEBLOCK", "CPPEVAL"},
16232           /*CanonicalDelimiter=*/"cc",
16233           /*BasedOnStyle=*/"",
16234       },
16235   };
16236 
16237   CHECK_PARSE("RawStringFormats:\n"
16238               "  - Language: TextProto\n"
16239               "    Delimiters:\n"
16240               "      - 'pb'\n"
16241               "      - 'proto'\n"
16242               "    EnclosingFunctions:\n"
16243               "      - 'PARSE_TEXT_PROTO'\n"
16244               "    BasedOnStyle: llvm\n"
16245               "  - Language: Cpp\n"
16246               "    Delimiters:\n"
16247               "      - 'cc'\n"
16248               "      - 'cpp'\n"
16249               "    EnclosingFunctions:\n"
16250               "      - 'C_CODEBLOCK'\n"
16251               "      - 'CPPEVAL'\n"
16252               "    CanonicalDelimiter: 'cc'",
16253               RawStringFormats, ExpectedRawStringFormats);
16254 
16255   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
16256               "  Minimum: 0\n"
16257               "  Maximum: 0",
16258               SpacesInLineCommentPrefix.Minimum, 0u);
16259   EXPECT_EQ(Style.SpacesInLineCommentPrefix.Maximum, 0u);
16260   Style.SpacesInLineCommentPrefix.Minimum = 1;
16261   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
16262               "  Minimum: 2",
16263               SpacesInLineCommentPrefix.Minimum, 0u);
16264   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
16265               "  Maximum: -1",
16266               SpacesInLineCommentPrefix.Maximum, -1u);
16267   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
16268               "  Minimum: 2",
16269               SpacesInLineCommentPrefix.Minimum, 2u);
16270   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
16271               "  Maximum: 1",
16272               SpacesInLineCommentPrefix.Maximum, 1u);
16273   EXPECT_EQ(Style.SpacesInLineCommentPrefix.Minimum, 1u);
16274 }
16275 
16276 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
16277   FormatStyle Style = {};
16278   Style.Language = FormatStyle::LK_Cpp;
16279   CHECK_PARSE("Language: Cpp\n"
16280               "IndentWidth: 12",
16281               IndentWidth, 12u);
16282   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
16283                                "IndentWidth: 34",
16284                                &Style),
16285             ParseError::Unsuitable);
16286   FormatStyle BinPackedTCS = {};
16287   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
16288   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
16289                                "InsertTrailingCommas: Wrapped",
16290                                &BinPackedTCS),
16291             ParseError::BinPackTrailingCommaConflict);
16292   EXPECT_EQ(12u, Style.IndentWidth);
16293   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
16294   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
16295 
16296   Style.Language = FormatStyle::LK_JavaScript;
16297   CHECK_PARSE("Language: JavaScript\n"
16298               "IndentWidth: 12",
16299               IndentWidth, 12u);
16300   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
16301   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
16302                                "IndentWidth: 34",
16303                                &Style),
16304             ParseError::Unsuitable);
16305   EXPECT_EQ(23u, Style.IndentWidth);
16306   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
16307   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
16308 
16309   CHECK_PARSE("BasedOnStyle: LLVM\n"
16310               "IndentWidth: 67",
16311               IndentWidth, 67u);
16312 
16313   CHECK_PARSE("---\n"
16314               "Language: JavaScript\n"
16315               "IndentWidth: 12\n"
16316               "---\n"
16317               "Language: Cpp\n"
16318               "IndentWidth: 34\n"
16319               "...\n",
16320               IndentWidth, 12u);
16321 
16322   Style.Language = FormatStyle::LK_Cpp;
16323   CHECK_PARSE("---\n"
16324               "Language: JavaScript\n"
16325               "IndentWidth: 12\n"
16326               "---\n"
16327               "Language: Cpp\n"
16328               "IndentWidth: 34\n"
16329               "...\n",
16330               IndentWidth, 34u);
16331   CHECK_PARSE("---\n"
16332               "IndentWidth: 78\n"
16333               "---\n"
16334               "Language: JavaScript\n"
16335               "IndentWidth: 56\n"
16336               "...\n",
16337               IndentWidth, 78u);
16338 
16339   Style.ColumnLimit = 123;
16340   Style.IndentWidth = 234;
16341   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
16342   Style.TabWidth = 345;
16343   EXPECT_FALSE(parseConfiguration("---\n"
16344                                   "IndentWidth: 456\n"
16345                                   "BreakBeforeBraces: Allman\n"
16346                                   "---\n"
16347                                   "Language: JavaScript\n"
16348                                   "IndentWidth: 111\n"
16349                                   "TabWidth: 111\n"
16350                                   "---\n"
16351                                   "Language: Cpp\n"
16352                                   "BreakBeforeBraces: Stroustrup\n"
16353                                   "TabWidth: 789\n"
16354                                   "...\n",
16355                                   &Style));
16356   EXPECT_EQ(123u, Style.ColumnLimit);
16357   EXPECT_EQ(456u, Style.IndentWidth);
16358   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
16359   EXPECT_EQ(789u, Style.TabWidth);
16360 
16361   EXPECT_EQ(parseConfiguration("---\n"
16362                                "Language: JavaScript\n"
16363                                "IndentWidth: 56\n"
16364                                "---\n"
16365                                "IndentWidth: 78\n"
16366                                "...\n",
16367                                &Style),
16368             ParseError::Error);
16369   EXPECT_EQ(parseConfiguration("---\n"
16370                                "Language: JavaScript\n"
16371                                "IndentWidth: 56\n"
16372                                "---\n"
16373                                "Language: JavaScript\n"
16374                                "IndentWidth: 78\n"
16375                                "...\n",
16376                                &Style),
16377             ParseError::Error);
16378 
16379   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
16380 }
16381 
16382 #undef CHECK_PARSE
16383 
16384 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
16385   FormatStyle Style = {};
16386   Style.Language = FormatStyle::LK_JavaScript;
16387   Style.BreakBeforeTernaryOperators = true;
16388   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
16389   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
16390 
16391   Style.BreakBeforeTernaryOperators = true;
16392   EXPECT_EQ(0, parseConfiguration("---\n"
16393                                   "BasedOnStyle: Google\n"
16394                                   "---\n"
16395                                   "Language: JavaScript\n"
16396                                   "IndentWidth: 76\n"
16397                                   "...\n",
16398                                   &Style)
16399                    .value());
16400   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
16401   EXPECT_EQ(76u, Style.IndentWidth);
16402   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
16403 }
16404 
16405 TEST_F(FormatTest, ConfigurationRoundTripTest) {
16406   FormatStyle Style = getLLVMStyle();
16407   std::string YAML = configurationAsText(Style);
16408   FormatStyle ParsedStyle = {};
16409   ParsedStyle.Language = FormatStyle::LK_Cpp;
16410   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
16411   EXPECT_EQ(Style, ParsedStyle);
16412 }
16413 
16414 TEST_F(FormatTest, WorksFor8bitEncodings) {
16415   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
16416             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
16417             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
16418             "\"\xef\xee\xf0\xf3...\"",
16419             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
16420                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
16421                    "\xef\xee\xf0\xf3...\"",
16422                    getLLVMStyleWithColumns(12)));
16423 }
16424 
16425 TEST_F(FormatTest, HandlesUTF8BOM) {
16426   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
16427   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
16428             format("\xef\xbb\xbf#include <iostream>"));
16429   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
16430             format("\xef\xbb\xbf\n#include <iostream>"));
16431 }
16432 
16433 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
16434 #if !defined(_MSC_VER)
16435 
16436 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
16437   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
16438                getLLVMStyleWithColumns(35));
16439   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
16440                getLLVMStyleWithColumns(31));
16441   verifyFormat("// Однажды в студёную зимнюю пору...",
16442                getLLVMStyleWithColumns(36));
16443   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
16444   verifyFormat("/* Однажды в студёную зимнюю пору... */",
16445                getLLVMStyleWithColumns(39));
16446   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
16447                getLLVMStyleWithColumns(35));
16448 }
16449 
16450 TEST_F(FormatTest, SplitsUTF8Strings) {
16451   // Non-printable characters' width is currently considered to be the length in
16452   // bytes in UTF8. The characters can be displayed in very different manner
16453   // (zero-width, single width with a substitution glyph, expanded to their code
16454   // (e.g. "<8d>"), so there's no single correct way to handle them.
16455   EXPECT_EQ("\"aaaaÄ\"\n"
16456             "\"\xc2\x8d\";",
16457             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
16458   EXPECT_EQ("\"aaaaaaaÄ\"\n"
16459             "\"\xc2\x8d\";",
16460             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
16461   EXPECT_EQ("\"Однажды, в \"\n"
16462             "\"студёную \"\n"
16463             "\"зимнюю \"\n"
16464             "\"пору,\"",
16465             format("\"Однажды, в студёную зимнюю пору,\"",
16466                    getLLVMStyleWithColumns(13)));
16467   EXPECT_EQ(
16468       "\"一 二 三 \"\n"
16469       "\"四 五六 \"\n"
16470       "\"七 八 九 \"\n"
16471       "\"十\"",
16472       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
16473   EXPECT_EQ("\"一\t\"\n"
16474             "\"二 \t\"\n"
16475             "\"三 四 \"\n"
16476             "\"五\t\"\n"
16477             "\"六 \t\"\n"
16478             "\"七 \"\n"
16479             "\"八九十\tqq\"",
16480             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
16481                    getLLVMStyleWithColumns(11)));
16482 
16483   // UTF8 character in an escape sequence.
16484   EXPECT_EQ("\"aaaaaa\"\n"
16485             "\"\\\xC2\x8D\"",
16486             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
16487 }
16488 
16489 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
16490   EXPECT_EQ("const char *sssss =\n"
16491             "    \"一二三四五六七八\\\n"
16492             " 九 十\";",
16493             format("const char *sssss = \"一二三四五六七八\\\n"
16494                    " 九 十\";",
16495                    getLLVMStyleWithColumns(30)));
16496 }
16497 
16498 TEST_F(FormatTest, SplitsUTF8LineComments) {
16499   EXPECT_EQ("// aaaaÄ\xc2\x8d",
16500             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
16501   EXPECT_EQ("// Я из лесу\n"
16502             "// вышел; был\n"
16503             "// сильный\n"
16504             "// мороз.",
16505             format("// Я из лесу вышел; был сильный мороз.",
16506                    getLLVMStyleWithColumns(13)));
16507   EXPECT_EQ("// 一二三\n"
16508             "// 四五六七\n"
16509             "// 八  九\n"
16510             "// 十",
16511             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
16512 }
16513 
16514 TEST_F(FormatTest, SplitsUTF8BlockComments) {
16515   EXPECT_EQ("/* Гляжу,\n"
16516             " * поднимается\n"
16517             " * медленно в\n"
16518             " * гору\n"
16519             " * Лошадка,\n"
16520             " * везущая\n"
16521             " * хворосту\n"
16522             " * воз. */",
16523             format("/* Гляжу, поднимается медленно в гору\n"
16524                    " * Лошадка, везущая хворосту воз. */",
16525                    getLLVMStyleWithColumns(13)));
16526   EXPECT_EQ(
16527       "/* 一二三\n"
16528       " * 四五六七\n"
16529       " * 八  九\n"
16530       " * 十  */",
16531       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
16532   EXPECT_EQ("/* �������� ��������\n"
16533             " * ��������\n"
16534             " * ������-�� */",
16535             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
16536 }
16537 
16538 #endif // _MSC_VER
16539 
16540 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
16541   FormatStyle Style = getLLVMStyle();
16542 
16543   Style.ConstructorInitializerIndentWidth = 4;
16544   verifyFormat(
16545       "SomeClass::Constructor()\n"
16546       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
16547       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
16548       Style);
16549 
16550   Style.ConstructorInitializerIndentWidth = 2;
16551   verifyFormat(
16552       "SomeClass::Constructor()\n"
16553       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
16554       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
16555       Style);
16556 
16557   Style.ConstructorInitializerIndentWidth = 0;
16558   verifyFormat(
16559       "SomeClass::Constructor()\n"
16560       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
16561       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
16562       Style);
16563   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
16564   verifyFormat(
16565       "SomeLongTemplateVariableName<\n"
16566       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
16567       Style);
16568   verifyFormat("bool smaller = 1 < "
16569                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
16570                "                       "
16571                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
16572                Style);
16573 
16574   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
16575   verifyFormat("SomeClass::Constructor() :\n"
16576                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
16577                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
16578                Style);
16579 }
16580 
16581 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
16582   FormatStyle Style = getLLVMStyle();
16583   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
16584   Style.ConstructorInitializerIndentWidth = 4;
16585   verifyFormat("SomeClass::Constructor()\n"
16586                "    : a(a)\n"
16587                "    , b(b)\n"
16588                "    , c(c) {}",
16589                Style);
16590   verifyFormat("SomeClass::Constructor()\n"
16591                "    : a(a) {}",
16592                Style);
16593 
16594   Style.ColumnLimit = 0;
16595   verifyFormat("SomeClass::Constructor()\n"
16596                "    : a(a) {}",
16597                Style);
16598   verifyFormat("SomeClass::Constructor() noexcept\n"
16599                "    : a(a) {}",
16600                Style);
16601   verifyFormat("SomeClass::Constructor()\n"
16602                "    : a(a)\n"
16603                "    , b(b)\n"
16604                "    , c(c) {}",
16605                Style);
16606   verifyFormat("SomeClass::Constructor()\n"
16607                "    : a(a) {\n"
16608                "  foo();\n"
16609                "  bar();\n"
16610                "}",
16611                Style);
16612 
16613   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
16614   verifyFormat("SomeClass::Constructor()\n"
16615                "    : a(a)\n"
16616                "    , b(b)\n"
16617                "    , c(c) {\n}",
16618                Style);
16619   verifyFormat("SomeClass::Constructor()\n"
16620                "    : a(a) {\n}",
16621                Style);
16622 
16623   Style.ColumnLimit = 80;
16624   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
16625   Style.ConstructorInitializerIndentWidth = 2;
16626   verifyFormat("SomeClass::Constructor()\n"
16627                "  : a(a)\n"
16628                "  , b(b)\n"
16629                "  , c(c) {}",
16630                Style);
16631 
16632   Style.ConstructorInitializerIndentWidth = 0;
16633   verifyFormat("SomeClass::Constructor()\n"
16634                ": a(a)\n"
16635                ", b(b)\n"
16636                ", c(c) {}",
16637                Style);
16638 
16639   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
16640   Style.ConstructorInitializerIndentWidth = 4;
16641   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
16642   verifyFormat(
16643       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
16644       Style);
16645   verifyFormat(
16646       "SomeClass::Constructor()\n"
16647       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
16648       Style);
16649   Style.ConstructorInitializerIndentWidth = 4;
16650   Style.ColumnLimit = 60;
16651   verifyFormat("SomeClass::Constructor()\n"
16652                "    : aaaaaaaa(aaaaaaaa)\n"
16653                "    , aaaaaaaa(aaaaaaaa)\n"
16654                "    , aaaaaaaa(aaaaaaaa) {}",
16655                Style);
16656 }
16657 
16658 TEST_F(FormatTest, Destructors) {
16659   verifyFormat("void F(int &i) { i.~int(); }");
16660   verifyFormat("void F(int &i) { i->~int(); }");
16661 }
16662 
16663 TEST_F(FormatTest, FormatsWithWebKitStyle) {
16664   FormatStyle Style = getWebKitStyle();
16665 
16666   // Don't indent in outer namespaces.
16667   verifyFormat("namespace outer {\n"
16668                "int i;\n"
16669                "namespace inner {\n"
16670                "    int i;\n"
16671                "} // namespace inner\n"
16672                "} // namespace outer\n"
16673                "namespace other_outer {\n"
16674                "int i;\n"
16675                "}",
16676                Style);
16677 
16678   // Don't indent case labels.
16679   verifyFormat("switch (variable) {\n"
16680                "case 1:\n"
16681                "case 2:\n"
16682                "    doSomething();\n"
16683                "    break;\n"
16684                "default:\n"
16685                "    ++variable;\n"
16686                "}",
16687                Style);
16688 
16689   // Wrap before binary operators.
16690   EXPECT_EQ("void f()\n"
16691             "{\n"
16692             "    if (aaaaaaaaaaaaaaaa\n"
16693             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
16694             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
16695             "        return;\n"
16696             "}",
16697             format("void f() {\n"
16698                    "if (aaaaaaaaaaaaaaaa\n"
16699                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
16700                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
16701                    "return;\n"
16702                    "}",
16703                    Style));
16704 
16705   // Allow functions on a single line.
16706   verifyFormat("void f() { return; }", Style);
16707 
16708   // Allow empty blocks on a single line and insert a space in empty blocks.
16709   EXPECT_EQ("void f() { }", format("void f() {}", Style));
16710   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
16711   // However, don't merge non-empty short loops.
16712   EXPECT_EQ("while (true) {\n"
16713             "    continue;\n"
16714             "}",
16715             format("while (true) { continue; }", Style));
16716 
16717   // Constructor initializers are formatted one per line with the "," on the
16718   // new line.
16719   verifyFormat("Constructor()\n"
16720                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
16721                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
16722                "          aaaaaaaaaaaaaa)\n"
16723                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
16724                "{\n"
16725                "}",
16726                Style);
16727   verifyFormat("SomeClass::Constructor()\n"
16728                "    : a(a)\n"
16729                "{\n"
16730                "}",
16731                Style);
16732   EXPECT_EQ("SomeClass::Constructor()\n"
16733             "    : a(a)\n"
16734             "{\n"
16735             "}",
16736             format("SomeClass::Constructor():a(a){}", Style));
16737   verifyFormat("SomeClass::Constructor()\n"
16738                "    : a(a)\n"
16739                "    , b(b)\n"
16740                "    , c(c)\n"
16741                "{\n"
16742                "}",
16743                Style);
16744   verifyFormat("SomeClass::Constructor()\n"
16745                "    : a(a)\n"
16746                "{\n"
16747                "    foo();\n"
16748                "    bar();\n"
16749                "}",
16750                Style);
16751 
16752   // Access specifiers should be aligned left.
16753   verifyFormat("class C {\n"
16754                "public:\n"
16755                "    int i;\n"
16756                "};",
16757                Style);
16758 
16759   // Do not align comments.
16760   verifyFormat("int a; // Do not\n"
16761                "double b; // align comments.",
16762                Style);
16763 
16764   // Do not align operands.
16765   EXPECT_EQ("ASSERT(aaaa\n"
16766             "    || bbbb);",
16767             format("ASSERT ( aaaa\n||bbbb);", Style));
16768 
16769   // Accept input's line breaks.
16770   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
16771             "    || bbbbbbbbbbbbbbb) {\n"
16772             "    i++;\n"
16773             "}",
16774             format("if (aaaaaaaaaaaaaaa\n"
16775                    "|| bbbbbbbbbbbbbbb) { i++; }",
16776                    Style));
16777   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
16778             "    i++;\n"
16779             "}",
16780             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
16781 
16782   // Don't automatically break all macro definitions (llvm.org/PR17842).
16783   verifyFormat("#define aNumber 10", Style);
16784   // However, generally keep the line breaks that the user authored.
16785   EXPECT_EQ("#define aNumber \\\n"
16786             "    10",
16787             format("#define aNumber \\\n"
16788                    " 10",
16789                    Style));
16790 
16791   // Keep empty and one-element array literals on a single line.
16792   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
16793             "                                  copyItems:YES];",
16794             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
16795                    "copyItems:YES];",
16796                    Style));
16797   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
16798             "                                  copyItems:YES];",
16799             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
16800                    "             copyItems:YES];",
16801                    Style));
16802   // FIXME: This does not seem right, there should be more indentation before
16803   // the array literal's entries. Nested blocks have the same problem.
16804   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
16805             "    @\"a\",\n"
16806             "    @\"a\"\n"
16807             "]\n"
16808             "                                  copyItems:YES];",
16809             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
16810                    "     @\"a\",\n"
16811                    "     @\"a\"\n"
16812                    "     ]\n"
16813                    "       copyItems:YES];",
16814                    Style));
16815   EXPECT_EQ(
16816       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
16817       "                                  copyItems:YES];",
16818       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
16819              "   copyItems:YES];",
16820              Style));
16821 
16822   verifyFormat("[self.a b:c c:d];", Style);
16823   EXPECT_EQ("[self.a b:c\n"
16824             "        c:d];",
16825             format("[self.a b:c\n"
16826                    "c:d];",
16827                    Style));
16828 }
16829 
16830 TEST_F(FormatTest, FormatsLambdas) {
16831   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
16832   verifyFormat(
16833       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
16834   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
16835   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
16836   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
16837   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
16838   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
16839   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
16840   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
16841   verifyFormat("int x = f(*+[] {});");
16842   verifyFormat("void f() {\n"
16843                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
16844                "}\n");
16845   verifyFormat("void f() {\n"
16846                "  other(x.begin(), //\n"
16847                "        x.end(),   //\n"
16848                "        [&](int, int) { return 1; });\n"
16849                "}\n");
16850   verifyFormat("void f() {\n"
16851                "  other.other.other.other.other(\n"
16852                "      x.begin(), x.end(),\n"
16853                "      [something, rather](int, int, int, int, int, int, int) { "
16854                "return 1; });\n"
16855                "}\n");
16856   verifyFormat(
16857       "void f() {\n"
16858       "  other.other.other.other.other(\n"
16859       "      x.begin(), x.end(),\n"
16860       "      [something, rather](int, int, int, int, int, int, int) {\n"
16861       "        //\n"
16862       "      });\n"
16863       "}\n");
16864   verifyFormat("SomeFunction([]() { // A cool function...\n"
16865                "  return 43;\n"
16866                "});");
16867   EXPECT_EQ("SomeFunction([]() {\n"
16868             "#define A a\n"
16869             "  return 43;\n"
16870             "});",
16871             format("SomeFunction([](){\n"
16872                    "#define A a\n"
16873                    "return 43;\n"
16874                    "});"));
16875   verifyFormat("void f() {\n"
16876                "  SomeFunction([](decltype(x), A *a) {});\n"
16877                "  SomeFunction([](typeof(x), A *a) {});\n"
16878                "  SomeFunction([](_Atomic(x), A *a) {});\n"
16879                "  SomeFunction([](__underlying_type(x), A *a) {});\n"
16880                "}");
16881   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
16882                "    [](const aaaaaaaaaa &a) { return a; });");
16883   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
16884                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
16885                "});");
16886   verifyFormat("Constructor()\n"
16887                "    : Field([] { // comment\n"
16888                "        int i;\n"
16889                "      }) {}");
16890   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
16891                "  return some_parameter.size();\n"
16892                "};");
16893   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
16894                "    [](const string &s) { return s; };");
16895   verifyFormat("int i = aaaaaa ? 1 //\n"
16896                "               : [] {\n"
16897                "                   return 2; //\n"
16898                "                 }();");
16899   verifyFormat("llvm::errs() << \"number of twos is \"\n"
16900                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
16901                "                  return x == 2; // force break\n"
16902                "                });");
16903   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
16904                "    [=](int iiiiiiiiiiii) {\n"
16905                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
16906                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
16907                "    });",
16908                getLLVMStyleWithColumns(60));
16909   verifyFormat("SomeFunction({[&] {\n"
16910                "                // comment\n"
16911                "              },\n"
16912                "              [&] {\n"
16913                "                // comment\n"
16914                "              }});");
16915   verifyFormat("SomeFunction({[&] {\n"
16916                "  // comment\n"
16917                "}});");
16918   verifyFormat(
16919       "virtual aaaaaaaaaaaaaaaa(\n"
16920       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
16921       "    aaaaa aaaaaaaaa);");
16922 
16923   // Lambdas with return types.
16924   verifyFormat("int c = []() -> int { return 2; }();\n");
16925   verifyFormat("int c = []() -> int * { return 2; }();\n");
16926   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
16927   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
16928   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
16929   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
16930   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
16931   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
16932   verifyFormat("[a, a]() -> a<1> {};");
16933   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
16934   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
16935   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
16936   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
16937   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
16938   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
16939   verifyFormat("[]() -> foo<!5> { return {}; };");
16940   verifyFormat("[]() -> foo<~5> { return {}; };");
16941   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
16942   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
16943   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
16944   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
16945   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
16946   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
16947   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
16948   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
16949   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
16950   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
16951   verifyFormat("namespace bar {\n"
16952                "// broken:\n"
16953                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
16954                "} // namespace bar");
16955   verifyFormat("namespace bar {\n"
16956                "// broken:\n"
16957                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
16958                "} // namespace bar");
16959   verifyFormat("namespace bar {\n"
16960                "// broken:\n"
16961                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
16962                "} // namespace bar");
16963   verifyFormat("namespace bar {\n"
16964                "// broken:\n"
16965                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
16966                "} // namespace bar");
16967   verifyFormat("namespace bar {\n"
16968                "// broken:\n"
16969                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
16970                "} // namespace bar");
16971   verifyFormat("namespace bar {\n"
16972                "// broken:\n"
16973                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
16974                "} // namespace bar");
16975   verifyFormat("namespace bar {\n"
16976                "// broken:\n"
16977                "auto foo{[]() -> foo<!5> { return {}; }};\n"
16978                "} // namespace bar");
16979   verifyFormat("namespace bar {\n"
16980                "// broken:\n"
16981                "auto foo{[]() -> foo<~5> { return {}; }};\n"
16982                "} // namespace bar");
16983   verifyFormat("namespace bar {\n"
16984                "// broken:\n"
16985                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
16986                "} // namespace bar");
16987   verifyFormat("namespace bar {\n"
16988                "// broken:\n"
16989                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
16990                "} // namespace bar");
16991   verifyFormat("namespace bar {\n"
16992                "// broken:\n"
16993                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
16994                "} // namespace bar");
16995   verifyFormat("namespace bar {\n"
16996                "// broken:\n"
16997                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
16998                "} // namespace bar");
16999   verifyFormat("namespace bar {\n"
17000                "// broken:\n"
17001                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
17002                "} // namespace bar");
17003   verifyFormat("namespace bar {\n"
17004                "// broken:\n"
17005                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
17006                "} // namespace bar");
17007   verifyFormat("namespace bar {\n"
17008                "// broken:\n"
17009                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
17010                "} // namespace bar");
17011   verifyFormat("namespace bar {\n"
17012                "// broken:\n"
17013                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
17014                "} // namespace bar");
17015   verifyFormat("namespace bar {\n"
17016                "// broken:\n"
17017                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
17018                "} // namespace bar");
17019   verifyFormat("namespace bar {\n"
17020                "// broken:\n"
17021                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
17022                "} // namespace bar");
17023   verifyFormat("[]() -> a<1> {};");
17024   verifyFormat("[]() -> a<1> { ; };");
17025   verifyFormat("[]() -> a<1> { ; }();");
17026   verifyFormat("[a, a]() -> a<true> {};");
17027   verifyFormat("[]() -> a<true> {};");
17028   verifyFormat("[]() -> a<true> { ; };");
17029   verifyFormat("[]() -> a<true> { ; }();");
17030   verifyFormat("[a, a]() -> a<false> {};");
17031   verifyFormat("[]() -> a<false> {};");
17032   verifyFormat("[]() -> a<false> { ; };");
17033   verifyFormat("[]() -> a<false> { ; }();");
17034   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
17035   verifyFormat("namespace bar {\n"
17036                "auto foo{[]() -> foo<false> { ; }};\n"
17037                "} // namespace bar");
17038   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
17039                "                   int j) -> int {\n"
17040                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
17041                "};");
17042   verifyFormat(
17043       "aaaaaaaaaaaaaaaaaaaaaa(\n"
17044       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
17045       "      return aaaaaaaaaaaaaaaaa;\n"
17046       "    });",
17047       getLLVMStyleWithColumns(70));
17048   verifyFormat("[]() //\n"
17049                "    -> int {\n"
17050                "  return 1; //\n"
17051                "};");
17052   verifyFormat("[]() -> Void<T...> {};");
17053   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
17054 
17055   // Lambdas with explicit template argument lists.
17056   verifyFormat(
17057       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
17058 
17059   // Multiple lambdas in the same parentheses change indentation rules. These
17060   // lambdas are forced to start on new lines.
17061   verifyFormat("SomeFunction(\n"
17062                "    []() {\n"
17063                "      //\n"
17064                "    },\n"
17065                "    []() {\n"
17066                "      //\n"
17067                "    });");
17068 
17069   // A lambda passed as arg0 is always pushed to the next line.
17070   verifyFormat("SomeFunction(\n"
17071                "    [this] {\n"
17072                "      //\n"
17073                "    },\n"
17074                "    1);\n");
17075 
17076   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
17077   // the arg0 case above.
17078   auto Style = getGoogleStyle();
17079   Style.BinPackArguments = false;
17080   verifyFormat("SomeFunction(\n"
17081                "    a,\n"
17082                "    [this] {\n"
17083                "      //\n"
17084                "    },\n"
17085                "    b);\n",
17086                Style);
17087   verifyFormat("SomeFunction(\n"
17088                "    a,\n"
17089                "    [this] {\n"
17090                "      //\n"
17091                "    },\n"
17092                "    b);\n");
17093 
17094   // A lambda with a very long line forces arg0 to be pushed out irrespective of
17095   // the BinPackArguments value (as long as the code is wide enough).
17096   verifyFormat(
17097       "something->SomeFunction(\n"
17098       "    a,\n"
17099       "    [this] {\n"
17100       "      "
17101       "D0000000000000000000000000000000000000000000000000000000000001();\n"
17102       "    },\n"
17103       "    b);\n");
17104 
17105   // A multi-line lambda is pulled up as long as the introducer fits on the
17106   // previous line and there are no further args.
17107   verifyFormat("function(1, [this, that] {\n"
17108                "  //\n"
17109                "});\n");
17110   verifyFormat("function([this, that] {\n"
17111                "  //\n"
17112                "});\n");
17113   // FIXME: this format is not ideal and we should consider forcing the first
17114   // arg onto its own line.
17115   verifyFormat("function(a, b, c, //\n"
17116                "         d, [this, that] {\n"
17117                "           //\n"
17118                "         });\n");
17119 
17120   // Multiple lambdas are treated correctly even when there is a short arg0.
17121   verifyFormat("SomeFunction(\n"
17122                "    1,\n"
17123                "    [this] {\n"
17124                "      //\n"
17125                "    },\n"
17126                "    [this] {\n"
17127                "      //\n"
17128                "    },\n"
17129                "    1);\n");
17130 
17131   // More complex introducers.
17132   verifyFormat("return [i, args...] {};");
17133 
17134   // Not lambdas.
17135   verifyFormat("constexpr char hello[]{\"hello\"};");
17136   verifyFormat("double &operator[](int i) { return 0; }\n"
17137                "int i;");
17138   verifyFormat("std::unique_ptr<int[]> foo() {}");
17139   verifyFormat("int i = a[a][a]->f();");
17140   verifyFormat("int i = (*b)[a]->f();");
17141 
17142   // Other corner cases.
17143   verifyFormat("void f() {\n"
17144                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
17145                "  );\n"
17146                "}");
17147 
17148   // Lambdas created through weird macros.
17149   verifyFormat("void f() {\n"
17150                "  MACRO((const AA &a) { return 1; });\n"
17151                "  MACRO((AA &a) { return 1; });\n"
17152                "}");
17153 
17154   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
17155                "      doo_dah();\n"
17156                "      doo_dah();\n"
17157                "    })) {\n"
17158                "}");
17159   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
17160                "                doo_dah();\n"
17161                "                doo_dah();\n"
17162                "              })) {\n"
17163                "}");
17164   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
17165                "                doo_dah();\n"
17166                "                doo_dah();\n"
17167                "              })) {\n"
17168                "}");
17169   verifyFormat("auto lambda = []() {\n"
17170                "  int a = 2\n"
17171                "#if A\n"
17172                "          + 2\n"
17173                "#endif\n"
17174                "      ;\n"
17175                "};");
17176 
17177   // Lambdas with complex multiline introducers.
17178   verifyFormat(
17179       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
17180       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
17181       "        -> ::std::unordered_set<\n"
17182       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
17183       "      //\n"
17184       "    });");
17185 
17186   FormatStyle DoNotMerge = getLLVMStyle();
17187   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
17188   verifyFormat("auto c = []() {\n"
17189                "  return b;\n"
17190                "};",
17191                "auto c = []() { return b; };", DoNotMerge);
17192   verifyFormat("auto c = []() {\n"
17193                "};",
17194                " auto c = []() {};", DoNotMerge);
17195 
17196   FormatStyle MergeEmptyOnly = getLLVMStyle();
17197   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
17198   verifyFormat("auto c = []() {\n"
17199                "  return b;\n"
17200                "};",
17201                "auto c = []() {\n"
17202                "  return b;\n"
17203                " };",
17204                MergeEmptyOnly);
17205   verifyFormat("auto c = []() {};",
17206                "auto c = []() {\n"
17207                "};",
17208                MergeEmptyOnly);
17209 
17210   FormatStyle MergeInline = getLLVMStyle();
17211   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
17212   verifyFormat("auto c = []() {\n"
17213                "  return b;\n"
17214                "};",
17215                "auto c = []() { return b; };", MergeInline);
17216   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
17217                MergeInline);
17218   verifyFormat("function([]() { return b; }, a)",
17219                "function([]() { return b; }, a)", MergeInline);
17220   verifyFormat("function(a, []() { return b; })",
17221                "function(a, []() { return b; })", MergeInline);
17222 
17223   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
17224   // AllowShortLambdasOnASingleLine
17225   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
17226   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
17227   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
17228   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
17229       FormatStyle::ShortLambdaStyle::SLS_None;
17230   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
17231                "    []()\n"
17232                "    {\n"
17233                "      return 17;\n"
17234                "    });",
17235                LLVMWithBeforeLambdaBody);
17236   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
17237                "    []()\n"
17238                "    {\n"
17239                "    });",
17240                LLVMWithBeforeLambdaBody);
17241   verifyFormat("auto fct_SLS_None = []()\n"
17242                "{\n"
17243                "  return 17;\n"
17244                "};",
17245                LLVMWithBeforeLambdaBody);
17246   verifyFormat("TwoNestedLambdas_SLS_None(\n"
17247                "    []()\n"
17248                "    {\n"
17249                "      return Call(\n"
17250                "          []()\n"
17251                "          {\n"
17252                "            return 17;\n"
17253                "          });\n"
17254                "    });",
17255                LLVMWithBeforeLambdaBody);
17256   verifyFormat("void Fct()\n"
17257                "{\n"
17258                "  return {[]()\n"
17259                "          {\n"
17260                "            return 17;\n"
17261                "          }};\n"
17262                "}",
17263                LLVMWithBeforeLambdaBody);
17264 
17265   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
17266       FormatStyle::ShortLambdaStyle::SLS_Empty;
17267   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
17268                "    []()\n"
17269                "    {\n"
17270                "      return 17;\n"
17271                "    });",
17272                LLVMWithBeforeLambdaBody);
17273   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
17274                LLVMWithBeforeLambdaBody);
17275   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
17276                "ongFunctionName_SLS_Empty(\n"
17277                "    []() {});",
17278                LLVMWithBeforeLambdaBody);
17279   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
17280                "                                []()\n"
17281                "                                {\n"
17282                "                                  return 17;\n"
17283                "                                });",
17284                LLVMWithBeforeLambdaBody);
17285   verifyFormat("auto fct_SLS_Empty = []()\n"
17286                "{\n"
17287                "  return 17;\n"
17288                "};",
17289                LLVMWithBeforeLambdaBody);
17290   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
17291                "    []()\n"
17292                "    {\n"
17293                "      return Call([]() {});\n"
17294                "    });",
17295                LLVMWithBeforeLambdaBody);
17296   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
17297                "                           []()\n"
17298                "                           {\n"
17299                "                             return Call([]() {});\n"
17300                "                           });",
17301                LLVMWithBeforeLambdaBody);
17302   verifyFormat(
17303       "FctWithLongLineInLambda_SLS_Empty(\n"
17304       "    []()\n"
17305       "    {\n"
17306       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
17307       "                               AndShouldNotBeConsiderAsInline,\n"
17308       "                               LambdaBodyMustBeBreak);\n"
17309       "    });",
17310       LLVMWithBeforeLambdaBody);
17311 
17312   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
17313       FormatStyle::ShortLambdaStyle::SLS_Inline;
17314   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
17315                LLVMWithBeforeLambdaBody);
17316   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
17317                LLVMWithBeforeLambdaBody);
17318   verifyFormat("auto fct_SLS_Inline = []()\n"
17319                "{\n"
17320                "  return 17;\n"
17321                "};",
17322                LLVMWithBeforeLambdaBody);
17323   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
17324                "17; }); });",
17325                LLVMWithBeforeLambdaBody);
17326   verifyFormat(
17327       "FctWithLongLineInLambda_SLS_Inline(\n"
17328       "    []()\n"
17329       "    {\n"
17330       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
17331       "                               AndShouldNotBeConsiderAsInline,\n"
17332       "                               LambdaBodyMustBeBreak);\n"
17333       "    });",
17334       LLVMWithBeforeLambdaBody);
17335   verifyFormat("FctWithMultipleParams_SLS_Inline("
17336                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
17337                "                                 []() { return 17; });",
17338                LLVMWithBeforeLambdaBody);
17339   verifyFormat(
17340       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
17341       LLVMWithBeforeLambdaBody);
17342 
17343   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
17344       FormatStyle::ShortLambdaStyle::SLS_All;
17345   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
17346                LLVMWithBeforeLambdaBody);
17347   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
17348                LLVMWithBeforeLambdaBody);
17349   verifyFormat("auto fct_SLS_All = []() { return 17; };",
17350                LLVMWithBeforeLambdaBody);
17351   verifyFormat("FctWithOneParam_SLS_All(\n"
17352                "    []()\n"
17353                "    {\n"
17354                "      // A cool function...\n"
17355                "      return 43;\n"
17356                "    });",
17357                LLVMWithBeforeLambdaBody);
17358   verifyFormat("FctWithMultipleParams_SLS_All("
17359                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
17360                "                              []() { return 17; });",
17361                LLVMWithBeforeLambdaBody);
17362   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
17363                LLVMWithBeforeLambdaBody);
17364   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
17365                LLVMWithBeforeLambdaBody);
17366   verifyFormat(
17367       "FctWithLongLineInLambda_SLS_All(\n"
17368       "    []()\n"
17369       "    {\n"
17370       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
17371       "                               AndShouldNotBeConsiderAsInline,\n"
17372       "                               LambdaBodyMustBeBreak);\n"
17373       "    });",
17374       LLVMWithBeforeLambdaBody);
17375   verifyFormat(
17376       "auto fct_SLS_All = []()\n"
17377       "{\n"
17378       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
17379       "                           AndShouldNotBeConsiderAsInline,\n"
17380       "                           LambdaBodyMustBeBreak);\n"
17381       "};",
17382       LLVMWithBeforeLambdaBody);
17383   LLVMWithBeforeLambdaBody.BinPackParameters = false;
17384   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
17385                LLVMWithBeforeLambdaBody);
17386   verifyFormat(
17387       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
17388       "                                FirstParam,\n"
17389       "                                SecondParam,\n"
17390       "                                ThirdParam,\n"
17391       "                                FourthParam);",
17392       LLVMWithBeforeLambdaBody);
17393   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
17394                "    []() { return "
17395                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
17396                "    FirstParam,\n"
17397                "    SecondParam,\n"
17398                "    ThirdParam,\n"
17399                "    FourthParam);",
17400                LLVMWithBeforeLambdaBody);
17401   verifyFormat(
17402       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
17403       "                                SecondParam,\n"
17404       "                                ThirdParam,\n"
17405       "                                FourthParam,\n"
17406       "                                []() { return SomeValueNotSoLong; });",
17407       LLVMWithBeforeLambdaBody);
17408   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
17409                "    []()\n"
17410                "    {\n"
17411                "      return "
17412                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
17413                "eConsiderAsInline;\n"
17414                "    });",
17415                LLVMWithBeforeLambdaBody);
17416   verifyFormat(
17417       "FctWithLongLineInLambda_SLS_All(\n"
17418       "    []()\n"
17419       "    {\n"
17420       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
17421       "                               AndShouldNotBeConsiderAsInline,\n"
17422       "                               LambdaBodyMustBeBreak);\n"
17423       "    });",
17424       LLVMWithBeforeLambdaBody);
17425   verifyFormat("FctWithTwoParams_SLS_All(\n"
17426                "    []()\n"
17427                "    {\n"
17428                "      // A cool function...\n"
17429                "      return 43;\n"
17430                "    },\n"
17431                "    87);",
17432                LLVMWithBeforeLambdaBody);
17433   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
17434                LLVMWithBeforeLambdaBody);
17435   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
17436                LLVMWithBeforeLambdaBody);
17437   verifyFormat(
17438       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
17439       LLVMWithBeforeLambdaBody);
17440   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
17441                "}); }, x);",
17442                LLVMWithBeforeLambdaBody);
17443   verifyFormat("TwoNestedLambdas_SLS_All(\n"
17444                "    []()\n"
17445                "    {\n"
17446                "      // A cool function...\n"
17447                "      return Call([]() { return 17; });\n"
17448                "    });",
17449                LLVMWithBeforeLambdaBody);
17450   verifyFormat("TwoNestedLambdas_SLS_All(\n"
17451                "    []()\n"
17452                "    {\n"
17453                "      return Call(\n"
17454                "          []()\n"
17455                "          {\n"
17456                "            // A cool function...\n"
17457                "            return 17;\n"
17458                "          });\n"
17459                "    });",
17460                LLVMWithBeforeLambdaBody);
17461 }
17462 
17463 TEST_F(FormatTest, LambdaWithLineComments) {
17464   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
17465   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
17466   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
17467   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
17468       FormatStyle::ShortLambdaStyle::SLS_All;
17469 
17470   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
17471   verifyFormat("auto k = []() // comment\n"
17472                "{ return; }",
17473                LLVMWithBeforeLambdaBody);
17474   verifyFormat("auto k = []() /* comment */ { return; }",
17475                LLVMWithBeforeLambdaBody);
17476   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
17477                LLVMWithBeforeLambdaBody);
17478   verifyFormat("auto k = []() // X\n"
17479                "{ return; }",
17480                LLVMWithBeforeLambdaBody);
17481   verifyFormat(
17482       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
17483       "{ return; }",
17484       LLVMWithBeforeLambdaBody);
17485 }
17486 
17487 TEST_F(FormatTest, EmptyLinesInLambdas) {
17488   verifyFormat("auto lambda = []() {\n"
17489                "  x(); //\n"
17490                "};",
17491                "auto lambda = []() {\n"
17492                "\n"
17493                "  x(); //\n"
17494                "\n"
17495                "};");
17496 }
17497 
17498 TEST_F(FormatTest, FormatsBlocks) {
17499   FormatStyle ShortBlocks = getLLVMStyle();
17500   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
17501   verifyFormat("int (^Block)(int, int);", ShortBlocks);
17502   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
17503   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
17504   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
17505   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
17506   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
17507 
17508   verifyFormat("foo(^{ bar(); });", ShortBlocks);
17509   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
17510   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
17511 
17512   verifyFormat("[operation setCompletionBlock:^{\n"
17513                "  [self onOperationDone];\n"
17514                "}];");
17515   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
17516                "  [self onOperationDone];\n"
17517                "}]};");
17518   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
17519                "  f();\n"
17520                "}];");
17521   verifyFormat("int a = [operation block:^int(int *i) {\n"
17522                "  return 1;\n"
17523                "}];");
17524   verifyFormat("[myObject doSomethingWith:arg1\n"
17525                "                      aaa:^int(int *a) {\n"
17526                "                        return 1;\n"
17527                "                      }\n"
17528                "                      bbb:f(a * bbbbbbbb)];");
17529 
17530   verifyFormat("[operation setCompletionBlock:^{\n"
17531                "  [self.delegate newDataAvailable];\n"
17532                "}];",
17533                getLLVMStyleWithColumns(60));
17534   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
17535                "  NSString *path = [self sessionFilePath];\n"
17536                "  if (path) {\n"
17537                "    // ...\n"
17538                "  }\n"
17539                "});");
17540   verifyFormat("[[SessionService sharedService]\n"
17541                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
17542                "      if (window) {\n"
17543                "        [self windowDidLoad:window];\n"
17544                "      } else {\n"
17545                "        [self errorLoadingWindow];\n"
17546                "      }\n"
17547                "    }];");
17548   verifyFormat("void (^largeBlock)(void) = ^{\n"
17549                "  // ...\n"
17550                "};\n",
17551                getLLVMStyleWithColumns(40));
17552   verifyFormat("[[SessionService sharedService]\n"
17553                "    loadWindowWithCompletionBlock: //\n"
17554                "        ^(SessionWindow *window) {\n"
17555                "          if (window) {\n"
17556                "            [self windowDidLoad:window];\n"
17557                "          } else {\n"
17558                "            [self errorLoadingWindow];\n"
17559                "          }\n"
17560                "        }];",
17561                getLLVMStyleWithColumns(60));
17562   verifyFormat("[myObject doSomethingWith:arg1\n"
17563                "    firstBlock:^(Foo *a) {\n"
17564                "      // ...\n"
17565                "      int i;\n"
17566                "    }\n"
17567                "    secondBlock:^(Bar *b) {\n"
17568                "      // ...\n"
17569                "      int i;\n"
17570                "    }\n"
17571                "    thirdBlock:^Foo(Bar *b) {\n"
17572                "      // ...\n"
17573                "      int i;\n"
17574                "    }];");
17575   verifyFormat("[myObject doSomethingWith:arg1\n"
17576                "               firstBlock:-1\n"
17577                "              secondBlock:^(Bar *b) {\n"
17578                "                // ...\n"
17579                "                int i;\n"
17580                "              }];");
17581 
17582   verifyFormat("f(^{\n"
17583                "  @autoreleasepool {\n"
17584                "    if (a) {\n"
17585                "      g();\n"
17586                "    }\n"
17587                "  }\n"
17588                "});");
17589   verifyFormat("Block b = ^int *(A *a, B *b) {}");
17590   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
17591                "};");
17592 
17593   FormatStyle FourIndent = getLLVMStyle();
17594   FourIndent.ObjCBlockIndentWidth = 4;
17595   verifyFormat("[operation setCompletionBlock:^{\n"
17596                "    [self onOperationDone];\n"
17597                "}];",
17598                FourIndent);
17599 }
17600 
17601 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
17602   FormatStyle ZeroColumn = getLLVMStyle();
17603   ZeroColumn.ColumnLimit = 0;
17604 
17605   verifyFormat("[[SessionService sharedService] "
17606                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
17607                "  if (window) {\n"
17608                "    [self windowDidLoad:window];\n"
17609                "  } else {\n"
17610                "    [self errorLoadingWindow];\n"
17611                "  }\n"
17612                "}];",
17613                ZeroColumn);
17614   EXPECT_EQ("[[SessionService sharedService]\n"
17615             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
17616             "      if (window) {\n"
17617             "        [self windowDidLoad:window];\n"
17618             "      } else {\n"
17619             "        [self errorLoadingWindow];\n"
17620             "      }\n"
17621             "    }];",
17622             format("[[SessionService sharedService]\n"
17623                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
17624                    "                if (window) {\n"
17625                    "    [self windowDidLoad:window];\n"
17626                    "  } else {\n"
17627                    "    [self errorLoadingWindow];\n"
17628                    "  }\n"
17629                    "}];",
17630                    ZeroColumn));
17631   verifyFormat("[myObject doSomethingWith:arg1\n"
17632                "    firstBlock:^(Foo *a) {\n"
17633                "      // ...\n"
17634                "      int i;\n"
17635                "    }\n"
17636                "    secondBlock:^(Bar *b) {\n"
17637                "      // ...\n"
17638                "      int i;\n"
17639                "    }\n"
17640                "    thirdBlock:^Foo(Bar *b) {\n"
17641                "      // ...\n"
17642                "      int i;\n"
17643                "    }];",
17644                ZeroColumn);
17645   verifyFormat("f(^{\n"
17646                "  @autoreleasepool {\n"
17647                "    if (a) {\n"
17648                "      g();\n"
17649                "    }\n"
17650                "  }\n"
17651                "});",
17652                ZeroColumn);
17653   verifyFormat("void (^largeBlock)(void) = ^{\n"
17654                "  // ...\n"
17655                "};",
17656                ZeroColumn);
17657 
17658   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
17659   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
17660             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
17661   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
17662   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
17663             "  int i;\n"
17664             "};",
17665             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
17666 }
17667 
17668 TEST_F(FormatTest, SupportsCRLF) {
17669   EXPECT_EQ("int a;\r\n"
17670             "int b;\r\n"
17671             "int c;\r\n",
17672             format("int a;\r\n"
17673                    "  int b;\r\n"
17674                    "    int c;\r\n",
17675                    getLLVMStyle()));
17676   EXPECT_EQ("int a;\r\n"
17677             "int b;\r\n"
17678             "int c;\r\n",
17679             format("int a;\r\n"
17680                    "  int b;\n"
17681                    "    int c;\r\n",
17682                    getLLVMStyle()));
17683   EXPECT_EQ("int a;\n"
17684             "int b;\n"
17685             "int c;\n",
17686             format("int a;\r\n"
17687                    "  int b;\n"
17688                    "    int c;\n",
17689                    getLLVMStyle()));
17690   EXPECT_EQ("\"aaaaaaa \"\r\n"
17691             "\"bbbbbbb\";\r\n",
17692             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
17693   EXPECT_EQ("#define A \\\r\n"
17694             "  b;      \\\r\n"
17695             "  c;      \\\r\n"
17696             "  d;\r\n",
17697             format("#define A \\\r\n"
17698                    "  b; \\\r\n"
17699                    "  c; d; \r\n",
17700                    getGoogleStyle()));
17701 
17702   EXPECT_EQ("/*\r\n"
17703             "multi line block comments\r\n"
17704             "should not introduce\r\n"
17705             "an extra carriage return\r\n"
17706             "*/\r\n",
17707             format("/*\r\n"
17708                    "multi line block comments\r\n"
17709                    "should not introduce\r\n"
17710                    "an extra carriage return\r\n"
17711                    "*/\r\n"));
17712   EXPECT_EQ("/*\r\n"
17713             "\r\n"
17714             "*/",
17715             format("/*\r\n"
17716                    "    \r\r\r\n"
17717                    "*/"));
17718 
17719   FormatStyle style = getLLVMStyle();
17720 
17721   style.DeriveLineEnding = true;
17722   style.UseCRLF = false;
17723   EXPECT_EQ("union FooBarBazQux {\n"
17724             "  int foo;\n"
17725             "  int bar;\n"
17726             "  int baz;\n"
17727             "};",
17728             format("union FooBarBazQux {\r\n"
17729                    "  int foo;\n"
17730                    "  int bar;\r\n"
17731                    "  int baz;\n"
17732                    "};",
17733                    style));
17734   style.UseCRLF = true;
17735   EXPECT_EQ("union FooBarBazQux {\r\n"
17736             "  int foo;\r\n"
17737             "  int bar;\r\n"
17738             "  int baz;\r\n"
17739             "};",
17740             format("union FooBarBazQux {\r\n"
17741                    "  int foo;\n"
17742                    "  int bar;\r\n"
17743                    "  int baz;\n"
17744                    "};",
17745                    style));
17746 
17747   style.DeriveLineEnding = false;
17748   style.UseCRLF = false;
17749   EXPECT_EQ("union FooBarBazQux {\n"
17750             "  int foo;\n"
17751             "  int bar;\n"
17752             "  int baz;\n"
17753             "  int qux;\n"
17754             "};",
17755             format("union FooBarBazQux {\r\n"
17756                    "  int foo;\n"
17757                    "  int bar;\r\n"
17758                    "  int baz;\n"
17759                    "  int qux;\r\n"
17760                    "};",
17761                    style));
17762   style.UseCRLF = true;
17763   EXPECT_EQ("union FooBarBazQux {\r\n"
17764             "  int foo;\r\n"
17765             "  int bar;\r\n"
17766             "  int baz;\r\n"
17767             "  int qux;\r\n"
17768             "};",
17769             format("union FooBarBazQux {\r\n"
17770                    "  int foo;\n"
17771                    "  int bar;\r\n"
17772                    "  int baz;\n"
17773                    "  int qux;\n"
17774                    "};",
17775                    style));
17776 
17777   style.DeriveLineEnding = true;
17778   style.UseCRLF = false;
17779   EXPECT_EQ("union FooBarBazQux {\r\n"
17780             "  int foo;\r\n"
17781             "  int bar;\r\n"
17782             "  int baz;\r\n"
17783             "  int qux;\r\n"
17784             "};",
17785             format("union FooBarBazQux {\r\n"
17786                    "  int foo;\n"
17787                    "  int bar;\r\n"
17788                    "  int baz;\n"
17789                    "  int qux;\r\n"
17790                    "};",
17791                    style));
17792   style.UseCRLF = true;
17793   EXPECT_EQ("union FooBarBazQux {\n"
17794             "  int foo;\n"
17795             "  int bar;\n"
17796             "  int baz;\n"
17797             "  int qux;\n"
17798             "};",
17799             format("union FooBarBazQux {\r\n"
17800                    "  int foo;\n"
17801                    "  int bar;\r\n"
17802                    "  int baz;\n"
17803                    "  int qux;\n"
17804                    "};",
17805                    style));
17806 }
17807 
17808 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
17809   verifyFormat("MY_CLASS(C) {\n"
17810                "  int i;\n"
17811                "  int j;\n"
17812                "};");
17813 }
17814 
17815 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
17816   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
17817   TwoIndent.ContinuationIndentWidth = 2;
17818 
17819   EXPECT_EQ("int i =\n"
17820             "  longFunction(\n"
17821             "    arg);",
17822             format("int i = longFunction(arg);", TwoIndent));
17823 
17824   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
17825   SixIndent.ContinuationIndentWidth = 6;
17826 
17827   EXPECT_EQ("int i =\n"
17828             "      longFunction(\n"
17829             "            arg);",
17830             format("int i = longFunction(arg);", SixIndent));
17831 }
17832 
17833 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
17834   FormatStyle Style = getLLVMStyle();
17835   verifyFormat("int Foo::getter(\n"
17836                "    //\n"
17837                ") const {\n"
17838                "  return foo;\n"
17839                "}",
17840                Style);
17841   verifyFormat("void Foo::setter(\n"
17842                "    //\n"
17843                ") {\n"
17844                "  foo = 1;\n"
17845                "}",
17846                Style);
17847 }
17848 
17849 TEST_F(FormatTest, SpacesInAngles) {
17850   FormatStyle Spaces = getLLVMStyle();
17851   Spaces.SpacesInAngles = true;
17852 
17853   verifyFormat("static_cast< int >(arg);", Spaces);
17854   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
17855   verifyFormat("f< int, float >();", Spaces);
17856   verifyFormat("template <> g() {}", Spaces);
17857   verifyFormat("template < std::vector< int > > f() {}", Spaces);
17858   verifyFormat("std::function< void(int, int) > fct;", Spaces);
17859   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
17860                Spaces);
17861 
17862   Spaces.Standard = FormatStyle::LS_Cpp03;
17863   Spaces.SpacesInAngles = true;
17864   verifyFormat("A< A< int > >();", Spaces);
17865 
17866   Spaces.SpacesInAngles = false;
17867   verifyFormat("A<A<int> >();", Spaces);
17868 
17869   Spaces.Standard = FormatStyle::LS_Cpp11;
17870   Spaces.SpacesInAngles = true;
17871   verifyFormat("A< A< int > >();", Spaces);
17872 
17873   Spaces.SpacesInAngles = false;
17874   verifyFormat("A<A<int>>();", Spaces);
17875 }
17876 
17877 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
17878   FormatStyle Style = getLLVMStyle();
17879   Style.SpaceAfterTemplateKeyword = false;
17880   verifyFormat("template<int> void foo();", Style);
17881 }
17882 
17883 TEST_F(FormatTest, TripleAngleBrackets) {
17884   verifyFormat("f<<<1, 1>>>();");
17885   verifyFormat("f<<<1, 1, 1, s>>>();");
17886   verifyFormat("f<<<a, b, c, d>>>();");
17887   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
17888   verifyFormat("f<param><<<1, 1>>>();");
17889   verifyFormat("f<1><<<1, 1>>>();");
17890   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
17891   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
17892                "aaaaaaaaaaa<<<\n    1, 1>>>();");
17893   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
17894                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
17895 }
17896 
17897 TEST_F(FormatTest, MergeLessLessAtEnd) {
17898   verifyFormat("<<");
17899   EXPECT_EQ("< < <", format("\\\n<<<"));
17900   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
17901                "aaallvm::outs() <<");
17902   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
17903                "aaaallvm::outs()\n    <<");
17904 }
17905 
17906 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
17907   std::string code = "#if A\n"
17908                      "#if B\n"
17909                      "a.\n"
17910                      "#endif\n"
17911                      "    a = 1;\n"
17912                      "#else\n"
17913                      "#endif\n"
17914                      "#if C\n"
17915                      "#else\n"
17916                      "#endif\n";
17917   EXPECT_EQ(code, format(code));
17918 }
17919 
17920 TEST_F(FormatTest, HandleConflictMarkers) {
17921   // Git/SVN conflict markers.
17922   EXPECT_EQ("int a;\n"
17923             "void f() {\n"
17924             "  callme(some(parameter1,\n"
17925             "<<<<<<< text by the vcs\n"
17926             "              parameter2),\n"
17927             "||||||| text by the vcs\n"
17928             "              parameter2),\n"
17929             "         parameter3,\n"
17930             "======= text by the vcs\n"
17931             "              parameter2, parameter3),\n"
17932             ">>>>>>> text by the vcs\n"
17933             "         otherparameter);\n",
17934             format("int a;\n"
17935                    "void f() {\n"
17936                    "  callme(some(parameter1,\n"
17937                    "<<<<<<< text by the vcs\n"
17938                    "  parameter2),\n"
17939                    "||||||| text by the vcs\n"
17940                    "  parameter2),\n"
17941                    "  parameter3,\n"
17942                    "======= text by the vcs\n"
17943                    "  parameter2,\n"
17944                    "  parameter3),\n"
17945                    ">>>>>>> text by the vcs\n"
17946                    "  otherparameter);\n"));
17947 
17948   // Perforce markers.
17949   EXPECT_EQ("void f() {\n"
17950             "  function(\n"
17951             ">>>> text by the vcs\n"
17952             "      parameter,\n"
17953             "==== text by the vcs\n"
17954             "      parameter,\n"
17955             "==== text by the vcs\n"
17956             "      parameter,\n"
17957             "<<<< text by the vcs\n"
17958             "      parameter);\n",
17959             format("void f() {\n"
17960                    "  function(\n"
17961                    ">>>> text by the vcs\n"
17962                    "  parameter,\n"
17963                    "==== text by the vcs\n"
17964                    "  parameter,\n"
17965                    "==== text by the vcs\n"
17966                    "  parameter,\n"
17967                    "<<<< text by the vcs\n"
17968                    "  parameter);\n"));
17969 
17970   EXPECT_EQ("<<<<<<<\n"
17971             "|||||||\n"
17972             "=======\n"
17973             ">>>>>>>",
17974             format("<<<<<<<\n"
17975                    "|||||||\n"
17976                    "=======\n"
17977                    ">>>>>>>"));
17978 
17979   EXPECT_EQ("<<<<<<<\n"
17980             "|||||||\n"
17981             "int i;\n"
17982             "=======\n"
17983             ">>>>>>>",
17984             format("<<<<<<<\n"
17985                    "|||||||\n"
17986                    "int i;\n"
17987                    "=======\n"
17988                    ">>>>>>>"));
17989 
17990   // FIXME: Handle parsing of macros around conflict markers correctly:
17991   EXPECT_EQ("#define Macro \\\n"
17992             "<<<<<<<\n"
17993             "Something \\\n"
17994             "|||||||\n"
17995             "Else \\\n"
17996             "=======\n"
17997             "Other \\\n"
17998             ">>>>>>>\n"
17999             "    End int i;\n",
18000             format("#define Macro \\\n"
18001                    "<<<<<<<\n"
18002                    "  Something \\\n"
18003                    "|||||||\n"
18004                    "  Else \\\n"
18005                    "=======\n"
18006                    "  Other \\\n"
18007                    ">>>>>>>\n"
18008                    "  End\n"
18009                    "int i;\n"));
18010 }
18011 
18012 TEST_F(FormatTest, DisableRegions) {
18013   EXPECT_EQ("int i;\n"
18014             "// clang-format off\n"
18015             "  int j;\n"
18016             "// clang-format on\n"
18017             "int k;",
18018             format(" int  i;\n"
18019                    "   // clang-format off\n"
18020                    "  int j;\n"
18021                    " // clang-format on\n"
18022                    "   int   k;"));
18023   EXPECT_EQ("int i;\n"
18024             "/* clang-format off */\n"
18025             "  int j;\n"
18026             "/* clang-format on */\n"
18027             "int k;",
18028             format(" int  i;\n"
18029                    "   /* clang-format off */\n"
18030                    "  int j;\n"
18031                    " /* clang-format on */\n"
18032                    "   int   k;"));
18033 
18034   // Don't reflow comments within disabled regions.
18035   EXPECT_EQ("// clang-format off\n"
18036             "// long long long long long long line\n"
18037             "/* clang-format on */\n"
18038             "/* long long long\n"
18039             " * long long long\n"
18040             " * line */\n"
18041             "int i;\n"
18042             "/* clang-format off */\n"
18043             "/* long long long long long long line */\n",
18044             format("// clang-format off\n"
18045                    "// long long long long long long line\n"
18046                    "/* clang-format on */\n"
18047                    "/* long long long long long long line */\n"
18048                    "int i;\n"
18049                    "/* clang-format off */\n"
18050                    "/* long long long long long long line */\n",
18051                    getLLVMStyleWithColumns(20)));
18052 }
18053 
18054 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
18055   format("? ) =");
18056   verifyNoCrash("#define a\\\n /**/}");
18057 }
18058 
18059 TEST_F(FormatTest, FormatsTableGenCode) {
18060   FormatStyle Style = getLLVMStyle();
18061   Style.Language = FormatStyle::LK_TableGen;
18062   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
18063 }
18064 
18065 TEST_F(FormatTest, ArrayOfTemplates) {
18066   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
18067             format("auto a = new unique_ptr<int > [ 10];"));
18068 
18069   FormatStyle Spaces = getLLVMStyle();
18070   Spaces.SpacesInSquareBrackets = true;
18071   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
18072             format("auto a = new unique_ptr<int > [10];", Spaces));
18073 }
18074 
18075 TEST_F(FormatTest, ArrayAsTemplateType) {
18076   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
18077             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
18078 
18079   FormatStyle Spaces = getLLVMStyle();
18080   Spaces.SpacesInSquareBrackets = true;
18081   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
18082             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
18083 }
18084 
18085 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
18086 
18087 TEST(FormatStyle, GetStyleWithEmptyFileName) {
18088   llvm::vfs::InMemoryFileSystem FS;
18089   auto Style1 = getStyle("file", "", "Google", "", &FS);
18090   ASSERT_TRUE((bool)Style1);
18091   ASSERT_EQ(*Style1, getGoogleStyle());
18092 }
18093 
18094 TEST(FormatStyle, GetStyleOfFile) {
18095   llvm::vfs::InMemoryFileSystem FS;
18096   // Test 1: format file in the same directory.
18097   ASSERT_TRUE(
18098       FS.addFile("/a/.clang-format", 0,
18099                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
18100   ASSERT_TRUE(
18101       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
18102   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
18103   ASSERT_TRUE((bool)Style1);
18104   ASSERT_EQ(*Style1, getLLVMStyle());
18105 
18106   // Test 2.1: fallback to default.
18107   ASSERT_TRUE(
18108       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
18109   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
18110   ASSERT_TRUE((bool)Style2);
18111   ASSERT_EQ(*Style2, getMozillaStyle());
18112 
18113   // Test 2.2: no format on 'none' fallback style.
18114   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
18115   ASSERT_TRUE((bool)Style2);
18116   ASSERT_EQ(*Style2, getNoStyle());
18117 
18118   // Test 2.3: format if config is found with no based style while fallback is
18119   // 'none'.
18120   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
18121                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
18122   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
18123   ASSERT_TRUE((bool)Style2);
18124   ASSERT_EQ(*Style2, getLLVMStyle());
18125 
18126   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
18127   Style2 = getStyle("{}", "a.h", "none", "", &FS);
18128   ASSERT_TRUE((bool)Style2);
18129   ASSERT_EQ(*Style2, getLLVMStyle());
18130 
18131   // Test 3: format file in parent directory.
18132   ASSERT_TRUE(
18133       FS.addFile("/c/.clang-format", 0,
18134                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
18135   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
18136                          llvm::MemoryBuffer::getMemBuffer("int i;")));
18137   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
18138   ASSERT_TRUE((bool)Style3);
18139   ASSERT_EQ(*Style3, getGoogleStyle());
18140 
18141   // Test 4: error on invalid fallback style
18142   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
18143   ASSERT_FALSE((bool)Style4);
18144   llvm::consumeError(Style4.takeError());
18145 
18146   // Test 5: error on invalid yaml on command line
18147   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
18148   ASSERT_FALSE((bool)Style5);
18149   llvm::consumeError(Style5.takeError());
18150 
18151   // Test 6: error on invalid style
18152   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
18153   ASSERT_FALSE((bool)Style6);
18154   llvm::consumeError(Style6.takeError());
18155 
18156   // Test 7: found config file, error on parsing it
18157   ASSERT_TRUE(
18158       FS.addFile("/d/.clang-format", 0,
18159                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
18160                                                   "InvalidKey: InvalidValue")));
18161   ASSERT_TRUE(
18162       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
18163   auto Style7a = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
18164   ASSERT_FALSE((bool)Style7a);
18165   llvm::consumeError(Style7a.takeError());
18166 
18167   auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
18168   ASSERT_TRUE((bool)Style7b);
18169 
18170   // Test 8: inferred per-language defaults apply.
18171   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
18172   ASSERT_TRUE((bool)StyleTd);
18173   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
18174 
18175   // Test 9.1: overwriting a file style, when parent no file exists with no
18176   // fallback style
18177   ASSERT_TRUE(FS.addFile(
18178       "/e/sub/.clang-format", 0,
18179       llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: InheritParentConfig\n"
18180                                        "ColumnLimit: 20")));
18181   ASSERT_TRUE(FS.addFile("/e/sub/code.cpp", 0,
18182                          llvm::MemoryBuffer::getMemBuffer("int i;")));
18183   auto Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
18184   ASSERT_TRUE(static_cast<bool>(Style9));
18185   ASSERT_EQ(*Style9, [] {
18186     auto Style = getNoStyle();
18187     Style.ColumnLimit = 20;
18188     return Style;
18189   }());
18190 
18191   // Test 9.2: with LLVM fallback style
18192   Style9 = getStyle("file", "/e/sub/code.cpp", "LLVM", "", &FS);
18193   ASSERT_TRUE(static_cast<bool>(Style9));
18194   ASSERT_EQ(*Style9, [] {
18195     auto Style = getLLVMStyle();
18196     Style.ColumnLimit = 20;
18197     return Style;
18198   }());
18199 
18200   // Test 9.3: with a parent file
18201   ASSERT_TRUE(
18202       FS.addFile("/e/.clang-format", 0,
18203                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google\n"
18204                                                   "UseTab: Always")));
18205   Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
18206   ASSERT_TRUE(static_cast<bool>(Style9));
18207   ASSERT_EQ(*Style9, [] {
18208     auto Style = getGoogleStyle();
18209     Style.ColumnLimit = 20;
18210     Style.UseTab = FormatStyle::UT_Always;
18211     return Style;
18212   }());
18213 
18214   // Test 9.4: propagate more than one level
18215   ASSERT_TRUE(FS.addFile("/e/sub/sub/code.cpp", 0,
18216                          llvm::MemoryBuffer::getMemBuffer("int i;")));
18217   ASSERT_TRUE(FS.addFile("/e/sub/sub/.clang-format", 0,
18218                          llvm::MemoryBuffer::getMemBuffer(
18219                              "BasedOnStyle: InheritParentConfig\n"
18220                              "WhitespaceSensitiveMacros: ['FOO', 'BAR']")));
18221   std::vector<std::string> NonDefaultWhiteSpaceMacros{"FOO", "BAR"};
18222 
18223   const auto SubSubStyle = [&NonDefaultWhiteSpaceMacros] {
18224     auto Style = getGoogleStyle();
18225     Style.ColumnLimit = 20;
18226     Style.UseTab = FormatStyle::UT_Always;
18227     Style.WhitespaceSensitiveMacros = NonDefaultWhiteSpaceMacros;
18228     return Style;
18229   }();
18230 
18231   ASSERT_NE(Style9->WhitespaceSensitiveMacros, NonDefaultWhiteSpaceMacros);
18232   Style9 = getStyle("file", "/e/sub/sub/code.cpp", "none", "", &FS);
18233   ASSERT_TRUE(static_cast<bool>(Style9));
18234   ASSERT_EQ(*Style9, SubSubStyle);
18235 
18236   // Test 9.5: use InheritParentConfig as style name
18237   Style9 =
18238       getStyle("inheritparentconfig", "/e/sub/sub/code.cpp", "none", "", &FS);
18239   ASSERT_TRUE(static_cast<bool>(Style9));
18240   ASSERT_EQ(*Style9, SubSubStyle);
18241 
18242   // Test 9.6: use command line style with inheritance
18243   Style9 = getStyle("{BasedOnStyle: InheritParentConfig}", "/e/sub/code.cpp",
18244                     "none", "", &FS);
18245   ASSERT_TRUE(static_cast<bool>(Style9));
18246   ASSERT_EQ(*Style9, SubSubStyle);
18247 
18248   // Test 9.7: use command line style with inheritance and own config
18249   Style9 = getStyle("{BasedOnStyle: InheritParentConfig, "
18250                     "WhitespaceSensitiveMacros: ['FOO', 'BAR']}",
18251                     "/e/sub/code.cpp", "none", "", &FS);
18252   ASSERT_TRUE(static_cast<bool>(Style9));
18253   ASSERT_EQ(*Style9, SubSubStyle);
18254 
18255   // Test 9.8: use inheritance from a file without BasedOnStyle
18256   ASSERT_TRUE(FS.addFile("/e/withoutbase/.clang-format", 0,
18257                          llvm::MemoryBuffer::getMemBuffer("ColumnLimit: 123")));
18258   ASSERT_TRUE(
18259       FS.addFile("/e/withoutbase/sub/.clang-format", 0,
18260                  llvm::MemoryBuffer::getMemBuffer(
18261                      "BasedOnStyle: InheritParentConfig\nIndentWidth: 7")));
18262   // Make sure we do not use the fallback style
18263   Style9 = getStyle("file", "/e/withoutbase/code.cpp", "google", "", &FS);
18264   ASSERT_TRUE(static_cast<bool>(Style9));
18265   ASSERT_EQ(*Style9, [] {
18266     auto Style = getLLVMStyle();
18267     Style.ColumnLimit = 123;
18268     return Style;
18269   }());
18270 
18271   Style9 = getStyle("file", "/e/withoutbase/sub/code.cpp", "google", "", &FS);
18272   ASSERT_TRUE(static_cast<bool>(Style9));
18273   ASSERT_EQ(*Style9, [] {
18274     auto Style = getLLVMStyle();
18275     Style.ColumnLimit = 123;
18276     Style.IndentWidth = 7;
18277     return Style;
18278   }());
18279 }
18280 
18281 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
18282   // Column limit is 20.
18283   std::string Code = "Type *a =\n"
18284                      "    new Type();\n"
18285                      "g(iiiii, 0, jjjjj,\n"
18286                      "  0, kkkkk, 0, mm);\n"
18287                      "int  bad     = format   ;";
18288   std::string Expected = "auto a = new Type();\n"
18289                          "g(iiiii, nullptr,\n"
18290                          "  jjjjj, nullptr,\n"
18291                          "  kkkkk, nullptr,\n"
18292                          "  mm);\n"
18293                          "int  bad     = format   ;";
18294   FileID ID = Context.createInMemoryFile("format.cpp", Code);
18295   tooling::Replacements Replaces = toReplacements(
18296       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
18297                             "auto "),
18298        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
18299                             "nullptr"),
18300        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
18301                             "nullptr"),
18302        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
18303                             "nullptr")});
18304 
18305   format::FormatStyle Style = format::getLLVMStyle();
18306   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
18307   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
18308   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
18309       << llvm::toString(FormattedReplaces.takeError()) << "\n";
18310   auto Result = applyAllReplacements(Code, *FormattedReplaces);
18311   EXPECT_TRUE(static_cast<bool>(Result));
18312   EXPECT_EQ(Expected, *Result);
18313 }
18314 
18315 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
18316   std::string Code = "#include \"a.h\"\n"
18317                      "#include \"c.h\"\n"
18318                      "\n"
18319                      "int main() {\n"
18320                      "  return 0;\n"
18321                      "}";
18322   std::string Expected = "#include \"a.h\"\n"
18323                          "#include \"b.h\"\n"
18324                          "#include \"c.h\"\n"
18325                          "\n"
18326                          "int main() {\n"
18327                          "  return 0;\n"
18328                          "}";
18329   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
18330   tooling::Replacements Replaces = toReplacements(
18331       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
18332                             "#include \"b.h\"\n")});
18333 
18334   format::FormatStyle Style = format::getLLVMStyle();
18335   Style.SortIncludes = FormatStyle::SI_CaseSensitive;
18336   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
18337   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
18338       << llvm::toString(FormattedReplaces.takeError()) << "\n";
18339   auto Result = applyAllReplacements(Code, *FormattedReplaces);
18340   EXPECT_TRUE(static_cast<bool>(Result));
18341   EXPECT_EQ(Expected, *Result);
18342 }
18343 
18344 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
18345   EXPECT_EQ("using std::cin;\n"
18346             "using std::cout;",
18347             format("using std::cout;\n"
18348                    "using std::cin;",
18349                    getGoogleStyle()));
18350 }
18351 
18352 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
18353   format::FormatStyle Style = format::getLLVMStyle();
18354   Style.Standard = FormatStyle::LS_Cpp03;
18355   // cpp03 recognize this string as identifier u8 and literal character 'a'
18356   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
18357 }
18358 
18359 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
18360   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
18361   // all modes, including C++11, C++14 and C++17
18362   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
18363 }
18364 
18365 TEST_F(FormatTest, DoNotFormatLikelyXml) {
18366   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
18367   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
18368 }
18369 
18370 TEST_F(FormatTest, StructuredBindings) {
18371   // Structured bindings is a C++17 feature.
18372   // all modes, including C++11, C++14 and C++17
18373   verifyFormat("auto [a, b] = f();");
18374   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
18375   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
18376   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
18377   EXPECT_EQ("auto const volatile [a, b] = f();",
18378             format("auto  const   volatile[a, b] = f();"));
18379   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
18380   EXPECT_EQ("auto &[a, b, c] = f();",
18381             format("auto   &[  a  ,  b,c   ] = f();"));
18382   EXPECT_EQ("auto &&[a, b, c] = f();",
18383             format("auto   &&[  a  ,  b,c   ] = f();"));
18384   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
18385   EXPECT_EQ("auto const volatile &&[a, b] = f();",
18386             format("auto  const  volatile  &&[a, b] = f();"));
18387   EXPECT_EQ("auto const &&[a, b] = f();",
18388             format("auto  const   &&  [a, b] = f();"));
18389   EXPECT_EQ("const auto &[a, b] = f();",
18390             format("const  auto  &  [a, b] = f();"));
18391   EXPECT_EQ("const auto volatile &&[a, b] = f();",
18392             format("const  auto   volatile  &&[a, b] = f();"));
18393   EXPECT_EQ("volatile const auto &&[a, b] = f();",
18394             format("volatile  const  auto   &&[a, b] = f();"));
18395   EXPECT_EQ("const auto &&[a, b] = f();",
18396             format("const  auto  &&  [a, b] = f();"));
18397 
18398   // Make sure we don't mistake structured bindings for lambdas.
18399   FormatStyle PointerMiddle = getLLVMStyle();
18400   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
18401   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
18402   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
18403   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
18404   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
18405   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
18406   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
18407   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
18408   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
18409   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
18410   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
18411   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
18412   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
18413 
18414   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
18415             format("for (const auto   &&   [a, b] : some_range) {\n}"));
18416   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
18417             format("for (const auto   &   [a, b] : some_range) {\n}"));
18418   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
18419             format("for (const auto[a, b] : some_range) {\n}"));
18420   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
18421   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
18422   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
18423   EXPECT_EQ("auto const &[x, y](expr);",
18424             format("auto  const  &  [x,y]  (expr);"));
18425   EXPECT_EQ("auto const &&[x, y](expr);",
18426             format("auto  const  &&  [x,y]  (expr);"));
18427   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
18428   EXPECT_EQ("auto const &[x, y]{expr};",
18429             format("auto  const  &  [x,y]  {expr};"));
18430   EXPECT_EQ("auto const &&[x, y]{expr};",
18431             format("auto  const  &&  [x,y]  {expr};"));
18432 
18433   format::FormatStyle Spaces = format::getLLVMStyle();
18434   Spaces.SpacesInSquareBrackets = true;
18435   verifyFormat("auto [ a, b ] = f();", Spaces);
18436   verifyFormat("auto &&[ a, b ] = f();", Spaces);
18437   verifyFormat("auto &[ a, b ] = f();", Spaces);
18438   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
18439   verifyFormat("auto const &[ a, b ] = f();", Spaces);
18440 }
18441 
18442 TEST_F(FormatTest, FileAndCode) {
18443   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
18444   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
18445   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
18446   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
18447   EXPECT_EQ(FormatStyle::LK_ObjC,
18448             guessLanguage("foo.h", "@interface Foo\n@end\n"));
18449   EXPECT_EQ(
18450       FormatStyle::LK_ObjC,
18451       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
18452   EXPECT_EQ(FormatStyle::LK_ObjC,
18453             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
18454   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
18455   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
18456   EXPECT_EQ(FormatStyle::LK_ObjC,
18457             guessLanguage("foo", "@interface Foo\n@end\n"));
18458   EXPECT_EQ(FormatStyle::LK_ObjC,
18459             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
18460   EXPECT_EQ(
18461       FormatStyle::LK_ObjC,
18462       guessLanguage("foo.h",
18463                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
18464   EXPECT_EQ(
18465       FormatStyle::LK_Cpp,
18466       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
18467 }
18468 
18469 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
18470   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
18471   EXPECT_EQ(FormatStyle::LK_ObjC,
18472             guessLanguage("foo.h", "array[[calculator getIndex]];"));
18473   EXPECT_EQ(FormatStyle::LK_Cpp,
18474             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
18475   EXPECT_EQ(
18476       FormatStyle::LK_Cpp,
18477       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
18478   EXPECT_EQ(FormatStyle::LK_ObjC,
18479             guessLanguage("foo.h", "[[noreturn foo] bar];"));
18480   EXPECT_EQ(FormatStyle::LK_Cpp,
18481             guessLanguage("foo.h", "[[clang::fallthrough]];"));
18482   EXPECT_EQ(FormatStyle::LK_ObjC,
18483             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
18484   EXPECT_EQ(FormatStyle::LK_Cpp,
18485             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
18486   EXPECT_EQ(FormatStyle::LK_Cpp,
18487             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
18488   EXPECT_EQ(FormatStyle::LK_ObjC,
18489             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
18490   EXPECT_EQ(FormatStyle::LK_Cpp,
18491             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
18492   EXPECT_EQ(
18493       FormatStyle::LK_Cpp,
18494       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
18495   EXPECT_EQ(
18496       FormatStyle::LK_Cpp,
18497       guessLanguage("foo.h",
18498                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
18499   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
18500 }
18501 
18502 TEST_F(FormatTest, GuessLanguageWithCaret) {
18503   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
18504   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
18505   EXPECT_EQ(FormatStyle::LK_ObjC,
18506             guessLanguage("foo.h", "int(^)(char, float);"));
18507   EXPECT_EQ(FormatStyle::LK_ObjC,
18508             guessLanguage("foo.h", "int(^foo)(char, float);"));
18509   EXPECT_EQ(FormatStyle::LK_ObjC,
18510             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
18511   EXPECT_EQ(FormatStyle::LK_ObjC,
18512             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
18513   EXPECT_EQ(
18514       FormatStyle::LK_ObjC,
18515       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
18516 }
18517 
18518 TEST_F(FormatTest, GuessLanguageWithPragmas) {
18519   EXPECT_EQ(FormatStyle::LK_Cpp,
18520             guessLanguage("foo.h", "__pragma(warning(disable:))"));
18521   EXPECT_EQ(FormatStyle::LK_Cpp,
18522             guessLanguage("foo.h", "#pragma(warning(disable:))"));
18523   EXPECT_EQ(FormatStyle::LK_Cpp,
18524             guessLanguage("foo.h", "_Pragma(warning(disable:))"));
18525 }
18526 
18527 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
18528   // ASM symbolic names are identifiers that must be surrounded by [] without
18529   // space in between:
18530   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
18531 
18532   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
18533   verifyFormat(R"(//
18534 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
18535 )");
18536 
18537   // A list of several ASM symbolic names.
18538   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
18539 
18540   // ASM symbolic names in inline ASM with inputs and outputs.
18541   verifyFormat(R"(//
18542 asm("cmoveq %1, %2, %[result]"
18543     : [result] "=r"(result)
18544     : "r"(test), "r"(new), "[result]"(old));
18545 )");
18546 
18547   // ASM symbolic names in inline ASM with no outputs.
18548   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
18549 }
18550 
18551 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
18552   EXPECT_EQ(FormatStyle::LK_Cpp,
18553             guessLanguage("foo.h", "void f() {\n"
18554                                    "  asm (\"mov %[e], %[d]\"\n"
18555                                    "     : [d] \"=rm\" (d)\n"
18556                                    "       [e] \"rm\" (*e));\n"
18557                                    "}"));
18558   EXPECT_EQ(FormatStyle::LK_Cpp,
18559             guessLanguage("foo.h", "void f() {\n"
18560                                    "  _asm (\"mov %[e], %[d]\"\n"
18561                                    "     : [d] \"=rm\" (d)\n"
18562                                    "       [e] \"rm\" (*e));\n"
18563                                    "}"));
18564   EXPECT_EQ(FormatStyle::LK_Cpp,
18565             guessLanguage("foo.h", "void f() {\n"
18566                                    "  __asm (\"mov %[e], %[d]\"\n"
18567                                    "     : [d] \"=rm\" (d)\n"
18568                                    "       [e] \"rm\" (*e));\n"
18569                                    "}"));
18570   EXPECT_EQ(FormatStyle::LK_Cpp,
18571             guessLanguage("foo.h", "void f() {\n"
18572                                    "  __asm__ (\"mov %[e], %[d]\"\n"
18573                                    "     : [d] \"=rm\" (d)\n"
18574                                    "       [e] \"rm\" (*e));\n"
18575                                    "}"));
18576   EXPECT_EQ(FormatStyle::LK_Cpp,
18577             guessLanguage("foo.h", "void f() {\n"
18578                                    "  asm (\"mov %[e], %[d]\"\n"
18579                                    "     : [d] \"=rm\" (d),\n"
18580                                    "       [e] \"rm\" (*e));\n"
18581                                    "}"));
18582   EXPECT_EQ(FormatStyle::LK_Cpp,
18583             guessLanguage("foo.h", "void f() {\n"
18584                                    "  asm volatile (\"mov %[e], %[d]\"\n"
18585                                    "     : [d] \"=rm\" (d)\n"
18586                                    "       [e] \"rm\" (*e));\n"
18587                                    "}"));
18588 }
18589 
18590 TEST_F(FormatTest, GuessLanguageWithChildLines) {
18591   EXPECT_EQ(FormatStyle::LK_Cpp,
18592             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
18593   EXPECT_EQ(FormatStyle::LK_ObjC,
18594             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
18595   EXPECT_EQ(
18596       FormatStyle::LK_Cpp,
18597       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
18598   EXPECT_EQ(
18599       FormatStyle::LK_ObjC,
18600       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
18601 }
18602 
18603 TEST_F(FormatTest, TypenameMacros) {
18604   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
18605 
18606   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
18607   FormatStyle Google = getGoogleStyleWithColumns(0);
18608   Google.TypenameMacros = TypenameMacros;
18609   verifyFormat("struct foo {\n"
18610                "  int bar;\n"
18611                "  TAILQ_ENTRY(a) bleh;\n"
18612                "};",
18613                Google);
18614 
18615   FormatStyle Macros = getLLVMStyle();
18616   Macros.TypenameMacros = TypenameMacros;
18617 
18618   verifyFormat("STACK_OF(int) a;", Macros);
18619   verifyFormat("STACK_OF(int) *a;", Macros);
18620   verifyFormat("STACK_OF(int const *) *a;", Macros);
18621   verifyFormat("STACK_OF(int *const) *a;", Macros);
18622   verifyFormat("STACK_OF(int, string) a;", Macros);
18623   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
18624   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
18625   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
18626   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
18627   verifyFormat("vector<LIST(uint64_t) *attr> x;", Macros);
18628   verifyFormat("vector<LIST(uint64_t) *const> f(LIST(uint64_t) *arg);", Macros);
18629 
18630   Macros.PointerAlignment = FormatStyle::PAS_Left;
18631   verifyFormat("STACK_OF(int)* a;", Macros);
18632   verifyFormat("STACK_OF(int*)* a;", Macros);
18633   verifyFormat("x = (STACK_OF(uint64_t))*a;", Macros);
18634   verifyFormat("x = (STACK_OF(uint64_t))&a;", Macros);
18635   verifyFormat("vector<STACK_OF(uint64_t)* attr> x;", Macros);
18636 }
18637 
18638 TEST_F(FormatTest, AtomicQualifier) {
18639   // Check that we treate _Atomic as a type and not a function call
18640   FormatStyle Google = getGoogleStyleWithColumns(0);
18641   verifyFormat("struct foo {\n"
18642                "  int a1;\n"
18643                "  _Atomic(a) a2;\n"
18644                "  _Atomic(_Atomic(int) *const) a3;\n"
18645                "};",
18646                Google);
18647   verifyFormat("_Atomic(uint64_t) a;");
18648   verifyFormat("_Atomic(uint64_t) *a;");
18649   verifyFormat("_Atomic(uint64_t const *) *a;");
18650   verifyFormat("_Atomic(uint64_t *const) *a;");
18651   verifyFormat("_Atomic(const uint64_t *) *a;");
18652   verifyFormat("_Atomic(uint64_t) a;");
18653   verifyFormat("_Atomic(_Atomic(uint64_t)) a;");
18654   verifyFormat("_Atomic(_Atomic(uint64_t)) a, b;");
18655   verifyFormat("for (_Atomic(uint64_t) *a = NULL; a;) {\n}");
18656   verifyFormat("_Atomic(uint64_t) f(_Atomic(uint64_t) *arg);");
18657 
18658   verifyFormat("_Atomic(uint64_t) *s(InitValue);");
18659   verifyFormat("_Atomic(uint64_t) *s{InitValue};");
18660   FormatStyle Style = getLLVMStyle();
18661   Style.PointerAlignment = FormatStyle::PAS_Left;
18662   verifyFormat("_Atomic(uint64_t)* s(InitValue);", Style);
18663   verifyFormat("_Atomic(uint64_t)* s{InitValue};", Style);
18664   verifyFormat("_Atomic(int)* a;", Style);
18665   verifyFormat("_Atomic(int*)* a;", Style);
18666   verifyFormat("vector<_Atomic(uint64_t)* attr> x;", Style);
18667 
18668   Style.SpacesInCStyleCastParentheses = true;
18669   Style.SpacesInParentheses = false;
18670   verifyFormat("x = ( _Atomic(uint64_t) )*a;", Style);
18671   Style.SpacesInCStyleCastParentheses = false;
18672   Style.SpacesInParentheses = true;
18673   verifyFormat("x = (_Atomic( uint64_t ))*a;", Style);
18674   verifyFormat("x = (_Atomic( uint64_t ))&a;", Style);
18675 }
18676 
18677 TEST_F(FormatTest, AmbersandInLamda) {
18678   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
18679   FormatStyle AlignStyle = getLLVMStyle();
18680   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
18681   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
18682   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
18683   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
18684 }
18685 
18686 TEST_F(FormatTest, SpacesInConditionalStatement) {
18687   FormatStyle Spaces = getLLVMStyle();
18688   Spaces.SpacesInConditionalStatement = true;
18689   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
18690   verifyFormat("if ( !a )\n  return;", Spaces);
18691   verifyFormat("if ( a )\n  return;", Spaces);
18692   verifyFormat("if constexpr ( a )\n  return;", Spaces);
18693   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
18694   verifyFormat("while ( a )\n  return;", Spaces);
18695   verifyFormat("while ( (a && b) )\n  return;", Spaces);
18696   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
18697   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
18698   // Check that space on the left of "::" is inserted as expected at beginning
18699   // of condition.
18700   verifyFormat("while ( ::func() )\n  return;", Spaces);
18701 }
18702 
18703 TEST_F(FormatTest, AlternativeOperators) {
18704   // Test case for ensuring alternate operators are not
18705   // combined with their right most neighbour.
18706   verifyFormat("int a and b;");
18707   verifyFormat("int a and_eq b;");
18708   verifyFormat("int a bitand b;");
18709   verifyFormat("int a bitor b;");
18710   verifyFormat("int a compl b;");
18711   verifyFormat("int a not b;");
18712   verifyFormat("int a not_eq b;");
18713   verifyFormat("int a or b;");
18714   verifyFormat("int a xor b;");
18715   verifyFormat("int a xor_eq b;");
18716   verifyFormat("return this not_eq bitand other;");
18717   verifyFormat("bool operator not_eq(const X bitand other)");
18718 
18719   verifyFormat("int a and 5;");
18720   verifyFormat("int a and_eq 5;");
18721   verifyFormat("int a bitand 5;");
18722   verifyFormat("int a bitor 5;");
18723   verifyFormat("int a compl 5;");
18724   verifyFormat("int a not 5;");
18725   verifyFormat("int a not_eq 5;");
18726   verifyFormat("int a or 5;");
18727   verifyFormat("int a xor 5;");
18728   verifyFormat("int a xor_eq 5;");
18729 
18730   verifyFormat("int a compl(5);");
18731   verifyFormat("int a not(5);");
18732 
18733   /* FIXME handle alternate tokens
18734    * https://en.cppreference.com/w/cpp/language/operator_alternative
18735   // alternative tokens
18736   verifyFormat("compl foo();");     //  ~foo();
18737   verifyFormat("foo() <%%>;");      // foo();
18738   verifyFormat("void foo() <%%>;"); // void foo(){}
18739   verifyFormat("int a <:1:>;");     // int a[1];[
18740   verifyFormat("%:define ABC abc"); // #define ABC abc
18741   verifyFormat("%:%:");             // ##
18742   */
18743 }
18744 
18745 TEST_F(FormatTest, STLWhileNotDefineChed) {
18746   verifyFormat("#if defined(while)\n"
18747                "#define while EMIT WARNING C4005\n"
18748                "#endif // while");
18749 }
18750 
18751 TEST_F(FormatTest, OperatorSpacing) {
18752   FormatStyle Style = getLLVMStyle();
18753   Style.PointerAlignment = FormatStyle::PAS_Right;
18754   verifyFormat("Foo::operator*();", Style);
18755   verifyFormat("Foo::operator void *();", Style);
18756   verifyFormat("Foo::operator void **();", Style);
18757   verifyFormat("Foo::operator void *&();", Style);
18758   verifyFormat("Foo::operator void *&&();", Style);
18759   verifyFormat("Foo::operator void const *();", Style);
18760   verifyFormat("Foo::operator void const **();", Style);
18761   verifyFormat("Foo::operator void const *&();", Style);
18762   verifyFormat("Foo::operator void const *&&();", Style);
18763   verifyFormat("Foo::operator()(void *);", Style);
18764   verifyFormat("Foo::operator*(void *);", Style);
18765   verifyFormat("Foo::operator*();", Style);
18766   verifyFormat("Foo::operator**();", Style);
18767   verifyFormat("Foo::operator&();", Style);
18768   verifyFormat("Foo::operator<int> *();", Style);
18769   verifyFormat("Foo::operator<Foo> *();", Style);
18770   verifyFormat("Foo::operator<int> **();", Style);
18771   verifyFormat("Foo::operator<Foo> **();", Style);
18772   verifyFormat("Foo::operator<int> &();", Style);
18773   verifyFormat("Foo::operator<Foo> &();", Style);
18774   verifyFormat("Foo::operator<int> &&();", Style);
18775   verifyFormat("Foo::operator<Foo> &&();", Style);
18776   verifyFormat("Foo::operator<int> *&();", Style);
18777   verifyFormat("Foo::operator<Foo> *&();", Style);
18778   verifyFormat("Foo::operator<int> *&&();", Style);
18779   verifyFormat("Foo::operator<Foo> *&&();", Style);
18780   verifyFormat("operator*(int (*)(), class Foo);", Style);
18781 
18782   verifyFormat("Foo::operator&();", Style);
18783   verifyFormat("Foo::operator void &();", Style);
18784   verifyFormat("Foo::operator void const &();", Style);
18785   verifyFormat("Foo::operator()(void &);", Style);
18786   verifyFormat("Foo::operator&(void &);", Style);
18787   verifyFormat("Foo::operator&();", Style);
18788   verifyFormat("operator&(int (&)(), class Foo);", Style);
18789 
18790   verifyFormat("Foo::operator&&();", Style);
18791   verifyFormat("Foo::operator**();", Style);
18792   verifyFormat("Foo::operator void &&();", Style);
18793   verifyFormat("Foo::operator void const &&();", Style);
18794   verifyFormat("Foo::operator()(void &&);", Style);
18795   verifyFormat("Foo::operator&&(void &&);", Style);
18796   verifyFormat("Foo::operator&&();", Style);
18797   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
18798   verifyFormat("operator const nsTArrayRight<E> &()", Style);
18799   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
18800                Style);
18801   verifyFormat("operator void **()", Style);
18802   verifyFormat("operator const FooRight<Object> &()", Style);
18803   verifyFormat("operator const FooRight<Object> *()", Style);
18804   verifyFormat("operator const FooRight<Object> **()", Style);
18805   verifyFormat("operator const FooRight<Object> *&()", Style);
18806   verifyFormat("operator const FooRight<Object> *&&()", Style);
18807 
18808   Style.PointerAlignment = FormatStyle::PAS_Left;
18809   verifyFormat("Foo::operator*();", Style);
18810   verifyFormat("Foo::operator**();", Style);
18811   verifyFormat("Foo::operator void*();", Style);
18812   verifyFormat("Foo::operator void**();", Style);
18813   verifyFormat("Foo::operator void*&();", Style);
18814   verifyFormat("Foo::operator void*&&();", Style);
18815   verifyFormat("Foo::operator void const*();", Style);
18816   verifyFormat("Foo::operator void const**();", Style);
18817   verifyFormat("Foo::operator void const*&();", Style);
18818   verifyFormat("Foo::operator void const*&&();", Style);
18819   verifyFormat("Foo::operator/*comment*/ void*();", Style);
18820   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
18821   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
18822   verifyFormat("Foo::operator()(void*);", Style);
18823   verifyFormat("Foo::operator*(void*);", Style);
18824   verifyFormat("Foo::operator*();", Style);
18825   verifyFormat("Foo::operator<int>*();", Style);
18826   verifyFormat("Foo::operator<Foo>*();", Style);
18827   verifyFormat("Foo::operator<int>**();", Style);
18828   verifyFormat("Foo::operator<Foo>**();", Style);
18829   verifyFormat("Foo::operator<Foo>*&();", Style);
18830   verifyFormat("Foo::operator<int>&();", Style);
18831   verifyFormat("Foo::operator<Foo>&();", Style);
18832   verifyFormat("Foo::operator<int>&&();", Style);
18833   verifyFormat("Foo::operator<Foo>&&();", Style);
18834   verifyFormat("Foo::operator<int>*&();", Style);
18835   verifyFormat("Foo::operator<Foo>*&();", Style);
18836   verifyFormat("operator*(int (*)(), class Foo);", Style);
18837 
18838   verifyFormat("Foo::operator&();", Style);
18839   verifyFormat("Foo::operator void&();", Style);
18840   verifyFormat("Foo::operator void const&();", Style);
18841   verifyFormat("Foo::operator/*comment*/ void&();", Style);
18842   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
18843   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
18844   verifyFormat("Foo::operator()(void&);", Style);
18845   verifyFormat("Foo::operator&(void&);", Style);
18846   verifyFormat("Foo::operator&();", Style);
18847   verifyFormat("operator&(int (&)(), class Foo);", Style);
18848 
18849   verifyFormat("Foo::operator&&();", Style);
18850   verifyFormat("Foo::operator void&&();", Style);
18851   verifyFormat("Foo::operator void const&&();", Style);
18852   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
18853   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
18854   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
18855   verifyFormat("Foo::operator()(void&&);", Style);
18856   verifyFormat("Foo::operator&&(void&&);", Style);
18857   verifyFormat("Foo::operator&&();", Style);
18858   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
18859   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
18860   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
18861                Style);
18862   verifyFormat("operator void**()", Style);
18863   verifyFormat("operator const FooLeft<Object>&()", Style);
18864   verifyFormat("operator const FooLeft<Object>*()", Style);
18865   verifyFormat("operator const FooLeft<Object>**()", Style);
18866   verifyFormat("operator const FooLeft<Object>*&()", Style);
18867   verifyFormat("operator const FooLeft<Object>*&&()", Style);
18868 
18869   // PR45107
18870   verifyFormat("operator Vector<String>&();", Style);
18871   verifyFormat("operator const Vector<String>&();", Style);
18872   verifyFormat("operator foo::Bar*();", Style);
18873   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
18874   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
18875                Style);
18876 
18877   Style.PointerAlignment = FormatStyle::PAS_Middle;
18878   verifyFormat("Foo::operator*();", Style);
18879   verifyFormat("Foo::operator void *();", Style);
18880   verifyFormat("Foo::operator()(void *);", Style);
18881   verifyFormat("Foo::operator*(void *);", Style);
18882   verifyFormat("Foo::operator*();", Style);
18883   verifyFormat("operator*(int (*)(), class Foo);", Style);
18884 
18885   verifyFormat("Foo::operator&();", Style);
18886   verifyFormat("Foo::operator void &();", Style);
18887   verifyFormat("Foo::operator void const &();", Style);
18888   verifyFormat("Foo::operator()(void &);", Style);
18889   verifyFormat("Foo::operator&(void &);", Style);
18890   verifyFormat("Foo::operator&();", Style);
18891   verifyFormat("operator&(int (&)(), class Foo);", Style);
18892 
18893   verifyFormat("Foo::operator&&();", Style);
18894   verifyFormat("Foo::operator void &&();", Style);
18895   verifyFormat("Foo::operator void const &&();", Style);
18896   verifyFormat("Foo::operator()(void &&);", Style);
18897   verifyFormat("Foo::operator&&(void &&);", Style);
18898   verifyFormat("Foo::operator&&();", Style);
18899   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
18900 }
18901 
18902 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
18903   FormatStyle Style = getLLVMStyle();
18904   // PR46157
18905   verifyFormat("foo(operator+, -42);", Style);
18906   verifyFormat("foo(operator++, -42);", Style);
18907   verifyFormat("foo(operator--, -42);", Style);
18908   verifyFormat("foo(-42, operator--);", Style);
18909   verifyFormat("foo(-42, operator, );", Style);
18910   verifyFormat("foo(operator, , -42);", Style);
18911 }
18912 
18913 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
18914   FormatStyle Style = getLLVMStyle();
18915   Style.WhitespaceSensitiveMacros.push_back("FOO");
18916 
18917   // Don't use the helpers here, since 'mess up' will change the whitespace
18918   // and these are all whitespace sensitive by definition
18919   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
18920             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
18921   EXPECT_EQ(
18922       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
18923       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
18924   EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
18925             format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
18926   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
18927             "       Still=Intentional);",
18928             format("FOO(String-ized&Messy+But,: :\n"
18929                    "       Still=Intentional);",
18930                    Style));
18931   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
18932   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
18933             "       Still=Intentional);",
18934             format("FOO(String-ized=&Messy+But,: :\n"
18935                    "       Still=Intentional);",
18936                    Style));
18937 
18938   Style.ColumnLimit = 21;
18939   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
18940             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
18941 }
18942 
18943 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
18944   // These tests are not in NamespaceFixer because that doesn't
18945   // test its interaction with line wrapping
18946   FormatStyle Style = getLLVMStyle();
18947   Style.ColumnLimit = 80;
18948   verifyFormat("namespace {\n"
18949                "int i;\n"
18950                "int j;\n"
18951                "} // namespace",
18952                Style);
18953 
18954   verifyFormat("namespace AAA {\n"
18955                "int i;\n"
18956                "int j;\n"
18957                "} // namespace AAA",
18958                Style);
18959 
18960   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
18961             "int i;\n"
18962             "int j;\n"
18963             "} // namespace Averyveryveryverylongnamespace",
18964             format("namespace Averyveryveryverylongnamespace {\n"
18965                    "int i;\n"
18966                    "int j;\n"
18967                    "}",
18968                    Style));
18969 
18970   EXPECT_EQ(
18971       "namespace "
18972       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
18973       "    went::mad::now {\n"
18974       "int i;\n"
18975       "int j;\n"
18976       "} // namespace\n"
18977       "  // "
18978       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
18979       "went::mad::now",
18980       format("namespace "
18981              "would::it::save::you::a::lot::of::time::if_::i::"
18982              "just::gave::up::and_::went::mad::now {\n"
18983              "int i;\n"
18984              "int j;\n"
18985              "}",
18986              Style));
18987 
18988   // This used to duplicate the comment again and again on subsequent runs
18989   EXPECT_EQ(
18990       "namespace "
18991       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
18992       "    went::mad::now {\n"
18993       "int i;\n"
18994       "int j;\n"
18995       "} // namespace\n"
18996       "  // "
18997       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
18998       "went::mad::now",
18999       format("namespace "
19000              "would::it::save::you::a::lot::of::time::if_::i::"
19001              "just::gave::up::and_::went::mad::now {\n"
19002              "int i;\n"
19003              "int j;\n"
19004              "} // namespace\n"
19005              "  // "
19006              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
19007              "and_::went::mad::now",
19008              Style));
19009 }
19010 
19011 TEST_F(FormatTest, LikelyUnlikely) {
19012   FormatStyle Style = getLLVMStyle();
19013 
19014   verifyFormat("if (argc > 5) [[unlikely]] {\n"
19015                "  return 29;\n"
19016                "}",
19017                Style);
19018 
19019   verifyFormat("if (argc > 5) [[likely]] {\n"
19020                "  return 29;\n"
19021                "}",
19022                Style);
19023 
19024   verifyFormat("if (argc > 5) [[unlikely]] {\n"
19025                "  return 29;\n"
19026                "} else [[likely]] {\n"
19027                "  return 42;\n"
19028                "}\n",
19029                Style);
19030 
19031   verifyFormat("if (argc > 5) [[unlikely]] {\n"
19032                "  return 29;\n"
19033                "} else if (argc > 10) [[likely]] {\n"
19034                "  return 99;\n"
19035                "} else {\n"
19036                "  return 42;\n"
19037                "}\n",
19038                Style);
19039 
19040   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
19041                "  return 29;\n"
19042                "}",
19043                Style);
19044 }
19045 
19046 TEST_F(FormatTest, PenaltyIndentedWhitespace) {
19047   verifyFormat("Constructor()\n"
19048                "    : aaaaaa(aaaaaa), aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
19049                "                          aaaa(aaaaaaaaaaaaaaaaaa, "
19050                "aaaaaaaaaaaaaaaaaat))");
19051   verifyFormat("Constructor()\n"
19052                "    : aaaaaaaaaaaaa(aaaaaa), "
19053                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa)");
19054 
19055   FormatStyle StyleWithWhitespacePenalty = getLLVMStyle();
19056   StyleWithWhitespacePenalty.PenaltyIndentedWhitespace = 5;
19057   verifyFormat("Constructor()\n"
19058                "    : aaaaaa(aaaaaa),\n"
19059                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
19060                "          aaaa(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaat))",
19061                StyleWithWhitespacePenalty);
19062   verifyFormat("Constructor()\n"
19063                "    : aaaaaaaaaaaaa(aaaaaa), "
19064                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa)",
19065                StyleWithWhitespacePenalty);
19066 }
19067 
19068 TEST_F(FormatTest, LLVMDefaultStyle) {
19069   FormatStyle Style = getLLVMStyle();
19070   verifyFormat("extern \"C\" {\n"
19071                "int foo();\n"
19072                "}",
19073                Style);
19074 }
19075 TEST_F(FormatTest, GNUDefaultStyle) {
19076   FormatStyle Style = getGNUStyle();
19077   verifyFormat("extern \"C\"\n"
19078                "{\n"
19079                "  int foo ();\n"
19080                "}",
19081                Style);
19082 }
19083 TEST_F(FormatTest, MozillaDefaultStyle) {
19084   FormatStyle Style = getMozillaStyle();
19085   verifyFormat("extern \"C\"\n"
19086                "{\n"
19087                "  int foo();\n"
19088                "}",
19089                Style);
19090 }
19091 TEST_F(FormatTest, GoogleDefaultStyle) {
19092   FormatStyle Style = getGoogleStyle();
19093   verifyFormat("extern \"C\" {\n"
19094                "int foo();\n"
19095                "}",
19096                Style);
19097 }
19098 TEST_F(FormatTest, ChromiumDefaultStyle) {
19099   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
19100   verifyFormat("extern \"C\" {\n"
19101                "int foo();\n"
19102                "}",
19103                Style);
19104 }
19105 TEST_F(FormatTest, MicrosoftDefaultStyle) {
19106   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
19107   verifyFormat("extern \"C\"\n"
19108                "{\n"
19109                "    int foo();\n"
19110                "}",
19111                Style);
19112 }
19113 TEST_F(FormatTest, WebKitDefaultStyle) {
19114   FormatStyle Style = getWebKitStyle();
19115   verifyFormat("extern \"C\" {\n"
19116                "int foo();\n"
19117                "}",
19118                Style);
19119 }
19120 
19121 TEST_F(FormatTest, ConceptsAndRequires) {
19122   FormatStyle Style = getLLVMStyle();
19123   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
19124 
19125   verifyFormat("template <typename T>\n"
19126                "concept Hashable = requires(T a) {\n"
19127                "  { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
19128                "};",
19129                Style);
19130   verifyFormat("template <typename T>\n"
19131                "concept EqualityComparable = requires(T a, T b) {\n"
19132                "  { a == b } -> bool;\n"
19133                "};",
19134                Style);
19135   verifyFormat("template <typename T>\n"
19136                "concept EqualityComparable = requires(T a, T b) {\n"
19137                "  { a == b } -> bool;\n"
19138                "  { a != b } -> bool;\n"
19139                "};",
19140                Style);
19141   verifyFormat("template <typename T>\n"
19142                "concept EqualityComparable = requires(T a, T b) {\n"
19143                "  { a == b } -> bool;\n"
19144                "  { a != b } -> bool;\n"
19145                "};",
19146                Style);
19147 
19148   verifyFormat("template <typename It>\n"
19149                "requires Iterator<It>\n"
19150                "void sort(It begin, It end) {\n"
19151                "  //....\n"
19152                "}",
19153                Style);
19154 
19155   verifyFormat("template <typename T>\n"
19156                "concept Large = sizeof(T) > 10;",
19157                Style);
19158 
19159   verifyFormat("template <typename T, typename U>\n"
19160                "concept FooableWith = requires(T t, U u) {\n"
19161                "  typename T::foo_type;\n"
19162                "  { t.foo(u) } -> typename T::foo_type;\n"
19163                "  t++;\n"
19164                "};\n"
19165                "void doFoo(FooableWith<int> auto t) {\n"
19166                "  t.foo(3);\n"
19167                "}",
19168                Style);
19169   verifyFormat("template <typename T>\n"
19170                "concept Context = sizeof(T) == 1;",
19171                Style);
19172   verifyFormat("template <typename T>\n"
19173                "concept Context = is_specialization_of_v<context, T>;",
19174                Style);
19175   verifyFormat("template <typename T>\n"
19176                "concept Node = std::is_object_v<T>;",
19177                Style);
19178   verifyFormat("template <typename T>\n"
19179                "concept Tree = true;",
19180                Style);
19181 
19182   verifyFormat("template <typename T> int g(T i) requires Concept1<I> {\n"
19183                "  //...\n"
19184                "}",
19185                Style);
19186 
19187   verifyFormat(
19188       "template <typename T> int g(T i) requires Concept1<I> && Concept2<I> {\n"
19189       "  //...\n"
19190       "}",
19191       Style);
19192 
19193   verifyFormat(
19194       "template <typename T> int g(T i) requires Concept1<I> || Concept2<I> {\n"
19195       "  //...\n"
19196       "}",
19197       Style);
19198 
19199   verifyFormat("template <typename T>\n"
19200                "veryveryvery_long_return_type g(T i) requires Concept1<I> || "
19201                "Concept2<I> {\n"
19202                "  //...\n"
19203                "}",
19204                Style);
19205 
19206   verifyFormat("template <typename T>\n"
19207                "veryveryvery_long_return_type g(T i) requires Concept1<I> && "
19208                "Concept2<I> {\n"
19209                "  //...\n"
19210                "}",
19211                Style);
19212 
19213   verifyFormat(
19214       "template <typename T>\n"
19215       "veryveryvery_long_return_type g(T i) requires Concept1 && Concept2 {\n"
19216       "  //...\n"
19217       "}",
19218       Style);
19219 
19220   verifyFormat(
19221       "template <typename T>\n"
19222       "veryveryvery_long_return_type g(T i) requires Concept1 || Concept2 {\n"
19223       "  //...\n"
19224       "}",
19225       Style);
19226 
19227   verifyFormat("template <typename It>\n"
19228                "requires Foo<It>() && Bar<It> {\n"
19229                "  //....\n"
19230                "}",
19231                Style);
19232 
19233   verifyFormat("template <typename It>\n"
19234                "requires Foo<Bar<It>>() && Bar<Foo<It, It>> {\n"
19235                "  //....\n"
19236                "}",
19237                Style);
19238 
19239   verifyFormat("template <typename It>\n"
19240                "requires Foo<Bar<It, It>>() && Bar<Foo<It, It>> {\n"
19241                "  //....\n"
19242                "}",
19243                Style);
19244 
19245   verifyFormat(
19246       "template <typename It>\n"
19247       "requires Foo<Bar<It>, Baz<It>>() && Bar<Foo<It>, Baz<It, It>> {\n"
19248       "  //....\n"
19249       "}",
19250       Style);
19251 
19252   Style.IndentRequires = true;
19253   verifyFormat("template <typename It>\n"
19254                "  requires Iterator<It>\n"
19255                "void sort(It begin, It end) {\n"
19256                "  //....\n"
19257                "}",
19258                Style);
19259   verifyFormat("template <std::size index_>\n"
19260                "  requires(index_ < sizeof...(Children_))\n"
19261                "Tree auto &child() {\n"
19262                "  // ...\n"
19263                "}",
19264                Style);
19265 
19266   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
19267   verifyFormat("template <typename T>\n"
19268                "concept Hashable = requires (T a) {\n"
19269                "  { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
19270                "};",
19271                Style);
19272 
19273   verifyFormat("template <class T = void>\n"
19274                "  requires EqualityComparable<T> || Same<T, void>\n"
19275                "struct equal_to;",
19276                Style);
19277 
19278   verifyFormat("template <class T>\n"
19279                "  requires requires {\n"
19280                "    T{};\n"
19281                "    T (int);\n"
19282                "  }\n",
19283                Style);
19284 
19285   Style.ColumnLimit = 78;
19286   verifyFormat("template <typename T>\n"
19287                "concept Context = Traits<typename T::traits_type> and\n"
19288                "    Interface<typename T::interface_type> and\n"
19289                "    Request<typename T::request_type> and\n"
19290                "    Response<typename T::response_type> and\n"
19291                "    ContextExtension<typename T::extension_type> and\n"
19292                "    ::std::is_copy_constructable<T> and "
19293                "::std::is_move_constructable<T> and\n"
19294                "    requires (T c) {\n"
19295                "  { c.response; } -> Response;\n"
19296                "} and requires (T c) {\n"
19297                "  { c.request; } -> Request;\n"
19298                "}\n",
19299                Style);
19300 
19301   verifyFormat("template <typename T>\n"
19302                "concept Context = Traits<typename T::traits_type> or\n"
19303                "    Interface<typename T::interface_type> or\n"
19304                "    Request<typename T::request_type> or\n"
19305                "    Response<typename T::response_type> or\n"
19306                "    ContextExtension<typename T::extension_type> or\n"
19307                "    ::std::is_copy_constructable<T> or "
19308                "::std::is_move_constructable<T> or\n"
19309                "    requires (T c) {\n"
19310                "  { c.response; } -> Response;\n"
19311                "} or requires (T c) {\n"
19312                "  { c.request; } -> Request;\n"
19313                "}\n",
19314                Style);
19315 
19316   verifyFormat("template <typename T>\n"
19317                "concept Context = Traits<typename T::traits_type> &&\n"
19318                "    Interface<typename T::interface_type> &&\n"
19319                "    Request<typename T::request_type> &&\n"
19320                "    Response<typename T::response_type> &&\n"
19321                "    ContextExtension<typename T::extension_type> &&\n"
19322                "    ::std::is_copy_constructable<T> && "
19323                "::std::is_move_constructable<T> &&\n"
19324                "    requires (T c) {\n"
19325                "  { c.response; } -> Response;\n"
19326                "} && requires (T c) {\n"
19327                "  { c.request; } -> Request;\n"
19328                "}\n",
19329                Style);
19330 
19331   verifyFormat("template <typename T>\nconcept someConcept = Constraint1<T> && "
19332                "Constraint2<T>;");
19333 
19334   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
19335   Style.BraceWrapping.AfterFunction = true;
19336   Style.BraceWrapping.AfterClass = true;
19337   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
19338   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
19339   verifyFormat("void Foo () requires (std::copyable<T>)\n"
19340                "{\n"
19341                "  return\n"
19342                "}\n",
19343                Style);
19344 
19345   verifyFormat("void Foo () requires std::copyable<T>\n"
19346                "{\n"
19347                "  return\n"
19348                "}\n",
19349                Style);
19350 
19351   verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
19352                "  requires (std::invocable<F, std::invoke_result_t<Args>...>)\n"
19353                "struct constant;",
19354                Style);
19355 
19356   verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
19357                "  requires std::invocable<F, std::invoke_result_t<Args>...>\n"
19358                "struct constant;",
19359                Style);
19360 
19361   verifyFormat("template <class T>\n"
19362                "class plane_with_very_very_very_long_name\n"
19363                "{\n"
19364                "  constexpr plane_with_very_very_very_long_name () requires "
19365                "std::copyable<T>\n"
19366                "      : plane_with_very_very_very_long_name (1)\n"
19367                "  {\n"
19368                "  }\n"
19369                "}\n",
19370                Style);
19371 
19372   verifyFormat("template <class T>\n"
19373                "class plane_with_long_name\n"
19374                "{\n"
19375                "  constexpr plane_with_long_name () requires std::copyable<T>\n"
19376                "      : plane_with_long_name (1)\n"
19377                "  {\n"
19378                "  }\n"
19379                "}\n",
19380                Style);
19381 
19382   Style.BreakBeforeConceptDeclarations = false;
19383   verifyFormat("template <typename T> concept Tree = true;", Style);
19384 
19385   Style.IndentRequires = false;
19386   verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
19387                "requires (std::invocable<F, std::invoke_result_t<Args>...>) "
19388                "struct constant;",
19389                Style);
19390 }
19391 
19392 TEST_F(FormatTest, StatementAttributeLikeMacros) {
19393   FormatStyle Style = getLLVMStyle();
19394   StringRef Source = "void Foo::slot() {\n"
19395                      "  unsigned char MyChar = 'x';\n"
19396                      "  emit signal(MyChar);\n"
19397                      "  Q_EMIT signal(MyChar);\n"
19398                      "}";
19399 
19400   EXPECT_EQ(Source, format(Source, Style));
19401 
19402   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
19403   EXPECT_EQ("void Foo::slot() {\n"
19404             "  unsigned char MyChar = 'x';\n"
19405             "  emit          signal(MyChar);\n"
19406             "  Q_EMIT signal(MyChar);\n"
19407             "}",
19408             format(Source, Style));
19409 
19410   Style.StatementAttributeLikeMacros.push_back("emit");
19411   EXPECT_EQ(Source, format(Source, Style));
19412 
19413   Style.StatementAttributeLikeMacros = {};
19414   EXPECT_EQ("void Foo::slot() {\n"
19415             "  unsigned char MyChar = 'x';\n"
19416             "  emit          signal(MyChar);\n"
19417             "  Q_EMIT        signal(MyChar);\n"
19418             "}",
19419             format(Source, Style));
19420 }
19421 
19422 TEST_F(FormatTest, IndentAccessModifiers) {
19423   FormatStyle Style = getLLVMStyle();
19424   Style.IndentAccessModifiers = true;
19425   // Members are *two* levels below the record;
19426   // Style.IndentWidth == 2, thus yielding a 4 spaces wide indentation.
19427   verifyFormat("class C {\n"
19428                "    int i;\n"
19429                "};\n",
19430                Style);
19431   verifyFormat("union C {\n"
19432                "    int i;\n"
19433                "    unsigned u;\n"
19434                "};\n",
19435                Style);
19436   // Access modifiers should be indented one level below the record.
19437   verifyFormat("class C {\n"
19438                "  public:\n"
19439                "    int i;\n"
19440                "};\n",
19441                Style);
19442   verifyFormat("struct S {\n"
19443                "  private:\n"
19444                "    class C {\n"
19445                "        int j;\n"
19446                "\n"
19447                "      public:\n"
19448                "        C();\n"
19449                "    };\n"
19450                "\n"
19451                "  public:\n"
19452                "    int i;\n"
19453                "};\n",
19454                Style);
19455   // Enumerations are not records and should be unaffected.
19456   Style.AllowShortEnumsOnASingleLine = false;
19457   verifyFormat("enum class E\n"
19458                "{\n"
19459                "  A,\n"
19460                "  B\n"
19461                "};\n",
19462                Style);
19463   // Test with a different indentation width;
19464   // also proves that the result is Style.AccessModifierOffset agnostic.
19465   Style.IndentWidth = 3;
19466   verifyFormat("class C {\n"
19467                "   public:\n"
19468                "      int i;\n"
19469                "};\n",
19470                Style);
19471 }
19472 
19473 TEST_F(FormatTest, LimitlessStringsAndComments) {
19474   auto Style = getLLVMStyleWithColumns(0);
19475   constexpr StringRef Code =
19476       "/**\n"
19477       " * This is a multiline comment with quite some long lines, at least for "
19478       "the LLVM Style.\n"
19479       " * We will redo this with strings and line comments. Just to  check if "
19480       "everything is working.\n"
19481       " */\n"
19482       "bool foo() {\n"
19483       "  /* Single line multi line comment. */\n"
19484       "  const std::string String = \"This is a multiline string with quite "
19485       "some long lines, at least for the LLVM Style.\"\n"
19486       "                             \"We already did it with multi line "
19487       "comments, and we will do it with line comments. Just to check if "
19488       "everything is working.\";\n"
19489       "  // This is a line comment (block) with quite some long lines, at "
19490       "least for the LLVM Style.\n"
19491       "  // We already did this with multi line comments and strings. Just to "
19492       "check if everything is working.\n"
19493       "  const std::string SmallString = \"Hello World\";\n"
19494       "  // Small line comment\n"
19495       "  return String.size() > SmallString.size();\n"
19496       "}";
19497   EXPECT_EQ(Code, format(Code, Style));
19498 }
19499 } // namespace
19500 } // namespace format
19501 } // namespace clang
19502