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, FormatsArrays) {
8891   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8892                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
8893   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
8894                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
8895   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
8896                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
8897   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8898                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8899   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8900                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
8901   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8902                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8903                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
8904   verifyFormat(
8905       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
8906       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
8907       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
8908   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
8909                "    .aaaaaaaaaaaaaaaaaaaaaa();");
8910 
8911   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
8912                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
8913   verifyFormat(
8914       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
8915       "                                  .aaaaaaa[0]\n"
8916       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
8917   verifyFormat("a[::b::c];");
8918 
8919   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
8920 
8921   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
8922   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
8923 }
8924 
8925 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
8926   verifyFormat("(a)->b();");
8927   verifyFormat("--a;");
8928 }
8929 
8930 TEST_F(FormatTest, HandlesIncludeDirectives) {
8931   verifyFormat("#include <string>\n"
8932                "#include <a/b/c.h>\n"
8933                "#include \"a/b/string\"\n"
8934                "#include \"string.h\"\n"
8935                "#include \"string.h\"\n"
8936                "#include <a-a>\n"
8937                "#include < path with space >\n"
8938                "#include_next <test.h>"
8939                "#include \"abc.h\" // this is included for ABC\n"
8940                "#include \"some long include\" // with a comment\n"
8941                "#include \"some very long include path\"\n"
8942                "#include <some/very/long/include/path>\n",
8943                getLLVMStyleWithColumns(35));
8944   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
8945   EXPECT_EQ("#include <a>", format("#include<a>"));
8946 
8947   verifyFormat("#import <string>");
8948   verifyFormat("#import <a/b/c.h>");
8949   verifyFormat("#import \"a/b/string\"");
8950   verifyFormat("#import \"string.h\"");
8951   verifyFormat("#import \"string.h\"");
8952   verifyFormat("#if __has_include(<strstream>)\n"
8953                "#include <strstream>\n"
8954                "#endif");
8955 
8956   verifyFormat("#define MY_IMPORT <a/b>");
8957 
8958   verifyFormat("#if __has_include(<a/b>)");
8959   verifyFormat("#if __has_include_next(<a/b>)");
8960   verifyFormat("#define F __has_include(<a/b>)");
8961   verifyFormat("#define F __has_include_next(<a/b>)");
8962 
8963   // Protocol buffer definition or missing "#".
8964   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
8965                getLLVMStyleWithColumns(30));
8966 
8967   FormatStyle Style = getLLVMStyle();
8968   Style.AlwaysBreakBeforeMultilineStrings = true;
8969   Style.ColumnLimit = 0;
8970   verifyFormat("#import \"abc.h\"", Style);
8971 
8972   // But 'import' might also be a regular C++ namespace.
8973   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8974                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8975 }
8976 
8977 //===----------------------------------------------------------------------===//
8978 // Error recovery tests.
8979 //===----------------------------------------------------------------------===//
8980 
8981 TEST_F(FormatTest, IncompleteParameterLists) {
8982   FormatStyle NoBinPacking = getLLVMStyle();
8983   NoBinPacking.BinPackParameters = false;
8984   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
8985                "                        double *min_x,\n"
8986                "                        double *max_x,\n"
8987                "                        double *min_y,\n"
8988                "                        double *max_y,\n"
8989                "                        double *min_z,\n"
8990                "                        double *max_z, ) {}",
8991                NoBinPacking);
8992 }
8993 
8994 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
8995   verifyFormat("void f() { return; }\n42");
8996   verifyFormat("void f() {\n"
8997                "  if (0)\n"
8998                "    return;\n"
8999                "}\n"
9000                "42");
9001   verifyFormat("void f() { return }\n42");
9002   verifyFormat("void f() {\n"
9003                "  if (0)\n"
9004                "    return\n"
9005                "}\n"
9006                "42");
9007 }
9008 
9009 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
9010   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
9011   EXPECT_EQ("void f() {\n"
9012             "  if (a)\n"
9013             "    return\n"
9014             "}",
9015             format("void  f  (  )  {  if  ( a )  return  }"));
9016   EXPECT_EQ("namespace N {\n"
9017             "void f()\n"
9018             "}",
9019             format("namespace  N  {  void f()  }"));
9020   EXPECT_EQ("namespace N {\n"
9021             "void f() {}\n"
9022             "void g()\n"
9023             "} // namespace N",
9024             format("namespace N  { void f( ) { } void g( ) }"));
9025 }
9026 
9027 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
9028   verifyFormat("int aaaaaaaa =\n"
9029                "    // Overlylongcomment\n"
9030                "    b;",
9031                getLLVMStyleWithColumns(20));
9032   verifyFormat("function(\n"
9033                "    ShortArgument,\n"
9034                "    LoooooooooooongArgument);\n",
9035                getLLVMStyleWithColumns(20));
9036 }
9037 
9038 TEST_F(FormatTest, IncorrectAccessSpecifier) {
9039   verifyFormat("public:");
9040   verifyFormat("class A {\n"
9041                "public\n"
9042                "  void f() {}\n"
9043                "};");
9044   verifyFormat("public\n"
9045                "int qwerty;");
9046   verifyFormat("public\n"
9047                "B {}");
9048   verifyFormat("public\n"
9049                "{}");
9050   verifyFormat("public\n"
9051                "B { int x; }");
9052 }
9053 
9054 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
9055   verifyFormat("{");
9056   verifyFormat("#})");
9057   verifyNoCrash("(/**/[:!] ?[).");
9058 }
9059 
9060 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
9061   // Found by oss-fuzz:
9062   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
9063   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
9064   Style.ColumnLimit = 60;
9065   verifyNoCrash(
9066       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
9067       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
9068       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
9069       Style);
9070 }
9071 
9072 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
9073   verifyFormat("do {\n}");
9074   verifyFormat("do {\n}\n"
9075                "f();");
9076   verifyFormat("do {\n}\n"
9077                "wheeee(fun);");
9078   verifyFormat("do {\n"
9079                "  f();\n"
9080                "}");
9081 }
9082 
9083 TEST_F(FormatTest, IncorrectCodeMissingParens) {
9084   verifyFormat("if {\n  foo;\n  foo();\n}");
9085   verifyFormat("switch {\n  foo;\n  foo();\n}");
9086   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
9087   verifyFormat("while {\n  foo;\n  foo();\n}");
9088   verifyFormat("do {\n  foo;\n  foo();\n} while;");
9089 }
9090 
9091 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
9092   verifyIncompleteFormat("namespace {\n"
9093                          "class Foo { Foo (\n"
9094                          "};\n"
9095                          "} // namespace");
9096 }
9097 
9098 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
9099   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
9100   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
9101   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
9102   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
9103 
9104   EXPECT_EQ("{\n"
9105             "  {\n"
9106             "    breakme(\n"
9107             "        qwe);\n"
9108             "  }\n",
9109             format("{\n"
9110                    "    {\n"
9111                    " breakme(qwe);\n"
9112                    "}\n",
9113                    getLLVMStyleWithColumns(10)));
9114 }
9115 
9116 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
9117   verifyFormat("int x = {\n"
9118                "    avariable,\n"
9119                "    b(alongervariable)};",
9120                getLLVMStyleWithColumns(25));
9121 }
9122 
9123 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
9124   verifyFormat("return (a)(b){1, 2, 3};");
9125 }
9126 
9127 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
9128   verifyFormat("vector<int> x{1, 2, 3, 4};");
9129   verifyFormat("vector<int> x{\n"
9130                "    1,\n"
9131                "    2,\n"
9132                "    3,\n"
9133                "    4,\n"
9134                "};");
9135   verifyFormat("vector<T> x{{}, {}, {}, {}};");
9136   verifyFormat("f({1, 2});");
9137   verifyFormat("auto v = Foo{-1};");
9138   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
9139   verifyFormat("Class::Class : member{1, 2, 3} {}");
9140   verifyFormat("new vector<int>{1, 2, 3};");
9141   verifyFormat("new int[3]{1, 2, 3};");
9142   verifyFormat("new int{1};");
9143   verifyFormat("return {arg1, arg2};");
9144   verifyFormat("return {arg1, SomeType{parameter}};");
9145   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
9146   verifyFormat("new T{arg1, arg2};");
9147   verifyFormat("f(MyMap[{composite, key}]);");
9148   verifyFormat("class Class {\n"
9149                "  T member = {arg1, arg2};\n"
9150                "};");
9151   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
9152   verifyFormat("const struct A a = {.a = 1, .b = 2};");
9153   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
9154   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
9155   verifyFormat("int a = std::is_integral<int>{} + 0;");
9156 
9157   verifyFormat("int foo(int i) { return fo1{}(i); }");
9158   verifyFormat("int foo(int i) { return fo1{}(i); }");
9159   verifyFormat("auto i = decltype(x){};");
9160   verifyFormat("auto i = typeof(x){};");
9161   verifyFormat("auto i = _Atomic(x){};");
9162   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
9163   verifyFormat("Node n{1, Node{1000}, //\n"
9164                "       2};");
9165   verifyFormat("Aaaa aaaaaaa{\n"
9166                "    {\n"
9167                "        aaaa,\n"
9168                "    },\n"
9169                "};");
9170   verifyFormat("class C : public D {\n"
9171                "  SomeClass SC{2};\n"
9172                "};");
9173   verifyFormat("class C : public A {\n"
9174                "  class D : public B {\n"
9175                "    void f() { int i{2}; }\n"
9176                "  };\n"
9177                "};");
9178   verifyFormat("#define A {a, a},");
9179 
9180   // Avoid breaking between equal sign and opening brace
9181   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
9182   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
9183   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
9184                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
9185                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
9186                "     {\"ccccccccccccccccccccc\", 2}};",
9187                AvoidBreakingFirstArgument);
9188 
9189   // Binpacking only if there is no trailing comma
9190   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
9191                "                      cccccccccc, dddddddddd};",
9192                getLLVMStyleWithColumns(50));
9193   verifyFormat("const Aaaaaa aaaaa = {\n"
9194                "    aaaaaaaaaaa,\n"
9195                "    bbbbbbbbbbb,\n"
9196                "    ccccccccccc,\n"
9197                "    ddddddddddd,\n"
9198                "};",
9199                getLLVMStyleWithColumns(50));
9200 
9201   // Cases where distinguising braced lists and blocks is hard.
9202   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
9203   verifyFormat("void f() {\n"
9204                "  return; // comment\n"
9205                "}\n"
9206                "SomeType t;");
9207   verifyFormat("void f() {\n"
9208                "  if (a) {\n"
9209                "    f();\n"
9210                "  }\n"
9211                "}\n"
9212                "SomeType t;");
9213 
9214   // In combination with BinPackArguments = false.
9215   FormatStyle NoBinPacking = getLLVMStyle();
9216   NoBinPacking.BinPackArguments = false;
9217   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
9218                "                      bbbbb,\n"
9219                "                      ccccc,\n"
9220                "                      ddddd,\n"
9221                "                      eeeee,\n"
9222                "                      ffffff,\n"
9223                "                      ggggg,\n"
9224                "                      hhhhhh,\n"
9225                "                      iiiiii,\n"
9226                "                      jjjjjj,\n"
9227                "                      kkkkkk};",
9228                NoBinPacking);
9229   verifyFormat("const Aaaaaa aaaaa = {\n"
9230                "    aaaaa,\n"
9231                "    bbbbb,\n"
9232                "    ccccc,\n"
9233                "    ddddd,\n"
9234                "    eeeee,\n"
9235                "    ffffff,\n"
9236                "    ggggg,\n"
9237                "    hhhhhh,\n"
9238                "    iiiiii,\n"
9239                "    jjjjjj,\n"
9240                "    kkkkkk,\n"
9241                "};",
9242                NoBinPacking);
9243   verifyFormat(
9244       "const Aaaaaa aaaaa = {\n"
9245       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
9246       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
9247       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
9248       "};",
9249       NoBinPacking);
9250 
9251   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
9252   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
9253             "    CDDDP83848_BMCR_REGISTER,\n"
9254             "    CDDDP83848_BMSR_REGISTER,\n"
9255             "    CDDDP83848_RBR_REGISTER};",
9256             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
9257                    "                                CDDDP83848_BMSR_REGISTER,\n"
9258                    "                                CDDDP83848_RBR_REGISTER};",
9259                    NoBinPacking));
9260 
9261   // FIXME: The alignment of these trailing comments might be bad. Then again,
9262   // this might be utterly useless in real code.
9263   verifyFormat("Constructor::Constructor()\n"
9264                "    : some_value{         //\n"
9265                "                 aaaaaaa, //\n"
9266                "                 bbbbbbb} {}");
9267 
9268   // In braced lists, the first comment is always assumed to belong to the
9269   // first element. Thus, it can be moved to the next or previous line as
9270   // appropriate.
9271   EXPECT_EQ("function({// First element:\n"
9272             "          1,\n"
9273             "          // Second element:\n"
9274             "          2});",
9275             format("function({\n"
9276                    "    // First element:\n"
9277                    "    1,\n"
9278                    "    // Second element:\n"
9279                    "    2});"));
9280   EXPECT_EQ("std::vector<int> MyNumbers{\n"
9281             "    // First element:\n"
9282             "    1,\n"
9283             "    // Second element:\n"
9284             "    2};",
9285             format("std::vector<int> MyNumbers{// First element:\n"
9286                    "                           1,\n"
9287                    "                           // Second element:\n"
9288                    "                           2};",
9289                    getLLVMStyleWithColumns(30)));
9290   // A trailing comma should still lead to an enforced line break and no
9291   // binpacking.
9292   EXPECT_EQ("vector<int> SomeVector = {\n"
9293             "    // aaa\n"
9294             "    1,\n"
9295             "    2,\n"
9296             "};",
9297             format("vector<int> SomeVector = { // aaa\n"
9298                    "    1, 2, };"));
9299 
9300   // C++11 brace initializer list l-braces should not be treated any differently
9301   // when breaking before lambda bodies is enabled
9302   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
9303   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
9304   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
9305   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
9306   verifyFormat(
9307       "std::runtime_error{\n"
9308       "    \"Long string which will force a break onto the next line...\"};",
9309       BreakBeforeLambdaBody);
9310 
9311   FormatStyle ExtraSpaces = getLLVMStyle();
9312   ExtraSpaces.Cpp11BracedListStyle = false;
9313   ExtraSpaces.ColumnLimit = 75;
9314   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
9315   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
9316   verifyFormat("f({ 1, 2 });", ExtraSpaces);
9317   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
9318   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
9319   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
9320   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
9321   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
9322   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
9323   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
9324   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
9325   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
9326   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
9327   verifyFormat("class Class {\n"
9328                "  T member = { arg1, arg2 };\n"
9329                "};",
9330                ExtraSpaces);
9331   verifyFormat(
9332       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9333       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
9334       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
9335       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
9336       ExtraSpaces);
9337   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
9338   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
9339                ExtraSpaces);
9340   verifyFormat(
9341       "someFunction(OtherParam,\n"
9342       "             BracedList{ // comment 1 (Forcing interesting break)\n"
9343       "                         param1, param2,\n"
9344       "                         // comment 2\n"
9345       "                         param3, param4 });",
9346       ExtraSpaces);
9347   verifyFormat(
9348       "std::this_thread::sleep_for(\n"
9349       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
9350       ExtraSpaces);
9351   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
9352                "    aaaaaaa,\n"
9353                "    aaaaaaaaaa,\n"
9354                "    aaaaa,\n"
9355                "    aaaaaaaaaaaaaaa,\n"
9356                "    aaa,\n"
9357                "    aaaaaaaaaa,\n"
9358                "    a,\n"
9359                "    aaaaaaaaaaaaaaaaaaaaa,\n"
9360                "    aaaaaaaaaaaa,\n"
9361                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
9362                "    aaaaaaa,\n"
9363                "    a};");
9364   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
9365   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
9366   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
9367 
9368   // Avoid breaking between initializer/equal sign and opening brace
9369   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
9370   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
9371                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9372                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9373                "  { \"ccccccccccccccccccccc\", 2 }\n"
9374                "};",
9375                ExtraSpaces);
9376   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
9377                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
9378                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
9379                "  { \"ccccccccccccccccccccc\", 2 }\n"
9380                "};",
9381                ExtraSpaces);
9382 
9383   FormatStyle SpaceBeforeBrace = getLLVMStyle();
9384   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
9385   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
9386   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
9387 
9388   FormatStyle SpaceBetweenBraces = getLLVMStyle();
9389   SpaceBetweenBraces.SpacesInAngles = true;
9390   SpaceBetweenBraces.SpacesInParentheses = true;
9391   SpaceBetweenBraces.SpacesInSquareBrackets = true;
9392   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
9393   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
9394   verifyFormat("vector< int > x{ // comment 1\n"
9395                "                 1, 2, 3, 4 };",
9396                SpaceBetweenBraces);
9397   SpaceBetweenBraces.ColumnLimit = 20;
9398   EXPECT_EQ("vector< int > x{\n"
9399             "    1, 2, 3, 4 };",
9400             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9401   SpaceBetweenBraces.ColumnLimit = 24;
9402   EXPECT_EQ("vector< int > x{ 1, 2,\n"
9403             "                 3, 4 };",
9404             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
9405   EXPECT_EQ("vector< int > x{\n"
9406             "    1,\n"
9407             "    2,\n"
9408             "    3,\n"
9409             "    4,\n"
9410             "};",
9411             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
9412   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
9413   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
9414   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
9415 }
9416 
9417 TEST_F(FormatTest, FormatSpacesInAngles) {
9418   FormatStyle SpaceInAngles = getLLVMStyle();
9419   SpaceInAngles.SpacesInAngles = true;
9420   verifyFormat("vector< ::std::string > x1;", SpaceInAngles);
9421   verifyFormat("Foo< int, Bar > x2;", SpaceInAngles);
9422   verifyFormat("Foo< ::int, ::Bar > x3;", SpaceInAngles);
9423 
9424   SpaceInAngles.SpacesInAngles = false;
9425   verifyFormat("vector<::std::string> x4;", SpaceInAngles);
9426   verifyFormat("vector<int> x5;", SpaceInAngles);
9427   verifyFormat("Foo<int, Bar> x6;", SpaceInAngles);
9428   verifyFormat("Foo<::int, ::Bar> x7;", SpaceInAngles);
9429 }
9430 
9431 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
9432   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9433                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9434                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9435                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9436                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9437                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9438   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
9439                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9440                "                 1, 22, 333, 4444, 55555, //\n"
9441                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9442                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
9443   verifyFormat(
9444       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9445       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
9446       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
9447       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9448       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9449       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
9450       "                 7777777};");
9451   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9452                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9453                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9454   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9455                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9456                "    // Separating comment.\n"
9457                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
9458   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
9459                "    // Leading comment\n"
9460                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
9461                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
9462   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9463                "                 1, 1, 1, 1};",
9464                getLLVMStyleWithColumns(39));
9465   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9466                "                 1, 1, 1, 1};",
9467                getLLVMStyleWithColumns(38));
9468   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
9469                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
9470                getLLVMStyleWithColumns(43));
9471   verifyFormat(
9472       "static unsigned SomeValues[10][3] = {\n"
9473       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
9474       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
9475   verifyFormat("static auto fields = new vector<string>{\n"
9476                "    \"aaaaaaaaaaaaa\",\n"
9477                "    \"aaaaaaaaaaaaa\",\n"
9478                "    \"aaaaaaaaaaaa\",\n"
9479                "    \"aaaaaaaaaaaaaa\",\n"
9480                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9481                "    \"aaaaaaaaaaaa\",\n"
9482                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
9483                "};");
9484   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
9485   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
9486                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
9487                "                 3, cccccccccccccccccccccc};",
9488                getLLVMStyleWithColumns(60));
9489 
9490   // Trailing commas.
9491   verifyFormat("vector<int> x = {\n"
9492                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
9493                "};",
9494                getLLVMStyleWithColumns(39));
9495   verifyFormat("vector<int> x = {\n"
9496                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
9497                "};",
9498                getLLVMStyleWithColumns(39));
9499   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
9500                "                 1, 1, 1, 1,\n"
9501                "                 /**/ /**/};",
9502                getLLVMStyleWithColumns(39));
9503 
9504   // Trailing comment in the first line.
9505   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
9506                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
9507                "    111111111,  222222222,  3333333333,  444444444,  //\n"
9508                "    11111111,   22222222,   333333333,   44444444};");
9509   // Trailing comment in the last line.
9510   verifyFormat("int aaaaa[] = {\n"
9511                "    1, 2, 3, // comment\n"
9512                "    4, 5, 6  // comment\n"
9513                "};");
9514 
9515   // With nested lists, we should either format one item per line or all nested
9516   // lists one on line.
9517   // FIXME: For some nested lists, we can do better.
9518   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
9519                "        {aaaaaaaaaaaaaaaaaaa},\n"
9520                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
9521                "        {aaaaaaaaaaaaaaaaa}};",
9522                getLLVMStyleWithColumns(60));
9523   verifyFormat(
9524       "SomeStruct my_struct_array = {\n"
9525       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
9526       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
9527       "    {aaa, aaa},\n"
9528       "    {aaa, aaa},\n"
9529       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
9530       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
9531       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
9532 
9533   // No column layout should be used here.
9534   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
9535                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
9536 
9537   verifyNoCrash("a<,");
9538 
9539   // No braced initializer here.
9540   verifyFormat("void f() {\n"
9541                "  struct Dummy {};\n"
9542                "  f(v);\n"
9543                "}");
9544 
9545   // Long lists should be formatted in columns even if they are nested.
9546   verifyFormat(
9547       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9548       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9549       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9550       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9551       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
9552       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
9553 
9554   // Allow "single-column" layout even if that violates the column limit. There
9555   // isn't going to be a better way.
9556   verifyFormat("std::vector<int> a = {\n"
9557                "    aaaaaaaa,\n"
9558                "    aaaaaaaa,\n"
9559                "    aaaaaaaa,\n"
9560                "    aaaaaaaa,\n"
9561                "    aaaaaaaaaa,\n"
9562                "    aaaaaaaa,\n"
9563                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
9564                getLLVMStyleWithColumns(30));
9565   verifyFormat("vector<int> aaaa = {\n"
9566                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9567                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
9568                "    aaaaaa.aaaaaaa,\n"
9569                "    aaaaaa.aaaaaaa,\n"
9570                "    aaaaaa.aaaaaaa,\n"
9571                "    aaaaaa.aaaaaaa,\n"
9572                "};");
9573 
9574   // Don't create hanging lists.
9575   verifyFormat("someFunction(Param, {List1, List2,\n"
9576                "                     List3});",
9577                getLLVMStyleWithColumns(35));
9578   verifyFormat("someFunction(Param, Param,\n"
9579                "             {List1, List2,\n"
9580                "              List3});",
9581                getLLVMStyleWithColumns(35));
9582   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
9583                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
9584 }
9585 
9586 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
9587   FormatStyle DoNotMerge = getLLVMStyle();
9588   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9589 
9590   verifyFormat("void f() { return 42; }");
9591   verifyFormat("void f() {\n"
9592                "  return 42;\n"
9593                "}",
9594                DoNotMerge);
9595   verifyFormat("void f() {\n"
9596                "  // Comment\n"
9597                "}");
9598   verifyFormat("{\n"
9599                "#error {\n"
9600                "  int a;\n"
9601                "}");
9602   verifyFormat("{\n"
9603                "  int a;\n"
9604                "#error {\n"
9605                "}");
9606   verifyFormat("void f() {} // comment");
9607   verifyFormat("void f() { int a; } // comment");
9608   verifyFormat("void f() {\n"
9609                "} // comment",
9610                DoNotMerge);
9611   verifyFormat("void f() {\n"
9612                "  int a;\n"
9613                "} // comment",
9614                DoNotMerge);
9615   verifyFormat("void f() {\n"
9616                "} // comment",
9617                getLLVMStyleWithColumns(15));
9618 
9619   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
9620   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
9621 
9622   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
9623   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
9624   verifyFormat("class C {\n"
9625                "  C()\n"
9626                "      : iiiiiiii(nullptr),\n"
9627                "        kkkkkkk(nullptr),\n"
9628                "        mmmmmmm(nullptr),\n"
9629                "        nnnnnnn(nullptr) {}\n"
9630                "};",
9631                getGoogleStyle());
9632 
9633   FormatStyle NoColumnLimit = getLLVMStyle();
9634   NoColumnLimit.ColumnLimit = 0;
9635   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
9636   EXPECT_EQ("class C {\n"
9637             "  A() : b(0) {}\n"
9638             "};",
9639             format("class C{A():b(0){}};", NoColumnLimit));
9640   EXPECT_EQ("A()\n"
9641             "    : b(0) {\n"
9642             "}",
9643             format("A()\n:b(0)\n{\n}", NoColumnLimit));
9644 
9645   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
9646   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
9647       FormatStyle::SFS_None;
9648   EXPECT_EQ("A()\n"
9649             "    : b(0) {\n"
9650             "}",
9651             format("A():b(0){}", DoNotMergeNoColumnLimit));
9652   EXPECT_EQ("A()\n"
9653             "    : b(0) {\n"
9654             "}",
9655             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
9656 
9657   verifyFormat("#define A          \\\n"
9658                "  void f() {       \\\n"
9659                "    int i;         \\\n"
9660                "  }",
9661                getLLVMStyleWithColumns(20));
9662   verifyFormat("#define A           \\\n"
9663                "  void f() { int i; }",
9664                getLLVMStyleWithColumns(21));
9665   verifyFormat("#define A            \\\n"
9666                "  void f() {         \\\n"
9667                "    int i;           \\\n"
9668                "  }                  \\\n"
9669                "  int j;",
9670                getLLVMStyleWithColumns(22));
9671   verifyFormat("#define A             \\\n"
9672                "  void f() { int i; } \\\n"
9673                "  int j;",
9674                getLLVMStyleWithColumns(23));
9675 }
9676 
9677 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
9678   FormatStyle MergeEmptyOnly = getLLVMStyle();
9679   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9680   verifyFormat("class C {\n"
9681                "  int f() {}\n"
9682                "};",
9683                MergeEmptyOnly);
9684   verifyFormat("class C {\n"
9685                "  int f() {\n"
9686                "    return 42;\n"
9687                "  }\n"
9688                "};",
9689                MergeEmptyOnly);
9690   verifyFormat("int f() {}", MergeEmptyOnly);
9691   verifyFormat("int f() {\n"
9692                "  return 42;\n"
9693                "}",
9694                MergeEmptyOnly);
9695 
9696   // Also verify behavior when BraceWrapping.AfterFunction = true
9697   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9698   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
9699   verifyFormat("int f() {}", MergeEmptyOnly);
9700   verifyFormat("class C {\n"
9701                "  int f() {}\n"
9702                "};",
9703                MergeEmptyOnly);
9704 }
9705 
9706 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
9707   FormatStyle MergeInlineOnly = getLLVMStyle();
9708   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9709   verifyFormat("class C {\n"
9710                "  int f() { return 42; }\n"
9711                "};",
9712                MergeInlineOnly);
9713   verifyFormat("int f() {\n"
9714                "  return 42;\n"
9715                "}",
9716                MergeInlineOnly);
9717 
9718   // SFS_Inline implies SFS_Empty
9719   verifyFormat("class C {\n"
9720                "  int f() {}\n"
9721                "};",
9722                MergeInlineOnly);
9723   verifyFormat("int f() {}", MergeInlineOnly);
9724 
9725   // Also verify behavior when BraceWrapping.AfterFunction = true
9726   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9727   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9728   verifyFormat("class C {\n"
9729                "  int f() { return 42; }\n"
9730                "};",
9731                MergeInlineOnly);
9732   verifyFormat("int f()\n"
9733                "{\n"
9734                "  return 42;\n"
9735                "}",
9736                MergeInlineOnly);
9737 
9738   // SFS_Inline implies SFS_Empty
9739   verifyFormat("int f() {}", MergeInlineOnly);
9740   verifyFormat("class C {\n"
9741                "  int f() {}\n"
9742                "};",
9743                MergeInlineOnly);
9744 }
9745 
9746 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
9747   FormatStyle MergeInlineOnly = getLLVMStyle();
9748   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
9749       FormatStyle::SFS_InlineOnly;
9750   verifyFormat("class C {\n"
9751                "  int f() { return 42; }\n"
9752                "};",
9753                MergeInlineOnly);
9754   verifyFormat("int f() {\n"
9755                "  return 42;\n"
9756                "}",
9757                MergeInlineOnly);
9758 
9759   // SFS_InlineOnly does not imply SFS_Empty
9760   verifyFormat("class C {\n"
9761                "  int f() {}\n"
9762                "};",
9763                MergeInlineOnly);
9764   verifyFormat("int f() {\n"
9765                "}",
9766                MergeInlineOnly);
9767 
9768   // Also verify behavior when BraceWrapping.AfterFunction = true
9769   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
9770   MergeInlineOnly.BraceWrapping.AfterFunction = true;
9771   verifyFormat("class C {\n"
9772                "  int f() { return 42; }\n"
9773                "};",
9774                MergeInlineOnly);
9775   verifyFormat("int f()\n"
9776                "{\n"
9777                "  return 42;\n"
9778                "}",
9779                MergeInlineOnly);
9780 
9781   // SFS_InlineOnly does not imply SFS_Empty
9782   verifyFormat("int f()\n"
9783                "{\n"
9784                "}",
9785                MergeInlineOnly);
9786   verifyFormat("class C {\n"
9787                "  int f() {}\n"
9788                "};",
9789                MergeInlineOnly);
9790 }
9791 
9792 TEST_F(FormatTest, SplitEmptyFunction) {
9793   FormatStyle Style = getLLVMStyle();
9794   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9795   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9796   Style.BraceWrapping.AfterFunction = true;
9797   Style.BraceWrapping.SplitEmptyFunction = false;
9798   Style.ColumnLimit = 40;
9799 
9800   verifyFormat("int f()\n"
9801                "{}",
9802                Style);
9803   verifyFormat("int f()\n"
9804                "{\n"
9805                "  return 42;\n"
9806                "}",
9807                Style);
9808   verifyFormat("int f()\n"
9809                "{\n"
9810                "  // some comment\n"
9811                "}",
9812                Style);
9813 
9814   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
9815   verifyFormat("int f() {}", Style);
9816   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9817                "{}",
9818                Style);
9819   verifyFormat("int f()\n"
9820                "{\n"
9821                "  return 0;\n"
9822                "}",
9823                Style);
9824 
9825   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
9826   verifyFormat("class Foo {\n"
9827                "  int f() {}\n"
9828                "};\n",
9829                Style);
9830   verifyFormat("class Foo {\n"
9831                "  int f() { return 0; }\n"
9832                "};\n",
9833                Style);
9834   verifyFormat("class Foo {\n"
9835                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9836                "  {}\n"
9837                "};\n",
9838                Style);
9839   verifyFormat("class Foo {\n"
9840                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9841                "  {\n"
9842                "    return 0;\n"
9843                "  }\n"
9844                "};\n",
9845                Style);
9846 
9847   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9848   verifyFormat("int f() {}", Style);
9849   verifyFormat("int f() { return 0; }", Style);
9850   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9851                "{}",
9852                Style);
9853   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
9854                "{\n"
9855                "  return 0;\n"
9856                "}",
9857                Style);
9858 }
9859 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
9860   FormatStyle Style = getLLVMStyle();
9861   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
9862   verifyFormat("#ifdef A\n"
9863                "int f() {}\n"
9864                "#else\n"
9865                "int g() {}\n"
9866                "#endif",
9867                Style);
9868 }
9869 
9870 TEST_F(FormatTest, SplitEmptyClass) {
9871   FormatStyle Style = getLLVMStyle();
9872   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9873   Style.BraceWrapping.AfterClass = true;
9874   Style.BraceWrapping.SplitEmptyRecord = false;
9875 
9876   verifyFormat("class Foo\n"
9877                "{};",
9878                Style);
9879   verifyFormat("/* something */ class Foo\n"
9880                "{};",
9881                Style);
9882   verifyFormat("template <typename X> class Foo\n"
9883                "{};",
9884                Style);
9885   verifyFormat("class Foo\n"
9886                "{\n"
9887                "  Foo();\n"
9888                "};",
9889                Style);
9890   verifyFormat("typedef class Foo\n"
9891                "{\n"
9892                "} Foo_t;",
9893                Style);
9894 
9895   Style.BraceWrapping.SplitEmptyRecord = true;
9896   Style.BraceWrapping.AfterStruct = true;
9897   verifyFormat("class rep\n"
9898                "{\n"
9899                "};",
9900                Style);
9901   verifyFormat("struct rep\n"
9902                "{\n"
9903                "};",
9904                Style);
9905   verifyFormat("template <typename T> class rep\n"
9906                "{\n"
9907                "};",
9908                Style);
9909   verifyFormat("template <typename T> struct rep\n"
9910                "{\n"
9911                "};",
9912                Style);
9913   verifyFormat("class rep\n"
9914                "{\n"
9915                "  int x;\n"
9916                "};",
9917                Style);
9918   verifyFormat("struct rep\n"
9919                "{\n"
9920                "  int x;\n"
9921                "};",
9922                Style);
9923   verifyFormat("template <typename T> class rep\n"
9924                "{\n"
9925                "  int x;\n"
9926                "};",
9927                Style);
9928   verifyFormat("template <typename T> struct rep\n"
9929                "{\n"
9930                "  int x;\n"
9931                "};",
9932                Style);
9933   verifyFormat("template <typename T> class rep // Foo\n"
9934                "{\n"
9935                "  int x;\n"
9936                "};",
9937                Style);
9938   verifyFormat("template <typename T> struct rep // Bar\n"
9939                "{\n"
9940                "  int x;\n"
9941                "};",
9942                Style);
9943 
9944   verifyFormat("template <typename T> class rep<T>\n"
9945                "{\n"
9946                "  int x;\n"
9947                "};",
9948                Style);
9949 
9950   verifyFormat("template <typename T> class rep<std::complex<T>>\n"
9951                "{\n"
9952                "  int x;\n"
9953                "};",
9954                Style);
9955   verifyFormat("template <typename T> class rep<std::complex<T>>\n"
9956                "{\n"
9957                "};",
9958                Style);
9959 }
9960 
9961 TEST_F(FormatTest, SplitEmptyStruct) {
9962   FormatStyle Style = getLLVMStyle();
9963   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9964   Style.BraceWrapping.AfterStruct = true;
9965   Style.BraceWrapping.SplitEmptyRecord = false;
9966 
9967   verifyFormat("struct Foo\n"
9968                "{};",
9969                Style);
9970   verifyFormat("/* something */ struct Foo\n"
9971                "{};",
9972                Style);
9973   verifyFormat("template <typename X> struct Foo\n"
9974                "{};",
9975                Style);
9976   verifyFormat("struct Foo\n"
9977                "{\n"
9978                "  Foo();\n"
9979                "};",
9980                Style);
9981   verifyFormat("typedef struct Foo\n"
9982                "{\n"
9983                "} Foo_t;",
9984                Style);
9985   // typedef struct Bar {} Bar_t;
9986 }
9987 
9988 TEST_F(FormatTest, SplitEmptyUnion) {
9989   FormatStyle Style = getLLVMStyle();
9990   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
9991   Style.BraceWrapping.AfterUnion = true;
9992   Style.BraceWrapping.SplitEmptyRecord = false;
9993 
9994   verifyFormat("union Foo\n"
9995                "{};",
9996                Style);
9997   verifyFormat("/* something */ union Foo\n"
9998                "{};",
9999                Style);
10000   verifyFormat("union Foo\n"
10001                "{\n"
10002                "  A,\n"
10003                "};",
10004                Style);
10005   verifyFormat("typedef union Foo\n"
10006                "{\n"
10007                "} Foo_t;",
10008                Style);
10009 }
10010 
10011 TEST_F(FormatTest, SplitEmptyNamespace) {
10012   FormatStyle Style = getLLVMStyle();
10013   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10014   Style.BraceWrapping.AfterNamespace = true;
10015   Style.BraceWrapping.SplitEmptyNamespace = false;
10016 
10017   verifyFormat("namespace Foo\n"
10018                "{};",
10019                Style);
10020   verifyFormat("/* something */ namespace Foo\n"
10021                "{};",
10022                Style);
10023   verifyFormat("inline namespace Foo\n"
10024                "{};",
10025                Style);
10026   verifyFormat("/* something */ inline namespace Foo\n"
10027                "{};",
10028                Style);
10029   verifyFormat("export namespace Foo\n"
10030                "{};",
10031                Style);
10032   verifyFormat("namespace Foo\n"
10033                "{\n"
10034                "void Bar();\n"
10035                "};",
10036                Style);
10037 }
10038 
10039 TEST_F(FormatTest, NeverMergeShortRecords) {
10040   FormatStyle Style = getLLVMStyle();
10041 
10042   verifyFormat("class Foo {\n"
10043                "  Foo();\n"
10044                "};",
10045                Style);
10046   verifyFormat("typedef class Foo {\n"
10047                "  Foo();\n"
10048                "} Foo_t;",
10049                Style);
10050   verifyFormat("struct Foo {\n"
10051                "  Foo();\n"
10052                "};",
10053                Style);
10054   verifyFormat("typedef struct Foo {\n"
10055                "  Foo();\n"
10056                "} Foo_t;",
10057                Style);
10058   verifyFormat("union Foo {\n"
10059                "  A,\n"
10060                "};",
10061                Style);
10062   verifyFormat("typedef union Foo {\n"
10063                "  A,\n"
10064                "} Foo_t;",
10065                Style);
10066   verifyFormat("namespace Foo {\n"
10067                "void Bar();\n"
10068                "};",
10069                Style);
10070 
10071   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
10072   Style.BraceWrapping.AfterClass = true;
10073   Style.BraceWrapping.AfterStruct = true;
10074   Style.BraceWrapping.AfterUnion = true;
10075   Style.BraceWrapping.AfterNamespace = true;
10076   verifyFormat("class Foo\n"
10077                "{\n"
10078                "  Foo();\n"
10079                "};",
10080                Style);
10081   verifyFormat("typedef class Foo\n"
10082                "{\n"
10083                "  Foo();\n"
10084                "} Foo_t;",
10085                Style);
10086   verifyFormat("struct Foo\n"
10087                "{\n"
10088                "  Foo();\n"
10089                "};",
10090                Style);
10091   verifyFormat("typedef struct Foo\n"
10092                "{\n"
10093                "  Foo();\n"
10094                "} Foo_t;",
10095                Style);
10096   verifyFormat("union Foo\n"
10097                "{\n"
10098                "  A,\n"
10099                "};",
10100                Style);
10101   verifyFormat("typedef union Foo\n"
10102                "{\n"
10103                "  A,\n"
10104                "} Foo_t;",
10105                Style);
10106   verifyFormat("namespace Foo\n"
10107                "{\n"
10108                "void Bar();\n"
10109                "};",
10110                Style);
10111 }
10112 
10113 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
10114   // Elaborate type variable declarations.
10115   verifyFormat("struct foo a = {bar};\nint n;");
10116   verifyFormat("class foo a = {bar};\nint n;");
10117   verifyFormat("union foo a = {bar};\nint n;");
10118 
10119   // Elaborate types inside function definitions.
10120   verifyFormat("struct foo f() {}\nint n;");
10121   verifyFormat("class foo f() {}\nint n;");
10122   verifyFormat("union foo f() {}\nint n;");
10123 
10124   // Templates.
10125   verifyFormat("template <class X> void f() {}\nint n;");
10126   verifyFormat("template <struct X> void f() {}\nint n;");
10127   verifyFormat("template <union X> void f() {}\nint n;");
10128 
10129   // Actual definitions...
10130   verifyFormat("struct {\n} n;");
10131   verifyFormat(
10132       "template <template <class T, class Y>, class Z> class X {\n} n;");
10133   verifyFormat("union Z {\n  int n;\n} x;");
10134   verifyFormat("class MACRO Z {\n} n;");
10135   verifyFormat("class MACRO(X) Z {\n} n;");
10136   verifyFormat("class __attribute__(X) Z {\n} n;");
10137   verifyFormat("class __declspec(X) Z {\n} n;");
10138   verifyFormat("class A##B##C {\n} n;");
10139   verifyFormat("class alignas(16) Z {\n} n;");
10140   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
10141   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
10142 
10143   // Redefinition from nested context:
10144   verifyFormat("class A::B::C {\n} n;");
10145 
10146   // Template definitions.
10147   verifyFormat(
10148       "template <typename F>\n"
10149       "Matcher(const Matcher<F> &Other,\n"
10150       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
10151       "                             !is_same<F, T>::value>::type * = 0)\n"
10152       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
10153 
10154   // FIXME: This is still incorrectly handled at the formatter side.
10155   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
10156   verifyFormat("int i = SomeFunction(a<b, a> b);");
10157 
10158   // FIXME:
10159   // This now gets parsed incorrectly as class definition.
10160   // verifyFormat("class A<int> f() {\n}\nint n;");
10161 
10162   // Elaborate types where incorrectly parsing the structural element would
10163   // break the indent.
10164   verifyFormat("if (true)\n"
10165                "  class X x;\n"
10166                "else\n"
10167                "  f();\n");
10168 
10169   // This is simply incomplete. Formatting is not important, but must not crash.
10170   verifyFormat("class A:");
10171 }
10172 
10173 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
10174   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
10175             format("#error Leave     all         white!!!!! space* alone!\n"));
10176   EXPECT_EQ(
10177       "#warning Leave     all         white!!!!! space* alone!\n",
10178       format("#warning Leave     all         white!!!!! space* alone!\n"));
10179   EXPECT_EQ("#error 1", format("  #  error   1"));
10180   EXPECT_EQ("#warning 1", format("  #  warning 1"));
10181 }
10182 
10183 TEST_F(FormatTest, FormatHashIfExpressions) {
10184   verifyFormat("#if AAAA && BBBB");
10185   verifyFormat("#if (AAAA && BBBB)");
10186   verifyFormat("#elif (AAAA && BBBB)");
10187   // FIXME: Come up with a better indentation for #elif.
10188   verifyFormat(
10189       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
10190       "    defined(BBBBBBBB)\n"
10191       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
10192       "    defined(BBBBBBBB)\n"
10193       "#endif",
10194       getLLVMStyleWithColumns(65));
10195 }
10196 
10197 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
10198   FormatStyle AllowsMergedIf = getGoogleStyle();
10199   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
10200       FormatStyle::SIS_WithoutElse;
10201   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
10202   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
10203   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
10204   EXPECT_EQ("if (true) return 42;",
10205             format("if (true)\nreturn 42;", AllowsMergedIf));
10206   FormatStyle ShortMergedIf = AllowsMergedIf;
10207   ShortMergedIf.ColumnLimit = 25;
10208   verifyFormat("#define A \\\n"
10209                "  if (true) return 42;",
10210                ShortMergedIf);
10211   verifyFormat("#define A \\\n"
10212                "  f();    \\\n"
10213                "  if (true)\n"
10214                "#define B",
10215                ShortMergedIf);
10216   verifyFormat("#define A \\\n"
10217                "  f();    \\\n"
10218                "  if (true)\n"
10219                "g();",
10220                ShortMergedIf);
10221   verifyFormat("{\n"
10222                "#ifdef A\n"
10223                "  // Comment\n"
10224                "  if (true) continue;\n"
10225                "#endif\n"
10226                "  // Comment\n"
10227                "  if (true) continue;\n"
10228                "}",
10229                ShortMergedIf);
10230   ShortMergedIf.ColumnLimit = 33;
10231   verifyFormat("#define A \\\n"
10232                "  if constexpr (true) return 42;",
10233                ShortMergedIf);
10234   verifyFormat("#define A \\\n"
10235                "  if CONSTEXPR (true) return 42;",
10236                ShortMergedIf);
10237   ShortMergedIf.ColumnLimit = 29;
10238   verifyFormat("#define A                   \\\n"
10239                "  if (aaaaaaaaaa) return 1; \\\n"
10240                "  return 2;",
10241                ShortMergedIf);
10242   ShortMergedIf.ColumnLimit = 28;
10243   verifyFormat("#define A         \\\n"
10244                "  if (aaaaaaaaaa) \\\n"
10245                "    return 1;     \\\n"
10246                "  return 2;",
10247                ShortMergedIf);
10248   verifyFormat("#define A                \\\n"
10249                "  if constexpr (aaaaaaa) \\\n"
10250                "    return 1;            \\\n"
10251                "  return 2;",
10252                ShortMergedIf);
10253   verifyFormat("#define A                \\\n"
10254                "  if CONSTEXPR (aaaaaaa) \\\n"
10255                "    return 1;            \\\n"
10256                "  return 2;",
10257                ShortMergedIf);
10258 }
10259 
10260 TEST_F(FormatTest, FormatStarDependingOnContext) {
10261   verifyFormat("void f(int *a);");
10262   verifyFormat("void f() { f(fint * b); }");
10263   verifyFormat("class A {\n  void f(int *a);\n};");
10264   verifyFormat("class A {\n  int *a;\n};");
10265   verifyFormat("namespace a {\n"
10266                "namespace b {\n"
10267                "class A {\n"
10268                "  void f() {}\n"
10269                "  int *a;\n"
10270                "};\n"
10271                "} // namespace b\n"
10272                "} // namespace a");
10273 }
10274 
10275 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
10276   verifyFormat("while");
10277   verifyFormat("operator");
10278 }
10279 
10280 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
10281   // This code would be painfully slow to format if we didn't skip it.
10282   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
10283                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10284                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10285                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10286                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
10287                    "A(1, 1)\n"
10288                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
10289                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10290                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10291                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10292                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10293                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10294                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10295                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10296                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
10297                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
10298   // Deeply nested part is untouched, rest is formatted.
10299   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
10300             format(std::string("int    i;\n") + Code + "int    j;\n",
10301                    getLLVMStyle(), SC_ExpectIncomplete));
10302 }
10303 
10304 //===----------------------------------------------------------------------===//
10305 // Objective-C tests.
10306 //===----------------------------------------------------------------------===//
10307 
10308 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
10309   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
10310   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
10311             format("-(NSUInteger)indexOfObject:(id)anObject;"));
10312   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
10313   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
10314   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
10315             format("-(NSInteger)Method3:(id)anObject;"));
10316   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
10317             format("-(NSInteger)Method4:(id)anObject;"));
10318   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
10319             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
10320   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
10321             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
10322   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10323             "forAllCells:(BOOL)flag;",
10324             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
10325                    "forAllCells:(BOOL)flag;"));
10326 
10327   // Very long objectiveC method declaration.
10328   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
10329                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
10330   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
10331                "                    inRange:(NSRange)range\n"
10332                "                   outRange:(NSRange)out_range\n"
10333                "                  outRange1:(NSRange)out_range1\n"
10334                "                  outRange2:(NSRange)out_range2\n"
10335                "                  outRange3:(NSRange)out_range3\n"
10336                "                  outRange4:(NSRange)out_range4\n"
10337                "                  outRange5:(NSRange)out_range5\n"
10338                "                  outRange6:(NSRange)out_range6\n"
10339                "                  outRange7:(NSRange)out_range7\n"
10340                "                  outRange8:(NSRange)out_range8\n"
10341                "                  outRange9:(NSRange)out_range9;");
10342 
10343   // When the function name has to be wrapped.
10344   FormatStyle Style = getLLVMStyle();
10345   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
10346   // and always indents instead.
10347   Style.IndentWrappedFunctionNames = false;
10348   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10349                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
10350                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
10351                "}",
10352                Style);
10353   Style.IndentWrappedFunctionNames = true;
10354   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
10355                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
10356                "               anotherName:(NSString)dddddddddddddd {\n"
10357                "}",
10358                Style);
10359 
10360   verifyFormat("- (int)sum:(vector<int>)numbers;");
10361   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
10362   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
10363   // protocol lists (but not for template classes):
10364   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
10365 
10366   verifyFormat("- (int (*)())foo:(int (*)())f;");
10367   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
10368 
10369   // If there's no return type (very rare in practice!), LLVM and Google style
10370   // agree.
10371   verifyFormat("- foo;");
10372   verifyFormat("- foo:(int)f;");
10373   verifyGoogleFormat("- foo:(int)foo;");
10374 }
10375 
10376 TEST_F(FormatTest, BreaksStringLiterals) {
10377   EXPECT_EQ("\"some text \"\n"
10378             "\"other\";",
10379             format("\"some text other\";", getLLVMStyleWithColumns(12)));
10380   EXPECT_EQ("\"some text \"\n"
10381             "\"other\";",
10382             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
10383   EXPECT_EQ(
10384       "#define A  \\\n"
10385       "  \"some \"  \\\n"
10386       "  \"text \"  \\\n"
10387       "  \"other\";",
10388       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
10389   EXPECT_EQ(
10390       "#define A  \\\n"
10391       "  \"so \"    \\\n"
10392       "  \"text \"  \\\n"
10393       "  \"other\";",
10394       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
10395 
10396   EXPECT_EQ("\"some text\"",
10397             format("\"some text\"", getLLVMStyleWithColumns(1)));
10398   EXPECT_EQ("\"some text\"",
10399             format("\"some text\"", getLLVMStyleWithColumns(11)));
10400   EXPECT_EQ("\"some \"\n"
10401             "\"text\"",
10402             format("\"some text\"", getLLVMStyleWithColumns(10)));
10403   EXPECT_EQ("\"some \"\n"
10404             "\"text\"",
10405             format("\"some text\"", getLLVMStyleWithColumns(7)));
10406   EXPECT_EQ("\"some\"\n"
10407             "\" tex\"\n"
10408             "\"t\"",
10409             format("\"some text\"", getLLVMStyleWithColumns(6)));
10410   EXPECT_EQ("\"some\"\n"
10411             "\" tex\"\n"
10412             "\" and\"",
10413             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
10414   EXPECT_EQ("\"some\"\n"
10415             "\"/tex\"\n"
10416             "\"/and\"",
10417             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
10418 
10419   EXPECT_EQ("variable =\n"
10420             "    \"long string \"\n"
10421             "    \"literal\";",
10422             format("variable = \"long string literal\";",
10423                    getLLVMStyleWithColumns(20)));
10424 
10425   EXPECT_EQ("variable = f(\n"
10426             "    \"long string \"\n"
10427             "    \"literal\",\n"
10428             "    short,\n"
10429             "    loooooooooooooooooooong);",
10430             format("variable = f(\"long string literal\", short, "
10431                    "loooooooooooooooooooong);",
10432                    getLLVMStyleWithColumns(20)));
10433 
10434   EXPECT_EQ(
10435       "f(g(\"long string \"\n"
10436       "    \"literal\"),\n"
10437       "  b);",
10438       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
10439   EXPECT_EQ("f(g(\"long string \"\n"
10440             "    \"literal\",\n"
10441             "    a),\n"
10442             "  b);",
10443             format("f(g(\"long string literal\", a), b);",
10444                    getLLVMStyleWithColumns(20)));
10445   EXPECT_EQ(
10446       "f(\"one two\".split(\n"
10447       "    variable));",
10448       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
10449   EXPECT_EQ("f(\"one two three four five six \"\n"
10450             "  \"seven\".split(\n"
10451             "      really_looooong_variable));",
10452             format("f(\"one two three four five six seven\"."
10453                    "split(really_looooong_variable));",
10454                    getLLVMStyleWithColumns(33)));
10455 
10456   EXPECT_EQ("f(\"some \"\n"
10457             "  \"text\",\n"
10458             "  other);",
10459             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
10460 
10461   // Only break as a last resort.
10462   verifyFormat(
10463       "aaaaaaaaaaaaaaaaaaaa(\n"
10464       "    aaaaaaaaaaaaaaaaaaaa,\n"
10465       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
10466 
10467   EXPECT_EQ("\"splitmea\"\n"
10468             "\"trandomp\"\n"
10469             "\"oint\"",
10470             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
10471 
10472   EXPECT_EQ("\"split/\"\n"
10473             "\"pathat/\"\n"
10474             "\"slashes\"",
10475             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10476 
10477   EXPECT_EQ("\"split/\"\n"
10478             "\"pathat/\"\n"
10479             "\"slashes\"",
10480             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
10481   EXPECT_EQ("\"split at \"\n"
10482             "\"spaces/at/\"\n"
10483             "\"slashes.at.any$\"\n"
10484             "\"non-alphanumeric%\"\n"
10485             "\"1111111111characte\"\n"
10486             "\"rs\"",
10487             format("\"split at "
10488                    "spaces/at/"
10489                    "slashes.at."
10490                    "any$non-"
10491                    "alphanumeric%"
10492                    "1111111111characte"
10493                    "rs\"",
10494                    getLLVMStyleWithColumns(20)));
10495 
10496   // Verify that splitting the strings understands
10497   // Style::AlwaysBreakBeforeMultilineStrings.
10498   EXPECT_EQ("aaaaaaaaaaaa(\n"
10499             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
10500             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
10501             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
10502                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10503                    "aaaaaaaaaaaaaaaaaaaaaa\");",
10504                    getGoogleStyle()));
10505   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10506             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
10507             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
10508                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
10509                    "aaaaaaaaaaaaaaaaaaaaaa\";",
10510                    getGoogleStyle()));
10511   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10512             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10513             format("llvm::outs() << "
10514                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
10515                    "aaaaaaaaaaaaaaaaaaa\";"));
10516   EXPECT_EQ("ffff(\n"
10517             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
10518             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10519             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
10520                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
10521                    getGoogleStyle()));
10522 
10523   FormatStyle Style = getLLVMStyleWithColumns(12);
10524   Style.BreakStringLiterals = false;
10525   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
10526 
10527   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
10528   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10529   EXPECT_EQ("#define A \\\n"
10530             "  \"some \" \\\n"
10531             "  \"text \" \\\n"
10532             "  \"other\";",
10533             format("#define A \"some text other\";", AlignLeft));
10534 }
10535 
10536 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
10537   EXPECT_EQ("C a = \"some more \"\n"
10538             "      \"text\";",
10539             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
10540 }
10541 
10542 TEST_F(FormatTest, FullyRemoveEmptyLines) {
10543   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
10544   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10545   EXPECT_EQ("int i = a(b());",
10546             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
10547 }
10548 
10549 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
10550   EXPECT_EQ(
10551       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10552       "(\n"
10553       "    \"x\t\");",
10554       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
10555              "aaaaaaa("
10556              "\"x\t\");"));
10557 }
10558 
10559 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
10560   EXPECT_EQ(
10561       "u8\"utf8 string \"\n"
10562       "u8\"literal\";",
10563       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
10564   EXPECT_EQ(
10565       "u\"utf16 string \"\n"
10566       "u\"literal\";",
10567       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
10568   EXPECT_EQ(
10569       "U\"utf32 string \"\n"
10570       "U\"literal\";",
10571       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
10572   EXPECT_EQ("L\"wide string \"\n"
10573             "L\"literal\";",
10574             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
10575   EXPECT_EQ("@\"NSString \"\n"
10576             "@\"literal\";",
10577             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
10578   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
10579 
10580   // This input makes clang-format try to split the incomplete unicode escape
10581   // sequence, which used to lead to a crasher.
10582   verifyNoCrash(
10583       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
10584       getLLVMStyleWithColumns(60));
10585 }
10586 
10587 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
10588   FormatStyle Style = getGoogleStyleWithColumns(15);
10589   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
10590   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
10591   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
10592   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
10593   EXPECT_EQ("u8R\"x(raw literal)x\";",
10594             format("u8R\"x(raw literal)x\";", Style));
10595 }
10596 
10597 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
10598   FormatStyle Style = getLLVMStyleWithColumns(20);
10599   EXPECT_EQ(
10600       "_T(\"aaaaaaaaaaaaaa\")\n"
10601       "_T(\"aaaaaaaaaaaaaa\")\n"
10602       "_T(\"aaaaaaaaaaaa\")",
10603       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
10604   EXPECT_EQ("f(x,\n"
10605             "  _T(\"aaaaaaaaaaaa\")\n"
10606             "  _T(\"aaa\"),\n"
10607             "  z);",
10608             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
10609 
10610   // FIXME: Handle embedded spaces in one iteration.
10611   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
10612   //            "_T(\"aaaaaaaaaaaaa\")\n"
10613   //            "_T(\"aaaaaaaaaaaaa\")\n"
10614   //            "_T(\"a\")",
10615   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10616   //                   getLLVMStyleWithColumns(20)));
10617   EXPECT_EQ(
10618       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
10619       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
10620   EXPECT_EQ("f(\n"
10621             "#if !TEST\n"
10622             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10623             "#endif\n"
10624             ");",
10625             format("f(\n"
10626                    "#if !TEST\n"
10627                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
10628                    "#endif\n"
10629                    ");"));
10630   EXPECT_EQ("f(\n"
10631             "\n"
10632             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
10633             format("f(\n"
10634                    "\n"
10635                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
10636 }
10637 
10638 TEST_F(FormatTest, BreaksStringLiteralOperands) {
10639   // In a function call with two operands, the second can be broken with no line
10640   // break before it.
10641   EXPECT_EQ(
10642       "func(a, \"long long \"\n"
10643       "        \"long long\");",
10644       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
10645   // In a function call with three operands, the second must be broken with a
10646   // line break before it.
10647   EXPECT_EQ("func(a,\n"
10648             "     \"long long long \"\n"
10649             "     \"long\",\n"
10650             "     c);",
10651             format("func(a, \"long long long long\", c);",
10652                    getLLVMStyleWithColumns(24)));
10653   // In a function call with three operands, the third must be broken with a
10654   // line break before it.
10655   EXPECT_EQ("func(a, b,\n"
10656             "     \"long long long \"\n"
10657             "     \"long\");",
10658             format("func(a, b, \"long long long long\");",
10659                    getLLVMStyleWithColumns(24)));
10660   // In a function call with three operands, both the second and the third must
10661   // be broken with a line break before them.
10662   EXPECT_EQ("func(a,\n"
10663             "     \"long long long \"\n"
10664             "     \"long\",\n"
10665             "     \"long long long \"\n"
10666             "     \"long\");",
10667             format("func(a, \"long long long long\", \"long long long long\");",
10668                    getLLVMStyleWithColumns(24)));
10669   // In a chain of << with two operands, the second can be broken with no line
10670   // break before it.
10671   EXPECT_EQ("a << \"line line \"\n"
10672             "     \"line\";",
10673             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
10674   // In a chain of << with three operands, the second can be broken with no line
10675   // break before it.
10676   EXPECT_EQ(
10677       "abcde << \"line \"\n"
10678       "         \"line line\"\n"
10679       "      << c;",
10680       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
10681   // In a chain of << with three operands, the third must be broken with a line
10682   // break before it.
10683   EXPECT_EQ(
10684       "a << b\n"
10685       "  << \"line line \"\n"
10686       "     \"line\";",
10687       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
10688   // In a chain of << with three operands, the second can be broken with no line
10689   // break before it and the third must be broken with a line break before it.
10690   EXPECT_EQ("abcd << \"line line \"\n"
10691             "        \"line\"\n"
10692             "     << \"line line \"\n"
10693             "        \"line\";",
10694             format("abcd << \"line line line\" << \"line line line\";",
10695                    getLLVMStyleWithColumns(20)));
10696   // In a chain of binary operators with two operands, the second can be broken
10697   // with no line break before it.
10698   EXPECT_EQ(
10699       "abcd + \"line line \"\n"
10700       "       \"line line\";",
10701       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
10702   // In a chain of binary operators with three operands, the second must be
10703   // broken with a line break before it.
10704   EXPECT_EQ("abcd +\n"
10705             "    \"line line \"\n"
10706             "    \"line line\" +\n"
10707             "    e;",
10708             format("abcd + \"line line line line\" + e;",
10709                    getLLVMStyleWithColumns(20)));
10710   // In a function call with two operands, with AlignAfterOpenBracket enabled,
10711   // the first must be broken with a line break before it.
10712   FormatStyle Style = getLLVMStyleWithColumns(25);
10713   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
10714   EXPECT_EQ("someFunction(\n"
10715             "    \"long long long \"\n"
10716             "    \"long\",\n"
10717             "    a);",
10718             format("someFunction(\"long long long long\", a);", Style));
10719 }
10720 
10721 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
10722   EXPECT_EQ(
10723       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10724       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10725       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
10726       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10727              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
10728              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
10729 }
10730 
10731 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
10732   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
10733             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
10734   EXPECT_EQ("fffffffffff(g(R\"x(\n"
10735             "multiline raw string literal xxxxxxxxxxxxxx\n"
10736             ")x\",\n"
10737             "              a),\n"
10738             "            b);",
10739             format("fffffffffff(g(R\"x(\n"
10740                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10741                    ")x\", a), b);",
10742                    getGoogleStyleWithColumns(20)));
10743   EXPECT_EQ("fffffffffff(\n"
10744             "    g(R\"x(qqq\n"
10745             "multiline raw string literal xxxxxxxxxxxxxx\n"
10746             ")x\",\n"
10747             "      a),\n"
10748             "    b);",
10749             format("fffffffffff(g(R\"x(qqq\n"
10750                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10751                    ")x\", a), b);",
10752                    getGoogleStyleWithColumns(20)));
10753 
10754   EXPECT_EQ("fffffffffff(R\"x(\n"
10755             "multiline raw string literal xxxxxxxxxxxxxx\n"
10756             ")x\");",
10757             format("fffffffffff(R\"x(\n"
10758                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10759                    ")x\");",
10760                    getGoogleStyleWithColumns(20)));
10761   EXPECT_EQ("fffffffffff(R\"x(\n"
10762             "multiline raw string literal xxxxxxxxxxxxxx\n"
10763             ")x\" + bbbbbb);",
10764             format("fffffffffff(R\"x(\n"
10765                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10766                    ")x\" +   bbbbbb);",
10767                    getGoogleStyleWithColumns(20)));
10768   EXPECT_EQ("fffffffffff(\n"
10769             "    R\"x(\n"
10770             "multiline raw string literal xxxxxxxxxxxxxx\n"
10771             ")x\" +\n"
10772             "    bbbbbb);",
10773             format("fffffffffff(\n"
10774                    " R\"x(\n"
10775                    "multiline raw string literal xxxxxxxxxxxxxx\n"
10776                    ")x\" + bbbbbb);",
10777                    getGoogleStyleWithColumns(20)));
10778   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
10779             format("fffffffffff(\n"
10780                    " R\"(single line raw string)\" + bbbbbb);"));
10781 }
10782 
10783 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
10784   verifyFormat("string a = \"unterminated;");
10785   EXPECT_EQ("function(\"unterminated,\n"
10786             "         OtherParameter);",
10787             format("function(  \"unterminated,\n"
10788                    "    OtherParameter);"));
10789 }
10790 
10791 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
10792   FormatStyle Style = getLLVMStyle();
10793   Style.Standard = FormatStyle::LS_Cpp03;
10794   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
10795             format("#define x(_a) printf(\"foo\"_a);", Style));
10796 }
10797 
10798 TEST_F(FormatTest, CppLexVersion) {
10799   FormatStyle Style = getLLVMStyle();
10800   // Formatting of x * y differs if x is a type.
10801   verifyFormat("void foo() { MACRO(a * b); }", Style);
10802   verifyFormat("void foo() { MACRO(int *b); }", Style);
10803 
10804   // LLVM style uses latest lexer.
10805   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
10806   Style.Standard = FormatStyle::LS_Cpp17;
10807   // But in c++17, char8_t isn't a keyword.
10808   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
10809 }
10810 
10811 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
10812 
10813 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
10814   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
10815             "             \"ddeeefff\");",
10816             format("someFunction(\"aaabbbcccdddeeefff\");",
10817                    getLLVMStyleWithColumns(25)));
10818   EXPECT_EQ("someFunction1234567890(\n"
10819             "    \"aaabbbcccdddeeefff\");",
10820             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10821                    getLLVMStyleWithColumns(26)));
10822   EXPECT_EQ("someFunction1234567890(\n"
10823             "    \"aaabbbcccdddeeeff\"\n"
10824             "    \"f\");",
10825             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10826                    getLLVMStyleWithColumns(25)));
10827   EXPECT_EQ("someFunction1234567890(\n"
10828             "    \"aaabbbcccdddeeeff\"\n"
10829             "    \"f\");",
10830             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
10831                    getLLVMStyleWithColumns(24)));
10832   EXPECT_EQ("someFunction(\n"
10833             "    \"aaabbbcc ddde \"\n"
10834             "    \"efff\");",
10835             format("someFunction(\"aaabbbcc ddde efff\");",
10836                    getLLVMStyleWithColumns(25)));
10837   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
10838             "             \"ddeeefff\");",
10839             format("someFunction(\"aaabbbccc ddeeefff\");",
10840                    getLLVMStyleWithColumns(25)));
10841   EXPECT_EQ("someFunction1234567890(\n"
10842             "    \"aaabb \"\n"
10843             "    \"cccdddeeefff\");",
10844             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
10845                    getLLVMStyleWithColumns(25)));
10846   EXPECT_EQ("#define A          \\\n"
10847             "  string s =       \\\n"
10848             "      \"123456789\"  \\\n"
10849             "      \"0\";         \\\n"
10850             "  int i;",
10851             format("#define A string s = \"1234567890\"; int i;",
10852                    getLLVMStyleWithColumns(20)));
10853   EXPECT_EQ("someFunction(\n"
10854             "    \"aaabbbcc \"\n"
10855             "    \"dddeeefff\");",
10856             format("someFunction(\"aaabbbcc dddeeefff\");",
10857                    getLLVMStyleWithColumns(25)));
10858 }
10859 
10860 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
10861   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
10862   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
10863   EXPECT_EQ("\"test\"\n"
10864             "\"\\n\"",
10865             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
10866   EXPECT_EQ("\"tes\\\\\"\n"
10867             "\"n\"",
10868             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
10869   EXPECT_EQ("\"\\\\\\\\\"\n"
10870             "\"\\n\"",
10871             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
10872   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
10873   EXPECT_EQ("\"\\uff01\"\n"
10874             "\"test\"",
10875             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
10876   EXPECT_EQ("\"\\Uff01ff02\"",
10877             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
10878   EXPECT_EQ("\"\\x000000000001\"\n"
10879             "\"next\"",
10880             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
10881   EXPECT_EQ("\"\\x000000000001next\"",
10882             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
10883   EXPECT_EQ("\"\\x000000000001\"",
10884             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
10885   EXPECT_EQ("\"test\"\n"
10886             "\"\\000000\"\n"
10887             "\"000001\"",
10888             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
10889   EXPECT_EQ("\"test\\000\"\n"
10890             "\"00000000\"\n"
10891             "\"1\"",
10892             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
10893 }
10894 
10895 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
10896   verifyFormat("void f() {\n"
10897                "  return g() {}\n"
10898                "  void h() {}");
10899   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
10900                "g();\n"
10901                "}");
10902 }
10903 
10904 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
10905   verifyFormat(
10906       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
10907 }
10908 
10909 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
10910   verifyFormat("class X {\n"
10911                "  void f() {\n"
10912                "  }\n"
10913                "};",
10914                getLLVMStyleWithColumns(12));
10915 }
10916 
10917 TEST_F(FormatTest, ConfigurableIndentWidth) {
10918   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
10919   EightIndent.IndentWidth = 8;
10920   EightIndent.ContinuationIndentWidth = 8;
10921   verifyFormat("void f() {\n"
10922                "        someFunction();\n"
10923                "        if (true) {\n"
10924                "                f();\n"
10925                "        }\n"
10926                "}",
10927                EightIndent);
10928   verifyFormat("class X {\n"
10929                "        void f() {\n"
10930                "        }\n"
10931                "};",
10932                EightIndent);
10933   verifyFormat("int x[] = {\n"
10934                "        call(),\n"
10935                "        call()};",
10936                EightIndent);
10937 }
10938 
10939 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
10940   verifyFormat("double\n"
10941                "f();",
10942                getLLVMStyleWithColumns(8));
10943 }
10944 
10945 TEST_F(FormatTest, ConfigurableUseOfTab) {
10946   FormatStyle Tab = getLLVMStyleWithColumns(42);
10947   Tab.IndentWidth = 8;
10948   Tab.UseTab = FormatStyle::UT_Always;
10949   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
10950 
10951   EXPECT_EQ("if (aaaaaaaa && // q\n"
10952             "    bb)\t\t// w\n"
10953             "\t;",
10954             format("if (aaaaaaaa &&// q\n"
10955                    "bb)// w\n"
10956                    ";",
10957                    Tab));
10958   EXPECT_EQ("if (aaa && bbb) // w\n"
10959             "\t;",
10960             format("if(aaa&&bbb)// w\n"
10961                    ";",
10962                    Tab));
10963 
10964   verifyFormat("class X {\n"
10965                "\tvoid f() {\n"
10966                "\t\tsomeFunction(parameter1,\n"
10967                "\t\t\t     parameter2);\n"
10968                "\t}\n"
10969                "};",
10970                Tab);
10971   verifyFormat("#define A                        \\\n"
10972                "\tvoid f() {               \\\n"
10973                "\t\tsomeFunction(    \\\n"
10974                "\t\t    parameter1,  \\\n"
10975                "\t\t    parameter2); \\\n"
10976                "\t}",
10977                Tab);
10978   verifyFormat("int a;\t      // x\n"
10979                "int bbbbbbbb; // x\n",
10980                Tab);
10981 
10982   Tab.TabWidth = 4;
10983   Tab.IndentWidth = 8;
10984   verifyFormat("class TabWidth4Indent8 {\n"
10985                "\t\tvoid f() {\n"
10986                "\t\t\t\tsomeFunction(parameter1,\n"
10987                "\t\t\t\t\t\t\t parameter2);\n"
10988                "\t\t}\n"
10989                "};",
10990                Tab);
10991 
10992   Tab.TabWidth = 4;
10993   Tab.IndentWidth = 4;
10994   verifyFormat("class TabWidth4Indent4 {\n"
10995                "\tvoid f() {\n"
10996                "\t\tsomeFunction(parameter1,\n"
10997                "\t\t\t\t\t parameter2);\n"
10998                "\t}\n"
10999                "};",
11000                Tab);
11001 
11002   Tab.TabWidth = 8;
11003   Tab.IndentWidth = 4;
11004   verifyFormat("class TabWidth8Indent4 {\n"
11005                "    void f() {\n"
11006                "\tsomeFunction(parameter1,\n"
11007                "\t\t     parameter2);\n"
11008                "    }\n"
11009                "};",
11010                Tab);
11011 
11012   Tab.TabWidth = 8;
11013   Tab.IndentWidth = 8;
11014   EXPECT_EQ("/*\n"
11015             "\t      a\t\tcomment\n"
11016             "\t      in multiple lines\n"
11017             "       */",
11018             format("   /*\t \t \n"
11019                    " \t \t a\t\tcomment\t \t\n"
11020                    " \t \t in multiple lines\t\n"
11021                    " \t  */",
11022                    Tab));
11023 
11024   Tab.UseTab = FormatStyle::UT_ForIndentation;
11025   verifyFormat("{\n"
11026                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11027                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11028                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11029                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11030                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11031                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11032                "};",
11033                Tab);
11034   verifyFormat("enum AA {\n"
11035                "\ta1, // Force multiple lines\n"
11036                "\ta2,\n"
11037                "\ta3\n"
11038                "};",
11039                Tab);
11040   EXPECT_EQ("if (aaaaaaaa && // q\n"
11041             "    bb)         // w\n"
11042             "\t;",
11043             format("if (aaaaaaaa &&// q\n"
11044                    "bb)// w\n"
11045                    ";",
11046                    Tab));
11047   verifyFormat("class X {\n"
11048                "\tvoid f() {\n"
11049                "\t\tsomeFunction(parameter1,\n"
11050                "\t\t             parameter2);\n"
11051                "\t}\n"
11052                "};",
11053                Tab);
11054   verifyFormat("{\n"
11055                "\tQ(\n"
11056                "\t    {\n"
11057                "\t\t    int a;\n"
11058                "\t\t    someFunction(aaaaaaaa,\n"
11059                "\t\t                 bbbbbbb);\n"
11060                "\t    },\n"
11061                "\t    p);\n"
11062                "}",
11063                Tab);
11064   EXPECT_EQ("{\n"
11065             "\t/* aaaa\n"
11066             "\t   bbbb */\n"
11067             "}",
11068             format("{\n"
11069                    "/* aaaa\n"
11070                    "   bbbb */\n"
11071                    "}",
11072                    Tab));
11073   EXPECT_EQ("{\n"
11074             "\t/*\n"
11075             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11076             "\t  bbbbbbbbbbbbb\n"
11077             "\t*/\n"
11078             "}",
11079             format("{\n"
11080                    "/*\n"
11081                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11082                    "*/\n"
11083                    "}",
11084                    Tab));
11085   EXPECT_EQ("{\n"
11086             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11087             "\t// bbbbbbbbbbbbb\n"
11088             "}",
11089             format("{\n"
11090                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11091                    "}",
11092                    Tab));
11093   EXPECT_EQ("{\n"
11094             "\t/*\n"
11095             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11096             "\t  bbbbbbbbbbbbb\n"
11097             "\t*/\n"
11098             "}",
11099             format("{\n"
11100                    "\t/*\n"
11101                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11102                    "\t*/\n"
11103                    "}",
11104                    Tab));
11105   EXPECT_EQ("{\n"
11106             "\t/*\n"
11107             "\n"
11108             "\t*/\n"
11109             "}",
11110             format("{\n"
11111                    "\t/*\n"
11112                    "\n"
11113                    "\t*/\n"
11114                    "}",
11115                    Tab));
11116   EXPECT_EQ("{\n"
11117             "\t/*\n"
11118             " asdf\n"
11119             "\t*/\n"
11120             "}",
11121             format("{\n"
11122                    "\t/*\n"
11123                    " asdf\n"
11124                    "\t*/\n"
11125                    "}",
11126                    Tab));
11127 
11128   Tab.UseTab = FormatStyle::UT_Never;
11129   EXPECT_EQ("/*\n"
11130             "              a\t\tcomment\n"
11131             "              in multiple lines\n"
11132             "       */",
11133             format("   /*\t \t \n"
11134                    " \t \t a\t\tcomment\t \t\n"
11135                    " \t \t in multiple lines\t\n"
11136                    " \t  */",
11137                    Tab));
11138   EXPECT_EQ("/* some\n"
11139             "   comment */",
11140             format(" \t \t /* some\n"
11141                    " \t \t    comment */",
11142                    Tab));
11143   EXPECT_EQ("int a; /* some\n"
11144             "   comment */",
11145             format(" \t \t int a; /* some\n"
11146                    " \t \t    comment */",
11147                    Tab));
11148 
11149   EXPECT_EQ("int a; /* some\n"
11150             "comment */",
11151             format(" \t \t int\ta; /* some\n"
11152                    " \t \t    comment */",
11153                    Tab));
11154   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11155             "    comment */",
11156             format(" \t \t f(\"\t\t\"); /* some\n"
11157                    " \t \t    comment */",
11158                    Tab));
11159   EXPECT_EQ("{\n"
11160             "        /*\n"
11161             "         * Comment\n"
11162             "         */\n"
11163             "        int i;\n"
11164             "}",
11165             format("{\n"
11166                    "\t/*\n"
11167                    "\t * Comment\n"
11168                    "\t */\n"
11169                    "\t int i;\n"
11170                    "}",
11171                    Tab));
11172 
11173   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11174   Tab.TabWidth = 8;
11175   Tab.IndentWidth = 8;
11176   EXPECT_EQ("if (aaaaaaaa && // q\n"
11177             "    bb)         // w\n"
11178             "\t;",
11179             format("if (aaaaaaaa &&// q\n"
11180                    "bb)// w\n"
11181                    ";",
11182                    Tab));
11183   EXPECT_EQ("if (aaa && bbb) // w\n"
11184             "\t;",
11185             format("if(aaa&&bbb)// w\n"
11186                    ";",
11187                    Tab));
11188   verifyFormat("class X {\n"
11189                "\tvoid f() {\n"
11190                "\t\tsomeFunction(parameter1,\n"
11191                "\t\t\t     parameter2);\n"
11192                "\t}\n"
11193                "};",
11194                Tab);
11195   verifyFormat("#define A                        \\\n"
11196                "\tvoid f() {               \\\n"
11197                "\t\tsomeFunction(    \\\n"
11198                "\t\t    parameter1,  \\\n"
11199                "\t\t    parameter2); \\\n"
11200                "\t}",
11201                Tab);
11202   Tab.TabWidth = 4;
11203   Tab.IndentWidth = 8;
11204   verifyFormat("class TabWidth4Indent8 {\n"
11205                "\t\tvoid f() {\n"
11206                "\t\t\t\tsomeFunction(parameter1,\n"
11207                "\t\t\t\t\t\t\t parameter2);\n"
11208                "\t\t}\n"
11209                "};",
11210                Tab);
11211   Tab.TabWidth = 4;
11212   Tab.IndentWidth = 4;
11213   verifyFormat("class TabWidth4Indent4 {\n"
11214                "\tvoid f() {\n"
11215                "\t\tsomeFunction(parameter1,\n"
11216                "\t\t\t\t\t parameter2);\n"
11217                "\t}\n"
11218                "};",
11219                Tab);
11220   Tab.TabWidth = 8;
11221   Tab.IndentWidth = 4;
11222   verifyFormat("class TabWidth8Indent4 {\n"
11223                "    void f() {\n"
11224                "\tsomeFunction(parameter1,\n"
11225                "\t\t     parameter2);\n"
11226                "    }\n"
11227                "};",
11228                Tab);
11229   Tab.TabWidth = 8;
11230   Tab.IndentWidth = 8;
11231   EXPECT_EQ("/*\n"
11232             "\t      a\t\tcomment\n"
11233             "\t      in multiple lines\n"
11234             "       */",
11235             format("   /*\t \t \n"
11236                    " \t \t a\t\tcomment\t \t\n"
11237                    " \t \t in multiple lines\t\n"
11238                    " \t  */",
11239                    Tab));
11240   verifyFormat("{\n"
11241                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11242                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11243                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11244                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11245                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11246                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11247                "};",
11248                Tab);
11249   verifyFormat("enum AA {\n"
11250                "\ta1, // Force multiple lines\n"
11251                "\ta2,\n"
11252                "\ta3\n"
11253                "};",
11254                Tab);
11255   EXPECT_EQ("if (aaaaaaaa && // q\n"
11256             "    bb)         // w\n"
11257             "\t;",
11258             format("if (aaaaaaaa &&// q\n"
11259                    "bb)// w\n"
11260                    ";",
11261                    Tab));
11262   verifyFormat("class X {\n"
11263                "\tvoid f() {\n"
11264                "\t\tsomeFunction(parameter1,\n"
11265                "\t\t\t     parameter2);\n"
11266                "\t}\n"
11267                "};",
11268                Tab);
11269   verifyFormat("{\n"
11270                "\tQ(\n"
11271                "\t    {\n"
11272                "\t\t    int a;\n"
11273                "\t\t    someFunction(aaaaaaaa,\n"
11274                "\t\t\t\t bbbbbbb);\n"
11275                "\t    },\n"
11276                "\t    p);\n"
11277                "}",
11278                Tab);
11279   EXPECT_EQ("{\n"
11280             "\t/* aaaa\n"
11281             "\t   bbbb */\n"
11282             "}",
11283             format("{\n"
11284                    "/* aaaa\n"
11285                    "   bbbb */\n"
11286                    "}",
11287                    Tab));
11288   EXPECT_EQ("{\n"
11289             "\t/*\n"
11290             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11291             "\t  bbbbbbbbbbbbb\n"
11292             "\t*/\n"
11293             "}",
11294             format("{\n"
11295                    "/*\n"
11296                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11297                    "*/\n"
11298                    "}",
11299                    Tab));
11300   EXPECT_EQ("{\n"
11301             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11302             "\t// bbbbbbbbbbbbb\n"
11303             "}",
11304             format("{\n"
11305                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11306                    "}",
11307                    Tab));
11308   EXPECT_EQ("{\n"
11309             "\t/*\n"
11310             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11311             "\t  bbbbbbbbbbbbb\n"
11312             "\t*/\n"
11313             "}",
11314             format("{\n"
11315                    "\t/*\n"
11316                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11317                    "\t*/\n"
11318                    "}",
11319                    Tab));
11320   EXPECT_EQ("{\n"
11321             "\t/*\n"
11322             "\n"
11323             "\t*/\n"
11324             "}",
11325             format("{\n"
11326                    "\t/*\n"
11327                    "\n"
11328                    "\t*/\n"
11329                    "}",
11330                    Tab));
11331   EXPECT_EQ("{\n"
11332             "\t/*\n"
11333             " asdf\n"
11334             "\t*/\n"
11335             "}",
11336             format("{\n"
11337                    "\t/*\n"
11338                    " asdf\n"
11339                    "\t*/\n"
11340                    "}",
11341                    Tab));
11342   EXPECT_EQ("/* some\n"
11343             "   comment */",
11344             format(" \t \t /* some\n"
11345                    " \t \t    comment */",
11346                    Tab));
11347   EXPECT_EQ("int a; /* some\n"
11348             "   comment */",
11349             format(" \t \t int a; /* some\n"
11350                    " \t \t    comment */",
11351                    Tab));
11352   EXPECT_EQ("int a; /* some\n"
11353             "comment */",
11354             format(" \t \t int\ta; /* some\n"
11355                    " \t \t    comment */",
11356                    Tab));
11357   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11358             "    comment */",
11359             format(" \t \t f(\"\t\t\"); /* some\n"
11360                    " \t \t    comment */",
11361                    Tab));
11362   EXPECT_EQ("{\n"
11363             "\t/*\n"
11364             "\t * Comment\n"
11365             "\t */\n"
11366             "\tint i;\n"
11367             "}",
11368             format("{\n"
11369                    "\t/*\n"
11370                    "\t * Comment\n"
11371                    "\t */\n"
11372                    "\t int i;\n"
11373                    "}",
11374                    Tab));
11375   Tab.TabWidth = 2;
11376   Tab.IndentWidth = 2;
11377   EXPECT_EQ("{\n"
11378             "\t/* aaaa\n"
11379             "\t\t bbbb */\n"
11380             "}",
11381             format("{\n"
11382                    "/* aaaa\n"
11383                    "\t bbbb */\n"
11384                    "}",
11385                    Tab));
11386   EXPECT_EQ("{\n"
11387             "\t/*\n"
11388             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11389             "\t\tbbbbbbbbbbbbb\n"
11390             "\t*/\n"
11391             "}",
11392             format("{\n"
11393                    "/*\n"
11394                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11395                    "*/\n"
11396                    "}",
11397                    Tab));
11398   Tab.AlignConsecutiveAssignments = true;
11399   Tab.AlignConsecutiveDeclarations = true;
11400   Tab.TabWidth = 4;
11401   Tab.IndentWidth = 4;
11402   verifyFormat("class Assign {\n"
11403                "\tvoid f() {\n"
11404                "\t\tint         x      = 123;\n"
11405                "\t\tint         random = 4;\n"
11406                "\t\tstd::string alphabet =\n"
11407                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11408                "\t}\n"
11409                "};",
11410                Tab);
11411 
11412   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11413   Tab.TabWidth = 8;
11414   Tab.IndentWidth = 8;
11415   EXPECT_EQ("if (aaaaaaaa && // q\n"
11416             "    bb)         // w\n"
11417             "\t;",
11418             format("if (aaaaaaaa &&// q\n"
11419                    "bb)// w\n"
11420                    ";",
11421                    Tab));
11422   EXPECT_EQ("if (aaa && bbb) // w\n"
11423             "\t;",
11424             format("if(aaa&&bbb)// w\n"
11425                    ";",
11426                    Tab));
11427   verifyFormat("class X {\n"
11428                "\tvoid f() {\n"
11429                "\t\tsomeFunction(parameter1,\n"
11430                "\t\t             parameter2);\n"
11431                "\t}\n"
11432                "};",
11433                Tab);
11434   verifyFormat("#define A                        \\\n"
11435                "\tvoid f() {               \\\n"
11436                "\t\tsomeFunction(    \\\n"
11437                "\t\t    parameter1,  \\\n"
11438                "\t\t    parameter2); \\\n"
11439                "\t}",
11440                Tab);
11441   Tab.TabWidth = 4;
11442   Tab.IndentWidth = 8;
11443   verifyFormat("class TabWidth4Indent8 {\n"
11444                "\t\tvoid f() {\n"
11445                "\t\t\t\tsomeFunction(parameter1,\n"
11446                "\t\t\t\t             parameter2);\n"
11447                "\t\t}\n"
11448                "};",
11449                Tab);
11450   Tab.TabWidth = 4;
11451   Tab.IndentWidth = 4;
11452   verifyFormat("class TabWidth4Indent4 {\n"
11453                "\tvoid f() {\n"
11454                "\t\tsomeFunction(parameter1,\n"
11455                "\t\t             parameter2);\n"
11456                "\t}\n"
11457                "};",
11458                Tab);
11459   Tab.TabWidth = 8;
11460   Tab.IndentWidth = 4;
11461   verifyFormat("class TabWidth8Indent4 {\n"
11462                "    void f() {\n"
11463                "\tsomeFunction(parameter1,\n"
11464                "\t             parameter2);\n"
11465                "    }\n"
11466                "};",
11467                Tab);
11468   Tab.TabWidth = 8;
11469   Tab.IndentWidth = 8;
11470   EXPECT_EQ("/*\n"
11471             "              a\t\tcomment\n"
11472             "              in multiple lines\n"
11473             "       */",
11474             format("   /*\t \t \n"
11475                    " \t \t a\t\tcomment\t \t\n"
11476                    " \t \t in multiple lines\t\n"
11477                    " \t  */",
11478                    Tab));
11479   verifyFormat("{\n"
11480                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11481                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11482                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11483                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11484                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11485                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
11486                "};",
11487                Tab);
11488   verifyFormat("enum AA {\n"
11489                "\ta1, // Force multiple lines\n"
11490                "\ta2,\n"
11491                "\ta3\n"
11492                "};",
11493                Tab);
11494   EXPECT_EQ("if (aaaaaaaa && // q\n"
11495             "    bb)         // w\n"
11496             "\t;",
11497             format("if (aaaaaaaa &&// q\n"
11498                    "bb)// w\n"
11499                    ";",
11500                    Tab));
11501   verifyFormat("class X {\n"
11502                "\tvoid f() {\n"
11503                "\t\tsomeFunction(parameter1,\n"
11504                "\t\t             parameter2);\n"
11505                "\t}\n"
11506                "};",
11507                Tab);
11508   verifyFormat("{\n"
11509                "\tQ(\n"
11510                "\t    {\n"
11511                "\t\t    int a;\n"
11512                "\t\t    someFunction(aaaaaaaa,\n"
11513                "\t\t                 bbbbbbb);\n"
11514                "\t    },\n"
11515                "\t    p);\n"
11516                "}",
11517                Tab);
11518   EXPECT_EQ("{\n"
11519             "\t/* aaaa\n"
11520             "\t   bbbb */\n"
11521             "}",
11522             format("{\n"
11523                    "/* aaaa\n"
11524                    "   bbbb */\n"
11525                    "}",
11526                    Tab));
11527   EXPECT_EQ("{\n"
11528             "\t/*\n"
11529             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11530             "\t  bbbbbbbbbbbbb\n"
11531             "\t*/\n"
11532             "}",
11533             format("{\n"
11534                    "/*\n"
11535                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11536                    "*/\n"
11537                    "}",
11538                    Tab));
11539   EXPECT_EQ("{\n"
11540             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11541             "\t// bbbbbbbbbbbbb\n"
11542             "}",
11543             format("{\n"
11544                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11545                    "}",
11546                    Tab));
11547   EXPECT_EQ("{\n"
11548             "\t/*\n"
11549             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11550             "\t  bbbbbbbbbbbbb\n"
11551             "\t*/\n"
11552             "}",
11553             format("{\n"
11554                    "\t/*\n"
11555                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11556                    "\t*/\n"
11557                    "}",
11558                    Tab));
11559   EXPECT_EQ("{\n"
11560             "\t/*\n"
11561             "\n"
11562             "\t*/\n"
11563             "}",
11564             format("{\n"
11565                    "\t/*\n"
11566                    "\n"
11567                    "\t*/\n"
11568                    "}",
11569                    Tab));
11570   EXPECT_EQ("{\n"
11571             "\t/*\n"
11572             " asdf\n"
11573             "\t*/\n"
11574             "}",
11575             format("{\n"
11576                    "\t/*\n"
11577                    " asdf\n"
11578                    "\t*/\n"
11579                    "}",
11580                    Tab));
11581   EXPECT_EQ("/* some\n"
11582             "   comment */",
11583             format(" \t \t /* some\n"
11584                    " \t \t    comment */",
11585                    Tab));
11586   EXPECT_EQ("int a; /* some\n"
11587             "   comment */",
11588             format(" \t \t int a; /* some\n"
11589                    " \t \t    comment */",
11590                    Tab));
11591   EXPECT_EQ("int a; /* some\n"
11592             "comment */",
11593             format(" \t \t int\ta; /* some\n"
11594                    " \t \t    comment */",
11595                    Tab));
11596   EXPECT_EQ("f(\"\t\t\"); /* some\n"
11597             "    comment */",
11598             format(" \t \t f(\"\t\t\"); /* some\n"
11599                    " \t \t    comment */",
11600                    Tab));
11601   EXPECT_EQ("{\n"
11602             "\t/*\n"
11603             "\t * Comment\n"
11604             "\t */\n"
11605             "\tint i;\n"
11606             "}",
11607             format("{\n"
11608                    "\t/*\n"
11609                    "\t * Comment\n"
11610                    "\t */\n"
11611                    "\t int i;\n"
11612                    "}",
11613                    Tab));
11614   Tab.TabWidth = 2;
11615   Tab.IndentWidth = 2;
11616   EXPECT_EQ("{\n"
11617             "\t/* aaaa\n"
11618             "\t   bbbb */\n"
11619             "}",
11620             format("{\n"
11621                    "/* aaaa\n"
11622                    "   bbbb */\n"
11623                    "}",
11624                    Tab));
11625   EXPECT_EQ("{\n"
11626             "\t/*\n"
11627             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11628             "\t  bbbbbbbbbbbbb\n"
11629             "\t*/\n"
11630             "}",
11631             format("{\n"
11632                    "/*\n"
11633                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
11634                    "*/\n"
11635                    "}",
11636                    Tab));
11637   Tab.AlignConsecutiveAssignments = true;
11638   Tab.AlignConsecutiveDeclarations = true;
11639   Tab.TabWidth = 4;
11640   Tab.IndentWidth = 4;
11641   verifyFormat("class Assign {\n"
11642                "\tvoid f() {\n"
11643                "\t\tint         x      = 123;\n"
11644                "\t\tint         random = 4;\n"
11645                "\t\tstd::string alphabet =\n"
11646                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
11647                "\t}\n"
11648                "};",
11649                Tab);
11650   Tab.AlignOperands = FormatStyle::OAS_Align;
11651   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb +\n"
11652                "                 cccccccccccccccccccc;",
11653                Tab);
11654   // no alignment
11655   verifyFormat("int aaaaaaaaaa =\n"
11656                "\tbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
11657                Tab);
11658   verifyFormat("return aaaaaaaaaaaaaaaa ? 111111111111111\n"
11659                "       : bbbbbbbbbbbbbb ? 222222222222222\n"
11660                "                        : 333333333333333;",
11661                Tab);
11662   Tab.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
11663   Tab.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
11664   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb\n"
11665                "               + cccccccccccccccccccc;",
11666                Tab);
11667 }
11668 
11669 TEST_F(FormatTest, ZeroTabWidth) {
11670   FormatStyle Tab = getLLVMStyleWithColumns(42);
11671   Tab.IndentWidth = 8;
11672   Tab.UseTab = FormatStyle::UT_Never;
11673   Tab.TabWidth = 0;
11674   EXPECT_EQ("void a(){\n"
11675             "    // line starts with '\t'\n"
11676             "};",
11677             format("void a(){\n"
11678                    "\t// line starts with '\t'\n"
11679                    "};",
11680                    Tab));
11681 
11682   EXPECT_EQ("void a(){\n"
11683             "    // line starts with '\t'\n"
11684             "};",
11685             format("void a(){\n"
11686                    "\t\t// line starts with '\t'\n"
11687                    "};",
11688                    Tab));
11689 
11690   Tab.UseTab = FormatStyle::UT_ForIndentation;
11691   EXPECT_EQ("void a(){\n"
11692             "    // line starts with '\t'\n"
11693             "};",
11694             format("void a(){\n"
11695                    "\t// line starts with '\t'\n"
11696                    "};",
11697                    Tab));
11698 
11699   EXPECT_EQ("void a(){\n"
11700             "    // line starts with '\t'\n"
11701             "};",
11702             format("void a(){\n"
11703                    "\t\t// line starts with '\t'\n"
11704                    "};",
11705                    Tab));
11706 
11707   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
11708   EXPECT_EQ("void a(){\n"
11709             "    // line starts with '\t'\n"
11710             "};",
11711             format("void a(){\n"
11712                    "\t// line starts with '\t'\n"
11713                    "};",
11714                    Tab));
11715 
11716   EXPECT_EQ("void a(){\n"
11717             "    // line starts with '\t'\n"
11718             "};",
11719             format("void a(){\n"
11720                    "\t\t// line starts with '\t'\n"
11721                    "};",
11722                    Tab));
11723 
11724   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
11725   EXPECT_EQ("void a(){\n"
11726             "    // line starts with '\t'\n"
11727             "};",
11728             format("void a(){\n"
11729                    "\t// line starts with '\t'\n"
11730                    "};",
11731                    Tab));
11732 
11733   EXPECT_EQ("void a(){\n"
11734             "    // line starts with '\t'\n"
11735             "};",
11736             format("void a(){\n"
11737                    "\t\t// line starts with '\t'\n"
11738                    "};",
11739                    Tab));
11740 
11741   Tab.UseTab = FormatStyle::UT_Always;
11742   EXPECT_EQ("void a(){\n"
11743             "// line starts with '\t'\n"
11744             "};",
11745             format("void a(){\n"
11746                    "\t// line starts with '\t'\n"
11747                    "};",
11748                    Tab));
11749 
11750   EXPECT_EQ("void a(){\n"
11751             "// line starts with '\t'\n"
11752             "};",
11753             format("void a(){\n"
11754                    "\t\t// line starts with '\t'\n"
11755                    "};",
11756                    Tab));
11757 }
11758 
11759 TEST_F(FormatTest, CalculatesOriginalColumn) {
11760   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11761             "q\"; /* some\n"
11762             "       comment */",
11763             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11764                    "q\"; /* some\n"
11765                    "       comment */",
11766                    getLLVMStyle()));
11767   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11768             "/* some\n"
11769             "   comment */",
11770             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
11771                    " /* some\n"
11772                    "    comment */",
11773                    getLLVMStyle()));
11774   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11775             "qqq\n"
11776             "/* some\n"
11777             "   comment */",
11778             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11779                    "qqq\n"
11780                    " /* some\n"
11781                    "    comment */",
11782                    getLLVMStyle()));
11783   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11784             "wwww; /* some\n"
11785             "         comment */",
11786             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
11787                    "wwww; /* some\n"
11788                    "         comment */",
11789                    getLLVMStyle()));
11790 }
11791 
11792 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
11793   FormatStyle NoSpace = getLLVMStyle();
11794   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
11795 
11796   verifyFormat("while(true)\n"
11797                "  continue;",
11798                NoSpace);
11799   verifyFormat("for(;;)\n"
11800                "  continue;",
11801                NoSpace);
11802   verifyFormat("if(true)\n"
11803                "  f();\n"
11804                "else if(true)\n"
11805                "  f();",
11806                NoSpace);
11807   verifyFormat("do {\n"
11808                "  do_something();\n"
11809                "} while(something());",
11810                NoSpace);
11811   verifyFormat("switch(x) {\n"
11812                "default:\n"
11813                "  break;\n"
11814                "}",
11815                NoSpace);
11816   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
11817   verifyFormat("size_t x = sizeof(x);", NoSpace);
11818   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
11819   verifyFormat("auto f(int x) -> typeof(x);", NoSpace);
11820   verifyFormat("auto f(int x) -> _Atomic(x);", NoSpace);
11821   verifyFormat("auto f(int x) -> __underlying_type(x);", NoSpace);
11822   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
11823   verifyFormat("alignas(128) char a[128];", NoSpace);
11824   verifyFormat("size_t x = alignof(MyType);", NoSpace);
11825   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
11826   verifyFormat("int f() throw(Deprecated);", NoSpace);
11827   verifyFormat("typedef void (*cb)(int);", NoSpace);
11828   verifyFormat("T A::operator()();", NoSpace);
11829   verifyFormat("X A::operator++(T);", NoSpace);
11830   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
11831 
11832   FormatStyle Space = getLLVMStyle();
11833   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
11834 
11835   verifyFormat("int f ();", Space);
11836   verifyFormat("void f (int a, T b) {\n"
11837                "  while (true)\n"
11838                "    continue;\n"
11839                "}",
11840                Space);
11841   verifyFormat("if (true)\n"
11842                "  f ();\n"
11843                "else if (true)\n"
11844                "  f ();",
11845                Space);
11846   verifyFormat("do {\n"
11847                "  do_something ();\n"
11848                "} while (something ());",
11849                Space);
11850   verifyFormat("switch (x) {\n"
11851                "default:\n"
11852                "  break;\n"
11853                "}",
11854                Space);
11855   verifyFormat("A::A () : a (1) {}", Space);
11856   verifyFormat("void f () __attribute__ ((asdf));", Space);
11857   verifyFormat("*(&a + 1);\n"
11858                "&((&a)[1]);\n"
11859                "a[(b + c) * d];\n"
11860                "(((a + 1) * 2) + 3) * 4;",
11861                Space);
11862   verifyFormat("#define A(x) x", Space);
11863   verifyFormat("#define A (x) x", Space);
11864   verifyFormat("#if defined(x)\n"
11865                "#endif",
11866                Space);
11867   verifyFormat("auto i = std::make_unique<int> (5);", Space);
11868   verifyFormat("size_t x = sizeof (x);", Space);
11869   verifyFormat("auto f (int x) -> decltype (x);", Space);
11870   verifyFormat("auto f (int x) -> typeof (x);", Space);
11871   verifyFormat("auto f (int x) -> _Atomic (x);", Space);
11872   verifyFormat("auto f (int x) -> __underlying_type (x);", Space);
11873   verifyFormat("int f (T x) noexcept (x.create ());", Space);
11874   verifyFormat("alignas (128) char a[128];", Space);
11875   verifyFormat("size_t x = alignof (MyType);", Space);
11876   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
11877   verifyFormat("int f () throw (Deprecated);", Space);
11878   verifyFormat("typedef void (*cb) (int);", Space);
11879   verifyFormat("T A::operator() ();", Space);
11880   verifyFormat("X A::operator++ (T);", Space);
11881   verifyFormat("auto lambda = [] () { return 0; };", Space);
11882   verifyFormat("int x = int (y);", Space);
11883 
11884   FormatStyle SomeSpace = getLLVMStyle();
11885   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
11886 
11887   verifyFormat("[]() -> float {}", SomeSpace);
11888   verifyFormat("[] (auto foo) {}", SomeSpace);
11889   verifyFormat("[foo]() -> int {}", SomeSpace);
11890   verifyFormat("int f();", SomeSpace);
11891   verifyFormat("void f (int a, T b) {\n"
11892                "  while (true)\n"
11893                "    continue;\n"
11894                "}",
11895                SomeSpace);
11896   verifyFormat("if (true)\n"
11897                "  f();\n"
11898                "else if (true)\n"
11899                "  f();",
11900                SomeSpace);
11901   verifyFormat("do {\n"
11902                "  do_something();\n"
11903                "} while (something());",
11904                SomeSpace);
11905   verifyFormat("switch (x) {\n"
11906                "default:\n"
11907                "  break;\n"
11908                "}",
11909                SomeSpace);
11910   verifyFormat("A::A() : a (1) {}", SomeSpace);
11911   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
11912   verifyFormat("*(&a + 1);\n"
11913                "&((&a)[1]);\n"
11914                "a[(b + c) * d];\n"
11915                "(((a + 1) * 2) + 3) * 4;",
11916                SomeSpace);
11917   verifyFormat("#define A(x) x", SomeSpace);
11918   verifyFormat("#define A (x) x", SomeSpace);
11919   verifyFormat("#if defined(x)\n"
11920                "#endif",
11921                SomeSpace);
11922   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
11923   verifyFormat("size_t x = sizeof (x);", SomeSpace);
11924   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
11925   verifyFormat("auto f (int x) -> typeof (x);", SomeSpace);
11926   verifyFormat("auto f (int x) -> _Atomic (x);", SomeSpace);
11927   verifyFormat("auto f (int x) -> __underlying_type (x);", SomeSpace);
11928   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
11929   verifyFormat("alignas (128) char a[128];", SomeSpace);
11930   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
11931   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
11932                SomeSpace);
11933   verifyFormat("int f() throw (Deprecated);", SomeSpace);
11934   verifyFormat("typedef void (*cb) (int);", SomeSpace);
11935   verifyFormat("T A::operator()();", SomeSpace);
11936   verifyFormat("X A::operator++ (T);", SomeSpace);
11937   verifyFormat("int x = int (y);", SomeSpace);
11938   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
11939 }
11940 
11941 TEST_F(FormatTest, SpaceAfterLogicalNot) {
11942   FormatStyle Spaces = getLLVMStyle();
11943   Spaces.SpaceAfterLogicalNot = true;
11944 
11945   verifyFormat("bool x = ! y", Spaces);
11946   verifyFormat("if (! isFailure())", Spaces);
11947   verifyFormat("if (! (a && b))", Spaces);
11948   verifyFormat("\"Error!\"", Spaces);
11949   verifyFormat("! ! x", Spaces);
11950 }
11951 
11952 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
11953   FormatStyle Spaces = getLLVMStyle();
11954 
11955   Spaces.SpacesInParentheses = true;
11956   verifyFormat("do_something( ::globalVar );", Spaces);
11957   verifyFormat("call( x, y, z );", Spaces);
11958   verifyFormat("call();", Spaces);
11959   verifyFormat("std::function<void( int, int )> callback;", Spaces);
11960   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
11961                Spaces);
11962   verifyFormat("while ( (bool)1 )\n"
11963                "  continue;",
11964                Spaces);
11965   verifyFormat("for ( ;; )\n"
11966                "  continue;",
11967                Spaces);
11968   verifyFormat("if ( true )\n"
11969                "  f();\n"
11970                "else if ( true )\n"
11971                "  f();",
11972                Spaces);
11973   verifyFormat("do {\n"
11974                "  do_something( (int)i );\n"
11975                "} while ( something() );",
11976                Spaces);
11977   verifyFormat("switch ( x ) {\n"
11978                "default:\n"
11979                "  break;\n"
11980                "}",
11981                Spaces);
11982 
11983   Spaces.SpacesInParentheses = false;
11984   Spaces.SpacesInCStyleCastParentheses = true;
11985   verifyFormat("Type *A = ( Type * )P;", Spaces);
11986   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
11987   verifyFormat("x = ( int32 )y;", Spaces);
11988   verifyFormat("int a = ( int )(2.0f);", Spaces);
11989   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
11990   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
11991   verifyFormat("#define x (( int )-1)", Spaces);
11992 
11993   // Run the first set of tests again with:
11994   Spaces.SpacesInParentheses = false;
11995   Spaces.SpaceInEmptyParentheses = true;
11996   Spaces.SpacesInCStyleCastParentheses = true;
11997   verifyFormat("call(x, y, z);", Spaces);
11998   verifyFormat("call( );", Spaces);
11999   verifyFormat("std::function<void(int, int)> callback;", Spaces);
12000   verifyFormat("while (( bool )1)\n"
12001                "  continue;",
12002                Spaces);
12003   verifyFormat("for (;;)\n"
12004                "  continue;",
12005                Spaces);
12006   verifyFormat("if (true)\n"
12007                "  f( );\n"
12008                "else if (true)\n"
12009                "  f( );",
12010                Spaces);
12011   verifyFormat("do {\n"
12012                "  do_something(( int )i);\n"
12013                "} while (something( ));",
12014                Spaces);
12015   verifyFormat("switch (x) {\n"
12016                "default:\n"
12017                "  break;\n"
12018                "}",
12019                Spaces);
12020 
12021   // Run the first set of tests again with:
12022   Spaces.SpaceAfterCStyleCast = true;
12023   verifyFormat("call(x, y, z);", Spaces);
12024   verifyFormat("call( );", Spaces);
12025   verifyFormat("std::function<void(int, int)> callback;", Spaces);
12026   verifyFormat("while (( bool ) 1)\n"
12027                "  continue;",
12028                Spaces);
12029   verifyFormat("for (;;)\n"
12030                "  continue;",
12031                Spaces);
12032   verifyFormat("if (true)\n"
12033                "  f( );\n"
12034                "else if (true)\n"
12035                "  f( );",
12036                Spaces);
12037   verifyFormat("do {\n"
12038                "  do_something(( int ) i);\n"
12039                "} while (something( ));",
12040                Spaces);
12041   verifyFormat("switch (x) {\n"
12042                "default:\n"
12043                "  break;\n"
12044                "}",
12045                Spaces);
12046 
12047   // Run subset of tests again with:
12048   Spaces.SpacesInCStyleCastParentheses = false;
12049   Spaces.SpaceAfterCStyleCast = true;
12050   verifyFormat("while ((bool) 1)\n"
12051                "  continue;",
12052                Spaces);
12053   verifyFormat("do {\n"
12054                "  do_something((int) i);\n"
12055                "} while (something( ));",
12056                Spaces);
12057 
12058   verifyFormat("size_t idx = (size_t) (ptr - ((char *) file));", Spaces);
12059   verifyFormat("size_t idx = (size_t) a;", Spaces);
12060   verifyFormat("size_t idx = (size_t) (a - 1);", Spaces);
12061   verifyFormat("size_t idx = (a->*foo)(a - 1);", Spaces);
12062   verifyFormat("size_t idx = (a->foo)(a - 1);", Spaces);
12063   verifyFormat("size_t idx = (*foo)(a - 1);", Spaces);
12064   Spaces.SpaceAfterCStyleCast = false;
12065   verifyFormat("size_t idx = (size_t)(ptr - ((char *)file));", Spaces);
12066   verifyFormat("size_t idx = (size_t)a;", Spaces);
12067   verifyFormat("size_t idx = (size_t)(a - 1);", Spaces);
12068   verifyFormat("size_t idx = (a->*foo)(a - 1);", Spaces);
12069   verifyFormat("size_t idx = (a->foo)(a - 1);", Spaces);
12070   verifyFormat("size_t idx = (*foo)(a - 1);", Spaces);
12071 }
12072 
12073 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
12074   verifyFormat("int a[5];");
12075   verifyFormat("a[3] += 42;");
12076 
12077   FormatStyle Spaces = getLLVMStyle();
12078   Spaces.SpacesInSquareBrackets = true;
12079   // Not lambdas.
12080   verifyFormat("int a[ 5 ];", Spaces);
12081   verifyFormat("a[ 3 ] += 42;", Spaces);
12082   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
12083   verifyFormat("double &operator[](int i) { return 0; }\n"
12084                "int i;",
12085                Spaces);
12086   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
12087   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
12088   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
12089   // Lambdas.
12090   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
12091   verifyFormat("return [ i, args... ] {};", Spaces);
12092   verifyFormat("int foo = [ &bar ]() {};", Spaces);
12093   verifyFormat("int foo = [ = ]() {};", Spaces);
12094   verifyFormat("int foo = [ & ]() {};", Spaces);
12095   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
12096   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
12097 }
12098 
12099 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
12100   FormatStyle NoSpaceStyle = getLLVMStyle();
12101   verifyFormat("int a[5];", NoSpaceStyle);
12102   verifyFormat("a[3] += 42;", NoSpaceStyle);
12103 
12104   verifyFormat("int a[1];", NoSpaceStyle);
12105   verifyFormat("int 1 [a];", NoSpaceStyle);
12106   verifyFormat("int a[1][2];", NoSpaceStyle);
12107   verifyFormat("a[7] = 5;", NoSpaceStyle);
12108   verifyFormat("int a = (f())[23];", NoSpaceStyle);
12109   verifyFormat("f([] {})", NoSpaceStyle);
12110 
12111   FormatStyle Space = getLLVMStyle();
12112   Space.SpaceBeforeSquareBrackets = true;
12113   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
12114   verifyFormat("return [i, args...] {};", Space);
12115 
12116   verifyFormat("int a [5];", Space);
12117   verifyFormat("a [3] += 42;", Space);
12118   verifyFormat("constexpr char hello []{\"hello\"};", Space);
12119   verifyFormat("double &operator[](int i) { return 0; }\n"
12120                "int i;",
12121                Space);
12122   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
12123   verifyFormat("int i = a [a][a]->f();", Space);
12124   verifyFormat("int i = (*b) [a]->f();", Space);
12125 
12126   verifyFormat("int a [1];", Space);
12127   verifyFormat("int 1 [a];", Space);
12128   verifyFormat("int a [1][2];", Space);
12129   verifyFormat("a [7] = 5;", Space);
12130   verifyFormat("int a = (f()) [23];", Space);
12131   verifyFormat("f([] {})", Space);
12132 }
12133 
12134 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
12135   verifyFormat("int a = 5;");
12136   verifyFormat("a += 42;");
12137   verifyFormat("a or_eq 8;");
12138 
12139   FormatStyle Spaces = getLLVMStyle();
12140   Spaces.SpaceBeforeAssignmentOperators = false;
12141   verifyFormat("int a= 5;", Spaces);
12142   verifyFormat("a+= 42;", Spaces);
12143   verifyFormat("a or_eq 8;", Spaces);
12144 }
12145 
12146 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
12147   verifyFormat("class Foo : public Bar {};");
12148   verifyFormat("Foo::Foo() : foo(1) {}");
12149   verifyFormat("for (auto a : b) {\n}");
12150   verifyFormat("int x = a ? b : c;");
12151   verifyFormat("{\n"
12152                "label0:\n"
12153                "  int x = 0;\n"
12154                "}");
12155   verifyFormat("switch (x) {\n"
12156                "case 1:\n"
12157                "default:\n"
12158                "}");
12159   verifyFormat("switch (allBraces) {\n"
12160                "case 1: {\n"
12161                "  break;\n"
12162                "}\n"
12163                "case 2: {\n"
12164                "  [[fallthrough]];\n"
12165                "}\n"
12166                "default: {\n"
12167                "  break;\n"
12168                "}\n"
12169                "}");
12170 
12171   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
12172   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
12173   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
12174   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
12175   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
12176   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
12177   verifyFormat("{\n"
12178                "label1:\n"
12179                "  int x = 0;\n"
12180                "}",
12181                CtorInitializerStyle);
12182   verifyFormat("switch (x) {\n"
12183                "case 1:\n"
12184                "default:\n"
12185                "}",
12186                CtorInitializerStyle);
12187   verifyFormat("switch (allBraces) {\n"
12188                "case 1: {\n"
12189                "  break;\n"
12190                "}\n"
12191                "case 2: {\n"
12192                "  [[fallthrough]];\n"
12193                "}\n"
12194                "default: {\n"
12195                "  break;\n"
12196                "}\n"
12197                "}",
12198                CtorInitializerStyle);
12199   CtorInitializerStyle.BreakConstructorInitializers =
12200       FormatStyle::BCIS_AfterColon;
12201   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
12202                "    aaaaaaaaaaaaaaaa(1),\n"
12203                "    bbbbbbbbbbbbbbbb(2) {}",
12204                CtorInitializerStyle);
12205   CtorInitializerStyle.BreakConstructorInitializers =
12206       FormatStyle::BCIS_BeforeComma;
12207   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12208                "    : aaaaaaaaaaaaaaaa(1)\n"
12209                "    , bbbbbbbbbbbbbbbb(2) {}",
12210                CtorInitializerStyle);
12211   CtorInitializerStyle.BreakConstructorInitializers =
12212       FormatStyle::BCIS_BeforeColon;
12213   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12214                "    : aaaaaaaaaaaaaaaa(1),\n"
12215                "      bbbbbbbbbbbbbbbb(2) {}",
12216                CtorInitializerStyle);
12217   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
12218   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
12219                ": aaaaaaaaaaaaaaaa(1),\n"
12220                "  bbbbbbbbbbbbbbbb(2) {}",
12221                CtorInitializerStyle);
12222 
12223   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
12224   InheritanceStyle.SpaceBeforeInheritanceColon = false;
12225   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
12226   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
12227   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
12228   verifyFormat("int x = a ? b : c;", InheritanceStyle);
12229   verifyFormat("{\n"
12230                "label2:\n"
12231                "  int x = 0;\n"
12232                "}",
12233                InheritanceStyle);
12234   verifyFormat("switch (x) {\n"
12235                "case 1:\n"
12236                "default:\n"
12237                "}",
12238                InheritanceStyle);
12239   verifyFormat("switch (allBraces) {\n"
12240                "case 1: {\n"
12241                "  break;\n"
12242                "}\n"
12243                "case 2: {\n"
12244                "  [[fallthrough]];\n"
12245                "}\n"
12246                "default: {\n"
12247                "  break;\n"
12248                "}\n"
12249                "}",
12250                InheritanceStyle);
12251   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
12252   verifyFormat("class Foooooooooooooooooooooo:\n"
12253                "    public aaaaaaaaaaaaaaaaaa,\n"
12254                "    public bbbbbbbbbbbbbbbbbb {\n"
12255                "}",
12256                InheritanceStyle);
12257   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
12258   verifyFormat("class Foooooooooooooooooooooo\n"
12259                "    : public aaaaaaaaaaaaaaaaaa\n"
12260                "    , public bbbbbbbbbbbbbbbbbb {\n"
12261                "}",
12262                InheritanceStyle);
12263   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
12264   verifyFormat("class Foooooooooooooooooooooo\n"
12265                "    : public aaaaaaaaaaaaaaaaaa,\n"
12266                "      public bbbbbbbbbbbbbbbbbb {\n"
12267                "}",
12268                InheritanceStyle);
12269   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
12270   verifyFormat("class Foooooooooooooooooooooo\n"
12271                ": public aaaaaaaaaaaaaaaaaa,\n"
12272                "  public bbbbbbbbbbbbbbbbbb {}",
12273                InheritanceStyle);
12274 
12275   FormatStyle ForLoopStyle = getLLVMStyle();
12276   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
12277   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
12278   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
12279   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
12280   verifyFormat("int x = a ? b : c;", ForLoopStyle);
12281   verifyFormat("{\n"
12282                "label2:\n"
12283                "  int x = 0;\n"
12284                "}",
12285                ForLoopStyle);
12286   verifyFormat("switch (x) {\n"
12287                "case 1:\n"
12288                "default:\n"
12289                "}",
12290                ForLoopStyle);
12291   verifyFormat("switch (allBraces) {\n"
12292                "case 1: {\n"
12293                "  break;\n"
12294                "}\n"
12295                "case 2: {\n"
12296                "  [[fallthrough]];\n"
12297                "}\n"
12298                "default: {\n"
12299                "  break;\n"
12300                "}\n"
12301                "}",
12302                ForLoopStyle);
12303 
12304   FormatStyle CaseStyle = getLLVMStyle();
12305   CaseStyle.SpaceBeforeCaseColon = true;
12306   verifyFormat("class Foo : public Bar {};", CaseStyle);
12307   verifyFormat("Foo::Foo() : foo(1) {}", CaseStyle);
12308   verifyFormat("for (auto a : b) {\n}", CaseStyle);
12309   verifyFormat("int x = a ? b : c;", CaseStyle);
12310   verifyFormat("switch (x) {\n"
12311                "case 1 :\n"
12312                "default :\n"
12313                "}",
12314                CaseStyle);
12315   verifyFormat("switch (allBraces) {\n"
12316                "case 1 : {\n"
12317                "  break;\n"
12318                "}\n"
12319                "case 2 : {\n"
12320                "  [[fallthrough]];\n"
12321                "}\n"
12322                "default : {\n"
12323                "  break;\n"
12324                "}\n"
12325                "}",
12326                CaseStyle);
12327 
12328   FormatStyle NoSpaceStyle = getLLVMStyle();
12329   EXPECT_EQ(NoSpaceStyle.SpaceBeforeCaseColon, false);
12330   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
12331   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
12332   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
12333   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
12334   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
12335   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
12336   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
12337   verifyFormat("{\n"
12338                "label3:\n"
12339                "  int x = 0;\n"
12340                "}",
12341                NoSpaceStyle);
12342   verifyFormat("switch (x) {\n"
12343                "case 1:\n"
12344                "default:\n"
12345                "}",
12346                NoSpaceStyle);
12347   verifyFormat("switch (allBraces) {\n"
12348                "case 1: {\n"
12349                "  break;\n"
12350                "}\n"
12351                "case 2: {\n"
12352                "  [[fallthrough]];\n"
12353                "}\n"
12354                "default: {\n"
12355                "  break;\n"
12356                "}\n"
12357                "}",
12358                NoSpaceStyle);
12359 
12360   FormatStyle InvertedSpaceStyle = getLLVMStyle();
12361   InvertedSpaceStyle.SpaceBeforeCaseColon = true;
12362   InvertedSpaceStyle.SpaceBeforeCtorInitializerColon = false;
12363   InvertedSpaceStyle.SpaceBeforeInheritanceColon = false;
12364   InvertedSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
12365   verifyFormat("class Foo: public Bar {};", InvertedSpaceStyle);
12366   verifyFormat("Foo::Foo(): foo(1) {}", InvertedSpaceStyle);
12367   verifyFormat("for (auto a: b) {\n}", InvertedSpaceStyle);
12368   verifyFormat("int x = a ? b : c;", InvertedSpaceStyle);
12369   verifyFormat("{\n"
12370                "label3:\n"
12371                "  int x = 0;\n"
12372                "}",
12373                InvertedSpaceStyle);
12374   verifyFormat("switch (x) {\n"
12375                "case 1 :\n"
12376                "case 2 : {\n"
12377                "  break;\n"
12378                "}\n"
12379                "default :\n"
12380                "  break;\n"
12381                "}",
12382                InvertedSpaceStyle);
12383   verifyFormat("switch (allBraces) {\n"
12384                "case 1 : {\n"
12385                "  break;\n"
12386                "}\n"
12387                "case 2 : {\n"
12388                "  [[fallthrough]];\n"
12389                "}\n"
12390                "default : {\n"
12391                "  break;\n"
12392                "}\n"
12393                "}",
12394                InvertedSpaceStyle);
12395 }
12396 
12397 TEST_F(FormatTest, ConfigurableSpaceAroundPointerQualifiers) {
12398   FormatStyle Style = getLLVMStyle();
12399 
12400   Style.PointerAlignment = FormatStyle::PAS_Left;
12401   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
12402   verifyFormat("void* const* x = NULL;", Style);
12403 
12404 #define verifyQualifierSpaces(Code, Pointers, Qualifiers)                      \
12405   do {                                                                         \
12406     Style.PointerAlignment = FormatStyle::Pointers;                            \
12407     Style.SpaceAroundPointerQualifiers = FormatStyle::Qualifiers;              \
12408     verifyFormat(Code, Style);                                                 \
12409   } while (false)
12410 
12411   verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Default);
12412   verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_Default);
12413   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Default);
12414 
12415   verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Before);
12416   verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Before);
12417   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Before);
12418 
12419   verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_After);
12420   verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_After);
12421   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_After);
12422 
12423   verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_Both);
12424   verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Both);
12425   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Both);
12426 
12427 #undef verifyQualifierSpaces
12428 
12429   FormatStyle Spaces = getLLVMStyle();
12430   Spaces.AttributeMacros.push_back("qualified");
12431   Spaces.PointerAlignment = FormatStyle::PAS_Right;
12432   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
12433   verifyFormat("SomeType *volatile *a = NULL;", Spaces);
12434   verifyFormat("SomeType *__attribute__((attr)) *a = NULL;", Spaces);
12435   verifyFormat("std::vector<SomeType *const *> x;", Spaces);
12436   verifyFormat("std::vector<SomeType *qualified *> x;", Spaces);
12437   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12438   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
12439   verifyFormat("SomeType * volatile *a = NULL;", Spaces);
12440   verifyFormat("SomeType * __attribute__((attr)) *a = NULL;", Spaces);
12441   verifyFormat("std::vector<SomeType * const *> x;", Spaces);
12442   verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
12443   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12444 
12445   // Check that SAPQ_Before doesn't result in extra spaces for PAS_Left.
12446   Spaces.PointerAlignment = FormatStyle::PAS_Left;
12447   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
12448   verifyFormat("SomeType* volatile* a = NULL;", Spaces);
12449   verifyFormat("SomeType* __attribute__((attr))* a = NULL;", Spaces);
12450   verifyFormat("std::vector<SomeType* const*> x;", Spaces);
12451   verifyFormat("std::vector<SomeType* qualified*> x;", Spaces);
12452   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12453   // However, setting it to SAPQ_After should add spaces after __attribute, etc.
12454   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
12455   verifyFormat("SomeType* volatile * a = NULL;", Spaces);
12456   verifyFormat("SomeType* __attribute__((attr)) * a = NULL;", Spaces);
12457   verifyFormat("std::vector<SomeType* const *> x;", Spaces);
12458   verifyFormat("std::vector<SomeType* qualified *> x;", Spaces);
12459   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12460 
12461   // PAS_Middle should not have any noticeable changes even for SAPQ_Both
12462   Spaces.PointerAlignment = FormatStyle::PAS_Middle;
12463   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
12464   verifyFormat("SomeType * volatile * a = NULL;", Spaces);
12465   verifyFormat("SomeType * __attribute__((attr)) * a = NULL;", Spaces);
12466   verifyFormat("std::vector<SomeType * const *> x;", Spaces);
12467   verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
12468   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
12469 }
12470 
12471 TEST_F(FormatTest, AlignConsecutiveMacros) {
12472   FormatStyle Style = getLLVMStyle();
12473   Style.AlignConsecutiveAssignments = true;
12474   Style.AlignConsecutiveDeclarations = true;
12475   Style.AlignConsecutiveMacros = false;
12476 
12477   verifyFormat("#define a 3\n"
12478                "#define bbbb 4\n"
12479                "#define ccc (5)",
12480                Style);
12481 
12482   verifyFormat("#define f(x) (x * x)\n"
12483                "#define fff(x, y, z) (x * y + z)\n"
12484                "#define ffff(x, y) (x - y)",
12485                Style);
12486 
12487   verifyFormat("#define foo(x, y) (x + y)\n"
12488                "#define bar (5, 6)(2 + 2)",
12489                Style);
12490 
12491   verifyFormat("#define a 3\n"
12492                "#define bbbb 4\n"
12493                "#define ccc (5)\n"
12494                "#define f(x) (x * x)\n"
12495                "#define fff(x, y, z) (x * y + z)\n"
12496                "#define ffff(x, y) (x - y)",
12497                Style);
12498 
12499   Style.AlignConsecutiveMacros = true;
12500   verifyFormat("#define a    3\n"
12501                "#define bbbb 4\n"
12502                "#define ccc  (5)",
12503                Style);
12504 
12505   verifyFormat("#define f(x)         (x * x)\n"
12506                "#define fff(x, y, z) (x * y + z)\n"
12507                "#define ffff(x, y)   (x - y)",
12508                Style);
12509 
12510   verifyFormat("#define foo(x, y) (x + y)\n"
12511                "#define bar       (5, 6)(2 + 2)",
12512                Style);
12513 
12514   verifyFormat("#define a            3\n"
12515                "#define bbbb         4\n"
12516                "#define ccc          (5)\n"
12517                "#define f(x)         (x * x)\n"
12518                "#define fff(x, y, z) (x * y + z)\n"
12519                "#define ffff(x, y)   (x - y)",
12520                Style);
12521 
12522   verifyFormat("#define a         5\n"
12523                "#define foo(x, y) (x + y)\n"
12524                "#define CCC       (6)\n"
12525                "auto lambda = []() {\n"
12526                "  auto  ii = 0;\n"
12527                "  float j  = 0;\n"
12528                "  return 0;\n"
12529                "};\n"
12530                "int   i  = 0;\n"
12531                "float i2 = 0;\n"
12532                "auto  v  = type{\n"
12533                "    i = 1,   //\n"
12534                "    (i = 2), //\n"
12535                "    i = 3    //\n"
12536                "};",
12537                Style);
12538 
12539   Style.AlignConsecutiveMacros = false;
12540   Style.ColumnLimit = 20;
12541 
12542   verifyFormat("#define a          \\\n"
12543                "  \"aabbbbbbbbbbbb\"\n"
12544                "#define D          \\\n"
12545                "  \"aabbbbbbbbbbbb\" \\\n"
12546                "  \"ccddeeeeeeeee\"\n"
12547                "#define B          \\\n"
12548                "  \"QQQQQQQQQQQQQ\"  \\\n"
12549                "  \"FFFFFFFFFFFFF\"  \\\n"
12550                "  \"LLLLLLLL\"\n",
12551                Style);
12552 
12553   Style.AlignConsecutiveMacros = true;
12554   verifyFormat("#define a          \\\n"
12555                "  \"aabbbbbbbbbbbb\"\n"
12556                "#define D          \\\n"
12557                "  \"aabbbbbbbbbbbb\" \\\n"
12558                "  \"ccddeeeeeeeee\"\n"
12559                "#define B          \\\n"
12560                "  \"QQQQQQQQQQQQQ\"  \\\n"
12561                "  \"FFFFFFFFFFFFF\"  \\\n"
12562                "  \"LLLLLLLL\"\n",
12563                Style);
12564 }
12565 
12566 TEST_F(FormatTest, AlignConsecutiveAssignments) {
12567   FormatStyle Alignment = getLLVMStyle();
12568   Alignment.AlignConsecutiveMacros = true;
12569   Alignment.AlignConsecutiveAssignments = false;
12570   verifyFormat("int a = 5;\n"
12571                "int oneTwoThree = 123;",
12572                Alignment);
12573   verifyFormat("int a = 5;\n"
12574                "int oneTwoThree = 123;",
12575                Alignment);
12576 
12577   Alignment.AlignConsecutiveAssignments = true;
12578   verifyFormat("int a           = 5;\n"
12579                "int oneTwoThree = 123;",
12580                Alignment);
12581   verifyFormat("int a           = method();\n"
12582                "int oneTwoThree = 133;",
12583                Alignment);
12584   verifyFormat("a &= 5;\n"
12585                "bcd *= 5;\n"
12586                "ghtyf += 5;\n"
12587                "dvfvdb -= 5;\n"
12588                "a /= 5;\n"
12589                "vdsvsv %= 5;\n"
12590                "sfdbddfbdfbb ^= 5;\n"
12591                "dvsdsv |= 5;\n"
12592                "int dsvvdvsdvvv = 123;",
12593                Alignment);
12594   verifyFormat("int i = 1, j = 10;\n"
12595                "something = 2000;",
12596                Alignment);
12597   verifyFormat("something = 2000;\n"
12598                "int i = 1, j = 10;\n",
12599                Alignment);
12600   verifyFormat("something = 2000;\n"
12601                "another   = 911;\n"
12602                "int i = 1, j = 10;\n"
12603                "oneMore = 1;\n"
12604                "i       = 2;",
12605                Alignment);
12606   verifyFormat("int a   = 5;\n"
12607                "int one = 1;\n"
12608                "method();\n"
12609                "int oneTwoThree = 123;\n"
12610                "int oneTwo      = 12;",
12611                Alignment);
12612   verifyFormat("int oneTwoThree = 123;\n"
12613                "int oneTwo      = 12;\n"
12614                "method();\n",
12615                Alignment);
12616   verifyFormat("int oneTwoThree = 123; // comment\n"
12617                "int oneTwo      = 12;  // comment",
12618                Alignment);
12619 
12620   // Bug 25167
12621   /* Uncomment when fixed
12622     verifyFormat("#if A\n"
12623                  "#else\n"
12624                  "int aaaaaaaa = 12;\n"
12625                  "#endif\n"
12626                  "#if B\n"
12627                  "#else\n"
12628                  "int a = 12;\n"
12629                  "#endif\n",
12630                  Alignment);
12631     verifyFormat("enum foo {\n"
12632                  "#if A\n"
12633                  "#else\n"
12634                  "  aaaaaaaa = 12;\n"
12635                  "#endif\n"
12636                  "#if B\n"
12637                  "#else\n"
12638                  "  a = 12;\n"
12639                  "#endif\n"
12640                  "};\n",
12641                  Alignment);
12642   */
12643 
12644   EXPECT_EQ("int a = 5;\n"
12645             "\n"
12646             "int oneTwoThree = 123;",
12647             format("int a       = 5;\n"
12648                    "\n"
12649                    "int oneTwoThree= 123;",
12650                    Alignment));
12651   EXPECT_EQ("int a   = 5;\n"
12652             "int one = 1;\n"
12653             "\n"
12654             "int oneTwoThree = 123;",
12655             format("int a = 5;\n"
12656                    "int one = 1;\n"
12657                    "\n"
12658                    "int oneTwoThree = 123;",
12659                    Alignment));
12660   EXPECT_EQ("int a   = 5;\n"
12661             "int one = 1;\n"
12662             "\n"
12663             "int oneTwoThree = 123;\n"
12664             "int oneTwo      = 12;",
12665             format("int a = 5;\n"
12666                    "int one = 1;\n"
12667                    "\n"
12668                    "int oneTwoThree = 123;\n"
12669                    "int oneTwo = 12;",
12670                    Alignment));
12671   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
12672   verifyFormat("#define A \\\n"
12673                "  int aaaa       = 12; \\\n"
12674                "  int b          = 23; \\\n"
12675                "  int ccc        = 234; \\\n"
12676                "  int dddddddddd = 2345;",
12677                Alignment);
12678   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12679   verifyFormat("#define A               \\\n"
12680                "  int aaaa       = 12;  \\\n"
12681                "  int b          = 23;  \\\n"
12682                "  int ccc        = 234; \\\n"
12683                "  int dddddddddd = 2345;",
12684                Alignment);
12685   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
12686   verifyFormat("#define A                                                      "
12687                "                \\\n"
12688                "  int aaaa       = 12;                                         "
12689                "                \\\n"
12690                "  int b          = 23;                                         "
12691                "                \\\n"
12692                "  int ccc        = 234;                                        "
12693                "                \\\n"
12694                "  int dddddddddd = 2345;",
12695                Alignment);
12696   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
12697                "k = 4, int l = 5,\n"
12698                "                  int m = 6) {\n"
12699                "  int j      = 10;\n"
12700                "  otherThing = 1;\n"
12701                "}",
12702                Alignment);
12703   verifyFormat("void SomeFunction(int parameter = 0) {\n"
12704                "  int i   = 1;\n"
12705                "  int j   = 2;\n"
12706                "  int big = 10000;\n"
12707                "}",
12708                Alignment);
12709   verifyFormat("class C {\n"
12710                "public:\n"
12711                "  int i            = 1;\n"
12712                "  virtual void f() = 0;\n"
12713                "};",
12714                Alignment);
12715   verifyFormat("int i = 1;\n"
12716                "if (SomeType t = getSomething()) {\n"
12717                "}\n"
12718                "int j   = 2;\n"
12719                "int big = 10000;",
12720                Alignment);
12721   verifyFormat("int j = 7;\n"
12722                "for (int k = 0; k < N; ++k) {\n"
12723                "}\n"
12724                "int j   = 2;\n"
12725                "int big = 10000;\n"
12726                "}",
12727                Alignment);
12728   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
12729   verifyFormat("int i = 1;\n"
12730                "LooooooooooongType loooooooooooooooooooooongVariable\n"
12731                "    = someLooooooooooooooooongFunction();\n"
12732                "int j = 2;",
12733                Alignment);
12734   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
12735   verifyFormat("int i = 1;\n"
12736                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
12737                "    someLooooooooooooooooongFunction();\n"
12738                "int j = 2;",
12739                Alignment);
12740 
12741   verifyFormat("auto lambda = []() {\n"
12742                "  auto i = 0;\n"
12743                "  return 0;\n"
12744                "};\n"
12745                "int i  = 0;\n"
12746                "auto v = type{\n"
12747                "    i = 1,   //\n"
12748                "    (i = 2), //\n"
12749                "    i = 3    //\n"
12750                "};",
12751                Alignment);
12752 
12753   verifyFormat(
12754       "int i      = 1;\n"
12755       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
12756       "                          loooooooooooooooooooooongParameterB);\n"
12757       "int j      = 2;",
12758       Alignment);
12759 
12760   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
12761                "          typename B   = very_long_type_name_1,\n"
12762                "          typename T_2 = very_long_type_name_2>\n"
12763                "auto foo() {}\n",
12764                Alignment);
12765   verifyFormat("int a, b = 1;\n"
12766                "int c  = 2;\n"
12767                "int dd = 3;\n",
12768                Alignment);
12769   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
12770                "float b[1][] = {{3.f}};\n",
12771                Alignment);
12772   verifyFormat("for (int i = 0; i < 1; i++)\n"
12773                "  int x = 1;\n",
12774                Alignment);
12775   verifyFormat("for (i = 0; i < 1; i++)\n"
12776                "  x = 1;\n"
12777                "y = 1;\n",
12778                Alignment);
12779 
12780   Alignment.ReflowComments = true;
12781   Alignment.ColumnLimit = 50;
12782   EXPECT_EQ("int x   = 0;\n"
12783             "int yy  = 1; /// specificlennospace\n"
12784             "int zzz = 2;\n",
12785             format("int x   = 0;\n"
12786                    "int yy  = 1; ///specificlennospace\n"
12787                    "int zzz = 2;\n",
12788                    Alignment));
12789 }
12790 
12791 TEST_F(FormatTest, AlignConsecutiveBitFields) {
12792   FormatStyle Alignment = getLLVMStyle();
12793   Alignment.AlignConsecutiveBitFields = true;
12794   verifyFormat("int const a     : 5;\n"
12795                "int oneTwoThree : 23;",
12796                Alignment);
12797 
12798   // Initializers are allowed starting with c++2a
12799   verifyFormat("int const a     : 5 = 1;\n"
12800                "int oneTwoThree : 23 = 0;",
12801                Alignment);
12802 
12803   Alignment.AlignConsecutiveDeclarations = true;
12804   verifyFormat("int const a           : 5;\n"
12805                "int       oneTwoThree : 23;",
12806                Alignment);
12807 
12808   verifyFormat("int const a           : 5;  // comment\n"
12809                "int       oneTwoThree : 23; // comment",
12810                Alignment);
12811 
12812   verifyFormat("int const a           : 5 = 1;\n"
12813                "int       oneTwoThree : 23 = 0;",
12814                Alignment);
12815 
12816   Alignment.AlignConsecutiveAssignments = true;
12817   verifyFormat("int const a           : 5  = 1;\n"
12818                "int       oneTwoThree : 23 = 0;",
12819                Alignment);
12820   verifyFormat("int const a           : 5  = {1};\n"
12821                "int       oneTwoThree : 23 = 0;",
12822                Alignment);
12823 
12824   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_None;
12825   verifyFormat("int const a          :5;\n"
12826                "int       oneTwoThree:23;",
12827                Alignment);
12828 
12829   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_Before;
12830   verifyFormat("int const a           :5;\n"
12831                "int       oneTwoThree :23;",
12832                Alignment);
12833 
12834   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_After;
12835   verifyFormat("int const a          : 5;\n"
12836                "int       oneTwoThree: 23;",
12837                Alignment);
12838 
12839   // Known limitations: ':' is only recognized as a bitfield colon when
12840   // followed by a number.
12841   /*
12842   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
12843                "int a           : 5;",
12844                Alignment);
12845   */
12846 }
12847 
12848 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
12849   FormatStyle Alignment = getLLVMStyle();
12850   Alignment.AlignConsecutiveMacros = true;
12851   Alignment.AlignConsecutiveDeclarations = false;
12852   verifyFormat("float const a = 5;\n"
12853                "int oneTwoThree = 123;",
12854                Alignment);
12855   verifyFormat("int a = 5;\n"
12856                "float const oneTwoThree = 123;",
12857                Alignment);
12858 
12859   Alignment.AlignConsecutiveDeclarations = true;
12860   verifyFormat("float const a = 5;\n"
12861                "int         oneTwoThree = 123;",
12862                Alignment);
12863   verifyFormat("int         a = method();\n"
12864                "float const oneTwoThree = 133;",
12865                Alignment);
12866   verifyFormat("int i = 1, j = 10;\n"
12867                "something = 2000;",
12868                Alignment);
12869   verifyFormat("something = 2000;\n"
12870                "int i = 1, j = 10;\n",
12871                Alignment);
12872   verifyFormat("float      something = 2000;\n"
12873                "double     another = 911;\n"
12874                "int        i = 1, j = 10;\n"
12875                "const int *oneMore = 1;\n"
12876                "unsigned   i = 2;",
12877                Alignment);
12878   verifyFormat("float a = 5;\n"
12879                "int   one = 1;\n"
12880                "method();\n"
12881                "const double       oneTwoThree = 123;\n"
12882                "const unsigned int oneTwo = 12;",
12883                Alignment);
12884   verifyFormat("int      oneTwoThree{0}; // comment\n"
12885                "unsigned oneTwo;         // comment",
12886                Alignment);
12887   EXPECT_EQ("float const a = 5;\n"
12888             "\n"
12889             "int oneTwoThree = 123;",
12890             format("float const   a = 5;\n"
12891                    "\n"
12892                    "int           oneTwoThree= 123;",
12893                    Alignment));
12894   EXPECT_EQ("float a = 5;\n"
12895             "int   one = 1;\n"
12896             "\n"
12897             "unsigned oneTwoThree = 123;",
12898             format("float    a = 5;\n"
12899                    "int      one = 1;\n"
12900                    "\n"
12901                    "unsigned oneTwoThree = 123;",
12902                    Alignment));
12903   EXPECT_EQ("float a = 5;\n"
12904             "int   one = 1;\n"
12905             "\n"
12906             "unsigned oneTwoThree = 123;\n"
12907             "int      oneTwo = 12;",
12908             format("float    a = 5;\n"
12909                    "int one = 1;\n"
12910                    "\n"
12911                    "unsigned oneTwoThree = 123;\n"
12912                    "int oneTwo = 12;",
12913                    Alignment));
12914   // Function prototype alignment
12915   verifyFormat("int    a();\n"
12916                "double b();",
12917                Alignment);
12918   verifyFormat("int    a(int x);\n"
12919                "double b();",
12920                Alignment);
12921   unsigned OldColumnLimit = Alignment.ColumnLimit;
12922   // We need to set ColumnLimit to zero, in order to stress nested alignments,
12923   // otherwise the function parameters will be re-flowed onto a single line.
12924   Alignment.ColumnLimit = 0;
12925   EXPECT_EQ("int    a(int   x,\n"
12926             "         float y);\n"
12927             "double b(int    x,\n"
12928             "         double y);",
12929             format("int a(int x,\n"
12930                    " float y);\n"
12931                    "double b(int x,\n"
12932                    " double y);",
12933                    Alignment));
12934   // This ensures that function parameters of function declarations are
12935   // correctly indented when their owning functions are indented.
12936   // The failure case here is for 'double y' to not be indented enough.
12937   EXPECT_EQ("double a(int x);\n"
12938             "int    b(int    y,\n"
12939             "         double z);",
12940             format("double a(int x);\n"
12941                    "int b(int y,\n"
12942                    " double z);",
12943                    Alignment));
12944   // Set ColumnLimit low so that we induce wrapping immediately after
12945   // the function name and opening paren.
12946   Alignment.ColumnLimit = 13;
12947   verifyFormat("int function(\n"
12948                "    int  x,\n"
12949                "    bool y);",
12950                Alignment);
12951   Alignment.ColumnLimit = OldColumnLimit;
12952   // Ensure function pointers don't screw up recursive alignment
12953   verifyFormat("int    a(int x, void (*fp)(int y));\n"
12954                "double b();",
12955                Alignment);
12956   Alignment.AlignConsecutiveAssignments = true;
12957   // Ensure recursive alignment is broken by function braces, so that the
12958   // "a = 1" does not align with subsequent assignments inside the function
12959   // body.
12960   verifyFormat("int func(int a = 1) {\n"
12961                "  int b  = 2;\n"
12962                "  int cc = 3;\n"
12963                "}",
12964                Alignment);
12965   verifyFormat("float      something = 2000;\n"
12966                "double     another   = 911;\n"
12967                "int        i = 1, j = 10;\n"
12968                "const int *oneMore = 1;\n"
12969                "unsigned   i       = 2;",
12970                Alignment);
12971   verifyFormat("int      oneTwoThree = {0}; // comment\n"
12972                "unsigned oneTwo      = 0;   // comment",
12973                Alignment);
12974   // Make sure that scope is correctly tracked, in the absence of braces
12975   verifyFormat("for (int i = 0; i < n; i++)\n"
12976                "  j = i;\n"
12977                "double x = 1;\n",
12978                Alignment);
12979   verifyFormat("if (int i = 0)\n"
12980                "  j = i;\n"
12981                "double x = 1;\n",
12982                Alignment);
12983   // Ensure operator[] and operator() are comprehended
12984   verifyFormat("struct test {\n"
12985                "  long long int foo();\n"
12986                "  int           operator[](int a);\n"
12987                "  double        bar();\n"
12988                "};\n",
12989                Alignment);
12990   verifyFormat("struct test {\n"
12991                "  long long int foo();\n"
12992                "  int           operator()(int a);\n"
12993                "  double        bar();\n"
12994                "};\n",
12995                Alignment);
12996   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
12997             "  int const i   = 1;\n"
12998             "  int *     j   = 2;\n"
12999             "  int       big = 10000;\n"
13000             "\n"
13001             "  unsigned oneTwoThree = 123;\n"
13002             "  int      oneTwo      = 12;\n"
13003             "  method();\n"
13004             "  float k  = 2;\n"
13005             "  int   ll = 10000;\n"
13006             "}",
13007             format("void SomeFunction(int parameter= 0) {\n"
13008                    " int const  i= 1;\n"
13009                    "  int *j=2;\n"
13010                    " int big  =  10000;\n"
13011                    "\n"
13012                    "unsigned oneTwoThree  =123;\n"
13013                    "int oneTwo = 12;\n"
13014                    "  method();\n"
13015                    "float k= 2;\n"
13016                    "int ll=10000;\n"
13017                    "}",
13018                    Alignment));
13019   Alignment.AlignConsecutiveAssignments = false;
13020   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
13021   verifyFormat("#define A \\\n"
13022                "  int       aaaa = 12; \\\n"
13023                "  float     b = 23; \\\n"
13024                "  const int ccc = 234; \\\n"
13025                "  unsigned  dddddddddd = 2345;",
13026                Alignment);
13027   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13028   verifyFormat("#define A              \\\n"
13029                "  int       aaaa = 12; \\\n"
13030                "  float     b = 23;    \\\n"
13031                "  const int ccc = 234; \\\n"
13032                "  unsigned  dddddddddd = 2345;",
13033                Alignment);
13034   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
13035   Alignment.ColumnLimit = 30;
13036   verifyFormat("#define A                    \\\n"
13037                "  int       aaaa = 12;       \\\n"
13038                "  float     b = 23;          \\\n"
13039                "  const int ccc = 234;       \\\n"
13040                "  int       dddddddddd = 2345;",
13041                Alignment);
13042   Alignment.ColumnLimit = 80;
13043   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
13044                "k = 4, int l = 5,\n"
13045                "                  int m = 6) {\n"
13046                "  const int j = 10;\n"
13047                "  otherThing = 1;\n"
13048                "}",
13049                Alignment);
13050   verifyFormat("void SomeFunction(int parameter = 0) {\n"
13051                "  int const i = 1;\n"
13052                "  int *     j = 2;\n"
13053                "  int       big = 10000;\n"
13054                "}",
13055                Alignment);
13056   verifyFormat("class C {\n"
13057                "public:\n"
13058                "  int          i = 1;\n"
13059                "  virtual void f() = 0;\n"
13060                "};",
13061                Alignment);
13062   verifyFormat("float i = 1;\n"
13063                "if (SomeType t = getSomething()) {\n"
13064                "}\n"
13065                "const unsigned j = 2;\n"
13066                "int            big = 10000;",
13067                Alignment);
13068   verifyFormat("float j = 7;\n"
13069                "for (int k = 0; k < N; ++k) {\n"
13070                "}\n"
13071                "unsigned j = 2;\n"
13072                "int      big = 10000;\n"
13073                "}",
13074                Alignment);
13075   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13076   verifyFormat("float              i = 1;\n"
13077                "LooooooooooongType loooooooooooooooooooooongVariable\n"
13078                "    = someLooooooooooooooooongFunction();\n"
13079                "int j = 2;",
13080                Alignment);
13081   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
13082   verifyFormat("int                i = 1;\n"
13083                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
13084                "    someLooooooooooooooooongFunction();\n"
13085                "int j = 2;",
13086                Alignment);
13087 
13088   Alignment.AlignConsecutiveAssignments = true;
13089   verifyFormat("auto lambda = []() {\n"
13090                "  auto  ii = 0;\n"
13091                "  float j  = 0;\n"
13092                "  return 0;\n"
13093                "};\n"
13094                "int   i  = 0;\n"
13095                "float i2 = 0;\n"
13096                "auto  v  = type{\n"
13097                "    i = 1,   //\n"
13098                "    (i = 2), //\n"
13099                "    i = 3    //\n"
13100                "};",
13101                Alignment);
13102   Alignment.AlignConsecutiveAssignments = false;
13103 
13104   verifyFormat(
13105       "int      i = 1;\n"
13106       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
13107       "                          loooooooooooooooooooooongParameterB);\n"
13108       "int      j = 2;",
13109       Alignment);
13110 
13111   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
13112   // We expect declarations and assignments to align, as long as it doesn't
13113   // exceed the column limit, starting a new alignment sequence whenever it
13114   // happens.
13115   Alignment.AlignConsecutiveAssignments = true;
13116   Alignment.ColumnLimit = 30;
13117   verifyFormat("float    ii              = 1;\n"
13118                "unsigned j               = 2;\n"
13119                "int someVerylongVariable = 1;\n"
13120                "AnotherLongType  ll = 123456;\n"
13121                "VeryVeryLongType k  = 2;\n"
13122                "int              myvar = 1;",
13123                Alignment);
13124   Alignment.ColumnLimit = 80;
13125   Alignment.AlignConsecutiveAssignments = false;
13126 
13127   verifyFormat(
13128       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
13129       "          typename LongType, typename B>\n"
13130       "auto foo() {}\n",
13131       Alignment);
13132   verifyFormat("float a, b = 1;\n"
13133                "int   c = 2;\n"
13134                "int   dd = 3;\n",
13135                Alignment);
13136   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
13137                "float b[1][] = {{3.f}};\n",
13138                Alignment);
13139   Alignment.AlignConsecutiveAssignments = true;
13140   verifyFormat("float a, b = 1;\n"
13141                "int   c  = 2;\n"
13142                "int   dd = 3;\n",
13143                Alignment);
13144   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
13145                "float b[1][] = {{3.f}};\n",
13146                Alignment);
13147   Alignment.AlignConsecutiveAssignments = false;
13148 
13149   Alignment.ColumnLimit = 30;
13150   Alignment.BinPackParameters = false;
13151   verifyFormat("void foo(float     a,\n"
13152                "         float     b,\n"
13153                "         int       c,\n"
13154                "         uint32_t *d) {\n"
13155                "  int *  e = 0;\n"
13156                "  float  f = 0;\n"
13157                "  double g = 0;\n"
13158                "}\n"
13159                "void bar(ino_t     a,\n"
13160                "         int       b,\n"
13161                "         uint32_t *c,\n"
13162                "         bool      d) {}\n",
13163                Alignment);
13164   Alignment.BinPackParameters = true;
13165   Alignment.ColumnLimit = 80;
13166 
13167   // Bug 33507
13168   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
13169   verifyFormat(
13170       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
13171       "  static const Version verVs2017;\n"
13172       "  return true;\n"
13173       "});\n",
13174       Alignment);
13175   Alignment.PointerAlignment = FormatStyle::PAS_Right;
13176 
13177   // See llvm.org/PR35641
13178   Alignment.AlignConsecutiveDeclarations = true;
13179   verifyFormat("int func() { //\n"
13180                "  int      b;\n"
13181                "  unsigned c;\n"
13182                "}",
13183                Alignment);
13184 
13185   // See PR37175
13186   FormatStyle Style = getMozillaStyle();
13187   Style.AlignConsecutiveDeclarations = true;
13188   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
13189             "foo(int a);",
13190             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
13191 }
13192 
13193 TEST_F(FormatTest, LinuxBraceBreaking) {
13194   FormatStyle LinuxBraceStyle = getLLVMStyle();
13195   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
13196   verifyFormat("namespace a\n"
13197                "{\n"
13198                "class A\n"
13199                "{\n"
13200                "  void f()\n"
13201                "  {\n"
13202                "    if (true) {\n"
13203                "      a();\n"
13204                "      b();\n"
13205                "    } else {\n"
13206                "      a();\n"
13207                "    }\n"
13208                "  }\n"
13209                "  void g() { return; }\n"
13210                "};\n"
13211                "struct B {\n"
13212                "  int x;\n"
13213                "};\n"
13214                "} // namespace a\n",
13215                LinuxBraceStyle);
13216   verifyFormat("enum X {\n"
13217                "  Y = 0,\n"
13218                "}\n",
13219                LinuxBraceStyle);
13220   verifyFormat("struct S {\n"
13221                "  int Type;\n"
13222                "  union {\n"
13223                "    int x;\n"
13224                "    double y;\n"
13225                "  } Value;\n"
13226                "  class C\n"
13227                "  {\n"
13228                "    MyFavoriteType Value;\n"
13229                "  } Class;\n"
13230                "}\n",
13231                LinuxBraceStyle);
13232 }
13233 
13234 TEST_F(FormatTest, MozillaBraceBreaking) {
13235   FormatStyle MozillaBraceStyle = getLLVMStyle();
13236   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
13237   MozillaBraceStyle.FixNamespaceComments = false;
13238   verifyFormat("namespace a {\n"
13239                "class A\n"
13240                "{\n"
13241                "  void f()\n"
13242                "  {\n"
13243                "    if (true) {\n"
13244                "      a();\n"
13245                "      b();\n"
13246                "    }\n"
13247                "  }\n"
13248                "  void g() { return; }\n"
13249                "};\n"
13250                "enum E\n"
13251                "{\n"
13252                "  A,\n"
13253                "  // foo\n"
13254                "  B,\n"
13255                "  C\n"
13256                "};\n"
13257                "struct B\n"
13258                "{\n"
13259                "  int x;\n"
13260                "};\n"
13261                "}\n",
13262                MozillaBraceStyle);
13263   verifyFormat("struct S\n"
13264                "{\n"
13265                "  int Type;\n"
13266                "  union\n"
13267                "  {\n"
13268                "    int x;\n"
13269                "    double y;\n"
13270                "  } Value;\n"
13271                "  class C\n"
13272                "  {\n"
13273                "    MyFavoriteType Value;\n"
13274                "  } Class;\n"
13275                "}\n",
13276                MozillaBraceStyle);
13277 }
13278 
13279 TEST_F(FormatTest, StroustrupBraceBreaking) {
13280   FormatStyle StroustrupBraceStyle = getLLVMStyle();
13281   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
13282   verifyFormat("namespace a {\n"
13283                "class A {\n"
13284                "  void f()\n"
13285                "  {\n"
13286                "    if (true) {\n"
13287                "      a();\n"
13288                "      b();\n"
13289                "    }\n"
13290                "  }\n"
13291                "  void g() { return; }\n"
13292                "};\n"
13293                "struct B {\n"
13294                "  int x;\n"
13295                "};\n"
13296                "} // namespace a\n",
13297                StroustrupBraceStyle);
13298 
13299   verifyFormat("void foo()\n"
13300                "{\n"
13301                "  if (a) {\n"
13302                "    a();\n"
13303                "  }\n"
13304                "  else {\n"
13305                "    b();\n"
13306                "  }\n"
13307                "}\n",
13308                StroustrupBraceStyle);
13309 
13310   verifyFormat("#ifdef _DEBUG\n"
13311                "int foo(int i = 0)\n"
13312                "#else\n"
13313                "int foo(int i = 5)\n"
13314                "#endif\n"
13315                "{\n"
13316                "  return i;\n"
13317                "}",
13318                StroustrupBraceStyle);
13319 
13320   verifyFormat("void foo() {}\n"
13321                "void bar()\n"
13322                "#ifdef _DEBUG\n"
13323                "{\n"
13324                "  foo();\n"
13325                "}\n"
13326                "#else\n"
13327                "{\n"
13328                "}\n"
13329                "#endif",
13330                StroustrupBraceStyle);
13331 
13332   verifyFormat("void foobar() { int i = 5; }\n"
13333                "#ifdef _DEBUG\n"
13334                "void bar() {}\n"
13335                "#else\n"
13336                "void bar() { foobar(); }\n"
13337                "#endif",
13338                StroustrupBraceStyle);
13339 }
13340 
13341 TEST_F(FormatTest, AllmanBraceBreaking) {
13342   FormatStyle AllmanBraceStyle = getLLVMStyle();
13343   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
13344 
13345   EXPECT_EQ("namespace a\n"
13346             "{\n"
13347             "void f();\n"
13348             "void g();\n"
13349             "} // namespace a\n",
13350             format("namespace a\n"
13351                    "{\n"
13352                    "void f();\n"
13353                    "void g();\n"
13354                    "}\n",
13355                    AllmanBraceStyle));
13356 
13357   verifyFormat("namespace a\n"
13358                "{\n"
13359                "class A\n"
13360                "{\n"
13361                "  void f()\n"
13362                "  {\n"
13363                "    if (true)\n"
13364                "    {\n"
13365                "      a();\n"
13366                "      b();\n"
13367                "    }\n"
13368                "  }\n"
13369                "  void g() { return; }\n"
13370                "};\n"
13371                "struct B\n"
13372                "{\n"
13373                "  int x;\n"
13374                "};\n"
13375                "union C\n"
13376                "{\n"
13377                "};\n"
13378                "} // namespace a",
13379                AllmanBraceStyle);
13380 
13381   verifyFormat("void f()\n"
13382                "{\n"
13383                "  if (true)\n"
13384                "  {\n"
13385                "    a();\n"
13386                "  }\n"
13387                "  else if (false)\n"
13388                "  {\n"
13389                "    b();\n"
13390                "  }\n"
13391                "  else\n"
13392                "  {\n"
13393                "    c();\n"
13394                "  }\n"
13395                "}\n",
13396                AllmanBraceStyle);
13397 
13398   verifyFormat("void f()\n"
13399                "{\n"
13400                "  for (int i = 0; i < 10; ++i)\n"
13401                "  {\n"
13402                "    a();\n"
13403                "  }\n"
13404                "  while (false)\n"
13405                "  {\n"
13406                "    b();\n"
13407                "  }\n"
13408                "  do\n"
13409                "  {\n"
13410                "    c();\n"
13411                "  } while (false)\n"
13412                "}\n",
13413                AllmanBraceStyle);
13414 
13415   verifyFormat("void f(int a)\n"
13416                "{\n"
13417                "  switch (a)\n"
13418                "  {\n"
13419                "  case 0:\n"
13420                "    break;\n"
13421                "  case 1:\n"
13422                "  {\n"
13423                "    break;\n"
13424                "  }\n"
13425                "  case 2:\n"
13426                "  {\n"
13427                "  }\n"
13428                "  break;\n"
13429                "  default:\n"
13430                "    break;\n"
13431                "  }\n"
13432                "}\n",
13433                AllmanBraceStyle);
13434 
13435   verifyFormat("enum X\n"
13436                "{\n"
13437                "  Y = 0,\n"
13438                "}\n",
13439                AllmanBraceStyle);
13440   verifyFormat("enum X\n"
13441                "{\n"
13442                "  Y = 0\n"
13443                "}\n",
13444                AllmanBraceStyle);
13445 
13446   verifyFormat("@interface BSApplicationController ()\n"
13447                "{\n"
13448                "@private\n"
13449                "  id _extraIvar;\n"
13450                "}\n"
13451                "@end\n",
13452                AllmanBraceStyle);
13453 
13454   verifyFormat("#ifdef _DEBUG\n"
13455                "int foo(int i = 0)\n"
13456                "#else\n"
13457                "int foo(int i = 5)\n"
13458                "#endif\n"
13459                "{\n"
13460                "  return i;\n"
13461                "}",
13462                AllmanBraceStyle);
13463 
13464   verifyFormat("void foo() {}\n"
13465                "void bar()\n"
13466                "#ifdef _DEBUG\n"
13467                "{\n"
13468                "  foo();\n"
13469                "}\n"
13470                "#else\n"
13471                "{\n"
13472                "}\n"
13473                "#endif",
13474                AllmanBraceStyle);
13475 
13476   verifyFormat("void foobar() { int i = 5; }\n"
13477                "#ifdef _DEBUG\n"
13478                "void bar() {}\n"
13479                "#else\n"
13480                "void bar() { foobar(); }\n"
13481                "#endif",
13482                AllmanBraceStyle);
13483 
13484   EXPECT_EQ(AllmanBraceStyle.AllowShortLambdasOnASingleLine,
13485             FormatStyle::SLS_All);
13486 
13487   verifyFormat("[](int i) { return i + 2; };\n"
13488                "[](int i, int j)\n"
13489                "{\n"
13490                "  auto x = i + j;\n"
13491                "  auto y = i * j;\n"
13492                "  return x ^ y;\n"
13493                "};\n"
13494                "void foo()\n"
13495                "{\n"
13496                "  auto shortLambda = [](int i) { return i + 2; };\n"
13497                "  auto longLambda = [](int i, int j)\n"
13498                "  {\n"
13499                "    auto x = i + j;\n"
13500                "    auto y = i * j;\n"
13501                "    return x ^ y;\n"
13502                "  };\n"
13503                "}",
13504                AllmanBraceStyle);
13505 
13506   AllmanBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
13507 
13508   verifyFormat("[](int i)\n"
13509                "{\n"
13510                "  return i + 2;\n"
13511                "};\n"
13512                "[](int i, int j)\n"
13513                "{\n"
13514                "  auto x = i + j;\n"
13515                "  auto y = i * j;\n"
13516                "  return x ^ y;\n"
13517                "};\n"
13518                "void foo()\n"
13519                "{\n"
13520                "  auto shortLambda = [](int i)\n"
13521                "  {\n"
13522                "    return i + 2;\n"
13523                "  };\n"
13524                "  auto longLambda = [](int i, int j)\n"
13525                "  {\n"
13526                "    auto x = i + j;\n"
13527                "    auto y = i * j;\n"
13528                "    return x ^ y;\n"
13529                "  };\n"
13530                "}",
13531                AllmanBraceStyle);
13532 
13533   // Reset
13534   AllmanBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_All;
13535 
13536   // This shouldn't affect ObjC blocks..
13537   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13538                "  // ...\n"
13539                "  int i;\n"
13540                "}];",
13541                AllmanBraceStyle);
13542   verifyFormat("void (^block)(void) = ^{\n"
13543                "  // ...\n"
13544                "  int i;\n"
13545                "};",
13546                AllmanBraceStyle);
13547   // .. or dict literals.
13548   verifyFormat("void f()\n"
13549                "{\n"
13550                "  // ...\n"
13551                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13552                "}",
13553                AllmanBraceStyle);
13554   verifyFormat("void f()\n"
13555                "{\n"
13556                "  // ...\n"
13557                "  [object someMethod:@{a : @\"b\"}];\n"
13558                "}",
13559                AllmanBraceStyle);
13560   verifyFormat("int f()\n"
13561                "{ // comment\n"
13562                "  return 42;\n"
13563                "}",
13564                AllmanBraceStyle);
13565 
13566   AllmanBraceStyle.ColumnLimit = 19;
13567   verifyFormat("void f() { int i; }", AllmanBraceStyle);
13568   AllmanBraceStyle.ColumnLimit = 18;
13569   verifyFormat("void f()\n"
13570                "{\n"
13571                "  int i;\n"
13572                "}",
13573                AllmanBraceStyle);
13574   AllmanBraceStyle.ColumnLimit = 80;
13575 
13576   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
13577   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13578       FormatStyle::SIS_WithoutElse;
13579   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13580   verifyFormat("void f(bool b)\n"
13581                "{\n"
13582                "  if (b)\n"
13583                "  {\n"
13584                "    return;\n"
13585                "  }\n"
13586                "}\n",
13587                BreakBeforeBraceShortIfs);
13588   verifyFormat("void f(bool b)\n"
13589                "{\n"
13590                "  if constexpr (b)\n"
13591                "  {\n"
13592                "    return;\n"
13593                "  }\n"
13594                "}\n",
13595                BreakBeforeBraceShortIfs);
13596   verifyFormat("void f(bool b)\n"
13597                "{\n"
13598                "  if CONSTEXPR (b)\n"
13599                "  {\n"
13600                "    return;\n"
13601                "  }\n"
13602                "}\n",
13603                BreakBeforeBraceShortIfs);
13604   verifyFormat("void f(bool b)\n"
13605                "{\n"
13606                "  if (b) return;\n"
13607                "}\n",
13608                BreakBeforeBraceShortIfs);
13609   verifyFormat("void f(bool b)\n"
13610                "{\n"
13611                "  if constexpr (b) return;\n"
13612                "}\n",
13613                BreakBeforeBraceShortIfs);
13614   verifyFormat("void f(bool b)\n"
13615                "{\n"
13616                "  if CONSTEXPR (b) return;\n"
13617                "}\n",
13618                BreakBeforeBraceShortIfs);
13619   verifyFormat("void f(bool b)\n"
13620                "{\n"
13621                "  while (b)\n"
13622                "  {\n"
13623                "    return;\n"
13624                "  }\n"
13625                "}\n",
13626                BreakBeforeBraceShortIfs);
13627 }
13628 
13629 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
13630   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
13631   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
13632 
13633   // Make a few changes to the style for testing purposes
13634   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
13635       FormatStyle::SFS_Empty;
13636   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
13637   WhitesmithsBraceStyle.ColumnLimit = 0;
13638 
13639   // FIXME: this test case can't decide whether there should be a blank line
13640   // after the ~D() line or not. It adds one if one doesn't exist in the test
13641   // and it removes the line if one exists.
13642   /*
13643   verifyFormat("class A;\n"
13644                "namespace B\n"
13645                "  {\n"
13646                "class C;\n"
13647                "// Comment\n"
13648                "class D\n"
13649                "  {\n"
13650                "public:\n"
13651                "  D();\n"
13652                "  ~D() {}\n"
13653                "private:\n"
13654                "  enum E\n"
13655                "    {\n"
13656                "    F\n"
13657                "    }\n"
13658                "  };\n"
13659                "  } // namespace B\n",
13660                WhitesmithsBraceStyle);
13661   */
13662 
13663   verifyFormat("namespace a\n"
13664                "  {\n"
13665                "class A\n"
13666                "  {\n"
13667                "  void f()\n"
13668                "    {\n"
13669                "    if (true)\n"
13670                "      {\n"
13671                "      a();\n"
13672                "      b();\n"
13673                "      }\n"
13674                "    }\n"
13675                "  void g()\n"
13676                "    {\n"
13677                "    return;\n"
13678                "    }\n"
13679                "  };\n"
13680                "struct B\n"
13681                "  {\n"
13682                "  int x;\n"
13683                "  };\n"
13684                "  } // namespace a",
13685                WhitesmithsBraceStyle);
13686 
13687   verifyFormat("void f()\n"
13688                "  {\n"
13689                "  if (true)\n"
13690                "    {\n"
13691                "    a();\n"
13692                "    }\n"
13693                "  else if (false)\n"
13694                "    {\n"
13695                "    b();\n"
13696                "    }\n"
13697                "  else\n"
13698                "    {\n"
13699                "    c();\n"
13700                "    }\n"
13701                "  }\n",
13702                WhitesmithsBraceStyle);
13703 
13704   verifyFormat("void f()\n"
13705                "  {\n"
13706                "  for (int i = 0; i < 10; ++i)\n"
13707                "    {\n"
13708                "    a();\n"
13709                "    }\n"
13710                "  while (false)\n"
13711                "    {\n"
13712                "    b();\n"
13713                "    }\n"
13714                "  do\n"
13715                "    {\n"
13716                "    c();\n"
13717                "    } while (false)\n"
13718                "  }\n",
13719                WhitesmithsBraceStyle);
13720 
13721   WhitesmithsBraceStyle.IndentCaseBlocks = true;
13722   verifyFormat("void switchTest1(int a)\n"
13723                "  {\n"
13724                "  switch (a)\n"
13725                "    {\n"
13726                "    case 2:\n"
13727                "      {\n"
13728                "      }\n"
13729                "    break;\n"
13730                "    }\n"
13731                "  }\n",
13732                WhitesmithsBraceStyle);
13733 
13734   verifyFormat("void switchTest2(int a)\n"
13735                "  {\n"
13736                "  switch (a)\n"
13737                "    {\n"
13738                "    case 0:\n"
13739                "    break;\n"
13740                "    case 1:\n"
13741                "      {\n"
13742                "      break;\n"
13743                "      }\n"
13744                "    case 2:\n"
13745                "      {\n"
13746                "      }\n"
13747                "    break;\n"
13748                "    default:\n"
13749                "    break;\n"
13750                "    }\n"
13751                "  }\n",
13752                WhitesmithsBraceStyle);
13753 
13754   verifyFormat("void switchTest3(int a)\n"
13755                "  {\n"
13756                "  switch (a)\n"
13757                "    {\n"
13758                "    case 0:\n"
13759                "      {\n"
13760                "      foo(x);\n"
13761                "      }\n"
13762                "    break;\n"
13763                "    default:\n"
13764                "      {\n"
13765                "      foo(1);\n"
13766                "      }\n"
13767                "    break;\n"
13768                "    }\n"
13769                "  }\n",
13770                WhitesmithsBraceStyle);
13771 
13772   WhitesmithsBraceStyle.IndentCaseBlocks = false;
13773 
13774   verifyFormat("void switchTest4(int a)\n"
13775                "  {\n"
13776                "  switch (a)\n"
13777                "    {\n"
13778                "  case 2:\n"
13779                "    {\n"
13780                "    }\n"
13781                "    break;\n"
13782                "    }\n"
13783                "  }\n",
13784                WhitesmithsBraceStyle);
13785 
13786   verifyFormat("void switchTest5(int a)\n"
13787                "  {\n"
13788                "  switch (a)\n"
13789                "    {\n"
13790                "  case 0:\n"
13791                "    break;\n"
13792                "  case 1:\n"
13793                "    {\n"
13794                "    foo();\n"
13795                "    break;\n"
13796                "    }\n"
13797                "  case 2:\n"
13798                "    {\n"
13799                "    }\n"
13800                "    break;\n"
13801                "  default:\n"
13802                "    break;\n"
13803                "    }\n"
13804                "  }\n",
13805                WhitesmithsBraceStyle);
13806 
13807   verifyFormat("void switchTest6(int a)\n"
13808                "  {\n"
13809                "  switch (a)\n"
13810                "    {\n"
13811                "  case 0:\n"
13812                "    {\n"
13813                "    foo(x);\n"
13814                "    }\n"
13815                "    break;\n"
13816                "  default:\n"
13817                "    {\n"
13818                "    foo(1);\n"
13819                "    }\n"
13820                "    break;\n"
13821                "    }\n"
13822                "  }\n",
13823                WhitesmithsBraceStyle);
13824 
13825   verifyFormat("enum X\n"
13826                "  {\n"
13827                "  Y = 0, // testing\n"
13828                "  }\n",
13829                WhitesmithsBraceStyle);
13830 
13831   verifyFormat("enum X\n"
13832                "  {\n"
13833                "  Y = 0\n"
13834                "  }\n",
13835                WhitesmithsBraceStyle);
13836   verifyFormat("enum X\n"
13837                "  {\n"
13838                "  Y = 0,\n"
13839                "  Z = 1\n"
13840                "  };\n",
13841                WhitesmithsBraceStyle);
13842 
13843   verifyFormat("@interface BSApplicationController ()\n"
13844                "  {\n"
13845                "@private\n"
13846                "  id _extraIvar;\n"
13847                "  }\n"
13848                "@end\n",
13849                WhitesmithsBraceStyle);
13850 
13851   verifyFormat("#ifdef _DEBUG\n"
13852                "int foo(int i = 0)\n"
13853                "#else\n"
13854                "int foo(int i = 5)\n"
13855                "#endif\n"
13856                "  {\n"
13857                "  return i;\n"
13858                "  }",
13859                WhitesmithsBraceStyle);
13860 
13861   verifyFormat("void foo() {}\n"
13862                "void bar()\n"
13863                "#ifdef _DEBUG\n"
13864                "  {\n"
13865                "  foo();\n"
13866                "  }\n"
13867                "#else\n"
13868                "  {\n"
13869                "  }\n"
13870                "#endif",
13871                WhitesmithsBraceStyle);
13872 
13873   verifyFormat("void foobar()\n"
13874                "  {\n"
13875                "  int i = 5;\n"
13876                "  }\n"
13877                "#ifdef _DEBUG\n"
13878                "void bar()\n"
13879                "  {\n"
13880                "  }\n"
13881                "#else\n"
13882                "void bar()\n"
13883                "  {\n"
13884                "  foobar();\n"
13885                "  }\n"
13886                "#endif",
13887                WhitesmithsBraceStyle);
13888 
13889   // This shouldn't affect ObjC blocks..
13890   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
13891                "  // ...\n"
13892                "  int i;\n"
13893                "}];",
13894                WhitesmithsBraceStyle);
13895   verifyFormat("void (^block)(void) = ^{\n"
13896                "  // ...\n"
13897                "  int i;\n"
13898                "};",
13899                WhitesmithsBraceStyle);
13900   // .. or dict literals.
13901   verifyFormat("void f()\n"
13902                "  {\n"
13903                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
13904                "  }",
13905                WhitesmithsBraceStyle);
13906 
13907   verifyFormat("int f()\n"
13908                "  { // comment\n"
13909                "  return 42;\n"
13910                "  }",
13911                WhitesmithsBraceStyle);
13912 
13913   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
13914   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
13915       FormatStyle::SIS_Always;
13916   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
13917   verifyFormat("void f(bool b)\n"
13918                "  {\n"
13919                "  if (b)\n"
13920                "    {\n"
13921                "    return;\n"
13922                "    }\n"
13923                "  }\n",
13924                BreakBeforeBraceShortIfs);
13925   verifyFormat("void f(bool b)\n"
13926                "  {\n"
13927                "  if (b) return;\n"
13928                "  }\n",
13929                BreakBeforeBraceShortIfs);
13930   verifyFormat("void f(bool b)\n"
13931                "  {\n"
13932                "  while (b)\n"
13933                "    {\n"
13934                "    return;\n"
13935                "    }\n"
13936                "  }\n",
13937                BreakBeforeBraceShortIfs);
13938 }
13939 
13940 TEST_F(FormatTest, GNUBraceBreaking) {
13941   FormatStyle GNUBraceStyle = getLLVMStyle();
13942   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
13943   verifyFormat("namespace a\n"
13944                "{\n"
13945                "class A\n"
13946                "{\n"
13947                "  void f()\n"
13948                "  {\n"
13949                "    int a;\n"
13950                "    {\n"
13951                "      int b;\n"
13952                "    }\n"
13953                "    if (true)\n"
13954                "      {\n"
13955                "        a();\n"
13956                "        b();\n"
13957                "      }\n"
13958                "  }\n"
13959                "  void g() { return; }\n"
13960                "}\n"
13961                "} // namespace a",
13962                GNUBraceStyle);
13963 
13964   verifyFormat("void f()\n"
13965                "{\n"
13966                "  if (true)\n"
13967                "    {\n"
13968                "      a();\n"
13969                "    }\n"
13970                "  else if (false)\n"
13971                "    {\n"
13972                "      b();\n"
13973                "    }\n"
13974                "  else\n"
13975                "    {\n"
13976                "      c();\n"
13977                "    }\n"
13978                "}\n",
13979                GNUBraceStyle);
13980 
13981   verifyFormat("void f()\n"
13982                "{\n"
13983                "  for (int i = 0; i < 10; ++i)\n"
13984                "    {\n"
13985                "      a();\n"
13986                "    }\n"
13987                "  while (false)\n"
13988                "    {\n"
13989                "      b();\n"
13990                "    }\n"
13991                "  do\n"
13992                "    {\n"
13993                "      c();\n"
13994                "    }\n"
13995                "  while (false);\n"
13996                "}\n",
13997                GNUBraceStyle);
13998 
13999   verifyFormat("void f(int a)\n"
14000                "{\n"
14001                "  switch (a)\n"
14002                "    {\n"
14003                "    case 0:\n"
14004                "      break;\n"
14005                "    case 1:\n"
14006                "      {\n"
14007                "        break;\n"
14008                "      }\n"
14009                "    case 2:\n"
14010                "      {\n"
14011                "      }\n"
14012                "      break;\n"
14013                "    default:\n"
14014                "      break;\n"
14015                "    }\n"
14016                "}\n",
14017                GNUBraceStyle);
14018 
14019   verifyFormat("enum X\n"
14020                "{\n"
14021                "  Y = 0,\n"
14022                "}\n",
14023                GNUBraceStyle);
14024 
14025   verifyFormat("@interface BSApplicationController ()\n"
14026                "{\n"
14027                "@private\n"
14028                "  id _extraIvar;\n"
14029                "}\n"
14030                "@end\n",
14031                GNUBraceStyle);
14032 
14033   verifyFormat("#ifdef _DEBUG\n"
14034                "int foo(int i = 0)\n"
14035                "#else\n"
14036                "int foo(int i = 5)\n"
14037                "#endif\n"
14038                "{\n"
14039                "  return i;\n"
14040                "}",
14041                GNUBraceStyle);
14042 
14043   verifyFormat("void foo() {}\n"
14044                "void bar()\n"
14045                "#ifdef _DEBUG\n"
14046                "{\n"
14047                "  foo();\n"
14048                "}\n"
14049                "#else\n"
14050                "{\n"
14051                "}\n"
14052                "#endif",
14053                GNUBraceStyle);
14054 
14055   verifyFormat("void foobar() { int i = 5; }\n"
14056                "#ifdef _DEBUG\n"
14057                "void bar() {}\n"
14058                "#else\n"
14059                "void bar() { foobar(); }\n"
14060                "#endif",
14061                GNUBraceStyle);
14062 }
14063 
14064 TEST_F(FormatTest, WebKitBraceBreaking) {
14065   FormatStyle WebKitBraceStyle = getLLVMStyle();
14066   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
14067   WebKitBraceStyle.FixNamespaceComments = false;
14068   verifyFormat("namespace a {\n"
14069                "class A {\n"
14070                "  void f()\n"
14071                "  {\n"
14072                "    if (true) {\n"
14073                "      a();\n"
14074                "      b();\n"
14075                "    }\n"
14076                "  }\n"
14077                "  void g() { return; }\n"
14078                "};\n"
14079                "enum E {\n"
14080                "  A,\n"
14081                "  // foo\n"
14082                "  B,\n"
14083                "  C\n"
14084                "};\n"
14085                "struct B {\n"
14086                "  int x;\n"
14087                "};\n"
14088                "}\n",
14089                WebKitBraceStyle);
14090   verifyFormat("struct S {\n"
14091                "  int Type;\n"
14092                "  union {\n"
14093                "    int x;\n"
14094                "    double y;\n"
14095                "  } Value;\n"
14096                "  class C {\n"
14097                "    MyFavoriteType Value;\n"
14098                "  } Class;\n"
14099                "};\n",
14100                WebKitBraceStyle);
14101 }
14102 
14103 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
14104   verifyFormat("void f() {\n"
14105                "  try {\n"
14106                "  } catch (const Exception &e) {\n"
14107                "  }\n"
14108                "}\n",
14109                getLLVMStyle());
14110 }
14111 
14112 TEST_F(FormatTest, UnderstandsPragmas) {
14113   verifyFormat("#pragma omp reduction(| : var)");
14114   verifyFormat("#pragma omp reduction(+ : var)");
14115 
14116   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
14117             "(including parentheses).",
14118             format("#pragma    mark   Any non-hyphenated or hyphenated string "
14119                    "(including parentheses)."));
14120 }
14121 
14122 TEST_F(FormatTest, UnderstandPragmaOption) {
14123   verifyFormat("#pragma option -C -A");
14124 
14125   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
14126 }
14127 
14128 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
14129   FormatStyle Style = getLLVMStyle();
14130   Style.ColumnLimit = 20;
14131 
14132   // See PR41213
14133   EXPECT_EQ("/*\n"
14134             " *\t9012345\n"
14135             " * /8901\n"
14136             " */",
14137             format("/*\n"
14138                    " *\t9012345 /8901\n"
14139                    " */",
14140                    Style));
14141   EXPECT_EQ("/*\n"
14142             " *345678\n"
14143             " *\t/8901\n"
14144             " */",
14145             format("/*\n"
14146                    " *345678\t/8901\n"
14147                    " */",
14148                    Style));
14149 
14150   verifyFormat("int a; // the\n"
14151                "       // comment",
14152                Style);
14153   EXPECT_EQ("int a; /* first line\n"
14154             "        * second\n"
14155             "        * line third\n"
14156             "        * line\n"
14157             "        */",
14158             format("int a; /* first line\n"
14159                    "        * second\n"
14160                    "        * line third\n"
14161                    "        * line\n"
14162                    "        */",
14163                    Style));
14164   EXPECT_EQ("int a; // first line\n"
14165             "       // second\n"
14166             "       // line third\n"
14167             "       // line",
14168             format("int a; // first line\n"
14169                    "       // second line\n"
14170                    "       // third line",
14171                    Style));
14172 
14173   Style.PenaltyExcessCharacter = 90;
14174   verifyFormat("int a; // the comment", Style);
14175   EXPECT_EQ("int a; // the comment\n"
14176             "       // aaa",
14177             format("int a; // the comment aaa", Style));
14178   EXPECT_EQ("int a; /* first line\n"
14179             "        * second line\n"
14180             "        * third line\n"
14181             "        */",
14182             format("int a; /* first line\n"
14183                    "        * second line\n"
14184                    "        * third line\n"
14185                    "        */",
14186                    Style));
14187   EXPECT_EQ("int a; // first line\n"
14188             "       // second line\n"
14189             "       // third line",
14190             format("int a; // first line\n"
14191                    "       // second line\n"
14192                    "       // third line",
14193                    Style));
14194   // FIXME: Investigate why this is not getting the same layout as the test
14195   // above.
14196   EXPECT_EQ("int a; /* first line\n"
14197             "        * second line\n"
14198             "        * third line\n"
14199             "        */",
14200             format("int a; /* first line second line third line"
14201                    "\n*/",
14202                    Style));
14203 
14204   EXPECT_EQ("// foo bar baz bazfoo\n"
14205             "// foo bar foo bar\n",
14206             format("// foo bar baz bazfoo\n"
14207                    "// foo bar foo           bar\n",
14208                    Style));
14209   EXPECT_EQ("// foo bar baz bazfoo\n"
14210             "// foo bar foo bar\n",
14211             format("// foo bar baz      bazfoo\n"
14212                    "// foo            bar foo bar\n",
14213                    Style));
14214 
14215   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
14216   // next one.
14217   EXPECT_EQ("// foo bar baz bazfoo\n"
14218             "// bar foo bar\n",
14219             format("// foo bar baz      bazfoo bar\n"
14220                    "// foo            bar\n",
14221                    Style));
14222 
14223   EXPECT_EQ("// foo bar baz bazfoo\n"
14224             "// foo bar baz bazfoo\n"
14225             "// bar foo bar\n",
14226             format("// foo bar baz      bazfoo\n"
14227                    "// foo bar baz      bazfoo bar\n"
14228                    "// foo bar\n",
14229                    Style));
14230 
14231   EXPECT_EQ("// foo bar baz bazfoo\n"
14232             "// foo bar baz bazfoo\n"
14233             "// bar foo bar\n",
14234             format("// foo bar baz      bazfoo\n"
14235                    "// foo bar baz      bazfoo bar\n"
14236                    "// foo           bar\n",
14237                    Style));
14238 
14239   // Make sure we do not keep protruding characters if strict mode reflow is
14240   // cheaper than keeping protruding characters.
14241   Style.ColumnLimit = 21;
14242   EXPECT_EQ(
14243       "// foo foo foo foo\n"
14244       "// foo foo foo foo\n"
14245       "// foo foo foo foo\n",
14246       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
14247 
14248   EXPECT_EQ("int a = /* long block\n"
14249             "           comment */\n"
14250             "    42;",
14251             format("int a = /* long block comment */ 42;", Style));
14252 }
14253 
14254 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
14255   for (size_t i = 1; i < Styles.size(); ++i)                                   \
14256   EXPECT_EQ(Styles[0], Styles[i])                                              \
14257       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
14258 
14259 TEST_F(FormatTest, GetsPredefinedStyleByName) {
14260   SmallVector<FormatStyle, 3> Styles;
14261   Styles.resize(3);
14262 
14263   Styles[0] = getLLVMStyle();
14264   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
14265   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
14266   EXPECT_ALL_STYLES_EQUAL(Styles);
14267 
14268   Styles[0] = getGoogleStyle();
14269   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
14270   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
14271   EXPECT_ALL_STYLES_EQUAL(Styles);
14272 
14273   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
14274   EXPECT_TRUE(
14275       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
14276   EXPECT_TRUE(
14277       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
14278   EXPECT_ALL_STYLES_EQUAL(Styles);
14279 
14280   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
14281   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
14282   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
14283   EXPECT_ALL_STYLES_EQUAL(Styles);
14284 
14285   Styles[0] = getMozillaStyle();
14286   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
14287   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
14288   EXPECT_ALL_STYLES_EQUAL(Styles);
14289 
14290   Styles[0] = getWebKitStyle();
14291   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
14292   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
14293   EXPECT_ALL_STYLES_EQUAL(Styles);
14294 
14295   Styles[0] = getGNUStyle();
14296   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
14297   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
14298   EXPECT_ALL_STYLES_EQUAL(Styles);
14299 
14300   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
14301 }
14302 
14303 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
14304   SmallVector<FormatStyle, 8> Styles;
14305   Styles.resize(2);
14306 
14307   Styles[0] = getGoogleStyle();
14308   Styles[1] = getLLVMStyle();
14309   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
14310   EXPECT_ALL_STYLES_EQUAL(Styles);
14311 
14312   Styles.resize(5);
14313   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
14314   Styles[1] = getLLVMStyle();
14315   Styles[1].Language = FormatStyle::LK_JavaScript;
14316   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
14317 
14318   Styles[2] = getLLVMStyle();
14319   Styles[2].Language = FormatStyle::LK_JavaScript;
14320   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
14321                                   "BasedOnStyle: Google",
14322                                   &Styles[2])
14323                    .value());
14324 
14325   Styles[3] = getLLVMStyle();
14326   Styles[3].Language = FormatStyle::LK_JavaScript;
14327   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
14328                                   "Language: JavaScript",
14329                                   &Styles[3])
14330                    .value());
14331 
14332   Styles[4] = getLLVMStyle();
14333   Styles[4].Language = FormatStyle::LK_JavaScript;
14334   EXPECT_EQ(0, parseConfiguration("---\n"
14335                                   "BasedOnStyle: LLVM\n"
14336                                   "IndentWidth: 123\n"
14337                                   "---\n"
14338                                   "BasedOnStyle: Google\n"
14339                                   "Language: JavaScript",
14340                                   &Styles[4])
14341                    .value());
14342   EXPECT_ALL_STYLES_EQUAL(Styles);
14343 }
14344 
14345 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
14346   Style.FIELD = false;                                                         \
14347   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
14348   EXPECT_TRUE(Style.FIELD);                                                    \
14349   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
14350   EXPECT_FALSE(Style.FIELD);
14351 
14352 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
14353 
14354 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
14355   Style.STRUCT.FIELD = false;                                                  \
14356   EXPECT_EQ(0,                                                                 \
14357             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
14358                 .value());                                                     \
14359   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
14360   EXPECT_EQ(0,                                                                 \
14361             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
14362                 .value());                                                     \
14363   EXPECT_FALSE(Style.STRUCT.FIELD);
14364 
14365 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
14366   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
14367 
14368 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
14369   EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!";          \
14370   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
14371   EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
14372 
14373 TEST_F(FormatTest, ParsesConfigurationBools) {
14374   FormatStyle Style = {};
14375   Style.Language = FormatStyle::LK_Cpp;
14376   CHECK_PARSE_BOOL(AlignTrailingComments);
14377   CHECK_PARSE_BOOL(AlignConsecutiveAssignments);
14378   CHECK_PARSE_BOOL(AlignConsecutiveBitFields);
14379   CHECK_PARSE_BOOL(AlignConsecutiveDeclarations);
14380   CHECK_PARSE_BOOL(AlignConsecutiveMacros);
14381   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
14382   CHECK_PARSE_BOOL(AllowAllConstructorInitializersOnNextLine);
14383   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
14384   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
14385   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
14386   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
14387   CHECK_PARSE_BOOL(BinPackArguments);
14388   CHECK_PARSE_BOOL(BinPackParameters);
14389   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
14390   CHECK_PARSE_BOOL(BreakBeforeConceptDeclarations);
14391   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
14392   CHECK_PARSE_BOOL(BreakStringLiterals);
14393   CHECK_PARSE_BOOL(CompactNamespaces);
14394   CHECK_PARSE_BOOL(ConstructorInitializerAllOnOneLineOrOnePerLine);
14395   CHECK_PARSE_BOOL(DeriveLineEnding);
14396   CHECK_PARSE_BOOL(DerivePointerAlignment);
14397   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
14398   CHECK_PARSE_BOOL(DisableFormat);
14399   CHECK_PARSE_BOOL(IndentCaseLabels);
14400   CHECK_PARSE_BOOL(IndentCaseBlocks);
14401   CHECK_PARSE_BOOL(IndentGotoLabels);
14402   CHECK_PARSE_BOOL(IndentRequires);
14403   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
14404   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
14405   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
14406   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
14407   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
14408   CHECK_PARSE_BOOL(ReflowComments);
14409   CHECK_PARSE_BOOL(SortIncludes);
14410   CHECK_PARSE_BOOL(SortUsingDeclarations);
14411   CHECK_PARSE_BOOL(SpacesInParentheses);
14412   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
14413   CHECK_PARSE_BOOL(SpacesInAngles);
14414   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
14415   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
14416   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
14417   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
14418   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
14419   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
14420   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
14421   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
14422   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
14423   CHECK_PARSE_BOOL(SpaceBeforeCaseColon);
14424   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
14425   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
14426   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
14427   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
14428   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
14429   CHECK_PARSE_BOOL(UseCRLF);
14430 
14431   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
14432   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
14433   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
14434   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
14435   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
14436   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
14437   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
14438   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
14439   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
14440   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
14441   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
14442   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
14443   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
14444   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
14445   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
14446   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
14447   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
14448 }
14449 
14450 #undef CHECK_PARSE_BOOL
14451 
14452 TEST_F(FormatTest, ParsesConfiguration) {
14453   FormatStyle Style = {};
14454   Style.Language = FormatStyle::LK_Cpp;
14455   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
14456   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
14457               ConstructorInitializerIndentWidth, 1234u);
14458   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
14459   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
14460   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
14461   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
14462   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
14463               PenaltyBreakBeforeFirstCallParameter, 1234u);
14464   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
14465               PenaltyBreakTemplateDeclaration, 1234u);
14466   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
14467   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
14468               PenaltyReturnTypeOnItsOwnLine, 1234u);
14469   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
14470               SpacesBeforeTrailingComments, 1234u);
14471   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
14472   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
14473   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
14474 
14475   Style.PointerAlignment = FormatStyle::PAS_Middle;
14476   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
14477               FormatStyle::PAS_Left);
14478   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
14479               FormatStyle::PAS_Right);
14480   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
14481               FormatStyle::PAS_Middle);
14482   // For backward compatibility:
14483   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
14484               FormatStyle::PAS_Left);
14485   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
14486               FormatStyle::PAS_Right);
14487   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
14488               FormatStyle::PAS_Middle);
14489 
14490   Style.Standard = FormatStyle::LS_Auto;
14491   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
14492   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
14493   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
14494   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
14495   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
14496   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
14497   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
14498   // Legacy aliases:
14499   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
14500   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
14501   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
14502   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
14503 
14504   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
14505   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
14506               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
14507   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
14508               FormatStyle::BOS_None);
14509   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
14510               FormatStyle::BOS_All);
14511   // For backward compatibility:
14512   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
14513               FormatStyle::BOS_None);
14514   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
14515               FormatStyle::BOS_All);
14516 
14517   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
14518   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
14519               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14520   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
14521               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
14522   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
14523               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
14524   // For backward compatibility:
14525   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
14526               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
14527 
14528   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
14529   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
14530               FormatStyle::BILS_BeforeComma);
14531   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
14532               FormatStyle::BILS_AfterColon);
14533   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
14534               FormatStyle::BILS_BeforeColon);
14535   // For backward compatibility:
14536   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
14537               FormatStyle::BILS_BeforeComma);
14538 
14539   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14540   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
14541               FormatStyle::BAS_Align);
14542   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
14543               FormatStyle::BAS_DontAlign);
14544   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
14545               FormatStyle::BAS_AlwaysBreak);
14546   // For backward compatibility:
14547   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
14548               FormatStyle::BAS_DontAlign);
14549   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
14550               FormatStyle::BAS_Align);
14551 
14552   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
14553   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
14554               FormatStyle::ENAS_DontAlign);
14555   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
14556               FormatStyle::ENAS_Left);
14557   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
14558               FormatStyle::ENAS_Right);
14559   // For backward compatibility:
14560   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
14561               FormatStyle::ENAS_Left);
14562   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
14563               FormatStyle::ENAS_Right);
14564 
14565   Style.AlignOperands = FormatStyle::OAS_Align;
14566   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
14567               FormatStyle::OAS_DontAlign);
14568   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
14569   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
14570               FormatStyle::OAS_AlignAfterOperator);
14571   // For backward compatibility:
14572   CHECK_PARSE("AlignOperands: false", AlignOperands,
14573               FormatStyle::OAS_DontAlign);
14574   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
14575 
14576   Style.UseTab = FormatStyle::UT_ForIndentation;
14577   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
14578   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
14579   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
14580   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
14581               FormatStyle::UT_ForContinuationAndIndentation);
14582   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
14583               FormatStyle::UT_AlignWithSpaces);
14584   // For backward compatibility:
14585   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
14586   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
14587 
14588   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
14589   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
14590               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14591   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
14592               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
14593   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
14594               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14595   // For backward compatibility:
14596   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
14597               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
14598   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
14599               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
14600 
14601   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
14602   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
14603               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14604   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
14605               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
14606   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
14607               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
14608   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
14609               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14610   // For backward compatibility:
14611   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
14612               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
14613   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
14614               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
14615 
14616   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Both;
14617   CHECK_PARSE("SpaceAroundPointerQualifiers: Default",
14618               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Default);
14619   CHECK_PARSE("SpaceAroundPointerQualifiers: Before",
14620               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Before);
14621   CHECK_PARSE("SpaceAroundPointerQualifiers: After",
14622               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_After);
14623   CHECK_PARSE("SpaceAroundPointerQualifiers: Both",
14624               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Both);
14625 
14626   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
14627   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
14628               FormatStyle::SBPO_Never);
14629   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
14630               FormatStyle::SBPO_Always);
14631   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
14632               FormatStyle::SBPO_ControlStatements);
14633   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
14634               FormatStyle::SBPO_NonEmptyParentheses);
14635   // For backward compatibility:
14636   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
14637               FormatStyle::SBPO_Never);
14638   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
14639               FormatStyle::SBPO_ControlStatements);
14640 
14641   Style.ColumnLimit = 123;
14642   FormatStyle BaseStyle = getLLVMStyle();
14643   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
14644   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
14645 
14646   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
14647   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
14648               FormatStyle::BS_Attach);
14649   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
14650               FormatStyle::BS_Linux);
14651   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
14652               FormatStyle::BS_Mozilla);
14653   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
14654               FormatStyle::BS_Stroustrup);
14655   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
14656               FormatStyle::BS_Allman);
14657   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
14658               FormatStyle::BS_Whitesmiths);
14659   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
14660   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
14661               FormatStyle::BS_WebKit);
14662   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
14663               FormatStyle::BS_Custom);
14664 
14665   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
14666   CHECK_PARSE("BraceWrapping:\n"
14667               "  AfterControlStatement: MultiLine",
14668               BraceWrapping.AfterControlStatement,
14669               FormatStyle::BWACS_MultiLine);
14670   CHECK_PARSE("BraceWrapping:\n"
14671               "  AfterControlStatement: Always",
14672               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14673   CHECK_PARSE("BraceWrapping:\n"
14674               "  AfterControlStatement: Never",
14675               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14676   // For backward compatibility:
14677   CHECK_PARSE("BraceWrapping:\n"
14678               "  AfterControlStatement: true",
14679               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
14680   CHECK_PARSE("BraceWrapping:\n"
14681               "  AfterControlStatement: false",
14682               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
14683 
14684   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
14685   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
14686               FormatStyle::RTBS_None);
14687   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
14688               FormatStyle::RTBS_All);
14689   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
14690               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
14691   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
14692               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
14693   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
14694               AlwaysBreakAfterReturnType,
14695               FormatStyle::RTBS_TopLevelDefinitions);
14696 
14697   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
14698   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
14699               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
14700   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
14701               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14702   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
14703               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14704   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
14705               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
14706   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
14707               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
14708 
14709   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
14710   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
14711               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
14712   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
14713               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
14714   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
14715               AlwaysBreakAfterDefinitionReturnType,
14716               FormatStyle::DRTBS_TopLevel);
14717 
14718   Style.NamespaceIndentation = FormatStyle::NI_All;
14719   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
14720               FormatStyle::NI_None);
14721   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
14722               FormatStyle::NI_Inner);
14723   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
14724               FormatStyle::NI_All);
14725 
14726   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Always;
14727   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
14728               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14729   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
14730               AllowShortIfStatementsOnASingleLine,
14731               FormatStyle::SIS_WithoutElse);
14732   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
14733               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Always);
14734   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
14735               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
14736   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
14737               AllowShortIfStatementsOnASingleLine,
14738               FormatStyle::SIS_WithoutElse);
14739 
14740   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
14741   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
14742               FormatStyle::IEBS_AfterExternBlock);
14743   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
14744               FormatStyle::IEBS_Indent);
14745   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
14746               FormatStyle::IEBS_NoIndent);
14747   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
14748               FormatStyle::IEBS_Indent);
14749   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
14750               FormatStyle::IEBS_NoIndent);
14751 
14752   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
14753   CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
14754               FormatStyle::BFCS_Both);
14755   CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
14756               FormatStyle::BFCS_None);
14757   CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
14758               FormatStyle::BFCS_Before);
14759   CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
14760               FormatStyle::BFCS_After);
14761 
14762   Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
14763   CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
14764               FormatStyle::SJSIO_After);
14765   CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
14766               FormatStyle::SJSIO_Before);
14767 
14768   // FIXME: This is required because parsing a configuration simply overwrites
14769   // the first N elements of the list instead of resetting it.
14770   Style.ForEachMacros.clear();
14771   std::vector<std::string> BoostForeach;
14772   BoostForeach.push_back("BOOST_FOREACH");
14773   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
14774   std::vector<std::string> BoostAndQForeach;
14775   BoostAndQForeach.push_back("BOOST_FOREACH");
14776   BoostAndQForeach.push_back("Q_FOREACH");
14777   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
14778               BoostAndQForeach);
14779 
14780   Style.AttributeMacros.clear();
14781   CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
14782               std::vector<std::string>{"__capability"});
14783   CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
14784               std::vector<std::string>({"attr1", "attr2"}));
14785 
14786   Style.StatementAttributeLikeMacros.clear();
14787   CHECK_PARSE("StatementAttributeLikeMacros: [emit,Q_EMIT]",
14788               StatementAttributeLikeMacros,
14789               std::vector<std::string>({"emit", "Q_EMIT"}));
14790 
14791   Style.StatementMacros.clear();
14792   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
14793               std::vector<std::string>{"QUNUSED"});
14794   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
14795               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
14796 
14797   Style.NamespaceMacros.clear();
14798   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
14799               std::vector<std::string>{"TESTSUITE"});
14800   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
14801               std::vector<std::string>({"TESTSUITE", "SUITE"}));
14802 
14803   Style.WhitespaceSensitiveMacros.clear();
14804   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
14805               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14806   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
14807               WhitespaceSensitiveMacros,
14808               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14809   Style.WhitespaceSensitiveMacros.clear();
14810   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
14811               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
14812   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
14813               WhitespaceSensitiveMacros,
14814               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
14815 
14816   Style.IncludeStyle.IncludeCategories.clear();
14817   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
14818       {"abc/.*", 2, 0, false}, {".*", 1, 0, true}};
14819   CHECK_PARSE("IncludeCategories:\n"
14820               "  - Regex: abc/.*\n"
14821               "    Priority: 2\n"
14822               "  - Regex: .*\n"
14823               "    Priority: 1\n"
14824               "    CaseSensitive: true\n",
14825               IncludeStyle.IncludeCategories, ExpectedCategories);
14826   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
14827               "abc$");
14828   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
14829               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
14830 
14831   Style.RawStringFormats.clear();
14832   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
14833       {
14834           FormatStyle::LK_TextProto,
14835           {"pb", "proto"},
14836           {"PARSE_TEXT_PROTO"},
14837           /*CanonicalDelimiter=*/"",
14838           "llvm",
14839       },
14840       {
14841           FormatStyle::LK_Cpp,
14842           {"cc", "cpp"},
14843           {"C_CODEBLOCK", "CPPEVAL"},
14844           /*CanonicalDelimiter=*/"cc",
14845           /*BasedOnStyle=*/"",
14846       },
14847   };
14848 
14849   CHECK_PARSE("RawStringFormats:\n"
14850               "  - Language: TextProto\n"
14851               "    Delimiters:\n"
14852               "      - 'pb'\n"
14853               "      - 'proto'\n"
14854               "    EnclosingFunctions:\n"
14855               "      - 'PARSE_TEXT_PROTO'\n"
14856               "    BasedOnStyle: llvm\n"
14857               "  - Language: Cpp\n"
14858               "    Delimiters:\n"
14859               "      - 'cc'\n"
14860               "      - 'cpp'\n"
14861               "    EnclosingFunctions:\n"
14862               "      - 'C_CODEBLOCK'\n"
14863               "      - 'CPPEVAL'\n"
14864               "    CanonicalDelimiter: 'cc'",
14865               RawStringFormats, ExpectedRawStringFormats);
14866 }
14867 
14868 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
14869   FormatStyle Style = {};
14870   Style.Language = FormatStyle::LK_Cpp;
14871   CHECK_PARSE("Language: Cpp\n"
14872               "IndentWidth: 12",
14873               IndentWidth, 12u);
14874   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
14875                                "IndentWidth: 34",
14876                                &Style),
14877             ParseError::Unsuitable);
14878   FormatStyle BinPackedTCS = {};
14879   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
14880   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
14881                                "InsertTrailingCommas: Wrapped",
14882                                &BinPackedTCS),
14883             ParseError::BinPackTrailingCommaConflict);
14884   EXPECT_EQ(12u, Style.IndentWidth);
14885   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14886   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14887 
14888   Style.Language = FormatStyle::LK_JavaScript;
14889   CHECK_PARSE("Language: JavaScript\n"
14890               "IndentWidth: 12",
14891               IndentWidth, 12u);
14892   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
14893   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
14894                                "IndentWidth: 34",
14895                                &Style),
14896             ParseError::Unsuitable);
14897   EXPECT_EQ(23u, Style.IndentWidth);
14898   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
14899   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14900 
14901   CHECK_PARSE("BasedOnStyle: LLVM\n"
14902               "IndentWidth: 67",
14903               IndentWidth, 67u);
14904 
14905   CHECK_PARSE("---\n"
14906               "Language: JavaScript\n"
14907               "IndentWidth: 12\n"
14908               "---\n"
14909               "Language: Cpp\n"
14910               "IndentWidth: 34\n"
14911               "...\n",
14912               IndentWidth, 12u);
14913 
14914   Style.Language = FormatStyle::LK_Cpp;
14915   CHECK_PARSE("---\n"
14916               "Language: JavaScript\n"
14917               "IndentWidth: 12\n"
14918               "---\n"
14919               "Language: Cpp\n"
14920               "IndentWidth: 34\n"
14921               "...\n",
14922               IndentWidth, 34u);
14923   CHECK_PARSE("---\n"
14924               "IndentWidth: 78\n"
14925               "---\n"
14926               "Language: JavaScript\n"
14927               "IndentWidth: 56\n"
14928               "...\n",
14929               IndentWidth, 78u);
14930 
14931   Style.ColumnLimit = 123;
14932   Style.IndentWidth = 234;
14933   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
14934   Style.TabWidth = 345;
14935   EXPECT_FALSE(parseConfiguration("---\n"
14936                                   "IndentWidth: 456\n"
14937                                   "BreakBeforeBraces: Allman\n"
14938                                   "---\n"
14939                                   "Language: JavaScript\n"
14940                                   "IndentWidth: 111\n"
14941                                   "TabWidth: 111\n"
14942                                   "---\n"
14943                                   "Language: Cpp\n"
14944                                   "BreakBeforeBraces: Stroustrup\n"
14945                                   "TabWidth: 789\n"
14946                                   "...\n",
14947                                   &Style));
14948   EXPECT_EQ(123u, Style.ColumnLimit);
14949   EXPECT_EQ(456u, Style.IndentWidth);
14950   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
14951   EXPECT_EQ(789u, Style.TabWidth);
14952 
14953   EXPECT_EQ(parseConfiguration("---\n"
14954                                "Language: JavaScript\n"
14955                                "IndentWidth: 56\n"
14956                                "---\n"
14957                                "IndentWidth: 78\n"
14958                                "...\n",
14959                                &Style),
14960             ParseError::Error);
14961   EXPECT_EQ(parseConfiguration("---\n"
14962                                "Language: JavaScript\n"
14963                                "IndentWidth: 56\n"
14964                                "---\n"
14965                                "Language: JavaScript\n"
14966                                "IndentWidth: 78\n"
14967                                "...\n",
14968                                &Style),
14969             ParseError::Error);
14970 
14971   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
14972 }
14973 
14974 #undef CHECK_PARSE
14975 
14976 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
14977   FormatStyle Style = {};
14978   Style.Language = FormatStyle::LK_JavaScript;
14979   Style.BreakBeforeTernaryOperators = true;
14980   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
14981   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14982 
14983   Style.BreakBeforeTernaryOperators = true;
14984   EXPECT_EQ(0, parseConfiguration("---\n"
14985                                   "BasedOnStyle: Google\n"
14986                                   "---\n"
14987                                   "Language: JavaScript\n"
14988                                   "IndentWidth: 76\n"
14989                                   "...\n",
14990                                   &Style)
14991                    .value());
14992   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
14993   EXPECT_EQ(76u, Style.IndentWidth);
14994   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
14995 }
14996 
14997 TEST_F(FormatTest, ConfigurationRoundTripTest) {
14998   FormatStyle Style = getLLVMStyle();
14999   std::string YAML = configurationAsText(Style);
15000   FormatStyle ParsedStyle = {};
15001   ParsedStyle.Language = FormatStyle::LK_Cpp;
15002   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
15003   EXPECT_EQ(Style, ParsedStyle);
15004 }
15005 
15006 TEST_F(FormatTest, WorksFor8bitEncodings) {
15007   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
15008             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
15009             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
15010             "\"\xef\xee\xf0\xf3...\"",
15011             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
15012                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
15013                    "\xef\xee\xf0\xf3...\"",
15014                    getLLVMStyleWithColumns(12)));
15015 }
15016 
15017 TEST_F(FormatTest, HandlesUTF8BOM) {
15018   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
15019   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
15020             format("\xef\xbb\xbf#include <iostream>"));
15021   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
15022             format("\xef\xbb\xbf\n#include <iostream>"));
15023 }
15024 
15025 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
15026 #if !defined(_MSC_VER)
15027 
15028 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
15029   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
15030                getLLVMStyleWithColumns(35));
15031   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
15032                getLLVMStyleWithColumns(31));
15033   verifyFormat("// Однажды в студёную зимнюю пору...",
15034                getLLVMStyleWithColumns(36));
15035   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
15036   verifyFormat("/* Однажды в студёную зимнюю пору... */",
15037                getLLVMStyleWithColumns(39));
15038   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
15039                getLLVMStyleWithColumns(35));
15040 }
15041 
15042 TEST_F(FormatTest, SplitsUTF8Strings) {
15043   // Non-printable characters' width is currently considered to be the length in
15044   // bytes in UTF8. The characters can be displayed in very different manner
15045   // (zero-width, single width with a substitution glyph, expanded to their code
15046   // (e.g. "<8d>"), so there's no single correct way to handle them.
15047   EXPECT_EQ("\"aaaaÄ\"\n"
15048             "\"\xc2\x8d\";",
15049             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
15050   EXPECT_EQ("\"aaaaaaaÄ\"\n"
15051             "\"\xc2\x8d\";",
15052             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
15053   EXPECT_EQ("\"Однажды, в \"\n"
15054             "\"студёную \"\n"
15055             "\"зимнюю \"\n"
15056             "\"пору,\"",
15057             format("\"Однажды, в студёную зимнюю пору,\"",
15058                    getLLVMStyleWithColumns(13)));
15059   EXPECT_EQ(
15060       "\"一 二 三 \"\n"
15061       "\"四 五六 \"\n"
15062       "\"七 八 九 \"\n"
15063       "\"十\"",
15064       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
15065   EXPECT_EQ("\"一\t\"\n"
15066             "\"二 \t\"\n"
15067             "\"三 四 \"\n"
15068             "\"五\t\"\n"
15069             "\"六 \t\"\n"
15070             "\"七 \"\n"
15071             "\"八九十\tqq\"",
15072             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
15073                    getLLVMStyleWithColumns(11)));
15074 
15075   // UTF8 character in an escape sequence.
15076   EXPECT_EQ("\"aaaaaa\"\n"
15077             "\"\\\xC2\x8D\"",
15078             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
15079 }
15080 
15081 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
15082   EXPECT_EQ("const char *sssss =\n"
15083             "    \"一二三四五六七八\\\n"
15084             " 九 十\";",
15085             format("const char *sssss = \"一二三四五六七八\\\n"
15086                    " 九 十\";",
15087                    getLLVMStyleWithColumns(30)));
15088 }
15089 
15090 TEST_F(FormatTest, SplitsUTF8LineComments) {
15091   EXPECT_EQ("// aaaaÄ\xc2\x8d",
15092             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
15093   EXPECT_EQ("// Я из лесу\n"
15094             "// вышел; был\n"
15095             "// сильный\n"
15096             "// мороз.",
15097             format("// Я из лесу вышел; был сильный мороз.",
15098                    getLLVMStyleWithColumns(13)));
15099   EXPECT_EQ("// 一二三\n"
15100             "// 四五六七\n"
15101             "// 八  九\n"
15102             "// 十",
15103             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
15104 }
15105 
15106 TEST_F(FormatTest, SplitsUTF8BlockComments) {
15107   EXPECT_EQ("/* Гляжу,\n"
15108             " * поднимается\n"
15109             " * медленно в\n"
15110             " * гору\n"
15111             " * Лошадка,\n"
15112             " * везущая\n"
15113             " * хворосту\n"
15114             " * воз. */",
15115             format("/* Гляжу, поднимается медленно в гору\n"
15116                    " * Лошадка, везущая хворосту воз. */",
15117                    getLLVMStyleWithColumns(13)));
15118   EXPECT_EQ(
15119       "/* 一二三\n"
15120       " * 四五六七\n"
15121       " * 八  九\n"
15122       " * 十  */",
15123       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
15124   EXPECT_EQ("/* �������� ��������\n"
15125             " * ��������\n"
15126             " * ������-�� */",
15127             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
15128 }
15129 
15130 #endif // _MSC_VER
15131 
15132 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
15133   FormatStyle Style = getLLVMStyle();
15134 
15135   Style.ConstructorInitializerIndentWidth = 4;
15136   verifyFormat(
15137       "SomeClass::Constructor()\n"
15138       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
15139       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
15140       Style);
15141 
15142   Style.ConstructorInitializerIndentWidth = 2;
15143   verifyFormat(
15144       "SomeClass::Constructor()\n"
15145       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
15146       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
15147       Style);
15148 
15149   Style.ConstructorInitializerIndentWidth = 0;
15150   verifyFormat(
15151       "SomeClass::Constructor()\n"
15152       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
15153       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
15154       Style);
15155   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
15156   verifyFormat(
15157       "SomeLongTemplateVariableName<\n"
15158       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
15159       Style);
15160   verifyFormat("bool smaller = 1 < "
15161                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
15162                "                       "
15163                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
15164                Style);
15165 
15166   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
15167   verifyFormat("SomeClass::Constructor() :\n"
15168                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
15169                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
15170                Style);
15171 }
15172 
15173 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
15174   FormatStyle Style = getLLVMStyle();
15175   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
15176   Style.ConstructorInitializerIndentWidth = 4;
15177   verifyFormat("SomeClass::Constructor()\n"
15178                "    : a(a)\n"
15179                "    , b(b)\n"
15180                "    , c(c) {}",
15181                Style);
15182   verifyFormat("SomeClass::Constructor()\n"
15183                "    : a(a) {}",
15184                Style);
15185 
15186   Style.ColumnLimit = 0;
15187   verifyFormat("SomeClass::Constructor()\n"
15188                "    : a(a) {}",
15189                Style);
15190   verifyFormat("SomeClass::Constructor() noexcept\n"
15191                "    : a(a) {}",
15192                Style);
15193   verifyFormat("SomeClass::Constructor()\n"
15194                "    : a(a)\n"
15195                "    , b(b)\n"
15196                "    , c(c) {}",
15197                Style);
15198   verifyFormat("SomeClass::Constructor()\n"
15199                "    : a(a) {\n"
15200                "  foo();\n"
15201                "  bar();\n"
15202                "}",
15203                Style);
15204 
15205   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
15206   verifyFormat("SomeClass::Constructor()\n"
15207                "    : a(a)\n"
15208                "    , b(b)\n"
15209                "    , c(c) {\n}",
15210                Style);
15211   verifyFormat("SomeClass::Constructor()\n"
15212                "    : a(a) {\n}",
15213                Style);
15214 
15215   Style.ColumnLimit = 80;
15216   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
15217   Style.ConstructorInitializerIndentWidth = 2;
15218   verifyFormat("SomeClass::Constructor()\n"
15219                "  : a(a)\n"
15220                "  , b(b)\n"
15221                "  , c(c) {}",
15222                Style);
15223 
15224   Style.ConstructorInitializerIndentWidth = 0;
15225   verifyFormat("SomeClass::Constructor()\n"
15226                ": a(a)\n"
15227                ", b(b)\n"
15228                ", c(c) {}",
15229                Style);
15230 
15231   Style.ConstructorInitializerAllOnOneLineOrOnePerLine = true;
15232   Style.ConstructorInitializerIndentWidth = 4;
15233   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
15234   verifyFormat(
15235       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
15236       Style);
15237   verifyFormat(
15238       "SomeClass::Constructor()\n"
15239       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
15240       Style);
15241   Style.ConstructorInitializerIndentWidth = 4;
15242   Style.ColumnLimit = 60;
15243   verifyFormat("SomeClass::Constructor()\n"
15244                "    : aaaaaaaa(aaaaaaaa)\n"
15245                "    , aaaaaaaa(aaaaaaaa)\n"
15246                "    , aaaaaaaa(aaaaaaaa) {}",
15247                Style);
15248 }
15249 
15250 TEST_F(FormatTest, Destructors) {
15251   verifyFormat("void F(int &i) { i.~int(); }");
15252   verifyFormat("void F(int &i) { i->~int(); }");
15253 }
15254 
15255 TEST_F(FormatTest, FormatsWithWebKitStyle) {
15256   FormatStyle Style = getWebKitStyle();
15257 
15258   // Don't indent in outer namespaces.
15259   verifyFormat("namespace outer {\n"
15260                "int i;\n"
15261                "namespace inner {\n"
15262                "    int i;\n"
15263                "} // namespace inner\n"
15264                "} // namespace outer\n"
15265                "namespace other_outer {\n"
15266                "int i;\n"
15267                "}",
15268                Style);
15269 
15270   // Don't indent case labels.
15271   verifyFormat("switch (variable) {\n"
15272                "case 1:\n"
15273                "case 2:\n"
15274                "    doSomething();\n"
15275                "    break;\n"
15276                "default:\n"
15277                "    ++variable;\n"
15278                "}",
15279                Style);
15280 
15281   // Wrap before binary operators.
15282   EXPECT_EQ("void f()\n"
15283             "{\n"
15284             "    if (aaaaaaaaaaaaaaaa\n"
15285             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
15286             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
15287             "        return;\n"
15288             "}",
15289             format("void f() {\n"
15290                    "if (aaaaaaaaaaaaaaaa\n"
15291                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
15292                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
15293                    "return;\n"
15294                    "}",
15295                    Style));
15296 
15297   // Allow functions on a single line.
15298   verifyFormat("void f() { return; }", Style);
15299 
15300   // Allow empty blocks on a single line and insert a space in empty blocks.
15301   EXPECT_EQ("void f() { }", format("void f() {}", Style));
15302   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
15303   // However, don't merge non-empty short loops.
15304   EXPECT_EQ("while (true) {\n"
15305             "    continue;\n"
15306             "}",
15307             format("while (true) { continue; }", Style));
15308 
15309   // Constructor initializers are formatted one per line with the "," on the
15310   // new line.
15311   verifyFormat("Constructor()\n"
15312                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
15313                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
15314                "          aaaaaaaaaaaaaa)\n"
15315                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
15316                "{\n"
15317                "}",
15318                Style);
15319   verifyFormat("SomeClass::Constructor()\n"
15320                "    : a(a)\n"
15321                "{\n"
15322                "}",
15323                Style);
15324   EXPECT_EQ("SomeClass::Constructor()\n"
15325             "    : a(a)\n"
15326             "{\n"
15327             "}",
15328             format("SomeClass::Constructor():a(a){}", Style));
15329   verifyFormat("SomeClass::Constructor()\n"
15330                "    : a(a)\n"
15331                "    , b(b)\n"
15332                "    , c(c)\n"
15333                "{\n"
15334                "}",
15335                Style);
15336   verifyFormat("SomeClass::Constructor()\n"
15337                "    : a(a)\n"
15338                "{\n"
15339                "    foo();\n"
15340                "    bar();\n"
15341                "}",
15342                Style);
15343 
15344   // Access specifiers should be aligned left.
15345   verifyFormat("class C {\n"
15346                "public:\n"
15347                "    int i;\n"
15348                "};",
15349                Style);
15350 
15351   // Do not align comments.
15352   verifyFormat("int a; // Do not\n"
15353                "double b; // align comments.",
15354                Style);
15355 
15356   // Do not align operands.
15357   EXPECT_EQ("ASSERT(aaaa\n"
15358             "    || bbbb);",
15359             format("ASSERT ( aaaa\n||bbbb);", Style));
15360 
15361   // Accept input's line breaks.
15362   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
15363             "    || bbbbbbbbbbbbbbb) {\n"
15364             "    i++;\n"
15365             "}",
15366             format("if (aaaaaaaaaaaaaaa\n"
15367                    "|| bbbbbbbbbbbbbbb) { i++; }",
15368                    Style));
15369   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
15370             "    i++;\n"
15371             "}",
15372             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
15373 
15374   // Don't automatically break all macro definitions (llvm.org/PR17842).
15375   verifyFormat("#define aNumber 10", Style);
15376   // However, generally keep the line breaks that the user authored.
15377   EXPECT_EQ("#define aNumber \\\n"
15378             "    10",
15379             format("#define aNumber \\\n"
15380                    " 10",
15381                    Style));
15382 
15383   // Keep empty and one-element array literals on a single line.
15384   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
15385             "                                  copyItems:YES];",
15386             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
15387                    "copyItems:YES];",
15388                    Style));
15389   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
15390             "                                  copyItems:YES];",
15391             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
15392                    "             copyItems:YES];",
15393                    Style));
15394   // FIXME: This does not seem right, there should be more indentation before
15395   // the array literal's entries. Nested blocks have the same problem.
15396   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
15397             "    @\"a\",\n"
15398             "    @\"a\"\n"
15399             "]\n"
15400             "                                  copyItems:YES];",
15401             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
15402                    "     @\"a\",\n"
15403                    "     @\"a\"\n"
15404                    "     ]\n"
15405                    "       copyItems:YES];",
15406                    Style));
15407   EXPECT_EQ(
15408       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
15409       "                                  copyItems:YES];",
15410       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
15411              "   copyItems:YES];",
15412              Style));
15413 
15414   verifyFormat("[self.a b:c c:d];", Style);
15415   EXPECT_EQ("[self.a b:c\n"
15416             "        c:d];",
15417             format("[self.a b:c\n"
15418                    "c:d];",
15419                    Style));
15420 }
15421 
15422 TEST_F(FormatTest, FormatsLambdas) {
15423   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
15424   verifyFormat(
15425       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
15426   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
15427   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
15428   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
15429   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
15430   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
15431   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
15432   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
15433   verifyFormat("int x = f(*+[] {});");
15434   verifyFormat("void f() {\n"
15435                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
15436                "}\n");
15437   verifyFormat("void f() {\n"
15438                "  other(x.begin(), //\n"
15439                "        x.end(),   //\n"
15440                "        [&](int, int) { return 1; });\n"
15441                "}\n");
15442   verifyFormat("void f() {\n"
15443                "  other.other.other.other.other(\n"
15444                "      x.begin(), x.end(),\n"
15445                "      [something, rather](int, int, int, int, int, int, int) { "
15446                "return 1; });\n"
15447                "}\n");
15448   verifyFormat(
15449       "void f() {\n"
15450       "  other.other.other.other.other(\n"
15451       "      x.begin(), x.end(),\n"
15452       "      [something, rather](int, int, int, int, int, int, int) {\n"
15453       "        //\n"
15454       "      });\n"
15455       "}\n");
15456   verifyFormat("SomeFunction([]() { // A cool function...\n"
15457                "  return 43;\n"
15458                "});");
15459   EXPECT_EQ("SomeFunction([]() {\n"
15460             "#define A a\n"
15461             "  return 43;\n"
15462             "});",
15463             format("SomeFunction([](){\n"
15464                    "#define A a\n"
15465                    "return 43;\n"
15466                    "});"));
15467   verifyFormat("void f() {\n"
15468                "  SomeFunction([](decltype(x), A *a) {});\n"
15469                "  SomeFunction([](typeof(x), A *a) {});\n"
15470                "  SomeFunction([](_Atomic(x), A *a) {});\n"
15471                "  SomeFunction([](__underlying_type(x), A *a) {});\n"
15472                "}");
15473   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15474                "    [](const aaaaaaaaaa &a) { return a; });");
15475   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
15476                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
15477                "});");
15478   verifyFormat("Constructor()\n"
15479                "    : Field([] { // comment\n"
15480                "        int i;\n"
15481                "      }) {}");
15482   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
15483                "  return some_parameter.size();\n"
15484                "};");
15485   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
15486                "    [](const string &s) { return s; };");
15487   verifyFormat("int i = aaaaaa ? 1 //\n"
15488                "               : [] {\n"
15489                "                   return 2; //\n"
15490                "                 }();");
15491   verifyFormat("llvm::errs() << \"number of twos is \"\n"
15492                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
15493                "                  return x == 2; // force break\n"
15494                "                });");
15495   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15496                "    [=](int iiiiiiiiiiii) {\n"
15497                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
15498                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
15499                "    });",
15500                getLLVMStyleWithColumns(60));
15501   verifyFormat("SomeFunction({[&] {\n"
15502                "                // comment\n"
15503                "              },\n"
15504                "              [&] {\n"
15505                "                // comment\n"
15506                "              }});");
15507   verifyFormat("SomeFunction({[&] {\n"
15508                "  // comment\n"
15509                "}});");
15510   verifyFormat(
15511       "virtual aaaaaaaaaaaaaaaa(\n"
15512       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
15513       "    aaaaa aaaaaaaaa);");
15514 
15515   // Lambdas with return types.
15516   verifyFormat("int c = []() -> int { return 2; }();\n");
15517   verifyFormat("int c = []() -> int * { return 2; }();\n");
15518   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
15519   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
15520   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
15521   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
15522   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
15523   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
15524   verifyFormat("[a, a]() -> a<1> {};");
15525   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
15526   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
15527   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
15528   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
15529   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
15530   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
15531   verifyFormat("[]() -> foo<!5> { return {}; };");
15532   verifyFormat("[]() -> foo<~5> { return {}; };");
15533   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
15534   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
15535   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
15536   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
15537   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
15538   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
15539   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
15540   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
15541   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
15542   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
15543   verifyFormat("namespace bar {\n"
15544                "// broken:\n"
15545                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
15546                "} // namespace bar");
15547   verifyFormat("namespace bar {\n"
15548                "// broken:\n"
15549                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
15550                "} // namespace bar");
15551   verifyFormat("namespace bar {\n"
15552                "// broken:\n"
15553                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
15554                "} // namespace bar");
15555   verifyFormat("namespace bar {\n"
15556                "// broken:\n"
15557                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
15558                "} // namespace bar");
15559   verifyFormat("namespace bar {\n"
15560                "// broken:\n"
15561                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
15562                "} // namespace bar");
15563   verifyFormat("namespace bar {\n"
15564                "// broken:\n"
15565                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
15566                "} // namespace bar");
15567   verifyFormat("namespace bar {\n"
15568                "// broken:\n"
15569                "auto foo{[]() -> foo<!5> { return {}; }};\n"
15570                "} // namespace bar");
15571   verifyFormat("namespace bar {\n"
15572                "// broken:\n"
15573                "auto foo{[]() -> foo<~5> { return {}; }};\n"
15574                "} // namespace bar");
15575   verifyFormat("namespace bar {\n"
15576                "// broken:\n"
15577                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
15578                "} // namespace bar");
15579   verifyFormat("namespace bar {\n"
15580                "// broken:\n"
15581                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
15582                "} // namespace bar");
15583   verifyFormat("namespace bar {\n"
15584                "// broken:\n"
15585                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
15586                "} // namespace bar");
15587   verifyFormat("namespace bar {\n"
15588                "// broken:\n"
15589                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
15590                "} // namespace bar");
15591   verifyFormat("namespace bar {\n"
15592                "// broken:\n"
15593                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
15594                "} // namespace bar");
15595   verifyFormat("namespace bar {\n"
15596                "// broken:\n"
15597                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
15598                "} // namespace bar");
15599   verifyFormat("namespace bar {\n"
15600                "// broken:\n"
15601                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
15602                "} // namespace bar");
15603   verifyFormat("namespace bar {\n"
15604                "// broken:\n"
15605                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
15606                "} // namespace bar");
15607   verifyFormat("namespace bar {\n"
15608                "// broken:\n"
15609                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
15610                "} // namespace bar");
15611   verifyFormat("namespace bar {\n"
15612                "// broken:\n"
15613                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
15614                "} // namespace bar");
15615   verifyFormat("[]() -> a<1> {};");
15616   verifyFormat("[]() -> a<1> { ; };");
15617   verifyFormat("[]() -> a<1> { ; }();");
15618   verifyFormat("[a, a]() -> a<true> {};");
15619   verifyFormat("[]() -> a<true> {};");
15620   verifyFormat("[]() -> a<true> { ; };");
15621   verifyFormat("[]() -> a<true> { ; }();");
15622   verifyFormat("[a, a]() -> a<false> {};");
15623   verifyFormat("[]() -> a<false> {};");
15624   verifyFormat("[]() -> a<false> { ; };");
15625   verifyFormat("[]() -> a<false> { ; }();");
15626   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
15627   verifyFormat("namespace bar {\n"
15628                "auto foo{[]() -> foo<false> { ; }};\n"
15629                "} // namespace bar");
15630   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
15631                "                   int j) -> int {\n"
15632                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
15633                "};");
15634   verifyFormat(
15635       "aaaaaaaaaaaaaaaaaaaaaa(\n"
15636       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
15637       "      return aaaaaaaaaaaaaaaaa;\n"
15638       "    });",
15639       getLLVMStyleWithColumns(70));
15640   verifyFormat("[]() //\n"
15641                "    -> int {\n"
15642                "  return 1; //\n"
15643                "};");
15644   verifyFormat("[]() -> Void<T...> {};");
15645   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
15646 
15647   // Lambdas with explicit template argument lists.
15648   verifyFormat(
15649       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
15650 
15651   // Multiple lambdas in the same parentheses change indentation rules. These
15652   // lambdas are forced to start on new lines.
15653   verifyFormat("SomeFunction(\n"
15654                "    []() {\n"
15655                "      //\n"
15656                "    },\n"
15657                "    []() {\n"
15658                "      //\n"
15659                "    });");
15660 
15661   // A lambda passed as arg0 is always pushed to the next line.
15662   verifyFormat("SomeFunction(\n"
15663                "    [this] {\n"
15664                "      //\n"
15665                "    },\n"
15666                "    1);\n");
15667 
15668   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
15669   // the arg0 case above.
15670   auto Style = getGoogleStyle();
15671   Style.BinPackArguments = false;
15672   verifyFormat("SomeFunction(\n"
15673                "    a,\n"
15674                "    [this] {\n"
15675                "      //\n"
15676                "    },\n"
15677                "    b);\n",
15678                Style);
15679   verifyFormat("SomeFunction(\n"
15680                "    a,\n"
15681                "    [this] {\n"
15682                "      //\n"
15683                "    },\n"
15684                "    b);\n");
15685 
15686   // A lambda with a very long line forces arg0 to be pushed out irrespective of
15687   // the BinPackArguments value (as long as the code is wide enough).
15688   verifyFormat(
15689       "something->SomeFunction(\n"
15690       "    a,\n"
15691       "    [this] {\n"
15692       "      "
15693       "D0000000000000000000000000000000000000000000000000000000000001();\n"
15694       "    },\n"
15695       "    b);\n");
15696 
15697   // A multi-line lambda is pulled up as long as the introducer fits on the
15698   // previous line and there are no further args.
15699   verifyFormat("function(1, [this, that] {\n"
15700                "  //\n"
15701                "});\n");
15702   verifyFormat("function([this, that] {\n"
15703                "  //\n"
15704                "});\n");
15705   // FIXME: this format is not ideal and we should consider forcing the first
15706   // arg onto its own line.
15707   verifyFormat("function(a, b, c, //\n"
15708                "         d, [this, that] {\n"
15709                "           //\n"
15710                "         });\n");
15711 
15712   // Multiple lambdas are treated correctly even when there is a short arg0.
15713   verifyFormat("SomeFunction(\n"
15714                "    1,\n"
15715                "    [this] {\n"
15716                "      //\n"
15717                "    },\n"
15718                "    [this] {\n"
15719                "      //\n"
15720                "    },\n"
15721                "    1);\n");
15722 
15723   // More complex introducers.
15724   verifyFormat("return [i, args...] {};");
15725 
15726   // Not lambdas.
15727   verifyFormat("constexpr char hello[]{\"hello\"};");
15728   verifyFormat("double &operator[](int i) { return 0; }\n"
15729                "int i;");
15730   verifyFormat("std::unique_ptr<int[]> foo() {}");
15731   verifyFormat("int i = a[a][a]->f();");
15732   verifyFormat("int i = (*b)[a]->f();");
15733 
15734   // Other corner cases.
15735   verifyFormat("void f() {\n"
15736                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
15737                "  );\n"
15738                "}");
15739 
15740   // Lambdas created through weird macros.
15741   verifyFormat("void f() {\n"
15742                "  MACRO((const AA &a) { return 1; });\n"
15743                "  MACRO((AA &a) { return 1; });\n"
15744                "}");
15745 
15746   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
15747                "      doo_dah();\n"
15748                "      doo_dah();\n"
15749                "    })) {\n"
15750                "}");
15751   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
15752                "                doo_dah();\n"
15753                "                doo_dah();\n"
15754                "              })) {\n"
15755                "}");
15756   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
15757                "                doo_dah();\n"
15758                "                doo_dah();\n"
15759                "              })) {\n"
15760                "}");
15761   verifyFormat("auto lambda = []() {\n"
15762                "  int a = 2\n"
15763                "#if A\n"
15764                "          + 2\n"
15765                "#endif\n"
15766                "      ;\n"
15767                "};");
15768 
15769   // Lambdas with complex multiline introducers.
15770   verifyFormat(
15771       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
15772       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
15773       "        -> ::std::unordered_set<\n"
15774       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
15775       "      //\n"
15776       "    });");
15777 
15778   FormatStyle DoNotMerge = getLLVMStyle();
15779   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
15780   verifyFormat("auto c = []() {\n"
15781                "  return b;\n"
15782                "};",
15783                "auto c = []() { return b; };", DoNotMerge);
15784   verifyFormat("auto c = []() {\n"
15785                "};",
15786                " auto c = []() {};", DoNotMerge);
15787 
15788   FormatStyle MergeEmptyOnly = getLLVMStyle();
15789   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
15790   verifyFormat("auto c = []() {\n"
15791                "  return b;\n"
15792                "};",
15793                "auto c = []() {\n"
15794                "  return b;\n"
15795                " };",
15796                MergeEmptyOnly);
15797   verifyFormat("auto c = []() {};",
15798                "auto c = []() {\n"
15799                "};",
15800                MergeEmptyOnly);
15801 
15802   FormatStyle MergeInline = getLLVMStyle();
15803   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
15804   verifyFormat("auto c = []() {\n"
15805                "  return b;\n"
15806                "};",
15807                "auto c = []() { return b; };", MergeInline);
15808   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
15809                MergeInline);
15810   verifyFormat("function([]() { return b; }, a)",
15811                "function([]() { return b; }, a)", MergeInline);
15812   verifyFormat("function(a, []() { return b; })",
15813                "function(a, []() { return b; })", MergeInline);
15814 
15815   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
15816   // AllowShortLambdasOnASingleLine
15817   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
15818   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
15819   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
15820   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15821       FormatStyle::ShortLambdaStyle::SLS_None;
15822   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
15823                "    []()\n"
15824                "    {\n"
15825                "      return 17;\n"
15826                "    });",
15827                LLVMWithBeforeLambdaBody);
15828   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
15829                "    []()\n"
15830                "    {\n"
15831                "    });",
15832                LLVMWithBeforeLambdaBody);
15833   verifyFormat("auto fct_SLS_None = []()\n"
15834                "{\n"
15835                "  return 17;\n"
15836                "};",
15837                LLVMWithBeforeLambdaBody);
15838   verifyFormat("TwoNestedLambdas_SLS_None(\n"
15839                "    []()\n"
15840                "    {\n"
15841                "      return Call(\n"
15842                "          []()\n"
15843                "          {\n"
15844                "            return 17;\n"
15845                "          });\n"
15846                "    });",
15847                LLVMWithBeforeLambdaBody);
15848   verifyFormat("void Fct()\n"
15849                "{\n"
15850                "  return {[]()\n"
15851                "          {\n"
15852                "            return 17;\n"
15853                "          }};\n"
15854                "}",
15855                LLVMWithBeforeLambdaBody);
15856 
15857   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15858       FormatStyle::ShortLambdaStyle::SLS_Empty;
15859   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
15860                "    []()\n"
15861                "    {\n"
15862                "      return 17;\n"
15863                "    });",
15864                LLVMWithBeforeLambdaBody);
15865   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
15866                LLVMWithBeforeLambdaBody);
15867   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
15868                "ongFunctionName_SLS_Empty(\n"
15869                "    []() {});",
15870                LLVMWithBeforeLambdaBody);
15871   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
15872                "                                []()\n"
15873                "                                {\n"
15874                "                                  return 17;\n"
15875                "                                });",
15876                LLVMWithBeforeLambdaBody);
15877   verifyFormat("auto fct_SLS_Empty = []()\n"
15878                "{\n"
15879                "  return 17;\n"
15880                "};",
15881                LLVMWithBeforeLambdaBody);
15882   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
15883                "    []()\n"
15884                "    {\n"
15885                "      return Call([]() {});\n"
15886                "    });",
15887                LLVMWithBeforeLambdaBody);
15888   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
15889                "                           []()\n"
15890                "                           {\n"
15891                "                             return Call([]() {});\n"
15892                "                           });",
15893                LLVMWithBeforeLambdaBody);
15894   verifyFormat(
15895       "FctWithLongLineInLambda_SLS_Empty(\n"
15896       "    []()\n"
15897       "    {\n"
15898       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15899       "                               AndShouldNotBeConsiderAsInline,\n"
15900       "                               LambdaBodyMustBeBreak);\n"
15901       "    });",
15902       LLVMWithBeforeLambdaBody);
15903 
15904   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15905       FormatStyle::ShortLambdaStyle::SLS_Inline;
15906   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
15907                LLVMWithBeforeLambdaBody);
15908   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
15909                LLVMWithBeforeLambdaBody);
15910   verifyFormat("auto fct_SLS_Inline = []()\n"
15911                "{\n"
15912                "  return 17;\n"
15913                "};",
15914                LLVMWithBeforeLambdaBody);
15915   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
15916                "17; }); });",
15917                LLVMWithBeforeLambdaBody);
15918   verifyFormat(
15919       "FctWithLongLineInLambda_SLS_Inline(\n"
15920       "    []()\n"
15921       "    {\n"
15922       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15923       "                               AndShouldNotBeConsiderAsInline,\n"
15924       "                               LambdaBodyMustBeBreak);\n"
15925       "    });",
15926       LLVMWithBeforeLambdaBody);
15927   verifyFormat("FctWithMultipleParams_SLS_Inline("
15928                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15929                "                                 []() { return 17; });",
15930                LLVMWithBeforeLambdaBody);
15931   verifyFormat(
15932       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
15933       LLVMWithBeforeLambdaBody);
15934 
15935   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
15936       FormatStyle::ShortLambdaStyle::SLS_All;
15937   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
15938                LLVMWithBeforeLambdaBody);
15939   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
15940                LLVMWithBeforeLambdaBody);
15941   verifyFormat("auto fct_SLS_All = []() { return 17; };",
15942                LLVMWithBeforeLambdaBody);
15943   verifyFormat("FctWithOneParam_SLS_All(\n"
15944                "    []()\n"
15945                "    {\n"
15946                "      // A cool function...\n"
15947                "      return 43;\n"
15948                "    });",
15949                LLVMWithBeforeLambdaBody);
15950   verifyFormat("FctWithMultipleParams_SLS_All("
15951                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
15952                "                              []() { return 17; });",
15953                LLVMWithBeforeLambdaBody);
15954   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
15955                LLVMWithBeforeLambdaBody);
15956   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
15957                LLVMWithBeforeLambdaBody);
15958   verifyFormat(
15959       "FctWithLongLineInLambda_SLS_All(\n"
15960       "    []()\n"
15961       "    {\n"
15962       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15963       "                               AndShouldNotBeConsiderAsInline,\n"
15964       "                               LambdaBodyMustBeBreak);\n"
15965       "    });",
15966       LLVMWithBeforeLambdaBody);
15967   verifyFormat(
15968       "auto fct_SLS_All = []()\n"
15969       "{\n"
15970       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
15971       "                           AndShouldNotBeConsiderAsInline,\n"
15972       "                           LambdaBodyMustBeBreak);\n"
15973       "};",
15974       LLVMWithBeforeLambdaBody);
15975   LLVMWithBeforeLambdaBody.BinPackParameters = false;
15976   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
15977                LLVMWithBeforeLambdaBody);
15978   verifyFormat(
15979       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
15980       "                                FirstParam,\n"
15981       "                                SecondParam,\n"
15982       "                                ThirdParam,\n"
15983       "                                FourthParam);",
15984       LLVMWithBeforeLambdaBody);
15985   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
15986                "    []() { return "
15987                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
15988                "    FirstParam,\n"
15989                "    SecondParam,\n"
15990                "    ThirdParam,\n"
15991                "    FourthParam);",
15992                LLVMWithBeforeLambdaBody);
15993   verifyFormat(
15994       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
15995       "                                SecondParam,\n"
15996       "                                ThirdParam,\n"
15997       "                                FourthParam,\n"
15998       "                                []() { return SomeValueNotSoLong; });",
15999       LLVMWithBeforeLambdaBody);
16000   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
16001                "    []()\n"
16002                "    {\n"
16003                "      return "
16004                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
16005                "eConsiderAsInline;\n"
16006                "    });",
16007                LLVMWithBeforeLambdaBody);
16008   verifyFormat(
16009       "FctWithLongLineInLambda_SLS_All(\n"
16010       "    []()\n"
16011       "    {\n"
16012       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
16013       "                               AndShouldNotBeConsiderAsInline,\n"
16014       "                               LambdaBodyMustBeBreak);\n"
16015       "    });",
16016       LLVMWithBeforeLambdaBody);
16017   verifyFormat("FctWithTwoParams_SLS_All(\n"
16018                "    []()\n"
16019                "    {\n"
16020                "      // A cool function...\n"
16021                "      return 43;\n"
16022                "    },\n"
16023                "    87);",
16024                LLVMWithBeforeLambdaBody);
16025   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
16026                LLVMWithBeforeLambdaBody);
16027   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
16028                LLVMWithBeforeLambdaBody);
16029   verifyFormat(
16030       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
16031       LLVMWithBeforeLambdaBody);
16032   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
16033                "}); }, x);",
16034                LLVMWithBeforeLambdaBody);
16035   verifyFormat("TwoNestedLambdas_SLS_All(\n"
16036                "    []()\n"
16037                "    {\n"
16038                "      // A cool function...\n"
16039                "      return Call([]() { return 17; });\n"
16040                "    });",
16041                LLVMWithBeforeLambdaBody);
16042   verifyFormat("TwoNestedLambdas_SLS_All(\n"
16043                "    []()\n"
16044                "    {\n"
16045                "      return Call(\n"
16046                "          []()\n"
16047                "          {\n"
16048                "            // A cool function...\n"
16049                "            return 17;\n"
16050                "          });\n"
16051                "    });",
16052                LLVMWithBeforeLambdaBody);
16053 }
16054 
16055 TEST_F(FormatTest, LambdaWithLineComments) {
16056   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
16057   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
16058   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
16059   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
16060       FormatStyle::ShortLambdaStyle::SLS_All;
16061 
16062   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
16063   verifyFormat("auto k = []() // comment\n"
16064                "{ return; }",
16065                LLVMWithBeforeLambdaBody);
16066   verifyFormat("auto k = []() /* comment */ { return; }",
16067                LLVMWithBeforeLambdaBody);
16068   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
16069                LLVMWithBeforeLambdaBody);
16070   verifyFormat("auto k = []() // X\n"
16071                "{ return; }",
16072                LLVMWithBeforeLambdaBody);
16073   verifyFormat(
16074       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
16075       "{ return; }",
16076       LLVMWithBeforeLambdaBody);
16077 }
16078 
16079 TEST_F(FormatTest, EmptyLinesInLambdas) {
16080   verifyFormat("auto lambda = []() {\n"
16081                "  x(); //\n"
16082                "};",
16083                "auto lambda = []() {\n"
16084                "\n"
16085                "  x(); //\n"
16086                "\n"
16087                "};");
16088 }
16089 
16090 TEST_F(FormatTest, FormatsBlocks) {
16091   FormatStyle ShortBlocks = getLLVMStyle();
16092   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
16093   verifyFormat("int (^Block)(int, int);", ShortBlocks);
16094   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
16095   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
16096   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
16097   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
16098   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
16099 
16100   verifyFormat("foo(^{ bar(); });", ShortBlocks);
16101   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
16102   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
16103 
16104   verifyFormat("[operation setCompletionBlock:^{\n"
16105                "  [self onOperationDone];\n"
16106                "}];");
16107   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
16108                "  [self onOperationDone];\n"
16109                "}]};");
16110   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
16111                "  f();\n"
16112                "}];");
16113   verifyFormat("int a = [operation block:^int(int *i) {\n"
16114                "  return 1;\n"
16115                "}];");
16116   verifyFormat("[myObject doSomethingWith:arg1\n"
16117                "                      aaa:^int(int *a) {\n"
16118                "                        return 1;\n"
16119                "                      }\n"
16120                "                      bbb:f(a * bbbbbbbb)];");
16121 
16122   verifyFormat("[operation setCompletionBlock:^{\n"
16123                "  [self.delegate newDataAvailable];\n"
16124                "}];",
16125                getLLVMStyleWithColumns(60));
16126   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
16127                "  NSString *path = [self sessionFilePath];\n"
16128                "  if (path) {\n"
16129                "    // ...\n"
16130                "  }\n"
16131                "});");
16132   verifyFormat("[[SessionService sharedService]\n"
16133                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
16134                "      if (window) {\n"
16135                "        [self windowDidLoad:window];\n"
16136                "      } else {\n"
16137                "        [self errorLoadingWindow];\n"
16138                "      }\n"
16139                "    }];");
16140   verifyFormat("void (^largeBlock)(void) = ^{\n"
16141                "  // ...\n"
16142                "};\n",
16143                getLLVMStyleWithColumns(40));
16144   verifyFormat("[[SessionService sharedService]\n"
16145                "    loadWindowWithCompletionBlock: //\n"
16146                "        ^(SessionWindow *window) {\n"
16147                "          if (window) {\n"
16148                "            [self windowDidLoad:window];\n"
16149                "          } else {\n"
16150                "            [self errorLoadingWindow];\n"
16151                "          }\n"
16152                "        }];",
16153                getLLVMStyleWithColumns(60));
16154   verifyFormat("[myObject doSomethingWith:arg1\n"
16155                "    firstBlock:^(Foo *a) {\n"
16156                "      // ...\n"
16157                "      int i;\n"
16158                "    }\n"
16159                "    secondBlock:^(Bar *b) {\n"
16160                "      // ...\n"
16161                "      int i;\n"
16162                "    }\n"
16163                "    thirdBlock:^Foo(Bar *b) {\n"
16164                "      // ...\n"
16165                "      int i;\n"
16166                "    }];");
16167   verifyFormat("[myObject doSomethingWith:arg1\n"
16168                "               firstBlock:-1\n"
16169                "              secondBlock:^(Bar *b) {\n"
16170                "                // ...\n"
16171                "                int i;\n"
16172                "              }];");
16173 
16174   verifyFormat("f(^{\n"
16175                "  @autoreleasepool {\n"
16176                "    if (a) {\n"
16177                "      g();\n"
16178                "    }\n"
16179                "  }\n"
16180                "});");
16181   verifyFormat("Block b = ^int *(A *a, B *b) {}");
16182   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
16183                "};");
16184 
16185   FormatStyle FourIndent = getLLVMStyle();
16186   FourIndent.ObjCBlockIndentWidth = 4;
16187   verifyFormat("[operation setCompletionBlock:^{\n"
16188                "    [self onOperationDone];\n"
16189                "}];",
16190                FourIndent);
16191 }
16192 
16193 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
16194   FormatStyle ZeroColumn = getLLVMStyle();
16195   ZeroColumn.ColumnLimit = 0;
16196 
16197   verifyFormat("[[SessionService sharedService] "
16198                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
16199                "  if (window) {\n"
16200                "    [self windowDidLoad:window];\n"
16201                "  } else {\n"
16202                "    [self errorLoadingWindow];\n"
16203                "  }\n"
16204                "}];",
16205                ZeroColumn);
16206   EXPECT_EQ("[[SessionService sharedService]\n"
16207             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
16208             "      if (window) {\n"
16209             "        [self windowDidLoad:window];\n"
16210             "      } else {\n"
16211             "        [self errorLoadingWindow];\n"
16212             "      }\n"
16213             "    }];",
16214             format("[[SessionService sharedService]\n"
16215                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
16216                    "                if (window) {\n"
16217                    "    [self windowDidLoad:window];\n"
16218                    "  } else {\n"
16219                    "    [self errorLoadingWindow];\n"
16220                    "  }\n"
16221                    "}];",
16222                    ZeroColumn));
16223   verifyFormat("[myObject doSomethingWith:arg1\n"
16224                "    firstBlock:^(Foo *a) {\n"
16225                "      // ...\n"
16226                "      int i;\n"
16227                "    }\n"
16228                "    secondBlock:^(Bar *b) {\n"
16229                "      // ...\n"
16230                "      int i;\n"
16231                "    }\n"
16232                "    thirdBlock:^Foo(Bar *b) {\n"
16233                "      // ...\n"
16234                "      int i;\n"
16235                "    }];",
16236                ZeroColumn);
16237   verifyFormat("f(^{\n"
16238                "  @autoreleasepool {\n"
16239                "    if (a) {\n"
16240                "      g();\n"
16241                "    }\n"
16242                "  }\n"
16243                "});",
16244                ZeroColumn);
16245   verifyFormat("void (^largeBlock)(void) = ^{\n"
16246                "  // ...\n"
16247                "};",
16248                ZeroColumn);
16249 
16250   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
16251   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
16252             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
16253   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
16254   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
16255             "  int i;\n"
16256             "};",
16257             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
16258 }
16259 
16260 TEST_F(FormatTest, SupportsCRLF) {
16261   EXPECT_EQ("int a;\r\n"
16262             "int b;\r\n"
16263             "int c;\r\n",
16264             format("int a;\r\n"
16265                    "  int b;\r\n"
16266                    "    int c;\r\n",
16267                    getLLVMStyle()));
16268   EXPECT_EQ("int a;\r\n"
16269             "int b;\r\n"
16270             "int c;\r\n",
16271             format("int a;\r\n"
16272                    "  int b;\n"
16273                    "    int c;\r\n",
16274                    getLLVMStyle()));
16275   EXPECT_EQ("int a;\n"
16276             "int b;\n"
16277             "int c;\n",
16278             format("int a;\r\n"
16279                    "  int b;\n"
16280                    "    int c;\n",
16281                    getLLVMStyle()));
16282   EXPECT_EQ("\"aaaaaaa \"\r\n"
16283             "\"bbbbbbb\";\r\n",
16284             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
16285   EXPECT_EQ("#define A \\\r\n"
16286             "  b;      \\\r\n"
16287             "  c;      \\\r\n"
16288             "  d;\r\n",
16289             format("#define A \\\r\n"
16290                    "  b; \\\r\n"
16291                    "  c; d; \r\n",
16292                    getGoogleStyle()));
16293 
16294   EXPECT_EQ("/*\r\n"
16295             "multi line block comments\r\n"
16296             "should not introduce\r\n"
16297             "an extra carriage return\r\n"
16298             "*/\r\n",
16299             format("/*\r\n"
16300                    "multi line block comments\r\n"
16301                    "should not introduce\r\n"
16302                    "an extra carriage return\r\n"
16303                    "*/\r\n"));
16304   EXPECT_EQ("/*\r\n"
16305             "\r\n"
16306             "*/",
16307             format("/*\r\n"
16308                    "    \r\r\r\n"
16309                    "*/"));
16310 
16311   FormatStyle style = getLLVMStyle();
16312 
16313   style.DeriveLineEnding = true;
16314   style.UseCRLF = false;
16315   EXPECT_EQ("union FooBarBazQux {\n"
16316             "  int foo;\n"
16317             "  int bar;\n"
16318             "  int baz;\n"
16319             "};",
16320             format("union FooBarBazQux {\r\n"
16321                    "  int foo;\n"
16322                    "  int bar;\r\n"
16323                    "  int baz;\n"
16324                    "};",
16325                    style));
16326   style.UseCRLF = true;
16327   EXPECT_EQ("union FooBarBazQux {\r\n"
16328             "  int foo;\r\n"
16329             "  int bar;\r\n"
16330             "  int baz;\r\n"
16331             "};",
16332             format("union FooBarBazQux {\r\n"
16333                    "  int foo;\n"
16334                    "  int bar;\r\n"
16335                    "  int baz;\n"
16336                    "};",
16337                    style));
16338 
16339   style.DeriveLineEnding = false;
16340   style.UseCRLF = false;
16341   EXPECT_EQ("union FooBarBazQux {\n"
16342             "  int foo;\n"
16343             "  int bar;\n"
16344             "  int baz;\n"
16345             "  int qux;\n"
16346             "};",
16347             format("union FooBarBazQux {\r\n"
16348                    "  int foo;\n"
16349                    "  int bar;\r\n"
16350                    "  int baz;\n"
16351                    "  int qux;\r\n"
16352                    "};",
16353                    style));
16354   style.UseCRLF = true;
16355   EXPECT_EQ("union FooBarBazQux {\r\n"
16356             "  int foo;\r\n"
16357             "  int bar;\r\n"
16358             "  int baz;\r\n"
16359             "  int qux;\r\n"
16360             "};",
16361             format("union FooBarBazQux {\r\n"
16362                    "  int foo;\n"
16363                    "  int bar;\r\n"
16364                    "  int baz;\n"
16365                    "  int qux;\n"
16366                    "};",
16367                    style));
16368 
16369   style.DeriveLineEnding = true;
16370   style.UseCRLF = false;
16371   EXPECT_EQ("union FooBarBazQux {\r\n"
16372             "  int foo;\r\n"
16373             "  int bar;\r\n"
16374             "  int baz;\r\n"
16375             "  int qux;\r\n"
16376             "};",
16377             format("union FooBarBazQux {\r\n"
16378                    "  int foo;\n"
16379                    "  int bar;\r\n"
16380                    "  int baz;\n"
16381                    "  int qux;\r\n"
16382                    "};",
16383                    style));
16384   style.UseCRLF = true;
16385   EXPECT_EQ("union FooBarBazQux {\n"
16386             "  int foo;\n"
16387             "  int bar;\n"
16388             "  int baz;\n"
16389             "  int qux;\n"
16390             "};",
16391             format("union FooBarBazQux {\r\n"
16392                    "  int foo;\n"
16393                    "  int bar;\r\n"
16394                    "  int baz;\n"
16395                    "  int qux;\n"
16396                    "};",
16397                    style));
16398 }
16399 
16400 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
16401   verifyFormat("MY_CLASS(C) {\n"
16402                "  int i;\n"
16403                "  int j;\n"
16404                "};");
16405 }
16406 
16407 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
16408   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
16409   TwoIndent.ContinuationIndentWidth = 2;
16410 
16411   EXPECT_EQ("int i =\n"
16412             "  longFunction(\n"
16413             "    arg);",
16414             format("int i = longFunction(arg);", TwoIndent));
16415 
16416   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
16417   SixIndent.ContinuationIndentWidth = 6;
16418 
16419   EXPECT_EQ("int i =\n"
16420             "      longFunction(\n"
16421             "            arg);",
16422             format("int i = longFunction(arg);", SixIndent));
16423 }
16424 
16425 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
16426   FormatStyle Style = getLLVMStyle();
16427   verifyFormat("int Foo::getter(\n"
16428                "    //\n"
16429                ") const {\n"
16430                "  return foo;\n"
16431                "}",
16432                Style);
16433   verifyFormat("void Foo::setter(\n"
16434                "    //\n"
16435                ") {\n"
16436                "  foo = 1;\n"
16437                "}",
16438                Style);
16439 }
16440 
16441 TEST_F(FormatTest, SpacesInAngles) {
16442   FormatStyle Spaces = getLLVMStyle();
16443   Spaces.SpacesInAngles = true;
16444 
16445   verifyFormat("static_cast< int >(arg);", Spaces);
16446   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
16447   verifyFormat("f< int, float >();", Spaces);
16448   verifyFormat("template <> g() {}", Spaces);
16449   verifyFormat("template < std::vector< int > > f() {}", Spaces);
16450   verifyFormat("std::function< void(int, int) > fct;", Spaces);
16451   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
16452                Spaces);
16453 
16454   Spaces.Standard = FormatStyle::LS_Cpp03;
16455   Spaces.SpacesInAngles = true;
16456   verifyFormat("A< A< int > >();", Spaces);
16457 
16458   Spaces.SpacesInAngles = false;
16459   verifyFormat("A<A<int> >();", Spaces);
16460 
16461   Spaces.Standard = FormatStyle::LS_Cpp11;
16462   Spaces.SpacesInAngles = true;
16463   verifyFormat("A< A< int > >();", Spaces);
16464 
16465   Spaces.SpacesInAngles = false;
16466   verifyFormat("A<A<int>>();", Spaces);
16467 }
16468 
16469 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
16470   FormatStyle Style = getLLVMStyle();
16471   Style.SpaceAfterTemplateKeyword = false;
16472   verifyFormat("template<int> void foo();", Style);
16473 }
16474 
16475 TEST_F(FormatTest, TripleAngleBrackets) {
16476   verifyFormat("f<<<1, 1>>>();");
16477   verifyFormat("f<<<1, 1, 1, s>>>();");
16478   verifyFormat("f<<<a, b, c, d>>>();");
16479   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
16480   verifyFormat("f<param><<<1, 1>>>();");
16481   verifyFormat("f<1><<<1, 1>>>();");
16482   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
16483   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16484                "aaaaaaaaaaa<<<\n    1, 1>>>();");
16485   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
16486                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
16487 }
16488 
16489 TEST_F(FormatTest, MergeLessLessAtEnd) {
16490   verifyFormat("<<");
16491   EXPECT_EQ("< < <", format("\\\n<<<"));
16492   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16493                "aaallvm::outs() <<");
16494   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
16495                "aaaallvm::outs()\n    <<");
16496 }
16497 
16498 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
16499   std::string code = "#if A\n"
16500                      "#if B\n"
16501                      "a.\n"
16502                      "#endif\n"
16503                      "    a = 1;\n"
16504                      "#else\n"
16505                      "#endif\n"
16506                      "#if C\n"
16507                      "#else\n"
16508                      "#endif\n";
16509   EXPECT_EQ(code, format(code));
16510 }
16511 
16512 TEST_F(FormatTest, HandleConflictMarkers) {
16513   // Git/SVN conflict markers.
16514   EXPECT_EQ("int a;\n"
16515             "void f() {\n"
16516             "  callme(some(parameter1,\n"
16517             "<<<<<<< text by the vcs\n"
16518             "              parameter2),\n"
16519             "||||||| text by the vcs\n"
16520             "              parameter2),\n"
16521             "         parameter3,\n"
16522             "======= text by the vcs\n"
16523             "              parameter2, parameter3),\n"
16524             ">>>>>>> text by the vcs\n"
16525             "         otherparameter);\n",
16526             format("int a;\n"
16527                    "void f() {\n"
16528                    "  callme(some(parameter1,\n"
16529                    "<<<<<<< text by the vcs\n"
16530                    "  parameter2),\n"
16531                    "||||||| text by the vcs\n"
16532                    "  parameter2),\n"
16533                    "  parameter3,\n"
16534                    "======= text by the vcs\n"
16535                    "  parameter2,\n"
16536                    "  parameter3),\n"
16537                    ">>>>>>> text by the vcs\n"
16538                    "  otherparameter);\n"));
16539 
16540   // Perforce markers.
16541   EXPECT_EQ("void f() {\n"
16542             "  function(\n"
16543             ">>>> text by the vcs\n"
16544             "      parameter,\n"
16545             "==== text by the vcs\n"
16546             "      parameter,\n"
16547             "==== text by the vcs\n"
16548             "      parameter,\n"
16549             "<<<< text by the vcs\n"
16550             "      parameter);\n",
16551             format("void f() {\n"
16552                    "  function(\n"
16553                    ">>>> text by the vcs\n"
16554                    "  parameter,\n"
16555                    "==== text by the vcs\n"
16556                    "  parameter,\n"
16557                    "==== text by the vcs\n"
16558                    "  parameter,\n"
16559                    "<<<< text by the vcs\n"
16560                    "  parameter);\n"));
16561 
16562   EXPECT_EQ("<<<<<<<\n"
16563             "|||||||\n"
16564             "=======\n"
16565             ">>>>>>>",
16566             format("<<<<<<<\n"
16567                    "|||||||\n"
16568                    "=======\n"
16569                    ">>>>>>>"));
16570 
16571   EXPECT_EQ("<<<<<<<\n"
16572             "|||||||\n"
16573             "int i;\n"
16574             "=======\n"
16575             ">>>>>>>",
16576             format("<<<<<<<\n"
16577                    "|||||||\n"
16578                    "int i;\n"
16579                    "=======\n"
16580                    ">>>>>>>"));
16581 
16582   // FIXME: Handle parsing of macros around conflict markers correctly:
16583   EXPECT_EQ("#define Macro \\\n"
16584             "<<<<<<<\n"
16585             "Something \\\n"
16586             "|||||||\n"
16587             "Else \\\n"
16588             "=======\n"
16589             "Other \\\n"
16590             ">>>>>>>\n"
16591             "    End int i;\n",
16592             format("#define Macro \\\n"
16593                    "<<<<<<<\n"
16594                    "  Something \\\n"
16595                    "|||||||\n"
16596                    "  Else \\\n"
16597                    "=======\n"
16598                    "  Other \\\n"
16599                    ">>>>>>>\n"
16600                    "  End\n"
16601                    "int i;\n"));
16602 }
16603 
16604 TEST_F(FormatTest, DisableRegions) {
16605   EXPECT_EQ("int i;\n"
16606             "// clang-format off\n"
16607             "  int j;\n"
16608             "// clang-format on\n"
16609             "int k;",
16610             format(" int  i;\n"
16611                    "   // clang-format off\n"
16612                    "  int j;\n"
16613                    " // clang-format on\n"
16614                    "   int   k;"));
16615   EXPECT_EQ("int i;\n"
16616             "/* clang-format off */\n"
16617             "  int j;\n"
16618             "/* clang-format on */\n"
16619             "int k;",
16620             format(" int  i;\n"
16621                    "   /* clang-format off */\n"
16622                    "  int j;\n"
16623                    " /* clang-format on */\n"
16624                    "   int   k;"));
16625 
16626   // Don't reflow comments within disabled regions.
16627   EXPECT_EQ("// clang-format off\n"
16628             "// long long long long long long line\n"
16629             "/* clang-format on */\n"
16630             "/* long long long\n"
16631             " * long long long\n"
16632             " * line */\n"
16633             "int i;\n"
16634             "/* clang-format off */\n"
16635             "/* long long long long long long line */\n",
16636             format("// clang-format off\n"
16637                    "// long long long long long long line\n"
16638                    "/* clang-format on */\n"
16639                    "/* long long long long long long line */\n"
16640                    "int i;\n"
16641                    "/* clang-format off */\n"
16642                    "/* long long long long long long line */\n",
16643                    getLLVMStyleWithColumns(20)));
16644 }
16645 
16646 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
16647   format("? ) =");
16648   verifyNoCrash("#define a\\\n /**/}");
16649 }
16650 
16651 TEST_F(FormatTest, FormatsTableGenCode) {
16652   FormatStyle Style = getLLVMStyle();
16653   Style.Language = FormatStyle::LK_TableGen;
16654   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
16655 }
16656 
16657 TEST_F(FormatTest, ArrayOfTemplates) {
16658   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
16659             format("auto a = new unique_ptr<int > [ 10];"));
16660 
16661   FormatStyle Spaces = getLLVMStyle();
16662   Spaces.SpacesInSquareBrackets = true;
16663   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
16664             format("auto a = new unique_ptr<int > [10];", Spaces));
16665 }
16666 
16667 TEST_F(FormatTest, ArrayAsTemplateType) {
16668   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
16669             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
16670 
16671   FormatStyle Spaces = getLLVMStyle();
16672   Spaces.SpacesInSquareBrackets = true;
16673   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
16674             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
16675 }
16676 
16677 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
16678 
16679 TEST(FormatStyle, GetStyleWithEmptyFileName) {
16680   llvm::vfs::InMemoryFileSystem FS;
16681   auto Style1 = getStyle("file", "", "Google", "", &FS);
16682   ASSERT_TRUE((bool)Style1);
16683   ASSERT_EQ(*Style1, getGoogleStyle());
16684 }
16685 
16686 TEST(FormatStyle, GetStyleOfFile) {
16687   llvm::vfs::InMemoryFileSystem FS;
16688   // Test 1: format file in the same directory.
16689   ASSERT_TRUE(
16690       FS.addFile("/a/.clang-format", 0,
16691                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
16692   ASSERT_TRUE(
16693       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16694   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
16695   ASSERT_TRUE((bool)Style1);
16696   ASSERT_EQ(*Style1, getLLVMStyle());
16697 
16698   // Test 2.1: fallback to default.
16699   ASSERT_TRUE(
16700       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16701   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
16702   ASSERT_TRUE((bool)Style2);
16703   ASSERT_EQ(*Style2, getMozillaStyle());
16704 
16705   // Test 2.2: no format on 'none' fallback style.
16706   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16707   ASSERT_TRUE((bool)Style2);
16708   ASSERT_EQ(*Style2, getNoStyle());
16709 
16710   // Test 2.3: format if config is found with no based style while fallback is
16711   // 'none'.
16712   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
16713                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
16714   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
16715   ASSERT_TRUE((bool)Style2);
16716   ASSERT_EQ(*Style2, getLLVMStyle());
16717 
16718   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
16719   Style2 = getStyle("{}", "a.h", "none", "", &FS);
16720   ASSERT_TRUE((bool)Style2);
16721   ASSERT_EQ(*Style2, getLLVMStyle());
16722 
16723   // Test 3: format file in parent directory.
16724   ASSERT_TRUE(
16725       FS.addFile("/c/.clang-format", 0,
16726                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
16727   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
16728                          llvm::MemoryBuffer::getMemBuffer("int i;")));
16729   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
16730   ASSERT_TRUE((bool)Style3);
16731   ASSERT_EQ(*Style3, getGoogleStyle());
16732 
16733   // Test 4: error on invalid fallback style
16734   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
16735   ASSERT_FALSE((bool)Style4);
16736   llvm::consumeError(Style4.takeError());
16737 
16738   // Test 5: error on invalid yaml on command line
16739   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
16740   ASSERT_FALSE((bool)Style5);
16741   llvm::consumeError(Style5.takeError());
16742 
16743   // Test 6: error on invalid style
16744   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
16745   ASSERT_FALSE((bool)Style6);
16746   llvm::consumeError(Style6.takeError());
16747 
16748   // Test 7: found config file, error on parsing it
16749   ASSERT_TRUE(
16750       FS.addFile("/d/.clang-format", 0,
16751                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
16752                                                   "InvalidKey: InvalidValue")));
16753   ASSERT_TRUE(
16754       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
16755   auto Style7a = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
16756   ASSERT_FALSE((bool)Style7a);
16757   llvm::consumeError(Style7a.takeError());
16758 
16759   auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
16760   ASSERT_TRUE((bool)Style7b);
16761 
16762   // Test 8: inferred per-language defaults apply.
16763   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
16764   ASSERT_TRUE((bool)StyleTd);
16765   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
16766 }
16767 
16768 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
16769   // Column limit is 20.
16770   std::string Code = "Type *a =\n"
16771                      "    new Type();\n"
16772                      "g(iiiii, 0, jjjjj,\n"
16773                      "  0, kkkkk, 0, mm);\n"
16774                      "int  bad     = format   ;";
16775   std::string Expected = "auto a = new Type();\n"
16776                          "g(iiiii, nullptr,\n"
16777                          "  jjjjj, nullptr,\n"
16778                          "  kkkkk, nullptr,\n"
16779                          "  mm);\n"
16780                          "int  bad     = format   ;";
16781   FileID ID = Context.createInMemoryFile("format.cpp", Code);
16782   tooling::Replacements Replaces = toReplacements(
16783       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
16784                             "auto "),
16785        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
16786                             "nullptr"),
16787        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
16788                             "nullptr"),
16789        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
16790                             "nullptr")});
16791 
16792   format::FormatStyle Style = format::getLLVMStyle();
16793   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
16794   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16795   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16796       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16797   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16798   EXPECT_TRUE(static_cast<bool>(Result));
16799   EXPECT_EQ(Expected, *Result);
16800 }
16801 
16802 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
16803   std::string Code = "#include \"a.h\"\n"
16804                      "#include \"c.h\"\n"
16805                      "\n"
16806                      "int main() {\n"
16807                      "  return 0;\n"
16808                      "}";
16809   std::string Expected = "#include \"a.h\"\n"
16810                          "#include \"b.h\"\n"
16811                          "#include \"c.h\"\n"
16812                          "\n"
16813                          "int main() {\n"
16814                          "  return 0;\n"
16815                          "}";
16816   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
16817   tooling::Replacements Replaces = toReplacements(
16818       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
16819                             "#include \"b.h\"\n")});
16820 
16821   format::FormatStyle Style = format::getLLVMStyle();
16822   Style.SortIncludes = true;
16823   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
16824   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
16825       << llvm::toString(FormattedReplaces.takeError()) << "\n";
16826   auto Result = applyAllReplacements(Code, *FormattedReplaces);
16827   EXPECT_TRUE(static_cast<bool>(Result));
16828   EXPECT_EQ(Expected, *Result);
16829 }
16830 
16831 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
16832   EXPECT_EQ("using std::cin;\n"
16833             "using std::cout;",
16834             format("using std::cout;\n"
16835                    "using std::cin;",
16836                    getGoogleStyle()));
16837 }
16838 
16839 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
16840   format::FormatStyle Style = format::getLLVMStyle();
16841   Style.Standard = FormatStyle::LS_Cpp03;
16842   // cpp03 recognize this string as identifier u8 and literal character 'a'
16843   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
16844 }
16845 
16846 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
16847   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
16848   // all modes, including C++11, C++14 and C++17
16849   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
16850 }
16851 
16852 TEST_F(FormatTest, DoNotFormatLikelyXml) {
16853   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
16854   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
16855 }
16856 
16857 TEST_F(FormatTest, StructuredBindings) {
16858   // Structured bindings is a C++17 feature.
16859   // all modes, including C++11, C++14 and C++17
16860   verifyFormat("auto [a, b] = f();");
16861   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
16862   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
16863   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
16864   EXPECT_EQ("auto const volatile [a, b] = f();",
16865             format("auto  const   volatile[a, b] = f();"));
16866   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
16867   EXPECT_EQ("auto &[a, b, c] = f();",
16868             format("auto   &[  a  ,  b,c   ] = f();"));
16869   EXPECT_EQ("auto &&[a, b, c] = f();",
16870             format("auto   &&[  a  ,  b,c   ] = f();"));
16871   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
16872   EXPECT_EQ("auto const volatile &&[a, b] = f();",
16873             format("auto  const  volatile  &&[a, b] = f();"));
16874   EXPECT_EQ("auto const &&[a, b] = f();",
16875             format("auto  const   &&  [a, b] = f();"));
16876   EXPECT_EQ("const auto &[a, b] = f();",
16877             format("const  auto  &  [a, b] = f();"));
16878   EXPECT_EQ("const auto volatile &&[a, b] = f();",
16879             format("const  auto   volatile  &&[a, b] = f();"));
16880   EXPECT_EQ("volatile const auto &&[a, b] = f();",
16881             format("volatile  const  auto   &&[a, b] = f();"));
16882   EXPECT_EQ("const auto &&[a, b] = f();",
16883             format("const  auto  &&  [a, b] = f();"));
16884 
16885   // Make sure we don't mistake structured bindings for lambdas.
16886   FormatStyle PointerMiddle = getLLVMStyle();
16887   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16888   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
16889   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
16890   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
16891   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
16892   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
16893   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
16894   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
16895   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
16896   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
16897   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
16898   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
16899   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
16900 
16901   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
16902             format("for (const auto   &&   [a, b] : some_range) {\n}"));
16903   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
16904             format("for (const auto   &   [a, b] : some_range) {\n}"));
16905   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
16906             format("for (const auto[a, b] : some_range) {\n}"));
16907   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
16908   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
16909   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
16910   EXPECT_EQ("auto const &[x, y](expr);",
16911             format("auto  const  &  [x,y]  (expr);"));
16912   EXPECT_EQ("auto const &&[x, y](expr);",
16913             format("auto  const  &&  [x,y]  (expr);"));
16914   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
16915   EXPECT_EQ("auto const &[x, y]{expr};",
16916             format("auto  const  &  [x,y]  {expr};"));
16917   EXPECT_EQ("auto const &&[x, y]{expr};",
16918             format("auto  const  &&  [x,y]  {expr};"));
16919 
16920   format::FormatStyle Spaces = format::getLLVMStyle();
16921   Spaces.SpacesInSquareBrackets = true;
16922   verifyFormat("auto [ a, b ] = f();", Spaces);
16923   verifyFormat("auto &&[ a, b ] = f();", Spaces);
16924   verifyFormat("auto &[ a, b ] = f();", Spaces);
16925   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
16926   verifyFormat("auto const &[ a, b ] = f();", Spaces);
16927 }
16928 
16929 TEST_F(FormatTest, FileAndCode) {
16930   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
16931   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
16932   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
16933   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
16934   EXPECT_EQ(FormatStyle::LK_ObjC,
16935             guessLanguage("foo.h", "@interface Foo\n@end\n"));
16936   EXPECT_EQ(
16937       FormatStyle::LK_ObjC,
16938       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
16939   EXPECT_EQ(FormatStyle::LK_ObjC,
16940             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
16941   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
16942   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
16943   EXPECT_EQ(FormatStyle::LK_ObjC,
16944             guessLanguage("foo", "@interface Foo\n@end\n"));
16945   EXPECT_EQ(FormatStyle::LK_ObjC,
16946             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
16947   EXPECT_EQ(
16948       FormatStyle::LK_ObjC,
16949       guessLanguage("foo.h",
16950                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
16951   EXPECT_EQ(
16952       FormatStyle::LK_Cpp,
16953       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
16954 }
16955 
16956 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
16957   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
16958   EXPECT_EQ(FormatStyle::LK_ObjC,
16959             guessLanguage("foo.h", "array[[calculator getIndex]];"));
16960   EXPECT_EQ(FormatStyle::LK_Cpp,
16961             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
16962   EXPECT_EQ(
16963       FormatStyle::LK_Cpp,
16964       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
16965   EXPECT_EQ(FormatStyle::LK_ObjC,
16966             guessLanguage("foo.h", "[[noreturn foo] bar];"));
16967   EXPECT_EQ(FormatStyle::LK_Cpp,
16968             guessLanguage("foo.h", "[[clang::fallthrough]];"));
16969   EXPECT_EQ(FormatStyle::LK_ObjC,
16970             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
16971   EXPECT_EQ(FormatStyle::LK_Cpp,
16972             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
16973   EXPECT_EQ(FormatStyle::LK_Cpp,
16974             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
16975   EXPECT_EQ(FormatStyle::LK_ObjC,
16976             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
16977   EXPECT_EQ(FormatStyle::LK_Cpp,
16978             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
16979   EXPECT_EQ(
16980       FormatStyle::LK_Cpp,
16981       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
16982   EXPECT_EQ(
16983       FormatStyle::LK_Cpp,
16984       guessLanguage("foo.h",
16985                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
16986   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
16987 }
16988 
16989 TEST_F(FormatTest, GuessLanguageWithCaret) {
16990   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
16991   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
16992   EXPECT_EQ(FormatStyle::LK_ObjC,
16993             guessLanguage("foo.h", "int(^)(char, float);"));
16994   EXPECT_EQ(FormatStyle::LK_ObjC,
16995             guessLanguage("foo.h", "int(^foo)(char, float);"));
16996   EXPECT_EQ(FormatStyle::LK_ObjC,
16997             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
16998   EXPECT_EQ(FormatStyle::LK_ObjC,
16999             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
17000   EXPECT_EQ(
17001       FormatStyle::LK_ObjC,
17002       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
17003 }
17004 
17005 TEST_F(FormatTest, GuessLanguageWithPragmas) {
17006   EXPECT_EQ(FormatStyle::LK_Cpp,
17007             guessLanguage("foo.h", "__pragma(warning(disable:))"));
17008   EXPECT_EQ(FormatStyle::LK_Cpp,
17009             guessLanguage("foo.h", "#pragma(warning(disable:))"));
17010   EXPECT_EQ(FormatStyle::LK_Cpp,
17011             guessLanguage("foo.h", "_Pragma(warning(disable:))"));
17012 }
17013 
17014 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
17015   // ASM symbolic names are identifiers that must be surrounded by [] without
17016   // space in between:
17017   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
17018 
17019   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
17020   verifyFormat(R"(//
17021 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
17022 )");
17023 
17024   // A list of several ASM symbolic names.
17025   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
17026 
17027   // ASM symbolic names in inline ASM with inputs and outputs.
17028   verifyFormat(R"(//
17029 asm("cmoveq %1, %2, %[result]"
17030     : [result] "=r"(result)
17031     : "r"(test), "r"(new), "[result]"(old));
17032 )");
17033 
17034   // ASM symbolic names in inline ASM with no outputs.
17035   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
17036 }
17037 
17038 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
17039   EXPECT_EQ(FormatStyle::LK_Cpp,
17040             guessLanguage("foo.h", "void f() {\n"
17041                                    "  asm (\"mov %[e], %[d]\"\n"
17042                                    "     : [d] \"=rm\" (d)\n"
17043                                    "       [e] \"rm\" (*e));\n"
17044                                    "}"));
17045   EXPECT_EQ(FormatStyle::LK_Cpp,
17046             guessLanguage("foo.h", "void f() {\n"
17047                                    "  _asm (\"mov %[e], %[d]\"\n"
17048                                    "     : [d] \"=rm\" (d)\n"
17049                                    "       [e] \"rm\" (*e));\n"
17050                                    "}"));
17051   EXPECT_EQ(FormatStyle::LK_Cpp,
17052             guessLanguage("foo.h", "void f() {\n"
17053                                    "  __asm (\"mov %[e], %[d]\"\n"
17054                                    "     : [d] \"=rm\" (d)\n"
17055                                    "       [e] \"rm\" (*e));\n"
17056                                    "}"));
17057   EXPECT_EQ(FormatStyle::LK_Cpp,
17058             guessLanguage("foo.h", "void f() {\n"
17059                                    "  __asm__ (\"mov %[e], %[d]\"\n"
17060                                    "     : [d] \"=rm\" (d)\n"
17061                                    "       [e] \"rm\" (*e));\n"
17062                                    "}"));
17063   EXPECT_EQ(FormatStyle::LK_Cpp,
17064             guessLanguage("foo.h", "void f() {\n"
17065                                    "  asm (\"mov %[e], %[d]\"\n"
17066                                    "     : [d] \"=rm\" (d),\n"
17067                                    "       [e] \"rm\" (*e));\n"
17068                                    "}"));
17069   EXPECT_EQ(FormatStyle::LK_Cpp,
17070             guessLanguage("foo.h", "void f() {\n"
17071                                    "  asm volatile (\"mov %[e], %[d]\"\n"
17072                                    "     : [d] \"=rm\" (d)\n"
17073                                    "       [e] \"rm\" (*e));\n"
17074                                    "}"));
17075 }
17076 
17077 TEST_F(FormatTest, GuessLanguageWithChildLines) {
17078   EXPECT_EQ(FormatStyle::LK_Cpp,
17079             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
17080   EXPECT_EQ(FormatStyle::LK_ObjC,
17081             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
17082   EXPECT_EQ(
17083       FormatStyle::LK_Cpp,
17084       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
17085   EXPECT_EQ(
17086       FormatStyle::LK_ObjC,
17087       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
17088 }
17089 
17090 TEST_F(FormatTest, TypenameMacros) {
17091   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
17092 
17093   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
17094   FormatStyle Google = getGoogleStyleWithColumns(0);
17095   Google.TypenameMacros = TypenameMacros;
17096   verifyFormat("struct foo {\n"
17097                "  int bar;\n"
17098                "  TAILQ_ENTRY(a) bleh;\n"
17099                "};",
17100                Google);
17101 
17102   FormatStyle Macros = getLLVMStyle();
17103   Macros.TypenameMacros = TypenameMacros;
17104 
17105   verifyFormat("STACK_OF(int) a;", Macros);
17106   verifyFormat("STACK_OF(int) *a;", Macros);
17107   verifyFormat("STACK_OF(int const *) *a;", Macros);
17108   verifyFormat("STACK_OF(int *const) *a;", Macros);
17109   verifyFormat("STACK_OF(int, string) a;", Macros);
17110   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
17111   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
17112   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
17113   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
17114   verifyFormat("vector<LIST(uint64_t) *attr> x;", Macros);
17115   verifyFormat("vector<LIST(uint64_t) *const> f(LIST(uint64_t) *arg);", Macros);
17116 
17117   Macros.PointerAlignment = FormatStyle::PAS_Left;
17118   verifyFormat("STACK_OF(int)* a;", Macros);
17119   verifyFormat("STACK_OF(int*)* a;", Macros);
17120   verifyFormat("x = (STACK_OF(uint64_t))*a;", Macros);
17121   verifyFormat("x = (STACK_OF(uint64_t))&a;", Macros);
17122   verifyFormat("vector<STACK_OF(uint64_t)* attr> x;", Macros);
17123 }
17124 
17125 TEST_F(FormatTest, AtomicQualifier) {
17126   // Check that we treate _Atomic as a type and not a function call
17127   FormatStyle Google = getGoogleStyleWithColumns(0);
17128   verifyFormat("struct foo {\n"
17129                "  int a1;\n"
17130                "  _Atomic(a) a2;\n"
17131                "  _Atomic(_Atomic(int) *const) a3;\n"
17132                "};",
17133                Google);
17134   verifyFormat("_Atomic(uint64_t) a;");
17135   verifyFormat("_Atomic(uint64_t) *a;");
17136   verifyFormat("_Atomic(uint64_t const *) *a;");
17137   verifyFormat("_Atomic(uint64_t *const) *a;");
17138   verifyFormat("_Atomic(const uint64_t *) *a;");
17139   verifyFormat("_Atomic(uint64_t) a;");
17140   verifyFormat("_Atomic(_Atomic(uint64_t)) a;");
17141   verifyFormat("_Atomic(_Atomic(uint64_t)) a, b;");
17142   verifyFormat("for (_Atomic(uint64_t) *a = NULL; a;) {\n}");
17143   verifyFormat("_Atomic(uint64_t) f(_Atomic(uint64_t) *arg);");
17144 
17145   verifyFormat("_Atomic(uint64_t) *s(InitValue);");
17146   verifyFormat("_Atomic(uint64_t) *s{InitValue};");
17147   FormatStyle Style = getLLVMStyle();
17148   Style.PointerAlignment = FormatStyle::PAS_Left;
17149   verifyFormat("_Atomic(uint64_t)* s(InitValue);", Style);
17150   verifyFormat("_Atomic(uint64_t)* s{InitValue};", Style);
17151   verifyFormat("_Atomic(int)* a;", Style);
17152   verifyFormat("_Atomic(int*)* a;", Style);
17153   verifyFormat("vector<_Atomic(uint64_t)* attr> x;", Style);
17154 
17155   Style.SpacesInCStyleCastParentheses = true;
17156   Style.SpacesInParentheses = false;
17157   verifyFormat("x = ( _Atomic(uint64_t) )*a;", Style);
17158   Style.SpacesInCStyleCastParentheses = false;
17159   Style.SpacesInParentheses = true;
17160   verifyFormat("x = (_Atomic( uint64_t ))*a;", Style);
17161   verifyFormat("x = (_Atomic( uint64_t ))&a;", Style);
17162 }
17163 
17164 TEST_F(FormatTest, AmbersandInLamda) {
17165   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
17166   FormatStyle AlignStyle = getLLVMStyle();
17167   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
17168   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
17169   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
17170   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
17171 }
17172 
17173 TEST_F(FormatTest, SpacesInConditionalStatement) {
17174   FormatStyle Spaces = getLLVMStyle();
17175   Spaces.SpacesInConditionalStatement = true;
17176   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
17177   verifyFormat("if ( !a )\n  return;", Spaces);
17178   verifyFormat("if ( a )\n  return;", Spaces);
17179   verifyFormat("if constexpr ( a )\n  return;", Spaces);
17180   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
17181   verifyFormat("while ( a )\n  return;", Spaces);
17182   verifyFormat("while ( (a && b) )\n  return;", Spaces);
17183   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
17184   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
17185   // Check that space on the left of "::" is inserted as expected at beginning
17186   // of condition.
17187   verifyFormat("while ( ::func() )\n  return;", Spaces);
17188 }
17189 
17190 TEST_F(FormatTest, AlternativeOperators) {
17191   // Test case for ensuring alternate operators are not
17192   // combined with their right most neighbour.
17193   verifyFormat("int a and b;");
17194   verifyFormat("int a and_eq b;");
17195   verifyFormat("int a bitand b;");
17196   verifyFormat("int a bitor b;");
17197   verifyFormat("int a compl b;");
17198   verifyFormat("int a not b;");
17199   verifyFormat("int a not_eq b;");
17200   verifyFormat("int a or b;");
17201   verifyFormat("int a xor b;");
17202   verifyFormat("int a xor_eq b;");
17203   verifyFormat("return this not_eq bitand other;");
17204   verifyFormat("bool operator not_eq(const X bitand other)");
17205 
17206   verifyFormat("int a and 5;");
17207   verifyFormat("int a and_eq 5;");
17208   verifyFormat("int a bitand 5;");
17209   verifyFormat("int a bitor 5;");
17210   verifyFormat("int a compl 5;");
17211   verifyFormat("int a not 5;");
17212   verifyFormat("int a not_eq 5;");
17213   verifyFormat("int a or 5;");
17214   verifyFormat("int a xor 5;");
17215   verifyFormat("int a xor_eq 5;");
17216 
17217   verifyFormat("int a compl(5);");
17218   verifyFormat("int a not(5);");
17219 
17220   /* FIXME handle alternate tokens
17221    * https://en.cppreference.com/w/cpp/language/operator_alternative
17222   // alternative tokens
17223   verifyFormat("compl foo();");     //  ~foo();
17224   verifyFormat("foo() <%%>;");      // foo();
17225   verifyFormat("void foo() <%%>;"); // void foo(){}
17226   verifyFormat("int a <:1:>;");     // int a[1];[
17227   verifyFormat("%:define ABC abc"); // #define ABC abc
17228   verifyFormat("%:%:");             // ##
17229   */
17230 }
17231 
17232 TEST_F(FormatTest, STLWhileNotDefineChed) {
17233   verifyFormat("#if defined(while)\n"
17234                "#define while EMIT WARNING C4005\n"
17235                "#endif // while");
17236 }
17237 
17238 TEST_F(FormatTest, OperatorSpacing) {
17239   FormatStyle Style = getLLVMStyle();
17240   Style.PointerAlignment = FormatStyle::PAS_Right;
17241   verifyFormat("Foo::operator*();", Style);
17242   verifyFormat("Foo::operator void *();", Style);
17243   verifyFormat("Foo::operator void **();", Style);
17244   verifyFormat("Foo::operator void *&();", Style);
17245   verifyFormat("Foo::operator void *&&();", Style);
17246   verifyFormat("Foo::operator()(void *);", Style);
17247   verifyFormat("Foo::operator*(void *);", Style);
17248   verifyFormat("Foo::operator*();", Style);
17249   verifyFormat("Foo::operator**();", Style);
17250   verifyFormat("Foo::operator&();", Style);
17251   verifyFormat("Foo::operator<int> *();", Style);
17252   verifyFormat("Foo::operator<Foo> *();", Style);
17253   verifyFormat("Foo::operator<int> **();", Style);
17254   verifyFormat("Foo::operator<Foo> **();", Style);
17255   verifyFormat("Foo::operator<int> &();", Style);
17256   verifyFormat("Foo::operator<Foo> &();", Style);
17257   verifyFormat("Foo::operator<int> &&();", Style);
17258   verifyFormat("Foo::operator<Foo> &&();", Style);
17259   verifyFormat("Foo::operator<int> *&();", Style);
17260   verifyFormat("Foo::operator<Foo> *&();", Style);
17261   verifyFormat("Foo::operator<int> *&&();", Style);
17262   verifyFormat("Foo::operator<Foo> *&&();", Style);
17263   verifyFormat("operator*(int (*)(), class Foo);", Style);
17264 
17265   verifyFormat("Foo::operator&();", Style);
17266   verifyFormat("Foo::operator void &();", Style);
17267   verifyFormat("Foo::operator()(void &);", Style);
17268   verifyFormat("Foo::operator&(void &);", Style);
17269   verifyFormat("Foo::operator&();", Style);
17270   verifyFormat("operator&(int (&)(), class Foo);", Style);
17271 
17272   verifyFormat("Foo::operator&&();", Style);
17273   verifyFormat("Foo::operator**();", Style);
17274   verifyFormat("Foo::operator void &&();", Style);
17275   verifyFormat("Foo::operator()(void &&);", Style);
17276   verifyFormat("Foo::operator&&(void &&);", Style);
17277   verifyFormat("Foo::operator&&();", Style);
17278   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
17279   verifyFormat("operator const nsTArrayRight<E> &()", Style);
17280   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
17281                Style);
17282   verifyFormat("operator void **()", Style);
17283   verifyFormat("operator const FooRight<Object> &()", Style);
17284   verifyFormat("operator const FooRight<Object> *()", Style);
17285   verifyFormat("operator const FooRight<Object> **()", Style);
17286   verifyFormat("operator const FooRight<Object> *&()", Style);
17287   verifyFormat("operator const FooRight<Object> *&&()", Style);
17288 
17289   Style.PointerAlignment = FormatStyle::PAS_Left;
17290   verifyFormat("Foo::operator*();", Style);
17291   verifyFormat("Foo::operator**();", Style);
17292   verifyFormat("Foo::operator void*();", Style);
17293   verifyFormat("Foo::operator void**();", Style);
17294   verifyFormat("Foo::operator void*&();", Style);
17295   verifyFormat("Foo::operator/*comment*/ void*();", Style);
17296   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
17297   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
17298   verifyFormat("Foo::operator()(void*);", Style);
17299   verifyFormat("Foo::operator*(void*);", Style);
17300   verifyFormat("Foo::operator*();", Style);
17301   verifyFormat("Foo::operator<int>*();", Style);
17302   verifyFormat("Foo::operator<Foo>*();", Style);
17303   verifyFormat("Foo::operator<int>**();", Style);
17304   verifyFormat("Foo::operator<Foo>**();", Style);
17305   verifyFormat("Foo::operator<Foo>*&();", Style);
17306   verifyFormat("Foo::operator<int>&();", Style);
17307   verifyFormat("Foo::operator<Foo>&();", Style);
17308   verifyFormat("Foo::operator<int>&&();", Style);
17309   verifyFormat("Foo::operator<Foo>&&();", Style);
17310   verifyFormat("Foo::operator<int>*&();", Style);
17311   verifyFormat("Foo::operator<Foo>*&();", Style);
17312   verifyFormat("operator*(int (*)(), class Foo);", Style);
17313 
17314   verifyFormat("Foo::operator&();", Style);
17315   verifyFormat("Foo::operator void&();", Style);
17316   verifyFormat("Foo::operator/*comment*/ void&();", Style);
17317   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
17318   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
17319   verifyFormat("Foo::operator()(void&);", Style);
17320   verifyFormat("Foo::operator&(void&);", Style);
17321   verifyFormat("Foo::operator&();", Style);
17322   verifyFormat("operator&(int (&)(), class Foo);", Style);
17323 
17324   verifyFormat("Foo::operator&&();", Style);
17325   verifyFormat("Foo::operator void&&();", Style);
17326   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
17327   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
17328   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
17329   verifyFormat("Foo::operator()(void&&);", Style);
17330   verifyFormat("Foo::operator&&(void&&);", Style);
17331   verifyFormat("Foo::operator&&();", Style);
17332   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
17333   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
17334   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
17335                Style);
17336   verifyFormat("operator void**()", Style);
17337   verifyFormat("operator const FooLeft<Object>&()", Style);
17338   verifyFormat("operator const FooLeft<Object>*()", Style);
17339   verifyFormat("operator const FooLeft<Object>**()", Style);
17340   verifyFormat("operator const FooLeft<Object>*&()", Style);
17341   verifyFormat("operator const FooLeft<Object>*&&()", Style);
17342 
17343   // PR45107
17344   verifyFormat("operator Vector<String>&();", Style);
17345   verifyFormat("operator const Vector<String>&();", Style);
17346   verifyFormat("operator foo::Bar*();", Style);
17347   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
17348   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
17349                Style);
17350 
17351   Style.PointerAlignment = FormatStyle::PAS_Middle;
17352   verifyFormat("Foo::operator*();", Style);
17353   verifyFormat("Foo::operator void *();", Style);
17354   verifyFormat("Foo::operator()(void *);", Style);
17355   verifyFormat("Foo::operator*(void *);", Style);
17356   verifyFormat("Foo::operator*();", Style);
17357   verifyFormat("operator*(int (*)(), class Foo);", Style);
17358 
17359   verifyFormat("Foo::operator&();", Style);
17360   verifyFormat("Foo::operator void &();", Style);
17361   verifyFormat("Foo::operator()(void &);", Style);
17362   verifyFormat("Foo::operator&(void &);", Style);
17363   verifyFormat("Foo::operator&();", Style);
17364   verifyFormat("operator&(int (&)(), class Foo);", Style);
17365 
17366   verifyFormat("Foo::operator&&();", Style);
17367   verifyFormat("Foo::operator void &&();", Style);
17368   verifyFormat("Foo::operator()(void &&);", Style);
17369   verifyFormat("Foo::operator&&(void &&);", Style);
17370   verifyFormat("Foo::operator&&();", Style);
17371   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
17372 }
17373 
17374 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
17375   FormatStyle Style = getLLVMStyle();
17376   // PR46157
17377   verifyFormat("foo(operator+, -42);", Style);
17378   verifyFormat("foo(operator++, -42);", Style);
17379   verifyFormat("foo(operator--, -42);", Style);
17380   verifyFormat("foo(-42, operator--);", Style);
17381   verifyFormat("foo(-42, operator, );", Style);
17382   verifyFormat("foo(operator, , -42);", Style);
17383 }
17384 
17385 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
17386   FormatStyle Style = getLLVMStyle();
17387   Style.WhitespaceSensitiveMacros.push_back("FOO");
17388 
17389   // Don't use the helpers here, since 'mess up' will change the whitespace
17390   // and these are all whitespace sensitive by definition
17391   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
17392             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
17393   EXPECT_EQ(
17394       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
17395       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
17396   EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
17397             format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
17398   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
17399             "       Still=Intentional);",
17400             format("FOO(String-ized&Messy+But,: :\n"
17401                    "       Still=Intentional);",
17402                    Style));
17403   Style.AlignConsecutiveAssignments = true;
17404   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
17405             "       Still=Intentional);",
17406             format("FOO(String-ized=&Messy+But,: :\n"
17407                    "       Still=Intentional);",
17408                    Style));
17409 
17410   Style.ColumnLimit = 21;
17411   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
17412             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
17413 }
17414 
17415 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
17416   // These tests are not in NamespaceFixer because that doesn't
17417   // test its interaction with line wrapping
17418   FormatStyle Style = getLLVMStyle();
17419   Style.ColumnLimit = 80;
17420   verifyFormat("namespace {\n"
17421                "int i;\n"
17422                "int j;\n"
17423                "} // namespace",
17424                Style);
17425 
17426   verifyFormat("namespace AAA {\n"
17427                "int i;\n"
17428                "int j;\n"
17429                "} // namespace AAA",
17430                Style);
17431 
17432   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
17433             "int i;\n"
17434             "int j;\n"
17435             "} // namespace Averyveryveryverylongnamespace",
17436             format("namespace Averyveryveryverylongnamespace {\n"
17437                    "int i;\n"
17438                    "int j;\n"
17439                    "}",
17440                    Style));
17441 
17442   EXPECT_EQ(
17443       "namespace "
17444       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
17445       "    went::mad::now {\n"
17446       "int i;\n"
17447       "int j;\n"
17448       "} // namespace\n"
17449       "  // "
17450       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
17451       "went::mad::now",
17452       format("namespace "
17453              "would::it::save::you::a::lot::of::time::if_::i::"
17454              "just::gave::up::and_::went::mad::now {\n"
17455              "int i;\n"
17456              "int j;\n"
17457              "}",
17458              Style));
17459 
17460   // This used to duplicate the comment again and again on subsequent runs
17461   EXPECT_EQ(
17462       "namespace "
17463       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
17464       "    went::mad::now {\n"
17465       "int i;\n"
17466       "int j;\n"
17467       "} // namespace\n"
17468       "  // "
17469       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
17470       "went::mad::now",
17471       format("namespace "
17472              "would::it::save::you::a::lot::of::time::if_::i::"
17473              "just::gave::up::and_::went::mad::now {\n"
17474              "int i;\n"
17475              "int j;\n"
17476              "} // namespace\n"
17477              "  // "
17478              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
17479              "and_::went::mad::now",
17480              Style));
17481 }
17482 
17483 TEST_F(FormatTest, LikelyUnlikely) {
17484   FormatStyle Style = getLLVMStyle();
17485 
17486   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17487                "  return 29;\n"
17488                "}",
17489                Style);
17490 
17491   verifyFormat("if (argc > 5) [[likely]] {\n"
17492                "  return 29;\n"
17493                "}",
17494                Style);
17495 
17496   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17497                "  return 29;\n"
17498                "} else [[likely]] {\n"
17499                "  return 42;\n"
17500                "}\n",
17501                Style);
17502 
17503   verifyFormat("if (argc > 5) [[unlikely]] {\n"
17504                "  return 29;\n"
17505                "} else if (argc > 10) [[likely]] {\n"
17506                "  return 99;\n"
17507                "} else {\n"
17508                "  return 42;\n"
17509                "}\n",
17510                Style);
17511 
17512   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
17513                "  return 29;\n"
17514                "}",
17515                Style);
17516 }
17517 
17518 TEST_F(FormatTest, PenaltyIndentedWhitespace) {
17519   verifyFormat("Constructor()\n"
17520                "    : aaaaaa(aaaaaa), aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
17521                "                          aaaa(aaaaaaaaaaaaaaaaaa, "
17522                "aaaaaaaaaaaaaaaaaat))");
17523   verifyFormat("Constructor()\n"
17524                "    : aaaaaaaaaaaaa(aaaaaa), "
17525                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa)");
17526 
17527   FormatStyle StyleWithWhitespacePenalty = getLLVMStyle();
17528   StyleWithWhitespacePenalty.PenaltyIndentedWhitespace = 5;
17529   verifyFormat("Constructor()\n"
17530                "    : aaaaaa(aaaaaa),\n"
17531                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
17532                "          aaaa(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaat))",
17533                StyleWithWhitespacePenalty);
17534   verifyFormat("Constructor()\n"
17535                "    : aaaaaaaaaaaaa(aaaaaa), "
17536                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa)",
17537                StyleWithWhitespacePenalty);
17538 }
17539 
17540 TEST_F(FormatTest, LLVMDefaultStyle) {
17541   FormatStyle Style = getLLVMStyle();
17542   verifyFormat("extern \"C\" {\n"
17543                "int foo();\n"
17544                "}",
17545                Style);
17546 }
17547 TEST_F(FormatTest, GNUDefaultStyle) {
17548   FormatStyle Style = getGNUStyle();
17549   verifyFormat("extern \"C\"\n"
17550                "{\n"
17551                "  int foo ();\n"
17552                "}",
17553                Style);
17554 }
17555 TEST_F(FormatTest, MozillaDefaultStyle) {
17556   FormatStyle Style = getMozillaStyle();
17557   verifyFormat("extern \"C\"\n"
17558                "{\n"
17559                "  int foo();\n"
17560                "}",
17561                Style);
17562 }
17563 TEST_F(FormatTest, GoogleDefaultStyle) {
17564   FormatStyle Style = getGoogleStyle();
17565   verifyFormat("extern \"C\" {\n"
17566                "int foo();\n"
17567                "}",
17568                Style);
17569 }
17570 TEST_F(FormatTest, ChromiumDefaultStyle) {
17571   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
17572   verifyFormat("extern \"C\" {\n"
17573                "int foo();\n"
17574                "}",
17575                Style);
17576 }
17577 TEST_F(FormatTest, MicrosoftDefaultStyle) {
17578   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
17579   verifyFormat("extern \"C\"\n"
17580                "{\n"
17581                "    int foo();\n"
17582                "}",
17583                Style);
17584 }
17585 TEST_F(FormatTest, WebKitDefaultStyle) {
17586   FormatStyle Style = getWebKitStyle();
17587   verifyFormat("extern \"C\" {\n"
17588                "int foo();\n"
17589                "}",
17590                Style);
17591 }
17592 
17593 TEST_F(FormatTest, ConceptsAndRequires) {
17594   FormatStyle Style = getLLVMStyle();
17595   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
17596 
17597   verifyFormat("template <typename T>\n"
17598                "concept Hashable = requires(T a) {\n"
17599                "  { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
17600                "};",
17601                Style);
17602   verifyFormat("template <typename T>\n"
17603                "concept EqualityComparable = requires(T a, T b) {\n"
17604                "  { a == b } -> bool;\n"
17605                "};",
17606                Style);
17607   verifyFormat("template <typename T>\n"
17608                "concept EqualityComparable = requires(T a, T b) {\n"
17609                "  { a == b } -> bool;\n"
17610                "  { a != b } -> bool;\n"
17611                "};",
17612                Style);
17613   verifyFormat("template <typename T>\n"
17614                "concept EqualityComparable = requires(T a, T b) {\n"
17615                "  { a == b } -> bool;\n"
17616                "  { a != b } -> bool;\n"
17617                "};",
17618                Style);
17619 
17620   verifyFormat("template <typename It>\n"
17621                "requires Iterator<It>\n"
17622                "void sort(It begin, It end) {\n"
17623                "  //....\n"
17624                "}",
17625                Style);
17626 
17627   verifyFormat("template <typename T>\n"
17628                "concept Large = sizeof(T) > 10;",
17629                Style);
17630 
17631   verifyFormat("template <typename T, typename U>\n"
17632                "concept FooableWith = requires(T t, U u) {\n"
17633                "  typename T::foo_type;\n"
17634                "  { t.foo(u) } -> typename T::foo_type;\n"
17635                "  t++;\n"
17636                "};\n"
17637                "void doFoo(FooableWith<int> auto t) {\n"
17638                "  t.foo(3);\n"
17639                "}",
17640                Style);
17641   verifyFormat("template <typename T>\n"
17642                "concept Context = sizeof(T) == 1;",
17643                Style);
17644   verifyFormat("template <typename T>\n"
17645                "concept Context = is_specialization_of_v<context, T>;",
17646                Style);
17647   verifyFormat("template <typename T>\n"
17648                "concept Node = std::is_object_v<T>;",
17649                Style);
17650   verifyFormat("template <typename T>\n"
17651                "concept Tree = true;",
17652                Style);
17653 
17654   verifyFormat("template <typename T> int g(T i) requires Concept1<I> {\n"
17655                "  //...\n"
17656                "}",
17657                Style);
17658 
17659   verifyFormat(
17660       "template <typename T> int g(T i) requires Concept1<I> && Concept2<I> {\n"
17661       "  //...\n"
17662       "}",
17663       Style);
17664 
17665   verifyFormat(
17666       "template <typename T> int g(T i) requires Concept1<I> || Concept2<I> {\n"
17667       "  //...\n"
17668       "}",
17669       Style);
17670 
17671   verifyFormat("template <typename T>\n"
17672                "veryveryvery_long_return_type g(T i) requires Concept1<I> || "
17673                "Concept2<I> {\n"
17674                "  //...\n"
17675                "}",
17676                Style);
17677 
17678   verifyFormat("template <typename T>\n"
17679                "veryveryvery_long_return_type g(T i) requires Concept1<I> && "
17680                "Concept2<I> {\n"
17681                "  //...\n"
17682                "}",
17683                Style);
17684 
17685   verifyFormat(
17686       "template <typename T>\n"
17687       "veryveryvery_long_return_type g(T i) requires Concept1 && Concept2 {\n"
17688       "  //...\n"
17689       "}",
17690       Style);
17691 
17692   verifyFormat(
17693       "template <typename T>\n"
17694       "veryveryvery_long_return_type g(T i) requires Concept1 || Concept2 {\n"
17695       "  //...\n"
17696       "}",
17697       Style);
17698 
17699   verifyFormat("template <typename It>\n"
17700                "requires Foo<It>() && Bar<It> {\n"
17701                "  //....\n"
17702                "}",
17703                Style);
17704 
17705   verifyFormat("template <typename It>\n"
17706                "requires Foo<Bar<It>>() && Bar<Foo<It, It>> {\n"
17707                "  //....\n"
17708                "}",
17709                Style);
17710 
17711   verifyFormat("template <typename It>\n"
17712                "requires Foo<Bar<It, It>>() && Bar<Foo<It, It>> {\n"
17713                "  //....\n"
17714                "}",
17715                Style);
17716 
17717   verifyFormat(
17718       "template <typename It>\n"
17719       "requires Foo<Bar<It>, Baz<It>>() && Bar<Foo<It>, Baz<It, It>> {\n"
17720       "  //....\n"
17721       "}",
17722       Style);
17723 
17724   Style.IndentRequires = true;
17725   verifyFormat("template <typename It>\n"
17726                "  requires Iterator<It>\n"
17727                "void sort(It begin, It end) {\n"
17728                "  //....\n"
17729                "}",
17730                Style);
17731   verifyFormat("template <std::size index_>\n"
17732                "  requires(index_ < sizeof...(Children_))\n"
17733                "Tree auto &child() {\n"
17734                "  // ...\n"
17735                "}",
17736                Style);
17737 
17738   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
17739   verifyFormat("template <typename T>\n"
17740                "concept Hashable = requires (T a) {\n"
17741                "  { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
17742                "};",
17743                Style);
17744 
17745   verifyFormat("template <class T = void>\n"
17746                "  requires EqualityComparable<T> || Same<T, void>\n"
17747                "struct equal_to;",
17748                Style);
17749 
17750   verifyFormat("template <class T>\n"
17751                "  requires requires {\n"
17752                "    T{};\n"
17753                "    T (int);\n"
17754                "  }\n",
17755                Style);
17756 
17757   Style.ColumnLimit = 78;
17758   verifyFormat("template <typename T>\n"
17759                "concept Context = Traits<typename T::traits_type> and\n"
17760                "    Interface<typename T::interface_type> and\n"
17761                "    Request<typename T::request_type> and\n"
17762                "    Response<typename T::response_type> and\n"
17763                "    ContextExtension<typename T::extension_type> and\n"
17764                "    ::std::is_copy_constructable<T> and "
17765                "::std::is_move_constructable<T> and\n"
17766                "    requires (T c) {\n"
17767                "  { c.response; } -> Response;\n"
17768                "} and requires (T c) {\n"
17769                "  { c.request; } -> Request;\n"
17770                "}\n",
17771                Style);
17772 
17773   verifyFormat("template <typename T>\n"
17774                "concept Context = Traits<typename T::traits_type> or\n"
17775                "    Interface<typename T::interface_type> or\n"
17776                "    Request<typename T::request_type> or\n"
17777                "    Response<typename T::response_type> or\n"
17778                "    ContextExtension<typename T::extension_type> or\n"
17779                "    ::std::is_copy_constructable<T> or "
17780                "::std::is_move_constructable<T> or\n"
17781                "    requires (T c) {\n"
17782                "  { c.response; } -> Response;\n"
17783                "} or requires (T c) {\n"
17784                "  { c.request; } -> Request;\n"
17785                "}\n",
17786                Style);
17787 
17788   verifyFormat("template <typename T>\n"
17789                "concept Context = Traits<typename T::traits_type> &&\n"
17790                "    Interface<typename T::interface_type> &&\n"
17791                "    Request<typename T::request_type> &&\n"
17792                "    Response<typename T::response_type> &&\n"
17793                "    ContextExtension<typename T::extension_type> &&\n"
17794                "    ::std::is_copy_constructable<T> && "
17795                "::std::is_move_constructable<T> &&\n"
17796                "    requires (T c) {\n"
17797                "  { c.response; } -> Response;\n"
17798                "} && requires (T c) {\n"
17799                "  { c.request; } -> Request;\n"
17800                "}\n",
17801                Style);
17802 
17803   verifyFormat("template <typename T>\nconcept someConcept = Constraint1<T> && "
17804                "Constraint2<T>;");
17805 
17806   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
17807   Style.BraceWrapping.AfterFunction = true;
17808   Style.BraceWrapping.AfterClass = true;
17809   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
17810   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
17811   verifyFormat("void Foo () requires (std::copyable<T>)\n"
17812                "{\n"
17813                "  return\n"
17814                "}\n",
17815                Style);
17816 
17817   verifyFormat("void Foo () requires std::copyable<T>\n"
17818                "{\n"
17819                "  return\n"
17820                "}\n",
17821                Style);
17822 
17823   verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
17824                "  requires (std::invocable<F, std::invoke_result_t<Args>...>)\n"
17825                "struct constant;",
17826                Style);
17827 
17828   verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
17829                "  requires std::invocable<F, std::invoke_result_t<Args>...>\n"
17830                "struct constant;",
17831                Style);
17832 
17833   verifyFormat("template <class T>\n"
17834                "class plane_with_very_very_very_long_name\n"
17835                "{\n"
17836                "  constexpr plane_with_very_very_very_long_name () requires "
17837                "std::copyable<T>\n"
17838                "      : plane_with_very_very_very_long_name (1)\n"
17839                "  {\n"
17840                "  }\n"
17841                "}\n",
17842                Style);
17843 
17844   verifyFormat("template <class T>\n"
17845                "class plane_with_long_name\n"
17846                "{\n"
17847                "  constexpr plane_with_long_name () requires std::copyable<T>\n"
17848                "      : plane_with_long_name (1)\n"
17849                "  {\n"
17850                "  }\n"
17851                "}\n",
17852                Style);
17853 
17854   Style.BreakBeforeConceptDeclarations = false;
17855   verifyFormat("template <typename T> concept Tree = true;", Style);
17856 
17857   Style.IndentRequires = false;
17858   verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
17859                "requires (std::invocable<F, std::invoke_result_t<Args>...>) "
17860                "struct constant;",
17861                Style);
17862 }
17863 
17864 TEST_F(FormatTest, StatementAttributeLikeMacros) {
17865   FormatStyle Style = getLLVMStyle();
17866   StringRef Source = "void Foo::slot() {\n"
17867                      "  unsigned char MyChar = 'x';\n"
17868                      "  emit signal(MyChar);\n"
17869                      "  Q_EMIT signal(MyChar);\n"
17870                      "}";
17871 
17872   EXPECT_EQ(Source, format(Source, Style));
17873 
17874   Style.AlignConsecutiveDeclarations = true;
17875   EXPECT_EQ("void Foo::slot() {\n"
17876             "  unsigned char MyChar = 'x';\n"
17877             "  emit          signal(MyChar);\n"
17878             "  Q_EMIT signal(MyChar);\n"
17879             "}",
17880             format(Source, Style));
17881 
17882   Style.StatementAttributeLikeMacros.push_back("emit");
17883   EXPECT_EQ(Source, format(Source, Style));
17884 
17885   Style.StatementAttributeLikeMacros = {};
17886   EXPECT_EQ("void Foo::slot() {\n"
17887             "  unsigned char MyChar = 'x';\n"
17888             "  emit          signal(MyChar);\n"
17889             "  Q_EMIT        signal(MyChar);\n"
17890             "}",
17891             format(Source, Style));
17892 }
17893 } // namespace
17894 } // namespace format
17895 } // namespace clang
17896