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::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   auto CustomStyle = clang::format::getLLVMStyle();
266   CustomStyle.BreakBeforeBraces = clang::format::FormatStyle::BS_Custom;
267   CustomStyle.BraceWrapping.AfterNamespace = true;
268   CustomStyle.KeepEmptyLinesAtTheStartOfBlocks = false;
269   EXPECT_EQ("namespace N\n"
270             "{\n"
271             "\n"
272             "int i;\n"
273             "}",
274             format("namespace N\n"
275                    "{\n"
276                    "\n"
277                    "\n"
278                    "int    i;\n"
279                    "}",
280                    CustomStyle));
281   EXPECT_EQ("/* something */ namespace N\n"
282             "{\n"
283             "\n"
284             "int i;\n"
285             "}",
286             format("/* something */ namespace N {\n"
287                    "\n"
288                    "\n"
289                    "int    i;\n"
290                    "}",
291                    CustomStyle));
292   EXPECT_EQ("inline namespace N\n"
293             "{\n"
294             "\n"
295             "int i;\n"
296             "}",
297             format("inline namespace N\n"
298                    "{\n"
299                    "\n"
300                    "\n"
301                    "int    i;\n"
302                    "}",
303                    CustomStyle));
304   EXPECT_EQ("/* something */ inline namespace N\n"
305             "{\n"
306             "\n"
307             "int i;\n"
308             "}",
309             format("/* something */ inline namespace N\n"
310                    "{\n"
311                    "\n"
312                    "int    i;\n"
313                    "}",
314                    CustomStyle));
315   EXPECT_EQ("export namespace N\n"
316             "{\n"
317             "\n"
318             "int i;\n"
319             "}",
320             format("export namespace N\n"
321                    "{\n"
322                    "\n"
323                    "int    i;\n"
324                    "}",
325                    CustomStyle));
326   EXPECT_EQ("namespace a\n"
327             "{\n"
328             "namespace b\n"
329             "{\n"
330             "\n"
331             "class AA {};\n"
332             "\n"
333             "} // namespace b\n"
334             "} // namespace a\n",
335             format("namespace a\n"
336                    "{\n"
337                    "namespace b\n"
338                    "{\n"
339                    "\n"
340                    "\n"
341                    "class AA {};\n"
342                    "\n"
343                    "\n"
344                    "}\n"
345                    "}\n",
346                    CustomStyle));
347   EXPECT_EQ("namespace A /* comment */\n"
348             "{\n"
349             "class B {}\n"
350             "} // namespace A",
351             format("namespace A /* comment */ { class B {} }", CustomStyle));
352   EXPECT_EQ("namespace A\n"
353             "{ /* comment */\n"
354             "class B {}\n"
355             "} // namespace A",
356             format("namespace A {/* comment */ class B {} }", CustomStyle));
357   EXPECT_EQ("namespace A\n"
358             "{ /* comment */\n"
359             "\n"
360             "class B {}\n"
361             "\n"
362             ""
363             "} // namespace A",
364             format("namespace A { /* comment */\n"
365                    "\n"
366                    "\n"
367                    "class B {}\n"
368                    "\n"
369                    "\n"
370                    "}",
371                    CustomStyle));
372   EXPECT_EQ("namespace A /* comment */\n"
373             "{\n"
374             "\n"
375             "class B {}\n"
376             "\n"
377             "} // namespace A",
378             format("namespace A/* comment */ {\n"
379                    "\n"
380                    "\n"
381                    "class B {}\n"
382                    "\n"
383                    "\n"
384                    "}",
385                    CustomStyle));
386 
387   // ...but do keep inlining and removing empty lines for non-block extern "C"
388   // functions.
389   verifyFormat("extern \"C\" int f() { return 42; }", getGoogleStyle());
390   EXPECT_EQ("extern \"C\" int f() {\n"
391             "  int i = 42;\n"
392             "  return i;\n"
393             "}",
394             format("extern \"C\" int f() {\n"
395                    "\n"
396                    "  int i = 42;\n"
397                    "  return i;\n"
398                    "}",
399                    getGoogleStyle()));
400 
401   // Remove empty lines at the beginning and end of blocks.
402   EXPECT_EQ("void f() {\n"
403             "\n"
404             "  if (a) {\n"
405             "\n"
406             "    f();\n"
407             "  }\n"
408             "}",
409             format("void f() {\n"
410                    "\n"
411                    "  if (a) {\n"
412                    "\n"
413                    "    f();\n"
414                    "\n"
415                    "  }\n"
416                    "\n"
417                    "}",
418                    getLLVMStyle()));
419   EXPECT_EQ("void f() {\n"
420             "  if (a) {\n"
421             "    f();\n"
422             "  }\n"
423             "}",
424             format("void f() {\n"
425                    "\n"
426                    "  if (a) {\n"
427                    "\n"
428                    "    f();\n"
429                    "\n"
430                    "  }\n"
431                    "\n"
432                    "}",
433                    getGoogleStyle()));
434 
435   // Don't remove empty lines in more complex control statements.
436   EXPECT_EQ("void f() {\n"
437             "  if (a) {\n"
438             "    f();\n"
439             "\n"
440             "  } else if (b) {\n"
441             "    f();\n"
442             "  }\n"
443             "}",
444             format("void f() {\n"
445                    "  if (a) {\n"
446                    "    f();\n"
447                    "\n"
448                    "  } else if (b) {\n"
449                    "    f();\n"
450                    "\n"
451                    "  }\n"
452                    "\n"
453                    "}"));
454 
455   // Don't remove empty lines before namespace endings.
456   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
457   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
458   EXPECT_EQ("namespace {\n"
459             "int i;\n"
460             "\n"
461             "}",
462             format("namespace {\n"
463                    "int i;\n"
464                    "\n"
465                    "}",
466                    LLVMWithNoNamespaceFix));
467   EXPECT_EQ("namespace {\n"
468             "int i;\n"
469             "}",
470             format("namespace {\n"
471                    "int i;\n"
472                    "}",
473                    LLVMWithNoNamespaceFix));
474   EXPECT_EQ("namespace {\n"
475             "int i;\n"
476             "\n"
477             "};",
478             format("namespace {\n"
479                    "int i;\n"
480                    "\n"
481                    "};",
482                    LLVMWithNoNamespaceFix));
483   EXPECT_EQ("namespace {\n"
484             "int i;\n"
485             "};",
486             format("namespace {\n"
487                    "int i;\n"
488                    "};",
489                    LLVMWithNoNamespaceFix));
490   EXPECT_EQ("namespace {\n"
491             "int i;\n"
492             "\n"
493             "}",
494             format("namespace {\n"
495                    "int i;\n"
496                    "\n"
497                    "}"));
498   EXPECT_EQ("namespace {\n"
499             "int i;\n"
500             "\n"
501             "} // namespace",
502             format("namespace {\n"
503                    "int i;\n"
504                    "\n"
505                    "}  // namespace"));
506 
507   FormatStyle Style = getLLVMStyle();
508   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
509   Style.MaxEmptyLinesToKeep = 2;
510   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
511   Style.BraceWrapping.AfterClass = true;
512   Style.BraceWrapping.AfterFunction = true;
513   Style.KeepEmptyLinesAtTheStartOfBlocks = false;
514 
515   EXPECT_EQ("class Foo\n"
516             "{\n"
517             "  Foo() {}\n"
518             "\n"
519             "  void funk() {}\n"
520             "};",
521             format("class Foo\n"
522                    "{\n"
523                    "  Foo()\n"
524                    "  {\n"
525                    "  }\n"
526                    "\n"
527                    "  void funk() {}\n"
528                    "};",
529                    Style));
530 }
531 
532 TEST_F(FormatTest, RecognizesBinaryOperatorKeywords) {
533   verifyFormat("x = (a) and (b);");
534   verifyFormat("x = (a) or (b);");
535   verifyFormat("x = (a) bitand (b);");
536   verifyFormat("x = (a) bitor (b);");
537   verifyFormat("x = (a) not_eq (b);");
538   verifyFormat("x = (a) and_eq (b);");
539   verifyFormat("x = (a) or_eq (b);");
540   verifyFormat("x = (a) xor (b);");
541 }
542 
543 TEST_F(FormatTest, RecognizesUnaryOperatorKeywords) {
544   verifyFormat("x = compl(a);");
545   verifyFormat("x = not(a);");
546   verifyFormat("x = bitand(a);");
547   // Unary operator must not be merged with the next identifier
548   verifyFormat("x = compl a;");
549   verifyFormat("x = not a;");
550   verifyFormat("x = bitand a;");
551 }
552 
553 //===----------------------------------------------------------------------===//
554 // Tests for control statements.
555 //===----------------------------------------------------------------------===//
556 
557 TEST_F(FormatTest, FormatIfWithoutCompoundStatement) {
558   verifyFormat("if (true)\n  f();\ng();");
559   verifyFormat("if (a)\n  if (b)\n    if (c)\n      g();\nh();");
560   verifyFormat("if (a)\n  if (b) {\n    f();\n  }\ng();");
561   verifyFormat("if constexpr (true)\n"
562                "  f();\ng();");
563   verifyFormat("if CONSTEXPR (true)\n"
564                "  f();\ng();");
565   verifyFormat("if constexpr (a)\n"
566                "  if constexpr (b)\n"
567                "    if constexpr (c)\n"
568                "      g();\n"
569                "h();");
570   verifyFormat("if CONSTEXPR (a)\n"
571                "  if CONSTEXPR (b)\n"
572                "    if CONSTEXPR (c)\n"
573                "      g();\n"
574                "h();");
575   verifyFormat("if constexpr (a)\n"
576                "  if constexpr (b) {\n"
577                "    f();\n"
578                "  }\n"
579                "g();");
580   verifyFormat("if CONSTEXPR (a)\n"
581                "  if CONSTEXPR (b) {\n"
582                "    f();\n"
583                "  }\n"
584                "g();");
585 
586   verifyFormat("if (a)\n"
587                "  g();");
588   verifyFormat("if (a) {\n"
589                "  g()\n"
590                "};");
591   verifyFormat("if (a)\n"
592                "  g();\n"
593                "else\n"
594                "  g();");
595   verifyFormat("if (a) {\n"
596                "  g();\n"
597                "} else\n"
598                "  g();");
599   verifyFormat("if (a)\n"
600                "  g();\n"
601                "else {\n"
602                "  g();\n"
603                "}");
604   verifyFormat("if (a) {\n"
605                "  g();\n"
606                "} else {\n"
607                "  g();\n"
608                "}");
609   verifyFormat("if (a)\n"
610                "  g();\n"
611                "else if (b)\n"
612                "  g();\n"
613                "else\n"
614                "  g();");
615   verifyFormat("if (a) {\n"
616                "  g();\n"
617                "} else if (b)\n"
618                "  g();\n"
619                "else\n"
620                "  g();");
621   verifyFormat("if (a)\n"
622                "  g();\n"
623                "else if (b) {\n"
624                "  g();\n"
625                "} else\n"
626                "  g();");
627   verifyFormat("if (a)\n"
628                "  g();\n"
629                "else if (b)\n"
630                "  g();\n"
631                "else {\n"
632                "  g();\n"
633                "}");
634   verifyFormat("if (a)\n"
635                "  g();\n"
636                "else if (b) {\n"
637                "  g();\n"
638                "} else {\n"
639                "  g();\n"
640                "}");
641   verifyFormat("if (a) {\n"
642                "  g();\n"
643                "} else if (b) {\n"
644                "  g();\n"
645                "} else {\n"
646                "  g();\n"
647                "}");
648 
649   FormatStyle AllowsMergedIf = getLLVMStyle();
650   AllowsMergedIf.IfMacros.push_back("MYIF");
651   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
652   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
653       FormatStyle::SIS_WithoutElse;
654   verifyFormat("if (a)\n"
655                "  // comment\n"
656                "  f();",
657                AllowsMergedIf);
658   verifyFormat("{\n"
659                "  if (a)\n"
660                "  label:\n"
661                "    f();\n"
662                "}",
663                AllowsMergedIf);
664   verifyFormat("#define A \\\n"
665                "  if (a)  \\\n"
666                "  label:  \\\n"
667                "    f()",
668                AllowsMergedIf);
669   verifyFormat("if (a)\n"
670                "  ;",
671                AllowsMergedIf);
672   verifyFormat("if (a)\n"
673                "  if (b) return;",
674                AllowsMergedIf);
675 
676   verifyFormat("if (a) // Can't merge this\n"
677                "  f();\n",
678                AllowsMergedIf);
679   verifyFormat("if (a) /* still don't merge */\n"
680                "  f();",
681                AllowsMergedIf);
682   verifyFormat("if (a) { // Never merge this\n"
683                "  f();\n"
684                "}",
685                AllowsMergedIf);
686   verifyFormat("if (a) { /* Never merge this */\n"
687                "  f();\n"
688                "}",
689                AllowsMergedIf);
690   verifyFormat("MYIF (a)\n"
691                "  // comment\n"
692                "  f();",
693                AllowsMergedIf);
694   verifyFormat("{\n"
695                "  MYIF (a)\n"
696                "  label:\n"
697                "    f();\n"
698                "}",
699                AllowsMergedIf);
700   verifyFormat("#define A  \\\n"
701                "  MYIF (a) \\\n"
702                "  label:   \\\n"
703                "    f()",
704                AllowsMergedIf);
705   verifyFormat("MYIF (a)\n"
706                "  ;",
707                AllowsMergedIf);
708   verifyFormat("MYIF (a)\n"
709                "  MYIF (b) return;",
710                AllowsMergedIf);
711 
712   verifyFormat("MYIF (a) // Can't merge this\n"
713                "  f();\n",
714                AllowsMergedIf);
715   verifyFormat("MYIF (a) /* still don't merge */\n"
716                "  f();",
717                AllowsMergedIf);
718   verifyFormat("MYIF (a) { // Never merge this\n"
719                "  f();\n"
720                "}",
721                AllowsMergedIf);
722   verifyFormat("MYIF (a) { /* Never merge this */\n"
723                "  f();\n"
724                "}",
725                AllowsMergedIf);
726 
727   AllowsMergedIf.ColumnLimit = 14;
728   // Where line-lengths matter, a 2-letter synonym that maintains line length.
729   // Not IF to avoid any confusion that IF is somehow special.
730   AllowsMergedIf.IfMacros.push_back("FI");
731   verifyFormat("if (a) return;", AllowsMergedIf);
732   verifyFormat("if (aaaaaaaaa)\n"
733                "  return;",
734                AllowsMergedIf);
735   verifyFormat("FI (a) return;", AllowsMergedIf);
736   verifyFormat("FI (aaaaaaaaa)\n"
737                "  return;",
738                AllowsMergedIf);
739 
740   AllowsMergedIf.ColumnLimit = 13;
741   verifyFormat("if (a)\n  return;", AllowsMergedIf);
742   verifyFormat("FI (a)\n  return;", AllowsMergedIf);
743 
744   FormatStyle AllowsMergedIfElse = getLLVMStyle();
745   AllowsMergedIfElse.IfMacros.push_back("MYIF");
746   AllowsMergedIfElse.AllowShortIfStatementsOnASingleLine =
747       FormatStyle::SIS_AllIfsAndElse;
748   verifyFormat("if (a)\n"
749                "  // comment\n"
750                "  f();\n"
751                "else\n"
752                "  // comment\n"
753                "  f();",
754                AllowsMergedIfElse);
755   verifyFormat("{\n"
756                "  if (a)\n"
757                "  label:\n"
758                "    f();\n"
759                "  else\n"
760                "  label:\n"
761                "    f();\n"
762                "}",
763                AllowsMergedIfElse);
764   verifyFormat("if (a)\n"
765                "  ;\n"
766                "else\n"
767                "  ;",
768                AllowsMergedIfElse);
769   verifyFormat("if (a) {\n"
770                "} else {\n"
771                "}",
772                AllowsMergedIfElse);
773   verifyFormat("if (a) return;\n"
774                "else if (b) return;\n"
775                "else return;",
776                AllowsMergedIfElse);
777   verifyFormat("if (a) {\n"
778                "} else return;",
779                AllowsMergedIfElse);
780   verifyFormat("if (a) {\n"
781                "} else if (b) return;\n"
782                "else return;",
783                AllowsMergedIfElse);
784   verifyFormat("if (a) return;\n"
785                "else if (b) {\n"
786                "} else return;",
787                AllowsMergedIfElse);
788   verifyFormat("if (a)\n"
789                "  if (b) return;\n"
790                "  else return;",
791                AllowsMergedIfElse);
792   verifyFormat("if constexpr (a)\n"
793                "  if constexpr (b) return;\n"
794                "  else if constexpr (c) return;\n"
795                "  else return;",
796                AllowsMergedIfElse);
797   verifyFormat("MYIF (a)\n"
798                "  // comment\n"
799                "  f();\n"
800                "else\n"
801                "  // comment\n"
802                "  f();",
803                AllowsMergedIfElse);
804   verifyFormat("{\n"
805                "  MYIF (a)\n"
806                "  label:\n"
807                "    f();\n"
808                "  else\n"
809                "  label:\n"
810                "    f();\n"
811                "}",
812                AllowsMergedIfElse);
813   verifyFormat("MYIF (a)\n"
814                "  ;\n"
815                "else\n"
816                "  ;",
817                AllowsMergedIfElse);
818   verifyFormat("MYIF (a) {\n"
819                "} else {\n"
820                "}",
821                AllowsMergedIfElse);
822   verifyFormat("MYIF (a) return;\n"
823                "else MYIF (b) return;\n"
824                "else return;",
825                AllowsMergedIfElse);
826   verifyFormat("MYIF (a) {\n"
827                "} else return;",
828                AllowsMergedIfElse);
829   verifyFormat("MYIF (a) {\n"
830                "} else MYIF (b) return;\n"
831                "else return;",
832                AllowsMergedIfElse);
833   verifyFormat("MYIF (a) return;\n"
834                "else MYIF (b) {\n"
835                "} else return;",
836                AllowsMergedIfElse);
837   verifyFormat("MYIF (a)\n"
838                "  MYIF (b) return;\n"
839                "  else return;",
840                AllowsMergedIfElse);
841   verifyFormat("MYIF constexpr (a)\n"
842                "  MYIF constexpr (b) return;\n"
843                "  else MYIF constexpr (c) return;\n"
844                "  else return;",
845                AllowsMergedIfElse);
846 }
847 
848 TEST_F(FormatTest, FormatIfWithoutCompoundStatementButElseWith) {
849   FormatStyle AllowsMergedIf = getLLVMStyle();
850   AllowsMergedIf.IfMacros.push_back("MYIF");
851   AllowsMergedIf.AlignEscapedNewlines = FormatStyle::ENAS_Left;
852   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
853       FormatStyle::SIS_WithoutElse;
854   verifyFormat("if (a)\n"
855                "  f();\n"
856                "else {\n"
857                "  g();\n"
858                "}",
859                AllowsMergedIf);
860   verifyFormat("if (a)\n"
861                "  f();\n"
862                "else\n"
863                "  g();\n",
864                AllowsMergedIf);
865 
866   verifyFormat("if (a) g();", AllowsMergedIf);
867   verifyFormat("if (a) {\n"
868                "  g()\n"
869                "};",
870                AllowsMergedIf);
871   verifyFormat("if (a)\n"
872                "  g();\n"
873                "else\n"
874                "  g();",
875                AllowsMergedIf);
876   verifyFormat("if (a) {\n"
877                "  g();\n"
878                "} else\n"
879                "  g();",
880                AllowsMergedIf);
881   verifyFormat("if (a)\n"
882                "  g();\n"
883                "else {\n"
884                "  g();\n"
885                "}",
886                AllowsMergedIf);
887   verifyFormat("if (a) {\n"
888                "  g();\n"
889                "} else {\n"
890                "  g();\n"
891                "}",
892                AllowsMergedIf);
893   verifyFormat("if (a)\n"
894                "  g();\n"
895                "else if (b)\n"
896                "  g();\n"
897                "else\n"
898                "  g();",
899                AllowsMergedIf);
900   verifyFormat("if (a) {\n"
901                "  g();\n"
902                "} else if (b)\n"
903                "  g();\n"
904                "else\n"
905                "  g();",
906                AllowsMergedIf);
907   verifyFormat("if (a)\n"
908                "  g();\n"
909                "else if (b) {\n"
910                "  g();\n"
911                "} else\n"
912                "  g();",
913                AllowsMergedIf);
914   verifyFormat("if (a)\n"
915                "  g();\n"
916                "else if (b)\n"
917                "  g();\n"
918                "else {\n"
919                "  g();\n"
920                "}",
921                AllowsMergedIf);
922   verifyFormat("if (a)\n"
923                "  g();\n"
924                "else if (b) {\n"
925                "  g();\n"
926                "} else {\n"
927                "  g();\n"
928                "}",
929                AllowsMergedIf);
930   verifyFormat("if (a) {\n"
931                "  g();\n"
932                "} else if (b) {\n"
933                "  g();\n"
934                "} else {\n"
935                "  g();\n"
936                "}",
937                AllowsMergedIf);
938   verifyFormat("MYIF (a)\n"
939                "  f();\n"
940                "else {\n"
941                "  g();\n"
942                "}",
943                AllowsMergedIf);
944   verifyFormat("MYIF (a)\n"
945                "  f();\n"
946                "else\n"
947                "  g();\n",
948                AllowsMergedIf);
949 
950   verifyFormat("MYIF (a) g();", AllowsMergedIf);
951   verifyFormat("MYIF (a) {\n"
952                "  g()\n"
953                "};",
954                AllowsMergedIf);
955   verifyFormat("MYIF (a)\n"
956                "  g();\n"
957                "else\n"
958                "  g();",
959                AllowsMergedIf);
960   verifyFormat("MYIF (a) {\n"
961                "  g();\n"
962                "} else\n"
963                "  g();",
964                AllowsMergedIf);
965   verifyFormat("MYIF (a)\n"
966                "  g();\n"
967                "else {\n"
968                "  g();\n"
969                "}",
970                AllowsMergedIf);
971   verifyFormat("MYIF (a) {\n"
972                "  g();\n"
973                "} else {\n"
974                "  g();\n"
975                "}",
976                AllowsMergedIf);
977   verifyFormat("MYIF (a)\n"
978                "  g();\n"
979                "else MYIF (b)\n"
980                "  g();\n"
981                "else\n"
982                "  g();",
983                AllowsMergedIf);
984   verifyFormat("MYIF (a)\n"
985                "  g();\n"
986                "else if (b)\n"
987                "  g();\n"
988                "else\n"
989                "  g();",
990                AllowsMergedIf);
991   verifyFormat("MYIF (a) {\n"
992                "  g();\n"
993                "} else MYIF (b)\n"
994                "  g();\n"
995                "else\n"
996                "  g();",
997                AllowsMergedIf);
998   verifyFormat("MYIF (a) {\n"
999                "  g();\n"
1000                "} else if (b)\n"
1001                "  g();\n"
1002                "else\n"
1003                "  g();",
1004                AllowsMergedIf);
1005   verifyFormat("MYIF (a)\n"
1006                "  g();\n"
1007                "else MYIF (b) {\n"
1008                "  g();\n"
1009                "} else\n"
1010                "  g();",
1011                AllowsMergedIf);
1012   verifyFormat("MYIF (a)\n"
1013                "  g();\n"
1014                "else if (b) {\n"
1015                "  g();\n"
1016                "} else\n"
1017                "  g();",
1018                AllowsMergedIf);
1019   verifyFormat("MYIF (a)\n"
1020                "  g();\n"
1021                "else MYIF (b)\n"
1022                "  g();\n"
1023                "else {\n"
1024                "  g();\n"
1025                "}",
1026                AllowsMergedIf);
1027   verifyFormat("MYIF (a)\n"
1028                "  g();\n"
1029                "else if (b)\n"
1030                "  g();\n"
1031                "else {\n"
1032                "  g();\n"
1033                "}",
1034                AllowsMergedIf);
1035   verifyFormat("MYIF (a)\n"
1036                "  g();\n"
1037                "else MYIF (b) {\n"
1038                "  g();\n"
1039                "} else {\n"
1040                "  g();\n"
1041                "}",
1042                AllowsMergedIf);
1043   verifyFormat("MYIF (a)\n"
1044                "  g();\n"
1045                "else if (b) {\n"
1046                "  g();\n"
1047                "} else {\n"
1048                "  g();\n"
1049                "}",
1050                AllowsMergedIf);
1051   verifyFormat("MYIF (a) {\n"
1052                "  g();\n"
1053                "} else MYIF (b) {\n"
1054                "  g();\n"
1055                "} else {\n"
1056                "  g();\n"
1057                "}",
1058                AllowsMergedIf);
1059   verifyFormat("MYIF (a) {\n"
1060                "  g();\n"
1061                "} else if (b) {\n"
1062                "  g();\n"
1063                "} else {\n"
1064                "  g();\n"
1065                "}",
1066                AllowsMergedIf);
1067 
1068   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
1069       FormatStyle::SIS_OnlyFirstIf;
1070 
1071   verifyFormat("if (a) f();\n"
1072                "else {\n"
1073                "  g();\n"
1074                "}",
1075                AllowsMergedIf);
1076   verifyFormat("if (a) f();\n"
1077                "else {\n"
1078                "  if (a) f();\n"
1079                "  else {\n"
1080                "    g();\n"
1081                "  }\n"
1082                "  g();\n"
1083                "}",
1084                AllowsMergedIf);
1085 
1086   verifyFormat("if (a) g();", AllowsMergedIf);
1087   verifyFormat("if (a) {\n"
1088                "  g()\n"
1089                "};",
1090                AllowsMergedIf);
1091   verifyFormat("if (a) g();\n"
1092                "else\n"
1093                "  g();",
1094                AllowsMergedIf);
1095   verifyFormat("if (a) {\n"
1096                "  g();\n"
1097                "} else\n"
1098                "  g();",
1099                AllowsMergedIf);
1100   verifyFormat("if (a) g();\n"
1101                "else {\n"
1102                "  g();\n"
1103                "}",
1104                AllowsMergedIf);
1105   verifyFormat("if (a) {\n"
1106                "  g();\n"
1107                "} else {\n"
1108                "  g();\n"
1109                "}",
1110                AllowsMergedIf);
1111   verifyFormat("if (a) g();\n"
1112                "else if (b)\n"
1113                "  g();\n"
1114                "else\n"
1115                "  g();",
1116                AllowsMergedIf);
1117   verifyFormat("if (a) {\n"
1118                "  g();\n"
1119                "} else if (b)\n"
1120                "  g();\n"
1121                "else\n"
1122                "  g();",
1123                AllowsMergedIf);
1124   verifyFormat("if (a) g();\n"
1125                "else if (b) {\n"
1126                "  g();\n"
1127                "} else\n"
1128                "  g();",
1129                AllowsMergedIf);
1130   verifyFormat("if (a) g();\n"
1131                "else if (b)\n"
1132                "  g();\n"
1133                "else {\n"
1134                "  g();\n"
1135                "}",
1136                AllowsMergedIf);
1137   verifyFormat("if (a) g();\n"
1138                "else if (b) {\n"
1139                "  g();\n"
1140                "} else {\n"
1141                "  g();\n"
1142                "}",
1143                AllowsMergedIf);
1144   verifyFormat("if (a) {\n"
1145                "  g();\n"
1146                "} else if (b) {\n"
1147                "  g();\n"
1148                "} else {\n"
1149                "  g();\n"
1150                "}",
1151                AllowsMergedIf);
1152   verifyFormat("MYIF (a) f();\n"
1153                "else {\n"
1154                "  g();\n"
1155                "}",
1156                AllowsMergedIf);
1157   verifyFormat("MYIF (a) f();\n"
1158                "else {\n"
1159                "  if (a) f();\n"
1160                "  else {\n"
1161                "    g();\n"
1162                "  }\n"
1163                "  g();\n"
1164                "}",
1165                AllowsMergedIf);
1166 
1167   verifyFormat("MYIF (a) g();", AllowsMergedIf);
1168   verifyFormat("MYIF (a) {\n"
1169                "  g()\n"
1170                "};",
1171                AllowsMergedIf);
1172   verifyFormat("MYIF (a) g();\n"
1173                "else\n"
1174                "  g();",
1175                AllowsMergedIf);
1176   verifyFormat("MYIF (a) {\n"
1177                "  g();\n"
1178                "} else\n"
1179                "  g();",
1180                AllowsMergedIf);
1181   verifyFormat("MYIF (a) g();\n"
1182                "else {\n"
1183                "  g();\n"
1184                "}",
1185                AllowsMergedIf);
1186   verifyFormat("MYIF (a) {\n"
1187                "  g();\n"
1188                "} else {\n"
1189                "  g();\n"
1190                "}",
1191                AllowsMergedIf);
1192   verifyFormat("MYIF (a) g();\n"
1193                "else MYIF (b)\n"
1194                "  g();\n"
1195                "else\n"
1196                "  g();",
1197                AllowsMergedIf);
1198   verifyFormat("MYIF (a) g();\n"
1199                "else if (b)\n"
1200                "  g();\n"
1201                "else\n"
1202                "  g();",
1203                AllowsMergedIf);
1204   verifyFormat("MYIF (a) {\n"
1205                "  g();\n"
1206                "} else MYIF (b)\n"
1207                "  g();\n"
1208                "else\n"
1209                "  g();",
1210                AllowsMergedIf);
1211   verifyFormat("MYIF (a) {\n"
1212                "  g();\n"
1213                "} else if (b)\n"
1214                "  g();\n"
1215                "else\n"
1216                "  g();",
1217                AllowsMergedIf);
1218   verifyFormat("MYIF (a) g();\n"
1219                "else MYIF (b) {\n"
1220                "  g();\n"
1221                "} else\n"
1222                "  g();",
1223                AllowsMergedIf);
1224   verifyFormat("MYIF (a) g();\n"
1225                "else if (b) {\n"
1226                "  g();\n"
1227                "} else\n"
1228                "  g();",
1229                AllowsMergedIf);
1230   verifyFormat("MYIF (a) g();\n"
1231                "else MYIF (b)\n"
1232                "  g();\n"
1233                "else {\n"
1234                "  g();\n"
1235                "}",
1236                AllowsMergedIf);
1237   verifyFormat("MYIF (a) g();\n"
1238                "else if (b)\n"
1239                "  g();\n"
1240                "else {\n"
1241                "  g();\n"
1242                "}",
1243                AllowsMergedIf);
1244   verifyFormat("MYIF (a) g();\n"
1245                "else MYIF (b) {\n"
1246                "  g();\n"
1247                "} else {\n"
1248                "  g();\n"
1249                "}",
1250                AllowsMergedIf);
1251   verifyFormat("MYIF (a) g();\n"
1252                "else if (b) {\n"
1253                "  g();\n"
1254                "} else {\n"
1255                "  g();\n"
1256                "}",
1257                AllowsMergedIf);
1258   verifyFormat("MYIF (a) {\n"
1259                "  g();\n"
1260                "} else MYIF (b) {\n"
1261                "  g();\n"
1262                "} else {\n"
1263                "  g();\n"
1264                "}",
1265                AllowsMergedIf);
1266   verifyFormat("MYIF (a) {\n"
1267                "  g();\n"
1268                "} else if (b) {\n"
1269                "  g();\n"
1270                "} else {\n"
1271                "  g();\n"
1272                "}",
1273                AllowsMergedIf);
1274 
1275   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
1276       FormatStyle::SIS_AllIfsAndElse;
1277 
1278   verifyFormat("if (a) f();\n"
1279                "else {\n"
1280                "  g();\n"
1281                "}",
1282                AllowsMergedIf);
1283   verifyFormat("if (a) f();\n"
1284                "else {\n"
1285                "  if (a) f();\n"
1286                "  else {\n"
1287                "    g();\n"
1288                "  }\n"
1289                "  g();\n"
1290                "}",
1291                AllowsMergedIf);
1292 
1293   verifyFormat("if (a) g();", AllowsMergedIf);
1294   verifyFormat("if (a) {\n"
1295                "  g()\n"
1296                "};",
1297                AllowsMergedIf);
1298   verifyFormat("if (a) g();\n"
1299                "else g();",
1300                AllowsMergedIf);
1301   verifyFormat("if (a) {\n"
1302                "  g();\n"
1303                "} else g();",
1304                AllowsMergedIf);
1305   verifyFormat("if (a) g();\n"
1306                "else {\n"
1307                "  g();\n"
1308                "}",
1309                AllowsMergedIf);
1310   verifyFormat("if (a) {\n"
1311                "  g();\n"
1312                "} else {\n"
1313                "  g();\n"
1314                "}",
1315                AllowsMergedIf);
1316   verifyFormat("if (a) g();\n"
1317                "else if (b) g();\n"
1318                "else g();",
1319                AllowsMergedIf);
1320   verifyFormat("if (a) {\n"
1321                "  g();\n"
1322                "} else if (b) g();\n"
1323                "else g();",
1324                AllowsMergedIf);
1325   verifyFormat("if (a) g();\n"
1326                "else if (b) {\n"
1327                "  g();\n"
1328                "} else g();",
1329                AllowsMergedIf);
1330   verifyFormat("if (a) g();\n"
1331                "else if (b) g();\n"
1332                "else {\n"
1333                "  g();\n"
1334                "}",
1335                AllowsMergedIf);
1336   verifyFormat("if (a) g();\n"
1337                "else if (b) {\n"
1338                "  g();\n"
1339                "} else {\n"
1340                "  g();\n"
1341                "}",
1342                AllowsMergedIf);
1343   verifyFormat("if (a) {\n"
1344                "  g();\n"
1345                "} else if (b) {\n"
1346                "  g();\n"
1347                "} else {\n"
1348                "  g();\n"
1349                "}",
1350                AllowsMergedIf);
1351   verifyFormat("MYIF (a) f();\n"
1352                "else {\n"
1353                "  g();\n"
1354                "}",
1355                AllowsMergedIf);
1356   verifyFormat("MYIF (a) f();\n"
1357                "else {\n"
1358                "  if (a) f();\n"
1359                "  else {\n"
1360                "    g();\n"
1361                "  }\n"
1362                "  g();\n"
1363                "}",
1364                AllowsMergedIf);
1365 
1366   verifyFormat("MYIF (a) g();", AllowsMergedIf);
1367   verifyFormat("MYIF (a) {\n"
1368                "  g()\n"
1369                "};",
1370                AllowsMergedIf);
1371   verifyFormat("MYIF (a) g();\n"
1372                "else g();",
1373                AllowsMergedIf);
1374   verifyFormat("MYIF (a) {\n"
1375                "  g();\n"
1376                "} else g();",
1377                AllowsMergedIf);
1378   verifyFormat("MYIF (a) g();\n"
1379                "else {\n"
1380                "  g();\n"
1381                "}",
1382                AllowsMergedIf);
1383   verifyFormat("MYIF (a) {\n"
1384                "  g();\n"
1385                "} else {\n"
1386                "  g();\n"
1387                "}",
1388                AllowsMergedIf);
1389   verifyFormat("MYIF (a) g();\n"
1390                "else MYIF (b) g();\n"
1391                "else g();",
1392                AllowsMergedIf);
1393   verifyFormat("MYIF (a) g();\n"
1394                "else if (b) g();\n"
1395                "else g();",
1396                AllowsMergedIf);
1397   verifyFormat("MYIF (a) {\n"
1398                "  g();\n"
1399                "} else MYIF (b) g();\n"
1400                "else g();",
1401                AllowsMergedIf);
1402   verifyFormat("MYIF (a) {\n"
1403                "  g();\n"
1404                "} else if (b) g();\n"
1405                "else g();",
1406                AllowsMergedIf);
1407   verifyFormat("MYIF (a) g();\n"
1408                "else MYIF (b) {\n"
1409                "  g();\n"
1410                "} else g();",
1411                AllowsMergedIf);
1412   verifyFormat("MYIF (a) g();\n"
1413                "else if (b) {\n"
1414                "  g();\n"
1415                "} else g();",
1416                AllowsMergedIf);
1417   verifyFormat("MYIF (a) g();\n"
1418                "else MYIF (b) g();\n"
1419                "else {\n"
1420                "  g();\n"
1421                "}",
1422                AllowsMergedIf);
1423   verifyFormat("MYIF (a) g();\n"
1424                "else if (b) g();\n"
1425                "else {\n"
1426                "  g();\n"
1427                "}",
1428                AllowsMergedIf);
1429   verifyFormat("MYIF (a) g();\n"
1430                "else MYIF (b) {\n"
1431                "  g();\n"
1432                "} else {\n"
1433                "  g();\n"
1434                "}",
1435                AllowsMergedIf);
1436   verifyFormat("MYIF (a) g();\n"
1437                "else if (b) {\n"
1438                "  g();\n"
1439                "} else {\n"
1440                "  g();\n"
1441                "}",
1442                AllowsMergedIf);
1443   verifyFormat("MYIF (a) {\n"
1444                "  g();\n"
1445                "} else MYIF (b) {\n"
1446                "  g();\n"
1447                "} else {\n"
1448                "  g();\n"
1449                "}",
1450                AllowsMergedIf);
1451   verifyFormat("MYIF (a) {\n"
1452                "  g();\n"
1453                "} else if (b) {\n"
1454                "  g();\n"
1455                "} else {\n"
1456                "  g();\n"
1457                "}",
1458                AllowsMergedIf);
1459 }
1460 
1461 TEST_F(FormatTest, FormatLoopsWithoutCompoundStatement) {
1462   FormatStyle AllowsMergedLoops = getLLVMStyle();
1463   AllowsMergedLoops.AllowShortLoopsOnASingleLine = true;
1464   verifyFormat("while (true) continue;", AllowsMergedLoops);
1465   verifyFormat("for (;;) continue;", AllowsMergedLoops);
1466   verifyFormat("for (int &v : vec) v *= 2;", AllowsMergedLoops);
1467   verifyFormat("while (true)\n"
1468                "  ;",
1469                AllowsMergedLoops);
1470   verifyFormat("for (;;)\n"
1471                "  ;",
1472                AllowsMergedLoops);
1473   verifyFormat("for (;;)\n"
1474                "  for (;;) continue;",
1475                AllowsMergedLoops);
1476   verifyFormat("for (;;) // Can't merge this\n"
1477                "  continue;",
1478                AllowsMergedLoops);
1479   verifyFormat("for (;;) /* still don't merge */\n"
1480                "  continue;",
1481                AllowsMergedLoops);
1482   verifyFormat("do a++;\n"
1483                "while (true);",
1484                AllowsMergedLoops);
1485   verifyFormat("do /* Don't merge */\n"
1486                "  a++;\n"
1487                "while (true);",
1488                AllowsMergedLoops);
1489   verifyFormat("do // Don't merge\n"
1490                "  a++;\n"
1491                "while (true);",
1492                AllowsMergedLoops);
1493   verifyFormat("do\n"
1494                "  // Don't merge\n"
1495                "  a++;\n"
1496                "while (true);",
1497                AllowsMergedLoops);
1498   // Without braces labels are interpreted differently.
1499   verifyFormat("{\n"
1500                "  do\n"
1501                "  label:\n"
1502                "    a++;\n"
1503                "  while (true);\n"
1504                "}",
1505                AllowsMergedLoops);
1506 }
1507 
1508 TEST_F(FormatTest, FormatShortBracedStatements) {
1509   FormatStyle AllowSimpleBracedStatements = getLLVMStyle();
1510   AllowSimpleBracedStatements.IfMacros.push_back("MYIF");
1511   // Where line-lengths matter, a 2-letter synonym that maintains line length.
1512   // Not IF to avoid any confusion that IF is somehow special.
1513   AllowSimpleBracedStatements.IfMacros.push_back("FI");
1514   AllowSimpleBracedStatements.ColumnLimit = 40;
1515   AllowSimpleBracedStatements.AllowShortBlocksOnASingleLine =
1516       FormatStyle::SBS_Always;
1517 
1518   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
1519       FormatStyle::SIS_WithoutElse;
1520   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
1521 
1522   AllowSimpleBracedStatements.BreakBeforeBraces = FormatStyle::BS_Custom;
1523   AllowSimpleBracedStatements.BraceWrapping.AfterFunction = true;
1524   AllowSimpleBracedStatements.BraceWrapping.SplitEmptyRecord = false;
1525 
1526   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
1527   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
1528   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
1529   verifyFormat("MYIF (true) {}", AllowSimpleBracedStatements);
1530   verifyFormat("MYIF constexpr (true) {}", AllowSimpleBracedStatements);
1531   verifyFormat("MYIF CONSTEXPR (true) {}", AllowSimpleBracedStatements);
1532   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
1533   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
1534   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
1535   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
1536   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
1537   verifyFormat("MYIF (true) { f(); }", AllowSimpleBracedStatements);
1538   verifyFormat("MYIF constexpr (true) { f(); }", AllowSimpleBracedStatements);
1539   verifyFormat("MYIF CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
1540   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
1541   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
1542   verifyFormat("if (true) { fffffffffffffffffffffff(); }",
1543                AllowSimpleBracedStatements);
1544   verifyFormat("if (true) {\n"
1545                "  ffffffffffffffffffffffff();\n"
1546                "}",
1547                AllowSimpleBracedStatements);
1548   verifyFormat("if (true) {\n"
1549                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
1550                "}",
1551                AllowSimpleBracedStatements);
1552   verifyFormat("if (true) { //\n"
1553                "  f();\n"
1554                "}",
1555                AllowSimpleBracedStatements);
1556   verifyFormat("if (true) {\n"
1557                "  f();\n"
1558                "  f();\n"
1559                "}",
1560                AllowSimpleBracedStatements);
1561   verifyFormat("if (true) {\n"
1562                "  f();\n"
1563                "} else {\n"
1564                "  f();\n"
1565                "}",
1566                AllowSimpleBracedStatements);
1567   verifyFormat("FI (true) { fffffffffffffffffffffff(); }",
1568                AllowSimpleBracedStatements);
1569   verifyFormat("MYIF (true) {\n"
1570                "  ffffffffffffffffffffffff();\n"
1571                "}",
1572                AllowSimpleBracedStatements);
1573   verifyFormat("MYIF (true) {\n"
1574                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
1575                "}",
1576                AllowSimpleBracedStatements);
1577   verifyFormat("MYIF (true) { //\n"
1578                "  f();\n"
1579                "}",
1580                AllowSimpleBracedStatements);
1581   verifyFormat("MYIF (true) {\n"
1582                "  f();\n"
1583                "  f();\n"
1584                "}",
1585                AllowSimpleBracedStatements);
1586   verifyFormat("MYIF (true) {\n"
1587                "  f();\n"
1588                "} else {\n"
1589                "  f();\n"
1590                "}",
1591                AllowSimpleBracedStatements);
1592 
1593   verifyFormat("struct A2 {\n"
1594                "  int X;\n"
1595                "};",
1596                AllowSimpleBracedStatements);
1597   verifyFormat("typedef struct A2 {\n"
1598                "  int X;\n"
1599                "} A2_t;",
1600                AllowSimpleBracedStatements);
1601   verifyFormat("template <int> struct A2 {\n"
1602                "  struct B {};\n"
1603                "};",
1604                AllowSimpleBracedStatements);
1605 
1606   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
1607       FormatStyle::SIS_Never;
1608   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
1609   verifyFormat("if (true) {\n"
1610                "  f();\n"
1611                "}",
1612                AllowSimpleBracedStatements);
1613   verifyFormat("if (true) {\n"
1614                "  f();\n"
1615                "} else {\n"
1616                "  f();\n"
1617                "}",
1618                AllowSimpleBracedStatements);
1619   verifyFormat("MYIF (true) {}", AllowSimpleBracedStatements);
1620   verifyFormat("MYIF (true) {\n"
1621                "  f();\n"
1622                "}",
1623                AllowSimpleBracedStatements);
1624   verifyFormat("MYIF (true) {\n"
1625                "  f();\n"
1626                "} else {\n"
1627                "  f();\n"
1628                "}",
1629                AllowSimpleBracedStatements);
1630 
1631   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
1632   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
1633   verifyFormat("while (true) {\n"
1634                "  f();\n"
1635                "}",
1636                AllowSimpleBracedStatements);
1637   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
1638   verifyFormat("for (;;) {\n"
1639                "  f();\n"
1640                "}",
1641                AllowSimpleBracedStatements);
1642 
1643   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
1644       FormatStyle::SIS_WithoutElse;
1645   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = true;
1646   AllowSimpleBracedStatements.BraceWrapping.AfterControlStatement =
1647       FormatStyle::BWACS_Always;
1648 
1649   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
1650   verifyFormat("if constexpr (true) {}", AllowSimpleBracedStatements);
1651   verifyFormat("if CONSTEXPR (true) {}", AllowSimpleBracedStatements);
1652   verifyFormat("MYIF (true) {}", AllowSimpleBracedStatements);
1653   verifyFormat("MYIF constexpr (true) {}", AllowSimpleBracedStatements);
1654   verifyFormat("MYIF CONSTEXPR (true) {}", AllowSimpleBracedStatements);
1655   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
1656   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
1657   verifyFormat("if (true) { f(); }", AllowSimpleBracedStatements);
1658   verifyFormat("if constexpr (true) { f(); }", AllowSimpleBracedStatements);
1659   verifyFormat("if CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
1660   verifyFormat("MYIF (true) { f(); }", AllowSimpleBracedStatements);
1661   verifyFormat("MYIF constexpr (true) { f(); }", AllowSimpleBracedStatements);
1662   verifyFormat("MYIF CONSTEXPR (true) { f(); }", AllowSimpleBracedStatements);
1663   verifyFormat("while (true) { f(); }", AllowSimpleBracedStatements);
1664   verifyFormat("for (;;) { f(); }", AllowSimpleBracedStatements);
1665   verifyFormat("if (true) { fffffffffffffffffffffff(); }",
1666                AllowSimpleBracedStatements);
1667   verifyFormat("if (true)\n"
1668                "{\n"
1669                "  ffffffffffffffffffffffff();\n"
1670                "}",
1671                AllowSimpleBracedStatements);
1672   verifyFormat("if (true)\n"
1673                "{\n"
1674                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
1675                "}",
1676                AllowSimpleBracedStatements);
1677   verifyFormat("if (true)\n"
1678                "{ //\n"
1679                "  f();\n"
1680                "}",
1681                AllowSimpleBracedStatements);
1682   verifyFormat("if (true)\n"
1683                "{\n"
1684                "  f();\n"
1685                "  f();\n"
1686                "}",
1687                AllowSimpleBracedStatements);
1688   verifyFormat("if (true)\n"
1689                "{\n"
1690                "  f();\n"
1691                "} else\n"
1692                "{\n"
1693                "  f();\n"
1694                "}",
1695                AllowSimpleBracedStatements);
1696   verifyFormat("FI (true) { fffffffffffffffffffffff(); }",
1697                AllowSimpleBracedStatements);
1698   verifyFormat("MYIF (true)\n"
1699                "{\n"
1700                "  ffffffffffffffffffffffff();\n"
1701                "}",
1702                AllowSimpleBracedStatements);
1703   verifyFormat("MYIF (true)\n"
1704                "{\n"
1705                "  ffffffffffffffffffffffffffffffffffffffffffffffffffffff();\n"
1706                "}",
1707                AllowSimpleBracedStatements);
1708   verifyFormat("MYIF (true)\n"
1709                "{ //\n"
1710                "  f();\n"
1711                "}",
1712                AllowSimpleBracedStatements);
1713   verifyFormat("MYIF (true)\n"
1714                "{\n"
1715                "  f();\n"
1716                "  f();\n"
1717                "}",
1718                AllowSimpleBracedStatements);
1719   verifyFormat("MYIF (true)\n"
1720                "{\n"
1721                "  f();\n"
1722                "} else\n"
1723                "{\n"
1724                "  f();\n"
1725                "}",
1726                AllowSimpleBracedStatements);
1727 
1728   AllowSimpleBracedStatements.AllowShortIfStatementsOnASingleLine =
1729       FormatStyle::SIS_Never;
1730   verifyFormat("if (true) {}", AllowSimpleBracedStatements);
1731   verifyFormat("if (true)\n"
1732                "{\n"
1733                "  f();\n"
1734                "}",
1735                AllowSimpleBracedStatements);
1736   verifyFormat("if (true)\n"
1737                "{\n"
1738                "  f();\n"
1739                "} else\n"
1740                "{\n"
1741                "  f();\n"
1742                "}",
1743                AllowSimpleBracedStatements);
1744   verifyFormat("MYIF (true) {}", AllowSimpleBracedStatements);
1745   verifyFormat("MYIF (true)\n"
1746                "{\n"
1747                "  f();\n"
1748                "}",
1749                AllowSimpleBracedStatements);
1750   verifyFormat("MYIF (true)\n"
1751                "{\n"
1752                "  f();\n"
1753                "} else\n"
1754                "{\n"
1755                "  f();\n"
1756                "}",
1757                AllowSimpleBracedStatements);
1758 
1759   AllowSimpleBracedStatements.AllowShortLoopsOnASingleLine = false;
1760   verifyFormat("while (true) {}", AllowSimpleBracedStatements);
1761   verifyFormat("while (true)\n"
1762                "{\n"
1763                "  f();\n"
1764                "}",
1765                AllowSimpleBracedStatements);
1766   verifyFormat("for (;;) {}", AllowSimpleBracedStatements);
1767   verifyFormat("for (;;)\n"
1768                "{\n"
1769                "  f();\n"
1770                "}",
1771                AllowSimpleBracedStatements);
1772 }
1773 
1774 TEST_F(FormatTest, ShortBlocksInMacrosDontMergeWithCodeAfterMacro) {
1775   FormatStyle Style = getLLVMStyleWithColumns(60);
1776   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
1777   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
1778   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
1779   EXPECT_EQ("#define A                                                  \\\n"
1780             "  if (HANDLEwernufrnuLwrmviferuvnierv)                     \\\n"
1781             "  {                                                        \\\n"
1782             "    RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier;               \\\n"
1783             "  }\n"
1784             "X;",
1785             format("#define A \\\n"
1786                    "   if (HANDLEwernufrnuLwrmviferuvnierv) { \\\n"
1787                    "      RET_ERR1_ANUIREUINERUIFNIOAerwfwrvnuier; \\\n"
1788                    "   }\n"
1789                    "X;",
1790                    Style));
1791 }
1792 
1793 TEST_F(FormatTest, ParseIfElse) {
1794   verifyFormat("if (true)\n"
1795                "  if (true)\n"
1796                "    if (true)\n"
1797                "      f();\n"
1798                "    else\n"
1799                "      g();\n"
1800                "  else\n"
1801                "    h();\n"
1802                "else\n"
1803                "  i();");
1804   verifyFormat("if (true)\n"
1805                "  if (true)\n"
1806                "    if (true) {\n"
1807                "      if (true)\n"
1808                "        f();\n"
1809                "    } else {\n"
1810                "      g();\n"
1811                "    }\n"
1812                "  else\n"
1813                "    h();\n"
1814                "else {\n"
1815                "  i();\n"
1816                "}");
1817   verifyFormat("if (true)\n"
1818                "  if constexpr (true)\n"
1819                "    if (true) {\n"
1820                "      if constexpr (true)\n"
1821                "        f();\n"
1822                "    } else {\n"
1823                "      g();\n"
1824                "    }\n"
1825                "  else\n"
1826                "    h();\n"
1827                "else {\n"
1828                "  i();\n"
1829                "}");
1830   verifyFormat("if (true)\n"
1831                "  if CONSTEXPR (true)\n"
1832                "    if (true) {\n"
1833                "      if CONSTEXPR (true)\n"
1834                "        f();\n"
1835                "    } else {\n"
1836                "      g();\n"
1837                "    }\n"
1838                "  else\n"
1839                "    h();\n"
1840                "else {\n"
1841                "  i();\n"
1842                "}");
1843   verifyFormat("void f() {\n"
1844                "  if (a) {\n"
1845                "  } else {\n"
1846                "  }\n"
1847                "}");
1848 }
1849 
1850 TEST_F(FormatTest, ElseIf) {
1851   verifyFormat("if (a) {\n} else if (b) {\n}");
1852   verifyFormat("if (a)\n"
1853                "  f();\n"
1854                "else if (b)\n"
1855                "  g();\n"
1856                "else\n"
1857                "  h();");
1858   verifyFormat("if (a)\n"
1859                "  f();\n"
1860                "else // comment\n"
1861                "  if (b) {\n"
1862                "    g();\n"
1863                "    h();\n"
1864                "  }");
1865   verifyFormat("if constexpr (a)\n"
1866                "  f();\n"
1867                "else if constexpr (b)\n"
1868                "  g();\n"
1869                "else\n"
1870                "  h();");
1871   verifyFormat("if CONSTEXPR (a)\n"
1872                "  f();\n"
1873                "else if CONSTEXPR (b)\n"
1874                "  g();\n"
1875                "else\n"
1876                "  h();");
1877   verifyFormat("if (a) {\n"
1878                "  f();\n"
1879                "}\n"
1880                "// or else ..\n"
1881                "else {\n"
1882                "  g()\n"
1883                "}");
1884 
1885   verifyFormat("if (a) {\n"
1886                "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
1887                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
1888                "}");
1889   verifyFormat("if (a) {\n"
1890                "} else if constexpr (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
1891                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
1892                "}");
1893   verifyFormat("if (a) {\n"
1894                "} else if CONSTEXPR (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
1895                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
1896                "}");
1897   verifyFormat("if (a) {\n"
1898                "} else if (\n"
1899                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
1900                "}",
1901                getLLVMStyleWithColumns(62));
1902   verifyFormat("if (a) {\n"
1903                "} else if constexpr (\n"
1904                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
1905                "}",
1906                getLLVMStyleWithColumns(62));
1907   verifyFormat("if (a) {\n"
1908                "} else if CONSTEXPR (\n"
1909                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
1910                "}",
1911                getLLVMStyleWithColumns(62));
1912 }
1913 
1914 TEST_F(FormatTest, SeparatePointerReferenceAlignment) {
1915   FormatStyle Style = getLLVMStyle();
1916   // Check first the default LLVM style
1917   // Style.PointerAlignment = FormatStyle::PAS_Right;
1918   // Style.ReferenceAlignment = FormatStyle::RAS_Pointer;
1919   verifyFormat("int *f1(int *a, int &b, int &&c);", Style);
1920   verifyFormat("int &f2(int &&c, int *a, int &b);", Style);
1921   verifyFormat("int &&f3(int &b, int &&c, int *a);", Style);
1922   verifyFormat("int *f1(int &a) const &;", Style);
1923   verifyFormat("int *f1(int &a) const & = 0;", Style);
1924   verifyFormat("int *a = f1();", Style);
1925   verifyFormat("int &b = f2();", Style);
1926   verifyFormat("int &&c = f3();", Style);
1927 
1928   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
1929   verifyFormat("Const unsigned int *c;\n"
1930                "const unsigned int *d;\n"
1931                "Const unsigned int &e;\n"
1932                "const unsigned int &f;\n"
1933                "const unsigned    &&g;\n"
1934                "Const unsigned      h;",
1935                Style);
1936 
1937   Style.PointerAlignment = FormatStyle::PAS_Left;
1938   Style.ReferenceAlignment = FormatStyle::RAS_Pointer;
1939   verifyFormat("int* f1(int* a, int& b, int&& c);", Style);
1940   verifyFormat("int& f2(int&& c, int* a, int& b);", Style);
1941   verifyFormat("int&& f3(int& b, int&& c, int* a);", Style);
1942   verifyFormat("int* f1(int& a) const& = 0;", Style);
1943   verifyFormat("int* a = f1();", Style);
1944   verifyFormat("int& b = f2();", Style);
1945   verifyFormat("int&& c = f3();", Style);
1946 
1947   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
1948   verifyFormat("Const unsigned int* c;\n"
1949                "const unsigned int* d;\n"
1950                "Const unsigned int& e;\n"
1951                "const unsigned int& f;\n"
1952                "const unsigned&&    g;\n"
1953                "Const unsigned      h;",
1954                Style);
1955 
1956   Style.PointerAlignment = FormatStyle::PAS_Right;
1957   Style.ReferenceAlignment = FormatStyle::RAS_Left;
1958   verifyFormat("int *f1(int *a, int& b, int&& c);", Style);
1959   verifyFormat("int& f2(int&& c, int *a, int& b);", Style);
1960   verifyFormat("int&& f3(int& b, int&& c, int *a);", Style);
1961   verifyFormat("int *a = f1();", Style);
1962   verifyFormat("int& b = f2();", Style);
1963   verifyFormat("int&& c = f3();", Style);
1964 
1965   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
1966   verifyFormat("Const unsigned int *c;\n"
1967                "const unsigned int *d;\n"
1968                "Const unsigned int& e;\n"
1969                "const unsigned int& f;\n"
1970                "const unsigned      g;\n"
1971                "Const unsigned      h;",
1972                Style);
1973 
1974   Style.PointerAlignment = FormatStyle::PAS_Left;
1975   Style.ReferenceAlignment = FormatStyle::RAS_Middle;
1976   verifyFormat("int* f1(int* a, int & b, int && c);", Style);
1977   verifyFormat("int & f2(int && c, int* a, int & b);", Style);
1978   verifyFormat("int && f3(int & b, int && c, int* a);", Style);
1979   verifyFormat("int* a = f1();", Style);
1980   verifyFormat("int & b = f2();", Style);
1981   verifyFormat("int && c = f3();", Style);
1982 
1983   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
1984   verifyFormat("Const unsigned int*  c;\n"
1985                "const unsigned int*  d;\n"
1986                "Const unsigned int & e;\n"
1987                "const unsigned int & f;\n"
1988                "const unsigned &&    g;\n"
1989                "Const unsigned       h;",
1990                Style);
1991 
1992   Style.PointerAlignment = FormatStyle::PAS_Middle;
1993   Style.ReferenceAlignment = FormatStyle::RAS_Right;
1994   verifyFormat("int * f1(int * a, int &b, int &&c);", Style);
1995   verifyFormat("int &f2(int &&c, int * a, int &b);", Style);
1996   verifyFormat("int &&f3(int &b, int &&c, int * a);", Style);
1997   verifyFormat("int * a = f1();", Style);
1998   verifyFormat("int &b = f2();", Style);
1999   verifyFormat("int &&c = f3();", Style);
2000 
2001   // FIXME: we don't handle this yet, so output may be arbitrary until it's
2002   // specifically handled
2003   // verifyFormat("int Add2(BTree * &Root, char * szToAdd)", Style);
2004 }
2005 
2006 TEST_F(FormatTest, FormatsForLoop) {
2007   verifyFormat(
2008       "for (int VeryVeryLongLoopVariable = 0; VeryVeryLongLoopVariable < 10;\n"
2009       "     ++VeryVeryLongLoopVariable)\n"
2010       "  ;");
2011   verifyFormat("for (;;)\n"
2012                "  f();");
2013   verifyFormat("for (;;) {\n}");
2014   verifyFormat("for (;;) {\n"
2015                "  f();\n"
2016                "}");
2017   verifyFormat("for (int i = 0; (i < 10); ++i) {\n}");
2018 
2019   verifyFormat(
2020       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
2021       "                                          E = UnwrappedLines.end();\n"
2022       "     I != E; ++I) {\n}");
2023 
2024   verifyFormat(
2025       "for (MachineFun::iterator IIII = PrevIt, EEEE = F.end(); IIII != EEEE;\n"
2026       "     ++IIIII) {\n}");
2027   verifyFormat("for (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaa =\n"
2028                "         aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa;\n"
2029                "     aaaaaaaaaaa != aaaaaaaaaaaaaaaaaaa; ++aaaaaaaaaaa) {\n}");
2030   verifyFormat("for (llvm::ArrayRef<NamedDecl *>::iterator\n"
2031                "         I = FD->getDeclsInPrototypeScope().begin(),\n"
2032                "         E = FD->getDeclsInPrototypeScope().end();\n"
2033                "     I != E; ++I) {\n}");
2034   verifyFormat("for (SmallVectorImpl<TemplateIdAnnotationn *>::iterator\n"
2035                "         I = Container.begin(),\n"
2036                "         E = Container.end();\n"
2037                "     I != E; ++I) {\n}",
2038                getLLVMStyleWithColumns(76));
2039 
2040   verifyFormat(
2041       "for (aaaaaaaaaaaaaaaaa aaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
2042       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa !=\n"
2043       "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2044       "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
2045       "     ++aaaaaaaaaaa) {\n}");
2046   verifyFormat("for (int i = 0; i < aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2047                "                bbbbbbbbbbbbbbbbbbbb < ccccccccccccccc;\n"
2048                "     ++i) {\n}");
2049   verifyFormat("for (int aaaaaaaaaaa = 1; aaaaaaaaaaa <= bbbbbbbbbbbbbbb;\n"
2050                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
2051                "}");
2052   verifyFormat("for (some_namespace::SomeIterator iter( // force break\n"
2053                "         aaaaaaaaaa);\n"
2054                "     iter; ++iter) {\n"
2055                "}");
2056   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2057                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
2058                "     aaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbbbbbbb;\n"
2059                "     ++aaaaaaaaaaaaaaaaaaaaaaaaaaa) {");
2060 
2061   // These should not be formatted as Objective-C for-in loops.
2062   verifyFormat("for (Foo *x = 0; x != in; x++) {\n}");
2063   verifyFormat("Foo *x;\nfor (x = 0; x != in; x++) {\n}");
2064   verifyFormat("Foo *x;\nfor (x in y) {\n}");
2065   verifyFormat(
2066       "for (const Foo<Bar> &baz = in.value(); !baz.at_end(); ++baz) {\n}");
2067 
2068   FormatStyle NoBinPacking = getLLVMStyle();
2069   NoBinPacking.BinPackParameters = false;
2070   verifyFormat("for (int aaaaaaaaaaa = 1;\n"
2071                "     aaaaaaaaaaa <= aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa,\n"
2072                "                                           aaaaaaaaaaaaaaaa,\n"
2073                "                                           aaaaaaaaaaaaaaaa,\n"
2074                "                                           aaaaaaaaaaaaaaaa);\n"
2075                "     aaaaaaaaaaa++, bbbbbbbbbbbbbbbbb++) {\n"
2076                "}",
2077                NoBinPacking);
2078   verifyFormat(
2079       "for (std::vector<UnwrappedLine>::iterator I = UnwrappedLines.begin(),\n"
2080       "                                          E = UnwrappedLines.end();\n"
2081       "     I != E;\n"
2082       "     ++I) {\n}",
2083       NoBinPacking);
2084 
2085   FormatStyle AlignLeft = getLLVMStyle();
2086   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
2087   verifyFormat("for (A* a = start; a < end; ++a, ++value) {\n}", AlignLeft);
2088 }
2089 
2090 TEST_F(FormatTest, RangeBasedForLoops) {
2091   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
2092                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
2093   verifyFormat("for (auto aaaaaaaaaaaaaaaaaaaaa :\n"
2094                "     aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa, aaaaaaaaaaaaa)) {\n}");
2095   verifyFormat("for (const aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaa :\n"
2096                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
2097   verifyFormat("for (aaaaaaaaa aaaaaaaaaaaaaaaaaaaaa :\n"
2098                "     aaaaaaaaaaaa.aaaaaaaaaaaa().aaaaaaaaa().a()) {\n}");
2099 }
2100 
2101 TEST_F(FormatTest, ForEachLoops) {
2102   verifyFormat("void f() {\n"
2103                "  foreach (Item *item, itemlist) {}\n"
2104                "  Q_FOREACH (Item *item, itemlist) {}\n"
2105                "  BOOST_FOREACH (Item *item, itemlist) {}\n"
2106                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
2107                "}");
2108 
2109   FormatStyle Style = getLLVMStyle();
2110   Style.SpaceBeforeParens =
2111       FormatStyle::SBPO_ControlStatementsExceptControlMacros;
2112   verifyFormat("void f() {\n"
2113                "  foreach(Item *item, itemlist) {}\n"
2114                "  Q_FOREACH(Item *item, itemlist) {}\n"
2115                "  BOOST_FOREACH(Item *item, itemlist) {}\n"
2116                "  UNKNOWN_FORACH(Item * item, itemlist) {}\n"
2117                "}",
2118                Style);
2119 
2120   // As function-like macros.
2121   verifyFormat("#define foreach(x, y)\n"
2122                "#define Q_FOREACH(x, y)\n"
2123                "#define BOOST_FOREACH(x, y)\n"
2124                "#define UNKNOWN_FOREACH(x, y)\n");
2125 
2126   // Not as function-like macros.
2127   verifyFormat("#define foreach (x, y)\n"
2128                "#define Q_FOREACH (x, y)\n"
2129                "#define BOOST_FOREACH (x, y)\n"
2130                "#define UNKNOWN_FOREACH (x, y)\n");
2131 
2132   // handle microsoft non standard extension
2133   verifyFormat("for each (char c in x->MyStringProperty)");
2134 }
2135 
2136 TEST_F(FormatTest, FormatsWhileLoop) {
2137   verifyFormat("while (true) {\n}");
2138   verifyFormat("while (true)\n"
2139                "  f();");
2140   verifyFormat("while () {\n}");
2141   verifyFormat("while () {\n"
2142                "  f();\n"
2143                "}");
2144 }
2145 
2146 TEST_F(FormatTest, FormatsDoWhile) {
2147   verifyFormat("do {\n"
2148                "  do_something();\n"
2149                "} while (something());");
2150   verifyFormat("do\n"
2151                "  do_something();\n"
2152                "while (something());");
2153 }
2154 
2155 TEST_F(FormatTest, FormatsSwitchStatement) {
2156   verifyFormat("switch (x) {\n"
2157                "case 1:\n"
2158                "  f();\n"
2159                "  break;\n"
2160                "case kFoo:\n"
2161                "case ns::kBar:\n"
2162                "case kBaz:\n"
2163                "  break;\n"
2164                "default:\n"
2165                "  g();\n"
2166                "  break;\n"
2167                "}");
2168   verifyFormat("switch (x) {\n"
2169                "case 1: {\n"
2170                "  f();\n"
2171                "  break;\n"
2172                "}\n"
2173                "case 2: {\n"
2174                "  break;\n"
2175                "}\n"
2176                "}");
2177   verifyFormat("switch (x) {\n"
2178                "case 1: {\n"
2179                "  f();\n"
2180                "  {\n"
2181                "    g();\n"
2182                "    h();\n"
2183                "  }\n"
2184                "  break;\n"
2185                "}\n"
2186                "}");
2187   verifyFormat("switch (x) {\n"
2188                "case 1: {\n"
2189                "  f();\n"
2190                "  if (foo) {\n"
2191                "    g();\n"
2192                "    h();\n"
2193                "  }\n"
2194                "  break;\n"
2195                "}\n"
2196                "}");
2197   verifyFormat("switch (x) {\n"
2198                "case 1: {\n"
2199                "  f();\n"
2200                "  g();\n"
2201                "} break;\n"
2202                "}");
2203   verifyFormat("switch (test)\n"
2204                "  ;");
2205   verifyFormat("switch (x) {\n"
2206                "default: {\n"
2207                "  // Do nothing.\n"
2208                "}\n"
2209                "}");
2210   verifyFormat("switch (x) {\n"
2211                "// comment\n"
2212                "// if 1, do f()\n"
2213                "case 1:\n"
2214                "  f();\n"
2215                "}");
2216   verifyFormat("switch (x) {\n"
2217                "case 1:\n"
2218                "  // Do amazing stuff\n"
2219                "  {\n"
2220                "    f();\n"
2221                "    g();\n"
2222                "  }\n"
2223                "  break;\n"
2224                "}");
2225   verifyFormat("#define A          \\\n"
2226                "  switch (x) {     \\\n"
2227                "  case a:          \\\n"
2228                "    foo = b;       \\\n"
2229                "  }",
2230                getLLVMStyleWithColumns(20));
2231   verifyFormat("#define OPERATION_CASE(name)           \\\n"
2232                "  case OP_name:                        \\\n"
2233                "    return operations::Operation##name\n",
2234                getLLVMStyleWithColumns(40));
2235   verifyFormat("switch (x) {\n"
2236                "case 1:;\n"
2237                "default:;\n"
2238                "  int i;\n"
2239                "}");
2240 
2241   verifyGoogleFormat("switch (x) {\n"
2242                      "  case 1:\n"
2243                      "    f();\n"
2244                      "    break;\n"
2245                      "  case kFoo:\n"
2246                      "  case ns::kBar:\n"
2247                      "  case kBaz:\n"
2248                      "    break;\n"
2249                      "  default:\n"
2250                      "    g();\n"
2251                      "    break;\n"
2252                      "}");
2253   verifyGoogleFormat("switch (x) {\n"
2254                      "  case 1: {\n"
2255                      "    f();\n"
2256                      "    break;\n"
2257                      "  }\n"
2258                      "}");
2259   verifyGoogleFormat("switch (test)\n"
2260                      "  ;");
2261 
2262   verifyGoogleFormat("#define OPERATION_CASE(name) \\\n"
2263                      "  case OP_name:              \\\n"
2264                      "    return operations::Operation##name\n");
2265   verifyGoogleFormat("Operation codeToOperation(OperationCode OpCode) {\n"
2266                      "  // Get the correction operation class.\n"
2267                      "  switch (OpCode) {\n"
2268                      "    CASE(Add);\n"
2269                      "    CASE(Subtract);\n"
2270                      "    default:\n"
2271                      "      return operations::Unknown;\n"
2272                      "  }\n"
2273                      "#undef OPERATION_CASE\n"
2274                      "}");
2275   verifyFormat("DEBUG({\n"
2276                "  switch (x) {\n"
2277                "  case A:\n"
2278                "    f();\n"
2279                "    break;\n"
2280                "    // fallthrough\n"
2281                "  case B:\n"
2282                "    g();\n"
2283                "    break;\n"
2284                "  }\n"
2285                "});");
2286   EXPECT_EQ("DEBUG({\n"
2287             "  switch (x) {\n"
2288             "  case A:\n"
2289             "    f();\n"
2290             "    break;\n"
2291             "  // On B:\n"
2292             "  case B:\n"
2293             "    g();\n"
2294             "    break;\n"
2295             "  }\n"
2296             "});",
2297             format("DEBUG({\n"
2298                    "  switch (x) {\n"
2299                    "  case A:\n"
2300                    "    f();\n"
2301                    "    break;\n"
2302                    "  // On B:\n"
2303                    "  case B:\n"
2304                    "    g();\n"
2305                    "    break;\n"
2306                    "  }\n"
2307                    "});",
2308                    getLLVMStyle()));
2309   EXPECT_EQ("switch (n) {\n"
2310             "case 0: {\n"
2311             "  return false;\n"
2312             "}\n"
2313             "default: {\n"
2314             "  return true;\n"
2315             "}\n"
2316             "}",
2317             format("switch (n)\n"
2318                    "{\n"
2319                    "case 0: {\n"
2320                    "  return false;\n"
2321                    "}\n"
2322                    "default: {\n"
2323                    "  return true;\n"
2324                    "}\n"
2325                    "}",
2326                    getLLVMStyle()));
2327   verifyFormat("switch (a) {\n"
2328                "case (b):\n"
2329                "  return;\n"
2330                "}");
2331 
2332   verifyFormat("switch (a) {\n"
2333                "case some_namespace::\n"
2334                "    some_constant:\n"
2335                "  return;\n"
2336                "}",
2337                getLLVMStyleWithColumns(34));
2338 
2339   FormatStyle Style = getLLVMStyle();
2340   Style.IndentCaseLabels = true;
2341   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
2342   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2343   Style.BraceWrapping.AfterCaseLabel = true;
2344   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
2345   EXPECT_EQ("switch (n)\n"
2346             "{\n"
2347             "  case 0:\n"
2348             "  {\n"
2349             "    return false;\n"
2350             "  }\n"
2351             "  default:\n"
2352             "  {\n"
2353             "    return true;\n"
2354             "  }\n"
2355             "}",
2356             format("switch (n) {\n"
2357                    "  case 0: {\n"
2358                    "    return false;\n"
2359                    "  }\n"
2360                    "  default: {\n"
2361                    "    return true;\n"
2362                    "  }\n"
2363                    "}",
2364                    Style));
2365   Style.BraceWrapping.AfterCaseLabel = false;
2366   EXPECT_EQ("switch (n)\n"
2367             "{\n"
2368             "  case 0: {\n"
2369             "    return false;\n"
2370             "  }\n"
2371             "  default: {\n"
2372             "    return true;\n"
2373             "  }\n"
2374             "}",
2375             format("switch (n) {\n"
2376                    "  case 0:\n"
2377                    "  {\n"
2378                    "    return false;\n"
2379                    "  }\n"
2380                    "  default:\n"
2381                    "  {\n"
2382                    "    return true;\n"
2383                    "  }\n"
2384                    "}",
2385                    Style));
2386   Style.IndentCaseLabels = false;
2387   Style.IndentCaseBlocks = true;
2388   EXPECT_EQ("switch (n)\n"
2389             "{\n"
2390             "case 0:\n"
2391             "  {\n"
2392             "    return false;\n"
2393             "  }\n"
2394             "case 1:\n"
2395             "  break;\n"
2396             "default:\n"
2397             "  {\n"
2398             "    return true;\n"
2399             "  }\n"
2400             "}",
2401             format("switch (n) {\n"
2402                    "case 0: {\n"
2403                    "  return false;\n"
2404                    "}\n"
2405                    "case 1:\n"
2406                    "  break;\n"
2407                    "default: {\n"
2408                    "  return true;\n"
2409                    "}\n"
2410                    "}",
2411                    Style));
2412   Style.IndentCaseLabels = true;
2413   Style.IndentCaseBlocks = true;
2414   EXPECT_EQ("switch (n)\n"
2415             "{\n"
2416             "  case 0:\n"
2417             "    {\n"
2418             "      return false;\n"
2419             "    }\n"
2420             "  case 1:\n"
2421             "    break;\n"
2422             "  default:\n"
2423             "    {\n"
2424             "      return true;\n"
2425             "    }\n"
2426             "}",
2427             format("switch (n) {\n"
2428                    "case 0: {\n"
2429                    "  return false;\n"
2430                    "}\n"
2431                    "case 1:\n"
2432                    "  break;\n"
2433                    "default: {\n"
2434                    "  return true;\n"
2435                    "}\n"
2436                    "}",
2437                    Style));
2438 }
2439 
2440 TEST_F(FormatTest, CaseRanges) {
2441   verifyFormat("switch (x) {\n"
2442                "case 'A' ... 'Z':\n"
2443                "case 1 ... 5:\n"
2444                "case a ... b:\n"
2445                "  break;\n"
2446                "}");
2447 }
2448 
2449 TEST_F(FormatTest, ShortEnums) {
2450   FormatStyle Style = getLLVMStyle();
2451   Style.AllowShortEnumsOnASingleLine = true;
2452   verifyFormat("enum { A, B, C } ShortEnum1, ShortEnum2;", Style);
2453   Style.AllowShortEnumsOnASingleLine = false;
2454   verifyFormat("enum {\n"
2455                "  A,\n"
2456                "  B,\n"
2457                "  C\n"
2458                "} ShortEnum1, ShortEnum2;",
2459                Style);
2460   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2461   Style.BraceWrapping.AfterEnum = true;
2462   verifyFormat("enum\n"
2463                "{\n"
2464                "  A,\n"
2465                "  B,\n"
2466                "  C\n"
2467                "} ShortEnum1, ShortEnum2;",
2468                Style);
2469 }
2470 
2471 TEST_F(FormatTest, ShortCaseLabels) {
2472   FormatStyle Style = getLLVMStyle();
2473   Style.AllowShortCaseLabelsOnASingleLine = true;
2474   verifyFormat("switch (a) {\n"
2475                "case 1: x = 1; break;\n"
2476                "case 2: return;\n"
2477                "case 3:\n"
2478                "case 4:\n"
2479                "case 5: return;\n"
2480                "case 6: // comment\n"
2481                "  return;\n"
2482                "case 7:\n"
2483                "  // comment\n"
2484                "  return;\n"
2485                "case 8:\n"
2486                "  x = 8; // comment\n"
2487                "  break;\n"
2488                "default: y = 1; break;\n"
2489                "}",
2490                Style);
2491   verifyFormat("switch (a) {\n"
2492                "case 0: return; // comment\n"
2493                "case 1: break;  // comment\n"
2494                "case 2: return;\n"
2495                "// comment\n"
2496                "case 3: return;\n"
2497                "// comment 1\n"
2498                "// comment 2\n"
2499                "// comment 3\n"
2500                "case 4: break; /* comment */\n"
2501                "case 5:\n"
2502                "  // comment\n"
2503                "  break;\n"
2504                "case 6: /* comment */ x = 1; break;\n"
2505                "case 7: x = /* comment */ 1; break;\n"
2506                "case 8:\n"
2507                "  x = 1; /* comment */\n"
2508                "  break;\n"
2509                "case 9:\n"
2510                "  break; // comment line 1\n"
2511                "         // comment line 2\n"
2512                "}",
2513                Style);
2514   EXPECT_EQ("switch (a) {\n"
2515             "case 1:\n"
2516             "  x = 8;\n"
2517             "  // fall through\n"
2518             "case 2: x = 8;\n"
2519             "// comment\n"
2520             "case 3:\n"
2521             "  return; /* comment line 1\n"
2522             "           * comment line 2 */\n"
2523             "case 4: i = 8;\n"
2524             "// something else\n"
2525             "#if FOO\n"
2526             "case 5: break;\n"
2527             "#endif\n"
2528             "}",
2529             format("switch (a) {\n"
2530                    "case 1: x = 8;\n"
2531                    "  // fall through\n"
2532                    "case 2:\n"
2533                    "  x = 8;\n"
2534                    "// comment\n"
2535                    "case 3:\n"
2536                    "  return; /* comment line 1\n"
2537                    "           * comment line 2 */\n"
2538                    "case 4:\n"
2539                    "  i = 8;\n"
2540                    "// something else\n"
2541                    "#if FOO\n"
2542                    "case 5: break;\n"
2543                    "#endif\n"
2544                    "}",
2545                    Style));
2546   EXPECT_EQ("switch (a) {\n"
2547             "case 0:\n"
2548             "  return; // long long long long long long long long long long "
2549             "long long comment\n"
2550             "          // line\n"
2551             "}",
2552             format("switch (a) {\n"
2553                    "case 0: return; // long long long long long long long long "
2554                    "long long long long comment line\n"
2555                    "}",
2556                    Style));
2557   EXPECT_EQ("switch (a) {\n"
2558             "case 0:\n"
2559             "  return; /* long long long long long long long long long long "
2560             "long long comment\n"
2561             "             line */\n"
2562             "}",
2563             format("switch (a) {\n"
2564                    "case 0: return; /* long long long long long long long long "
2565                    "long long long long comment line */\n"
2566                    "}",
2567                    Style));
2568   verifyFormat("switch (a) {\n"
2569                "#if FOO\n"
2570                "case 0: return 0;\n"
2571                "#endif\n"
2572                "}",
2573                Style);
2574   verifyFormat("switch (a) {\n"
2575                "case 1: {\n"
2576                "}\n"
2577                "case 2: {\n"
2578                "  return;\n"
2579                "}\n"
2580                "case 3: {\n"
2581                "  x = 1;\n"
2582                "  return;\n"
2583                "}\n"
2584                "case 4:\n"
2585                "  if (x)\n"
2586                "    return;\n"
2587                "}",
2588                Style);
2589   Style.ColumnLimit = 21;
2590   verifyFormat("switch (a) {\n"
2591                "case 1: x = 1; break;\n"
2592                "case 2: return;\n"
2593                "case 3:\n"
2594                "case 4:\n"
2595                "case 5: return;\n"
2596                "default:\n"
2597                "  y = 1;\n"
2598                "  break;\n"
2599                "}",
2600                Style);
2601   Style.ColumnLimit = 80;
2602   Style.AllowShortCaseLabelsOnASingleLine = false;
2603   Style.IndentCaseLabels = true;
2604   EXPECT_EQ("switch (n) {\n"
2605             "  default /*comments*/:\n"
2606             "    return true;\n"
2607             "  case 0:\n"
2608             "    return false;\n"
2609             "}",
2610             format("switch (n) {\n"
2611                    "default/*comments*/:\n"
2612                    "  return true;\n"
2613                    "case 0:\n"
2614                    "  return false;\n"
2615                    "}",
2616                    Style));
2617   Style.AllowShortCaseLabelsOnASingleLine = true;
2618   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
2619   Style.BraceWrapping.AfterCaseLabel = true;
2620   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
2621   EXPECT_EQ("switch (n)\n"
2622             "{\n"
2623             "  case 0:\n"
2624             "  {\n"
2625             "    return false;\n"
2626             "  }\n"
2627             "  default:\n"
2628             "  {\n"
2629             "    return true;\n"
2630             "  }\n"
2631             "}",
2632             format("switch (n) {\n"
2633                    "  case 0: {\n"
2634                    "    return false;\n"
2635                    "  }\n"
2636                    "  default:\n"
2637                    "  {\n"
2638                    "    return true;\n"
2639                    "  }\n"
2640                    "}",
2641                    Style));
2642 }
2643 
2644 TEST_F(FormatTest, FormatsLabels) {
2645   verifyFormat("void f() {\n"
2646                "  some_code();\n"
2647                "test_label:\n"
2648                "  some_other_code();\n"
2649                "  {\n"
2650                "    some_more_code();\n"
2651                "  another_label:\n"
2652                "    some_more_code();\n"
2653                "  }\n"
2654                "}");
2655   verifyFormat("{\n"
2656                "  some_code();\n"
2657                "test_label:\n"
2658                "  some_other_code();\n"
2659                "}");
2660   verifyFormat("{\n"
2661                "  some_code();\n"
2662                "test_label:;\n"
2663                "  int i = 0;\n"
2664                "}");
2665   FormatStyle Style = getLLVMStyle();
2666   Style.IndentGotoLabels = false;
2667   verifyFormat("void f() {\n"
2668                "  some_code();\n"
2669                "test_label:\n"
2670                "  some_other_code();\n"
2671                "  {\n"
2672                "    some_more_code();\n"
2673                "another_label:\n"
2674                "    some_more_code();\n"
2675                "  }\n"
2676                "}",
2677                Style);
2678   verifyFormat("{\n"
2679                "  some_code();\n"
2680                "test_label:\n"
2681                "  some_other_code();\n"
2682                "}",
2683                Style);
2684   verifyFormat("{\n"
2685                "  some_code();\n"
2686                "test_label:;\n"
2687                "  int i = 0;\n"
2688                "}");
2689 }
2690 
2691 TEST_F(FormatTest, MultiLineControlStatements) {
2692   FormatStyle Style = getLLVMStyle();
2693   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
2694   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_MultiLine;
2695   Style.ColumnLimit = 20;
2696   // Short lines should keep opening brace on same line.
2697   EXPECT_EQ("if (foo) {\n"
2698             "  bar();\n"
2699             "}",
2700             format("if(foo){bar();}", Style));
2701   EXPECT_EQ("if (foo) {\n"
2702             "  bar();\n"
2703             "} else {\n"
2704             "  baz();\n"
2705             "}",
2706             format("if(foo){bar();}else{baz();}", Style));
2707   EXPECT_EQ("if (foo && bar) {\n"
2708             "  baz();\n"
2709             "}",
2710             format("if(foo&&bar){baz();}", Style));
2711   EXPECT_EQ("if (foo) {\n"
2712             "  bar();\n"
2713             "} else if (baz) {\n"
2714             "  quux();\n"
2715             "}",
2716             format("if(foo){bar();}else if(baz){quux();}", Style));
2717   EXPECT_EQ(
2718       "if (foo) {\n"
2719       "  bar();\n"
2720       "} else if (baz) {\n"
2721       "  quux();\n"
2722       "} else {\n"
2723       "  foobar();\n"
2724       "}",
2725       format("if(foo){bar();}else if(baz){quux();}else{foobar();}", Style));
2726   EXPECT_EQ("for (;;) {\n"
2727             "  foo();\n"
2728             "}",
2729             format("for(;;){foo();}"));
2730   EXPECT_EQ("while (1) {\n"
2731             "  foo();\n"
2732             "}",
2733             format("while(1){foo();}", Style));
2734   EXPECT_EQ("switch (foo) {\n"
2735             "case bar:\n"
2736             "  return;\n"
2737             "}",
2738             format("switch(foo){case bar:return;}", Style));
2739   EXPECT_EQ("try {\n"
2740             "  foo();\n"
2741             "} catch (...) {\n"
2742             "  bar();\n"
2743             "}",
2744             format("try{foo();}catch(...){bar();}", Style));
2745   EXPECT_EQ("do {\n"
2746             "  foo();\n"
2747             "} while (bar &&\n"
2748             "         baz);",
2749             format("do{foo();}while(bar&&baz);", Style));
2750   // Long lines should put opening brace on new line.
2751   EXPECT_EQ("if (foo && bar &&\n"
2752             "    baz)\n"
2753             "{\n"
2754             "  quux();\n"
2755             "}",
2756             format("if(foo&&bar&&baz){quux();}", Style));
2757   EXPECT_EQ("if (foo && bar &&\n"
2758             "    baz)\n"
2759             "{\n"
2760             "  quux();\n"
2761             "}",
2762             format("if (foo && bar &&\n"
2763                    "    baz) {\n"
2764                    "  quux();\n"
2765                    "}",
2766                    Style));
2767   EXPECT_EQ("if (foo) {\n"
2768             "  bar();\n"
2769             "} else if (baz ||\n"
2770             "           quux)\n"
2771             "{\n"
2772             "  foobar();\n"
2773             "}",
2774             format("if(foo){bar();}else if(baz||quux){foobar();}", Style));
2775   EXPECT_EQ(
2776       "if (foo) {\n"
2777       "  bar();\n"
2778       "} else if (baz ||\n"
2779       "           quux)\n"
2780       "{\n"
2781       "  foobar();\n"
2782       "} else {\n"
2783       "  barbaz();\n"
2784       "}",
2785       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
2786              Style));
2787   EXPECT_EQ("for (int i = 0;\n"
2788             "     i < 10; ++i)\n"
2789             "{\n"
2790             "  foo();\n"
2791             "}",
2792             format("for(int i=0;i<10;++i){foo();}", Style));
2793   EXPECT_EQ("foreach (int i,\n"
2794             "         list)\n"
2795             "{\n"
2796             "  foo();\n"
2797             "}",
2798             format("foreach(int i, list){foo();}", Style));
2799   Style.ColumnLimit =
2800       40; // to concentrate at brace wrapping, not line wrap due to column limit
2801   EXPECT_EQ("foreach (int i, list) {\n"
2802             "  foo();\n"
2803             "}",
2804             format("foreach(int i, list){foo();}", Style));
2805   Style.ColumnLimit =
2806       20; // to concentrate at brace wrapping, not line wrap due to column limit
2807   EXPECT_EQ("while (foo || bar ||\n"
2808             "       baz)\n"
2809             "{\n"
2810             "  quux();\n"
2811             "}",
2812             format("while(foo||bar||baz){quux();}", Style));
2813   EXPECT_EQ("switch (\n"
2814             "    foo = barbaz)\n"
2815             "{\n"
2816             "case quux:\n"
2817             "  return;\n"
2818             "}",
2819             format("switch(foo=barbaz){case quux:return;}", Style));
2820   EXPECT_EQ("try {\n"
2821             "  foo();\n"
2822             "} catch (\n"
2823             "    Exception &bar)\n"
2824             "{\n"
2825             "  baz();\n"
2826             "}",
2827             format("try{foo();}catch(Exception&bar){baz();}", Style));
2828   Style.ColumnLimit =
2829       40; // to concentrate at brace wrapping, not line wrap due to column limit
2830   EXPECT_EQ("try {\n"
2831             "  foo();\n"
2832             "} catch (Exception &bar) {\n"
2833             "  baz();\n"
2834             "}",
2835             format("try{foo();}catch(Exception&bar){baz();}", Style));
2836   Style.ColumnLimit =
2837       20; // to concentrate at brace wrapping, not line wrap due to column limit
2838 
2839   Style.BraceWrapping.BeforeElse = true;
2840   EXPECT_EQ(
2841       "if (foo) {\n"
2842       "  bar();\n"
2843       "}\n"
2844       "else if (baz ||\n"
2845       "         quux)\n"
2846       "{\n"
2847       "  foobar();\n"
2848       "}\n"
2849       "else {\n"
2850       "  barbaz();\n"
2851       "}",
2852       format("if(foo){bar();}else if(baz||quux){foobar();}else{barbaz();}",
2853              Style));
2854 
2855   Style.BraceWrapping.BeforeCatch = true;
2856   EXPECT_EQ("try {\n"
2857             "  foo();\n"
2858             "}\n"
2859             "catch (...) {\n"
2860             "  baz();\n"
2861             "}",
2862             format("try{foo();}catch(...){baz();}", Style));
2863 }
2864 
2865 TEST_F(FormatTest, BeforeWhile) {
2866   FormatStyle Style = getLLVMStyle();
2867   Style.BreakBeforeBraces = FormatStyle::BraceBreakingStyle::BS_Custom;
2868 
2869   verifyFormat("do {\n"
2870                "  foo();\n"
2871                "} while (1);",
2872                Style);
2873   Style.BraceWrapping.BeforeWhile = true;
2874   verifyFormat("do {\n"
2875                "  foo();\n"
2876                "}\n"
2877                "while (1);",
2878                Style);
2879 }
2880 
2881 //===----------------------------------------------------------------------===//
2882 // Tests for classes, namespaces, etc.
2883 //===----------------------------------------------------------------------===//
2884 
2885 TEST_F(FormatTest, DoesNotBreakSemiAfterClassDecl) {
2886   verifyFormat("class A {};");
2887 }
2888 
2889 TEST_F(FormatTest, UnderstandsAccessSpecifiers) {
2890   verifyFormat("class A {\n"
2891                "public:\n"
2892                "public: // comment\n"
2893                "protected:\n"
2894                "private:\n"
2895                "  void f() {}\n"
2896                "};");
2897   verifyFormat("export class A {\n"
2898                "public:\n"
2899                "public: // comment\n"
2900                "protected:\n"
2901                "private:\n"
2902                "  void f() {}\n"
2903                "};");
2904   verifyGoogleFormat("class A {\n"
2905                      " public:\n"
2906                      " protected:\n"
2907                      " private:\n"
2908                      "  void f() {}\n"
2909                      "};");
2910   verifyGoogleFormat("export class A {\n"
2911                      " public:\n"
2912                      " protected:\n"
2913                      " private:\n"
2914                      "  void f() {}\n"
2915                      "};");
2916   verifyFormat("class A {\n"
2917                "public slots:\n"
2918                "  void f1() {}\n"
2919                "public Q_SLOTS:\n"
2920                "  void f2() {}\n"
2921                "protected slots:\n"
2922                "  void f3() {}\n"
2923                "protected Q_SLOTS:\n"
2924                "  void f4() {}\n"
2925                "private slots:\n"
2926                "  void f5() {}\n"
2927                "private Q_SLOTS:\n"
2928                "  void f6() {}\n"
2929                "signals:\n"
2930                "  void g1();\n"
2931                "Q_SIGNALS:\n"
2932                "  void g2();\n"
2933                "};");
2934 
2935   // Don't interpret 'signals' the wrong way.
2936   verifyFormat("signals.set();");
2937   verifyFormat("for (Signals signals : f()) {\n}");
2938   verifyFormat("{\n"
2939                "  signals.set(); // This needs indentation.\n"
2940                "}");
2941   verifyFormat("void f() {\n"
2942                "label:\n"
2943                "  signals.baz();\n"
2944                "}");
2945 }
2946 
2947 TEST_F(FormatTest, SeparatesLogicalBlocks) {
2948   EXPECT_EQ("class A {\n"
2949             "public:\n"
2950             "  void f();\n"
2951             "\n"
2952             "private:\n"
2953             "  void g() {}\n"
2954             "  // test\n"
2955             "protected:\n"
2956             "  int h;\n"
2957             "};",
2958             format("class A {\n"
2959                    "public:\n"
2960                    "void f();\n"
2961                    "private:\n"
2962                    "void g() {}\n"
2963                    "// test\n"
2964                    "protected:\n"
2965                    "int h;\n"
2966                    "};"));
2967   EXPECT_EQ("class A {\n"
2968             "protected:\n"
2969             "public:\n"
2970             "  void f();\n"
2971             "};",
2972             format("class A {\n"
2973                    "protected:\n"
2974                    "\n"
2975                    "public:\n"
2976                    "\n"
2977                    "  void f();\n"
2978                    "};"));
2979 
2980   // Even ensure proper spacing inside macros.
2981   EXPECT_EQ("#define B     \\\n"
2982             "  class A {   \\\n"
2983             "   protected: \\\n"
2984             "   public:    \\\n"
2985             "    void f(); \\\n"
2986             "  };",
2987             format("#define B     \\\n"
2988                    "  class A {   \\\n"
2989                    "   protected: \\\n"
2990                    "              \\\n"
2991                    "   public:    \\\n"
2992                    "              \\\n"
2993                    "    void f(); \\\n"
2994                    "  };",
2995                    getGoogleStyle()));
2996   // But don't remove empty lines after macros ending in access specifiers.
2997   EXPECT_EQ("#define A private:\n"
2998             "\n"
2999             "int i;",
3000             format("#define A         private:\n"
3001                    "\n"
3002                    "int              i;"));
3003 }
3004 
3005 TEST_F(FormatTest, FormatsClasses) {
3006   verifyFormat("class A : public B {};");
3007   verifyFormat("class A : public ::B {};");
3008 
3009   verifyFormat(
3010       "class AAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
3011       "                             public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
3012   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
3013                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
3014                "      public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};");
3015   verifyFormat(
3016       "class A : public B, public C, public D, public E, public F {};");
3017   verifyFormat("class AAAAAAAAAAAA : public B,\n"
3018                "                     public C,\n"
3019                "                     public D,\n"
3020                "                     public E,\n"
3021                "                     public F,\n"
3022                "                     public G {};");
3023 
3024   verifyFormat("class\n"
3025                "    ReallyReallyLongClassName {\n"
3026                "  int i;\n"
3027                "};",
3028                getLLVMStyleWithColumns(32));
3029   verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
3030                "                           aaaaaaaaaaaaaaaa> {};");
3031   verifyFormat("struct aaaaaaaaaaaaaaaaaaaa\n"
3032                "    : public aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaa,\n"
3033                "                                 aaaaaaaaaaaaaaaaaaaaaa> {};");
3034   verifyFormat("template <class R, class C>\n"
3035                "struct Aaaaaaaaaaaaaaaaa<R (C::*)(int) const>\n"
3036                "    : Aaaaaaaaaaaaaaaaa<R (C::*)(int)> {};");
3037   verifyFormat("class ::A::B {};");
3038 }
3039 
3040 TEST_F(FormatTest, BreakInheritanceStyle) {
3041   FormatStyle StyleWithInheritanceBreakBeforeComma = getLLVMStyle();
3042   StyleWithInheritanceBreakBeforeComma.BreakInheritanceList =
3043       FormatStyle::BILS_BeforeComma;
3044   verifyFormat("class MyClass : public X {};",
3045                StyleWithInheritanceBreakBeforeComma);
3046   verifyFormat("class MyClass\n"
3047                "    : public X\n"
3048                "    , public Y {};",
3049                StyleWithInheritanceBreakBeforeComma);
3050   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA\n"
3051                "    : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB\n"
3052                "    , public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
3053                StyleWithInheritanceBreakBeforeComma);
3054   verifyFormat("struct aaaaaaaaaaaaa\n"
3055                "    : public aaaaaaaaaaaaaaaaaaa< // break\n"
3056                "          aaaaaaaaaaaaaaaa> {};",
3057                StyleWithInheritanceBreakBeforeComma);
3058 
3059   FormatStyle StyleWithInheritanceBreakAfterColon = getLLVMStyle();
3060   StyleWithInheritanceBreakAfterColon.BreakInheritanceList =
3061       FormatStyle::BILS_AfterColon;
3062   verifyFormat("class MyClass : public X {};",
3063                StyleWithInheritanceBreakAfterColon);
3064   verifyFormat("class MyClass : public X, public Y {};",
3065                StyleWithInheritanceBreakAfterColon);
3066   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAA :\n"
3067                "    public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
3068                "    public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC {};",
3069                StyleWithInheritanceBreakAfterColon);
3070   verifyFormat("struct aaaaaaaaaaaaa :\n"
3071                "    public aaaaaaaaaaaaaaaaaaa< // break\n"
3072                "        aaaaaaaaaaaaaaaa> {};",
3073                StyleWithInheritanceBreakAfterColon);
3074 
3075   FormatStyle StyleWithInheritanceBreakAfterComma = getLLVMStyle();
3076   StyleWithInheritanceBreakAfterComma.BreakInheritanceList =
3077       FormatStyle::BILS_AfterComma;
3078   verifyFormat("class MyClass : public X {};",
3079                StyleWithInheritanceBreakAfterComma);
3080   verifyFormat("class MyClass : public X,\n"
3081                "                public Y {};",
3082                StyleWithInheritanceBreakAfterComma);
3083   verifyFormat(
3084       "class AAAAAAAAAAAAAAAAAAAAAA : public BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB,\n"
3085       "                               public CCCCCCCCCCCCCCCCCCCCCCCCCCCCCC "
3086       "{};",
3087       StyleWithInheritanceBreakAfterComma);
3088   verifyFormat("struct aaaaaaaaaaaaa : public aaaaaaaaaaaaaaaaaaa< // break\n"
3089                "                           aaaaaaaaaaaaaaaa> {};",
3090                StyleWithInheritanceBreakAfterComma);
3091   verifyFormat("class AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n"
3092                "    : public OnceBreak,\n"
3093                "      public AlwaysBreak,\n"
3094                "      EvenBasesFitInOneLine {};",
3095                StyleWithInheritanceBreakAfterComma);
3096 }
3097 
3098 TEST_F(FormatTest, FormatsVariableDeclarationsAfterStructOrClass) {
3099   verifyFormat("class A {\n} a, b;");
3100   verifyFormat("struct A {\n} a, b;");
3101   verifyFormat("union A {\n} a;");
3102 }
3103 
3104 TEST_F(FormatTest, FormatsEnum) {
3105   verifyFormat("enum {\n"
3106                "  Zero,\n"
3107                "  One = 1,\n"
3108                "  Two = One + 1,\n"
3109                "  Three = (One + Two),\n"
3110                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
3111                "  Five = (One, Two, Three, Four, 5)\n"
3112                "};");
3113   verifyGoogleFormat("enum {\n"
3114                      "  Zero,\n"
3115                      "  One = 1,\n"
3116                      "  Two = One + 1,\n"
3117                      "  Three = (One + Two),\n"
3118                      "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
3119                      "  Five = (One, Two, Three, Four, 5)\n"
3120                      "};");
3121   verifyFormat("enum Enum {};");
3122   verifyFormat("enum {};");
3123   verifyFormat("enum X E {} d;");
3124   verifyFormat("enum __attribute__((...)) E {} d;");
3125   verifyFormat("enum __declspec__((...)) E {} d;");
3126   verifyFormat("enum {\n"
3127                "  Bar = Foo<int, int>::value\n"
3128                "};",
3129                getLLVMStyleWithColumns(30));
3130 
3131   verifyFormat("enum ShortEnum { A, B, C };");
3132   verifyGoogleFormat("enum ShortEnum { A, B, C };");
3133 
3134   EXPECT_EQ("enum KeepEmptyLines {\n"
3135             "  ONE,\n"
3136             "\n"
3137             "  TWO,\n"
3138             "\n"
3139             "  THREE\n"
3140             "}",
3141             format("enum KeepEmptyLines {\n"
3142                    "  ONE,\n"
3143                    "\n"
3144                    "  TWO,\n"
3145                    "\n"
3146                    "\n"
3147                    "  THREE\n"
3148                    "}"));
3149   verifyFormat("enum E { // comment\n"
3150                "  ONE,\n"
3151                "  TWO\n"
3152                "};\n"
3153                "int i;");
3154 
3155   FormatStyle EightIndent = getLLVMStyle();
3156   EightIndent.IndentWidth = 8;
3157   verifyFormat("enum {\n"
3158                "        VOID,\n"
3159                "        CHAR,\n"
3160                "        SHORT,\n"
3161                "        INT,\n"
3162                "        LONG,\n"
3163                "        SIGNED,\n"
3164                "        UNSIGNED,\n"
3165                "        BOOL,\n"
3166                "        FLOAT,\n"
3167                "        DOUBLE,\n"
3168                "        COMPLEX\n"
3169                "};",
3170                EightIndent);
3171 
3172   // Not enums.
3173   verifyFormat("enum X f() {\n"
3174                "  a();\n"
3175                "  return 42;\n"
3176                "}");
3177   verifyFormat("enum X Type::f() {\n"
3178                "  a();\n"
3179                "  return 42;\n"
3180                "}");
3181   verifyFormat("enum ::X f() {\n"
3182                "  a();\n"
3183                "  return 42;\n"
3184                "}");
3185   verifyFormat("enum ns::X f() {\n"
3186                "  a();\n"
3187                "  return 42;\n"
3188                "}");
3189 }
3190 
3191 TEST_F(FormatTest, FormatsEnumsWithErrors) {
3192   verifyFormat("enum Type {\n"
3193                "  One = 0; // These semicolons should be commas.\n"
3194                "  Two = 1;\n"
3195                "};");
3196   verifyFormat("namespace n {\n"
3197                "enum Type {\n"
3198                "  One,\n"
3199                "  Two, // missing };\n"
3200                "  int i;\n"
3201                "}\n"
3202                "void g() {}");
3203 }
3204 
3205 TEST_F(FormatTest, FormatsEnumStruct) {
3206   verifyFormat("enum struct {\n"
3207                "  Zero,\n"
3208                "  One = 1,\n"
3209                "  Two = One + 1,\n"
3210                "  Three = (One + Two),\n"
3211                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
3212                "  Five = (One, Two, Three, Four, 5)\n"
3213                "};");
3214   verifyFormat("enum struct Enum {};");
3215   verifyFormat("enum struct {};");
3216   verifyFormat("enum struct X E {} d;");
3217   verifyFormat("enum struct __attribute__((...)) E {} d;");
3218   verifyFormat("enum struct __declspec__((...)) E {} d;");
3219   verifyFormat("enum struct X f() {\n  a();\n  return 42;\n}");
3220 }
3221 
3222 TEST_F(FormatTest, FormatsEnumClass) {
3223   verifyFormat("enum class {\n"
3224                "  Zero,\n"
3225                "  One = 1,\n"
3226                "  Two = One + 1,\n"
3227                "  Three = (One + Two),\n"
3228                "  Four = (Zero && (One ^ Two)) | (One << Two),\n"
3229                "  Five = (One, Two, Three, Four, 5)\n"
3230                "};");
3231   verifyFormat("enum class Enum {};");
3232   verifyFormat("enum class {};");
3233   verifyFormat("enum class X E {} d;");
3234   verifyFormat("enum class __attribute__((...)) E {} d;");
3235   verifyFormat("enum class __declspec__((...)) E {} d;");
3236   verifyFormat("enum class X f() {\n  a();\n  return 42;\n}");
3237 }
3238 
3239 TEST_F(FormatTest, FormatsEnumTypes) {
3240   verifyFormat("enum X : int {\n"
3241                "  A, // Force multiple lines.\n"
3242                "  B\n"
3243                "};");
3244   verifyFormat("enum X : int { A, B };");
3245   verifyFormat("enum X : std::uint32_t { A, B };");
3246 }
3247 
3248 TEST_F(FormatTest, FormatsTypedefEnum) {
3249   FormatStyle Style = getLLVMStyle();
3250   Style.ColumnLimit = 40;
3251   verifyFormat("typedef enum {} EmptyEnum;");
3252   verifyFormat("typedef enum { A, B, C } ShortEnum;");
3253   verifyFormat("typedef enum {\n"
3254                "  ZERO = 0,\n"
3255                "  ONE = 1,\n"
3256                "  TWO = 2,\n"
3257                "  THREE = 3\n"
3258                "} LongEnum;",
3259                Style);
3260   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3261   Style.BraceWrapping.AfterEnum = true;
3262   verifyFormat("typedef enum {} EmptyEnum;");
3263   verifyFormat("typedef enum { A, B, C } ShortEnum;");
3264   verifyFormat("typedef enum\n"
3265                "{\n"
3266                "  ZERO = 0,\n"
3267                "  ONE = 1,\n"
3268                "  TWO = 2,\n"
3269                "  THREE = 3\n"
3270                "} LongEnum;",
3271                Style);
3272 }
3273 
3274 TEST_F(FormatTest, FormatsNSEnums) {
3275   verifyGoogleFormat("typedef NS_ENUM(NSInteger, SomeName) { AAA, BBB }");
3276   verifyGoogleFormat(
3277       "typedef NS_CLOSED_ENUM(NSInteger, SomeName) { AAA, BBB }");
3278   verifyGoogleFormat("typedef NS_ENUM(NSInteger, MyType) {\n"
3279                      "  // Information about someDecentlyLongValue.\n"
3280                      "  someDecentlyLongValue,\n"
3281                      "  // Information about anotherDecentlyLongValue.\n"
3282                      "  anotherDecentlyLongValue,\n"
3283                      "  // Information about aThirdDecentlyLongValue.\n"
3284                      "  aThirdDecentlyLongValue\n"
3285                      "};");
3286   verifyGoogleFormat("typedef NS_CLOSED_ENUM(NSInteger, MyType) {\n"
3287                      "  // Information about someDecentlyLongValue.\n"
3288                      "  someDecentlyLongValue,\n"
3289                      "  // Information about anotherDecentlyLongValue.\n"
3290                      "  anotherDecentlyLongValue,\n"
3291                      "  // Information about aThirdDecentlyLongValue.\n"
3292                      "  aThirdDecentlyLongValue\n"
3293                      "};");
3294   verifyGoogleFormat("typedef NS_OPTIONS(NSInteger, MyType) {\n"
3295                      "  a = 1,\n"
3296                      "  b = 2,\n"
3297                      "  c = 3,\n"
3298                      "};");
3299   verifyGoogleFormat("typedef CF_ENUM(NSInteger, MyType) {\n"
3300                      "  a = 1,\n"
3301                      "  b = 2,\n"
3302                      "  c = 3,\n"
3303                      "};");
3304   verifyGoogleFormat("typedef CF_CLOSED_ENUM(NSInteger, MyType) {\n"
3305                      "  a = 1,\n"
3306                      "  b = 2,\n"
3307                      "  c = 3,\n"
3308                      "};");
3309   verifyGoogleFormat("typedef CF_OPTIONS(NSInteger, MyType) {\n"
3310                      "  a = 1,\n"
3311                      "  b = 2,\n"
3312                      "  c = 3,\n"
3313                      "};");
3314 }
3315 
3316 TEST_F(FormatTest, FormatsBitfields) {
3317   verifyFormat("struct Bitfields {\n"
3318                "  unsigned sClass : 8;\n"
3319                "  unsigned ValueKind : 2;\n"
3320                "};");
3321   verifyFormat("struct A {\n"
3322                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa : 1,\n"
3323                "      bbbbbbbbbbbbbbbbbbbbbbbbb;\n"
3324                "};");
3325   verifyFormat("struct MyStruct {\n"
3326                "  uchar data;\n"
3327                "  uchar : 8;\n"
3328                "  uchar : 8;\n"
3329                "  uchar other;\n"
3330                "};");
3331   FormatStyle Style = getLLVMStyle();
3332   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
3333   verifyFormat("struct Bitfields {\n"
3334                "  unsigned sClass:8;\n"
3335                "  unsigned ValueKind:2;\n"
3336                "  uchar other;\n"
3337                "};",
3338                Style);
3339   verifyFormat("struct A {\n"
3340                "  int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:1,\n"
3341                "      bbbbbbbbbbbbbbbbbbbbbbbbb:2;\n"
3342                "};",
3343                Style);
3344   Style.BitFieldColonSpacing = FormatStyle::BFCS_Before;
3345   verifyFormat("struct Bitfields {\n"
3346                "  unsigned sClass :8;\n"
3347                "  unsigned ValueKind :2;\n"
3348                "  uchar other;\n"
3349                "};",
3350                Style);
3351   Style.BitFieldColonSpacing = FormatStyle::BFCS_After;
3352   verifyFormat("struct Bitfields {\n"
3353                "  unsigned sClass: 8;\n"
3354                "  unsigned ValueKind: 2;\n"
3355                "  uchar other;\n"
3356                "};",
3357                Style);
3358 }
3359 
3360 TEST_F(FormatTest, FormatsNamespaces) {
3361   FormatStyle LLVMWithNoNamespaceFix = getLLVMStyle();
3362   LLVMWithNoNamespaceFix.FixNamespaceComments = false;
3363 
3364   verifyFormat("namespace some_namespace {\n"
3365                "class A {};\n"
3366                "void f() { f(); }\n"
3367                "}",
3368                LLVMWithNoNamespaceFix);
3369   verifyFormat("namespace N::inline D {\n"
3370                "class A {};\n"
3371                "void f() { f(); }\n"
3372                "}",
3373                LLVMWithNoNamespaceFix);
3374   verifyFormat("namespace N::inline D::E {\n"
3375                "class A {};\n"
3376                "void f() { f(); }\n"
3377                "}",
3378                LLVMWithNoNamespaceFix);
3379   verifyFormat("namespace [[deprecated(\"foo[bar\")]] some_namespace {\n"
3380                "class A {};\n"
3381                "void f() { f(); }\n"
3382                "}",
3383                LLVMWithNoNamespaceFix);
3384   verifyFormat("/* something */ namespace some_namespace {\n"
3385                "class A {};\n"
3386                "void f() { f(); }\n"
3387                "}",
3388                LLVMWithNoNamespaceFix);
3389   verifyFormat("namespace {\n"
3390                "class A {};\n"
3391                "void f() { f(); }\n"
3392                "}",
3393                LLVMWithNoNamespaceFix);
3394   verifyFormat("/* something */ namespace {\n"
3395                "class A {};\n"
3396                "void f() { f(); }\n"
3397                "}",
3398                LLVMWithNoNamespaceFix);
3399   verifyFormat("inline namespace X {\n"
3400                "class A {};\n"
3401                "void f() { f(); }\n"
3402                "}",
3403                LLVMWithNoNamespaceFix);
3404   verifyFormat("/* something */ inline namespace X {\n"
3405                "class A {};\n"
3406                "void f() { f(); }\n"
3407                "}",
3408                LLVMWithNoNamespaceFix);
3409   verifyFormat("export namespace X {\n"
3410                "class A {};\n"
3411                "void f() { f(); }\n"
3412                "}",
3413                LLVMWithNoNamespaceFix);
3414   verifyFormat("using namespace some_namespace;\n"
3415                "class A {};\n"
3416                "void f() { f(); }",
3417                LLVMWithNoNamespaceFix);
3418 
3419   // This code is more common than we thought; if we
3420   // layout this correctly the semicolon will go into
3421   // its own line, which is undesirable.
3422   verifyFormat("namespace {};", LLVMWithNoNamespaceFix);
3423   verifyFormat("namespace {\n"
3424                "class A {};\n"
3425                "};",
3426                LLVMWithNoNamespaceFix);
3427 
3428   verifyFormat("namespace {\n"
3429                "int SomeVariable = 0; // comment\n"
3430                "} // namespace",
3431                LLVMWithNoNamespaceFix);
3432   EXPECT_EQ("#ifndef HEADER_GUARD\n"
3433             "#define HEADER_GUARD\n"
3434             "namespace my_namespace {\n"
3435             "int i;\n"
3436             "} // my_namespace\n"
3437             "#endif // HEADER_GUARD",
3438             format("#ifndef HEADER_GUARD\n"
3439                    " #define HEADER_GUARD\n"
3440                    "   namespace my_namespace {\n"
3441                    "int i;\n"
3442                    "}    // my_namespace\n"
3443                    "#endif    // HEADER_GUARD",
3444                    LLVMWithNoNamespaceFix));
3445 
3446   EXPECT_EQ("namespace A::B {\n"
3447             "class C {};\n"
3448             "}",
3449             format("namespace A::B {\n"
3450                    "class C {};\n"
3451                    "}",
3452                    LLVMWithNoNamespaceFix));
3453 
3454   FormatStyle Style = getLLVMStyle();
3455   Style.NamespaceIndentation = FormatStyle::NI_All;
3456   EXPECT_EQ("namespace out {\n"
3457             "  int i;\n"
3458             "  namespace in {\n"
3459             "    int i;\n"
3460             "  } // namespace in\n"
3461             "} // namespace out",
3462             format("namespace out {\n"
3463                    "int i;\n"
3464                    "namespace in {\n"
3465                    "int i;\n"
3466                    "} // namespace in\n"
3467                    "} // namespace out",
3468                    Style));
3469 
3470   Style.NamespaceIndentation = FormatStyle::NI_Inner;
3471   EXPECT_EQ("namespace out {\n"
3472             "int i;\n"
3473             "namespace in {\n"
3474             "  int i;\n"
3475             "} // namespace in\n"
3476             "} // namespace out",
3477             format("namespace out {\n"
3478                    "int i;\n"
3479                    "namespace in {\n"
3480                    "int i;\n"
3481                    "} // namespace in\n"
3482                    "} // namespace out",
3483                    Style));
3484 }
3485 
3486 TEST_F(FormatTest, NamespaceMacros) {
3487   FormatStyle Style = getLLVMStyle();
3488   Style.NamespaceMacros.push_back("TESTSUITE");
3489 
3490   verifyFormat("TESTSUITE(A) {\n"
3491                "int foo();\n"
3492                "} // TESTSUITE(A)",
3493                Style);
3494 
3495   verifyFormat("TESTSUITE(A, B) {\n"
3496                "int foo();\n"
3497                "} // TESTSUITE(A)",
3498                Style);
3499 
3500   // Properly indent according to NamespaceIndentation style
3501   Style.NamespaceIndentation = FormatStyle::NI_All;
3502   verifyFormat("TESTSUITE(A) {\n"
3503                "  int foo();\n"
3504                "} // TESTSUITE(A)",
3505                Style);
3506   verifyFormat("TESTSUITE(A) {\n"
3507                "  namespace B {\n"
3508                "    int foo();\n"
3509                "  } // namespace B\n"
3510                "} // TESTSUITE(A)",
3511                Style);
3512   verifyFormat("namespace A {\n"
3513                "  TESTSUITE(B) {\n"
3514                "    int foo();\n"
3515                "  } // TESTSUITE(B)\n"
3516                "} // namespace A",
3517                Style);
3518 
3519   Style.NamespaceIndentation = FormatStyle::NI_Inner;
3520   verifyFormat("TESTSUITE(A) {\n"
3521                "TESTSUITE(B) {\n"
3522                "  int foo();\n"
3523                "} // TESTSUITE(B)\n"
3524                "} // TESTSUITE(A)",
3525                Style);
3526   verifyFormat("TESTSUITE(A) {\n"
3527                "namespace B {\n"
3528                "  int foo();\n"
3529                "} // namespace B\n"
3530                "} // TESTSUITE(A)",
3531                Style);
3532   verifyFormat("namespace A {\n"
3533                "TESTSUITE(B) {\n"
3534                "  int foo();\n"
3535                "} // TESTSUITE(B)\n"
3536                "} // namespace A",
3537                Style);
3538 
3539   // Properly merge namespace-macros blocks in CompactNamespaces mode
3540   Style.NamespaceIndentation = FormatStyle::NI_None;
3541   Style.CompactNamespaces = true;
3542   verifyFormat("TESTSUITE(A) { TESTSUITE(B) {\n"
3543                "}} // TESTSUITE(A::B)",
3544                Style);
3545 
3546   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
3547             "}} // TESTSUITE(out::in)",
3548             format("TESTSUITE(out) {\n"
3549                    "TESTSUITE(in) {\n"
3550                    "} // TESTSUITE(in)\n"
3551                    "} // TESTSUITE(out)",
3552                    Style));
3553 
3554   EXPECT_EQ("TESTSUITE(out) { TESTSUITE(in) {\n"
3555             "}} // TESTSUITE(out::in)",
3556             format("TESTSUITE(out) {\n"
3557                    "TESTSUITE(in) {\n"
3558                    "} // TESTSUITE(in)\n"
3559                    "} // TESTSUITE(out)",
3560                    Style));
3561 
3562   // Do not merge different namespaces/macros
3563   EXPECT_EQ("namespace out {\n"
3564             "TESTSUITE(in) {\n"
3565             "} // TESTSUITE(in)\n"
3566             "} // namespace out",
3567             format("namespace out {\n"
3568                    "TESTSUITE(in) {\n"
3569                    "} // TESTSUITE(in)\n"
3570                    "} // namespace out",
3571                    Style));
3572   EXPECT_EQ("TESTSUITE(out) {\n"
3573             "namespace in {\n"
3574             "} // namespace in\n"
3575             "} // TESTSUITE(out)",
3576             format("TESTSUITE(out) {\n"
3577                    "namespace in {\n"
3578                    "} // namespace in\n"
3579                    "} // TESTSUITE(out)",
3580                    Style));
3581   Style.NamespaceMacros.push_back("FOOBAR");
3582   EXPECT_EQ("TESTSUITE(out) {\n"
3583             "FOOBAR(in) {\n"
3584             "} // FOOBAR(in)\n"
3585             "} // TESTSUITE(out)",
3586             format("TESTSUITE(out) {\n"
3587                    "FOOBAR(in) {\n"
3588                    "} // FOOBAR(in)\n"
3589                    "} // TESTSUITE(out)",
3590                    Style));
3591 }
3592 
3593 TEST_F(FormatTest, FormatsCompactNamespaces) {
3594   FormatStyle Style = getLLVMStyle();
3595   Style.CompactNamespaces = true;
3596   Style.NamespaceMacros.push_back("TESTSUITE");
3597 
3598   verifyFormat("namespace A { namespace B {\n"
3599                "}} // namespace A::B",
3600                Style);
3601 
3602   EXPECT_EQ("namespace out { namespace in {\n"
3603             "}} // namespace out::in",
3604             format("namespace out {\n"
3605                    "namespace in {\n"
3606                    "} // namespace in\n"
3607                    "} // namespace out",
3608                    Style));
3609 
3610   // Only namespaces which have both consecutive opening and end get compacted
3611   EXPECT_EQ("namespace out {\n"
3612             "namespace in1 {\n"
3613             "} // namespace in1\n"
3614             "namespace in2 {\n"
3615             "} // namespace in2\n"
3616             "} // namespace out",
3617             format("namespace out {\n"
3618                    "namespace in1 {\n"
3619                    "} // namespace in1\n"
3620                    "namespace in2 {\n"
3621                    "} // namespace in2\n"
3622                    "} // namespace out",
3623                    Style));
3624 
3625   EXPECT_EQ("namespace out {\n"
3626             "int i;\n"
3627             "namespace in {\n"
3628             "int j;\n"
3629             "} // namespace in\n"
3630             "int k;\n"
3631             "} // namespace out",
3632             format("namespace out { int i;\n"
3633                    "namespace in { int j; } // namespace in\n"
3634                    "int k; } // namespace out",
3635                    Style));
3636 
3637   EXPECT_EQ("namespace A { namespace B { namespace C {\n"
3638             "}}} // namespace A::B::C\n",
3639             format("namespace A { namespace B {\n"
3640                    "namespace C {\n"
3641                    "}} // namespace B::C\n"
3642                    "} // namespace A\n",
3643                    Style));
3644 
3645   Style.ColumnLimit = 40;
3646   EXPECT_EQ("namespace aaaaaaaaaa {\n"
3647             "namespace bbbbbbbbbb {\n"
3648             "}} // namespace aaaaaaaaaa::bbbbbbbbbb",
3649             format("namespace aaaaaaaaaa {\n"
3650                    "namespace bbbbbbbbbb {\n"
3651                    "} // namespace bbbbbbbbbb\n"
3652                    "} // namespace aaaaaaaaaa",
3653                    Style));
3654 
3655   EXPECT_EQ("namespace aaaaaa { namespace bbbbbb {\n"
3656             "namespace cccccc {\n"
3657             "}}} // namespace aaaaaa::bbbbbb::cccccc",
3658             format("namespace aaaaaa {\n"
3659                    "namespace bbbbbb {\n"
3660                    "namespace cccccc {\n"
3661                    "} // namespace cccccc\n"
3662                    "} // namespace bbbbbb\n"
3663                    "} // namespace aaaaaa",
3664                    Style));
3665   Style.ColumnLimit = 80;
3666 
3667   // Extra semicolon after 'inner' closing brace prevents merging
3668   EXPECT_EQ("namespace out { namespace in {\n"
3669             "}; } // namespace out::in",
3670             format("namespace out {\n"
3671                    "namespace in {\n"
3672                    "}; // namespace in\n"
3673                    "} // namespace out",
3674                    Style));
3675 
3676   // Extra semicolon after 'outer' closing brace is conserved
3677   EXPECT_EQ("namespace out { namespace in {\n"
3678             "}}; // namespace out::in",
3679             format("namespace out {\n"
3680                    "namespace in {\n"
3681                    "} // namespace in\n"
3682                    "}; // namespace out",
3683                    Style));
3684 
3685   Style.NamespaceIndentation = FormatStyle::NI_All;
3686   EXPECT_EQ("namespace out { namespace in {\n"
3687             "  int i;\n"
3688             "}} // namespace out::in",
3689             format("namespace out {\n"
3690                    "namespace in {\n"
3691                    "int i;\n"
3692                    "} // namespace in\n"
3693                    "} // namespace out",
3694                    Style));
3695   EXPECT_EQ("namespace out { namespace mid {\n"
3696             "  namespace in {\n"
3697             "    int j;\n"
3698             "  } // namespace in\n"
3699             "  int k;\n"
3700             "}} // namespace out::mid",
3701             format("namespace out { namespace mid {\n"
3702                    "namespace in { int j; } // namespace in\n"
3703                    "int k; }} // namespace out::mid",
3704                    Style));
3705 
3706   Style.NamespaceIndentation = FormatStyle::NI_Inner;
3707   EXPECT_EQ("namespace out { namespace in {\n"
3708             "  int i;\n"
3709             "}} // namespace out::in",
3710             format("namespace out {\n"
3711                    "namespace in {\n"
3712                    "int i;\n"
3713                    "} // namespace in\n"
3714                    "} // namespace out",
3715                    Style));
3716   EXPECT_EQ("namespace out { namespace mid { namespace in {\n"
3717             "  int i;\n"
3718             "}}} // namespace out::mid::in",
3719             format("namespace out {\n"
3720                    "namespace mid {\n"
3721                    "namespace in {\n"
3722                    "int i;\n"
3723                    "} // namespace in\n"
3724                    "} // namespace mid\n"
3725                    "} // namespace out",
3726                    Style));
3727 }
3728 
3729 TEST_F(FormatTest, FormatsExternC) {
3730   verifyFormat("extern \"C\" {\nint a;");
3731   verifyFormat("extern \"C\" {}");
3732   verifyFormat("extern \"C\" {\n"
3733                "int foo();\n"
3734                "}");
3735   verifyFormat("extern \"C\" int foo() {}");
3736   verifyFormat("extern \"C\" int foo();");
3737   verifyFormat("extern \"C\" int foo() {\n"
3738                "  int i = 42;\n"
3739                "  return i;\n"
3740                "}");
3741 
3742   FormatStyle Style = getLLVMStyle();
3743   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3744   Style.BraceWrapping.AfterFunction = true;
3745   verifyFormat("extern \"C\" int foo() {}", Style);
3746   verifyFormat("extern \"C\" int foo();", Style);
3747   verifyFormat("extern \"C\" int foo()\n"
3748                "{\n"
3749                "  int i = 42;\n"
3750                "  return i;\n"
3751                "}",
3752                Style);
3753 
3754   Style.BraceWrapping.AfterExternBlock = true;
3755   Style.BraceWrapping.SplitEmptyRecord = false;
3756   verifyFormat("extern \"C\"\n"
3757                "{}",
3758                Style);
3759   verifyFormat("extern \"C\"\n"
3760                "{\n"
3761                "  int foo();\n"
3762                "}",
3763                Style);
3764 }
3765 
3766 TEST_F(FormatTest, IndentExternBlockStyle) {
3767   FormatStyle Style = getLLVMStyle();
3768   Style.IndentWidth = 2;
3769 
3770   Style.IndentExternBlock = FormatStyle::IEBS_Indent;
3771   verifyFormat("extern \"C\" { /*9*/\n}", Style);
3772   verifyFormat("extern \"C\" {\n"
3773                "  int foo10();\n"
3774                "}",
3775                Style);
3776 
3777   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
3778   verifyFormat("extern \"C\" { /*11*/\n}", Style);
3779   verifyFormat("extern \"C\" {\n"
3780                "int foo12();\n"
3781                "}",
3782                Style);
3783 
3784   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
3785   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3786   Style.BraceWrapping.AfterExternBlock = true;
3787   verifyFormat("extern \"C\"\n{ /*13*/\n}", Style);
3788   verifyFormat("extern \"C\"\n{\n"
3789                "  int foo14();\n"
3790                "}",
3791                Style);
3792 
3793   Style.IndentExternBlock = FormatStyle::IEBS_AfterExternBlock;
3794   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3795   Style.BraceWrapping.AfterExternBlock = false;
3796   verifyFormat("extern \"C\" { /*15*/\n}", Style);
3797   verifyFormat("extern \"C\" {\n"
3798                "int foo16();\n"
3799                "}",
3800                Style);
3801 }
3802 
3803 TEST_F(FormatTest, FormatsInlineASM) {
3804   verifyFormat("asm(\"xyz\" : \"=a\"(a), \"=d\"(b) : \"a\"(data));");
3805   verifyFormat("asm(\"nop\" ::: \"memory\");");
3806   verifyFormat(
3807       "asm(\"movq\\t%%rbx, %%rsi\\n\\t\"\n"
3808       "    \"cpuid\\n\\t\"\n"
3809       "    \"xchgq\\t%%rbx, %%rsi\\n\\t\"\n"
3810       "    : \"=a\"(*rEAX), \"=S\"(*rEBX), \"=c\"(*rECX), \"=d\"(*rEDX)\n"
3811       "    : \"a\"(value));");
3812   EXPECT_EQ(
3813       "void NS_InvokeByIndex(void *that, unsigned int methodIndex) {\n"
3814       "  __asm {\n"
3815       "        mov     edx,[that] // vtable in edx\n"
3816       "        mov     eax,methodIndex\n"
3817       "        call    [edx][eax*4] // stdcall\n"
3818       "  }\n"
3819       "}",
3820       format("void NS_InvokeByIndex(void *that,   unsigned int methodIndex) {\n"
3821              "    __asm {\n"
3822              "        mov     edx,[that] // vtable in edx\n"
3823              "        mov     eax,methodIndex\n"
3824              "        call    [edx][eax*4] // stdcall\n"
3825              "    }\n"
3826              "}"));
3827   EXPECT_EQ("_asm {\n"
3828             "  xor eax, eax;\n"
3829             "  cpuid;\n"
3830             "}",
3831             format("_asm {\n"
3832                    "  xor eax, eax;\n"
3833                    "  cpuid;\n"
3834                    "}"));
3835   verifyFormat("void function() {\n"
3836                "  // comment\n"
3837                "  asm(\"\");\n"
3838                "}");
3839   EXPECT_EQ("__asm {\n"
3840             "}\n"
3841             "int i;",
3842             format("__asm   {\n"
3843                    "}\n"
3844                    "int   i;"));
3845 }
3846 
3847 TEST_F(FormatTest, FormatTryCatch) {
3848   verifyFormat("try {\n"
3849                "  throw a * b;\n"
3850                "} catch (int a) {\n"
3851                "  // Do nothing.\n"
3852                "} catch (...) {\n"
3853                "  exit(42);\n"
3854                "}");
3855 
3856   // Function-level try statements.
3857   verifyFormat("int f() try { return 4; } catch (...) {\n"
3858                "  return 5;\n"
3859                "}");
3860   verifyFormat("class A {\n"
3861                "  int a;\n"
3862                "  A() try : a(0) {\n"
3863                "  } catch (...) {\n"
3864                "    throw;\n"
3865                "  }\n"
3866                "};\n");
3867   verifyFormat("class A {\n"
3868                "  int a;\n"
3869                "  A() try : a(0), b{1} {\n"
3870                "  } catch (...) {\n"
3871                "    throw;\n"
3872                "  }\n"
3873                "};\n");
3874   verifyFormat("class A {\n"
3875                "  int a;\n"
3876                "  A() try : a(0), b{1}, c{2} {\n"
3877                "  } catch (...) {\n"
3878                "    throw;\n"
3879                "  }\n"
3880                "};\n");
3881   verifyFormat("class A {\n"
3882                "  int a;\n"
3883                "  A() try : a(0), b{1}, c{2} {\n"
3884                "    { // New scope.\n"
3885                "    }\n"
3886                "  } catch (...) {\n"
3887                "    throw;\n"
3888                "  }\n"
3889                "};\n");
3890 
3891   // Incomplete try-catch blocks.
3892   verifyIncompleteFormat("try {} catch (");
3893 }
3894 
3895 TEST_F(FormatTest, FormatTryAsAVariable) {
3896   verifyFormat("int try;");
3897   verifyFormat("int try, size;");
3898   verifyFormat("try = foo();");
3899   verifyFormat("if (try < size) {\n  return true;\n}");
3900 
3901   verifyFormat("int catch;");
3902   verifyFormat("int catch, size;");
3903   verifyFormat("catch = foo();");
3904   verifyFormat("if (catch < size) {\n  return true;\n}");
3905 
3906   FormatStyle Style = getLLVMStyle();
3907   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
3908   Style.BraceWrapping.AfterFunction = true;
3909   Style.BraceWrapping.BeforeCatch = true;
3910   verifyFormat("try {\n"
3911                "  int bar = 1;\n"
3912                "}\n"
3913                "catch (...) {\n"
3914                "  int bar = 1;\n"
3915                "}",
3916                Style);
3917   verifyFormat("#if NO_EX\n"
3918                "try\n"
3919                "#endif\n"
3920                "{\n"
3921                "}\n"
3922                "#if NO_EX\n"
3923                "catch (...) {\n"
3924                "}",
3925                Style);
3926   verifyFormat("try /* abc */ {\n"
3927                "  int bar = 1;\n"
3928                "}\n"
3929                "catch (...) {\n"
3930                "  int bar = 1;\n"
3931                "}",
3932                Style);
3933   verifyFormat("try\n"
3934                "// abc\n"
3935                "{\n"
3936                "  int bar = 1;\n"
3937                "}\n"
3938                "catch (...) {\n"
3939                "  int bar = 1;\n"
3940                "}",
3941                Style);
3942 }
3943 
3944 TEST_F(FormatTest, FormatSEHTryCatch) {
3945   verifyFormat("__try {\n"
3946                "  int a = b * c;\n"
3947                "} __except (EXCEPTION_EXECUTE_HANDLER) {\n"
3948                "  // Do nothing.\n"
3949                "}");
3950 
3951   verifyFormat("__try {\n"
3952                "  int a = b * c;\n"
3953                "} __finally {\n"
3954                "  // Do nothing.\n"
3955                "}");
3956 
3957   verifyFormat("DEBUG({\n"
3958                "  __try {\n"
3959                "  } __finally {\n"
3960                "  }\n"
3961                "});\n");
3962 }
3963 
3964 TEST_F(FormatTest, IncompleteTryCatchBlocks) {
3965   verifyFormat("try {\n"
3966                "  f();\n"
3967                "} catch {\n"
3968                "  g();\n"
3969                "}");
3970   verifyFormat("try {\n"
3971                "  f();\n"
3972                "} catch (A a) MACRO(x) {\n"
3973                "  g();\n"
3974                "} catch (B b) MACRO(x) {\n"
3975                "  g();\n"
3976                "}");
3977 }
3978 
3979 TEST_F(FormatTest, FormatTryCatchBraceStyles) {
3980   FormatStyle Style = getLLVMStyle();
3981   for (auto BraceStyle : {FormatStyle::BS_Attach, FormatStyle::BS_Mozilla,
3982                           FormatStyle::BS_WebKit}) {
3983     Style.BreakBeforeBraces = BraceStyle;
3984     verifyFormat("try {\n"
3985                  "  // something\n"
3986                  "} catch (...) {\n"
3987                  "  // something\n"
3988                  "}",
3989                  Style);
3990   }
3991   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
3992   verifyFormat("try {\n"
3993                "  // something\n"
3994                "}\n"
3995                "catch (...) {\n"
3996                "  // something\n"
3997                "}",
3998                Style);
3999   verifyFormat("__try {\n"
4000                "  // something\n"
4001                "}\n"
4002                "__finally {\n"
4003                "  // something\n"
4004                "}",
4005                Style);
4006   verifyFormat("@try {\n"
4007                "  // something\n"
4008                "}\n"
4009                "@finally {\n"
4010                "  // something\n"
4011                "}",
4012                Style);
4013   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
4014   verifyFormat("try\n"
4015                "{\n"
4016                "  // something\n"
4017                "}\n"
4018                "catch (...)\n"
4019                "{\n"
4020                "  // something\n"
4021                "}",
4022                Style);
4023   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
4024   verifyFormat("try\n"
4025                "  {\n"
4026                "  // something white\n"
4027                "  }\n"
4028                "catch (...)\n"
4029                "  {\n"
4030                "  // something white\n"
4031                "  }",
4032                Style);
4033   Style.BreakBeforeBraces = FormatStyle::BS_GNU;
4034   verifyFormat("try\n"
4035                "  {\n"
4036                "    // something\n"
4037                "  }\n"
4038                "catch (...)\n"
4039                "  {\n"
4040                "    // something\n"
4041                "  }",
4042                Style);
4043   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
4044   Style.BraceWrapping.BeforeCatch = true;
4045   verifyFormat("try {\n"
4046                "  // something\n"
4047                "}\n"
4048                "catch (...) {\n"
4049                "  // something\n"
4050                "}",
4051                Style);
4052 }
4053 
4054 TEST_F(FormatTest, StaticInitializers) {
4055   verifyFormat("static SomeClass SC = {1, 'a'};");
4056 
4057   verifyFormat("static SomeClass WithALoooooooooooooooooooongName = {\n"
4058                "    100000000, "
4059                "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"};");
4060 
4061   // Here, everything other than the "}" would fit on a line.
4062   verifyFormat("static int LooooooooooooooooooooooooongVariable[1] = {\n"
4063                "    10000000000000000000000000};");
4064   EXPECT_EQ("S s = {a,\n"
4065             "\n"
4066             "       b};",
4067             format("S s = {\n"
4068                    "  a,\n"
4069                    "\n"
4070                    "  b\n"
4071                    "};"));
4072 
4073   // FIXME: This would fit into the column limit if we'd fit "{ {" on the first
4074   // line. However, the formatting looks a bit off and this probably doesn't
4075   // happen often in practice.
4076   verifyFormat("static int Variable[1] = {\n"
4077                "    {1000000000000000000000000000000000000}};",
4078                getLLVMStyleWithColumns(40));
4079 }
4080 
4081 TEST_F(FormatTest, DesignatedInitializers) {
4082   verifyFormat("const struct A a = {.a = 1, .b = 2};");
4083   verifyFormat("const struct A a = {.aaaaaaaaaa = 1,\n"
4084                "                    .bbbbbbbbbb = 2,\n"
4085                "                    .cccccccccc = 3,\n"
4086                "                    .dddddddddd = 4,\n"
4087                "                    .eeeeeeeeee = 5};");
4088   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
4089                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaa = 1,\n"
4090                "    .bbbbbbbbbbbbbbbbbbbbbbbbbbb = 2,\n"
4091                "    .ccccccccccccccccccccccccccc = 3,\n"
4092                "    .ddddddddddddddddddddddddddd = 4,\n"
4093                "    .eeeeeeeeeeeeeeeeeeeeeeeeeee = 5};");
4094 
4095   verifyGoogleFormat("const struct A a = {.a = 1, .b = 2};");
4096 
4097   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
4098   verifyFormat("const struct A a = {[1] = aaaaaaaaaa,\n"
4099                "                    [2] = bbbbbbbbbb,\n"
4100                "                    [3] = cccccccccc,\n"
4101                "                    [4] = dddddddddd,\n"
4102                "                    [5] = eeeeeeeeee};");
4103   verifyFormat("const struct Aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa = {\n"
4104                "    [1] = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
4105                "    [2] = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
4106                "    [3] = cccccccccccccccccccccccccccccccccccccc,\n"
4107                "    [4] = dddddddddddddddddddddddddddddddddddddd,\n"
4108                "    [5] = eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee};");
4109 }
4110 
4111 TEST_F(FormatTest, NestedStaticInitializers) {
4112   verifyFormat("static A x = {{{}}};\n");
4113   verifyFormat("static A x = {{{init1, init2, init3, init4},\n"
4114                "               {init1, init2, init3, init4}}};",
4115                getLLVMStyleWithColumns(50));
4116 
4117   verifyFormat("somes Status::global_reps[3] = {\n"
4118                "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
4119                "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
4120                "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};",
4121                getLLVMStyleWithColumns(60));
4122   verifyGoogleFormat("SomeType Status::global_reps[3] = {\n"
4123                      "    {kGlobalRef, OK_CODE, NULL, NULL, NULL},\n"
4124                      "    {kGlobalRef, CANCELLED_CODE, NULL, NULL, NULL},\n"
4125                      "    {kGlobalRef, UNKNOWN_CODE, NULL, NULL, NULL}};");
4126   verifyFormat("CGRect cg_rect = {{rect.fLeft, rect.fTop},\n"
4127                "                  {rect.fRight - rect.fLeft, rect.fBottom - "
4128                "rect.fTop}};");
4129 
4130   verifyFormat(
4131       "SomeArrayOfSomeType a = {\n"
4132       "    {{1, 2, 3},\n"
4133       "     {1, 2, 3},\n"
4134       "     {111111111111111111111111111111, 222222222222222222222222222222,\n"
4135       "      333333333333333333333333333333},\n"
4136       "     {1, 2, 3},\n"
4137       "     {1, 2, 3}}};");
4138   verifyFormat(
4139       "SomeArrayOfSomeType a = {\n"
4140       "    {{1, 2, 3}},\n"
4141       "    {{1, 2, 3}},\n"
4142       "    {{111111111111111111111111111111, 222222222222222222222222222222,\n"
4143       "      333333333333333333333333333333}},\n"
4144       "    {{1, 2, 3}},\n"
4145       "    {{1, 2, 3}}};");
4146 
4147   verifyFormat("struct {\n"
4148                "  unsigned bit;\n"
4149                "  const char *const name;\n"
4150                "} kBitsToOs[] = {{kOsMac, \"Mac\"},\n"
4151                "                 {kOsWin, \"Windows\"},\n"
4152                "                 {kOsLinux, \"Linux\"},\n"
4153                "                 {kOsCrOS, \"Chrome OS\"}};");
4154   verifyFormat("struct {\n"
4155                "  unsigned bit;\n"
4156                "  const char *const name;\n"
4157                "} kBitsToOs[] = {\n"
4158                "    {kOsMac, \"Mac\"},\n"
4159                "    {kOsWin, \"Windows\"},\n"
4160                "    {kOsLinux, \"Linux\"},\n"
4161                "    {kOsCrOS, \"Chrome OS\"},\n"
4162                "};");
4163 }
4164 
4165 TEST_F(FormatTest, FormatsSmallMacroDefinitionsInSingleLine) {
4166   verifyFormat("#define ALooooooooooooooooooooooooooooooooooooooongMacro("
4167                "                      \\\n"
4168                "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)");
4169 }
4170 
4171 TEST_F(FormatTest, DoesNotBreakPureVirtualFunctionDefinition) {
4172   verifyFormat("virtual void write(ELFWriter *writerrr,\n"
4173                "                   OwningPtr<FileOutputBuffer> &buffer) = 0;");
4174 
4175   // Do break defaulted and deleted functions.
4176   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
4177                "    default;",
4178                getLLVMStyleWithColumns(40));
4179   verifyFormat("virtual void ~Deeeeeeeestructor() =\n"
4180                "    delete;",
4181                getLLVMStyleWithColumns(40));
4182 }
4183 
4184 TEST_F(FormatTest, BreaksStringLiteralsOnlyInDefine) {
4185   verifyFormat("# 1111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\" 2 3",
4186                getLLVMStyleWithColumns(40));
4187   verifyFormat("#line 11111 \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
4188                getLLVMStyleWithColumns(40));
4189   EXPECT_EQ("#define Q                              \\\n"
4190             "  \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/\"    \\\n"
4191             "  \"aaaaaaaa.cpp\"",
4192             format("#define Q \"/aaaaaaaaa/aaaaaaaaaaaaaaaaaaa/aaaaaaaa.cpp\"",
4193                    getLLVMStyleWithColumns(40)));
4194 }
4195 
4196 TEST_F(FormatTest, UnderstandsLinePPDirective) {
4197   EXPECT_EQ("# 123 \"A string literal\"",
4198             format("   #     123    \"A string literal\""));
4199 }
4200 
4201 TEST_F(FormatTest, LayoutUnknownPPDirective) {
4202   EXPECT_EQ("#;", format("#;"));
4203   verifyFormat("#\n;\n;\n;");
4204 }
4205 
4206 TEST_F(FormatTest, UnescapedEndOfLineEndsPPDirective) {
4207   EXPECT_EQ("#line 42 \"test\"\n",
4208             format("#  \\\n  line  \\\n  42  \\\n  \"test\"\n"));
4209   EXPECT_EQ("#define A B\n", format("#  \\\n define  \\\n    A  \\\n       B\n",
4210                                     getLLVMStyleWithColumns(12)));
4211 }
4212 
4213 TEST_F(FormatTest, EndOfFileEndsPPDirective) {
4214   EXPECT_EQ("#line 42 \"test\"",
4215             format("#  \\\n  line  \\\n  42  \\\n  \"test\""));
4216   EXPECT_EQ("#define A B", format("#  \\\n define  \\\n    A  \\\n       B"));
4217 }
4218 
4219 TEST_F(FormatTest, DoesntRemoveUnknownTokens) {
4220   verifyFormat("#define A \\x20");
4221   verifyFormat("#define A \\ x20");
4222   EXPECT_EQ("#define A \\ x20", format("#define A \\   x20"));
4223   verifyFormat("#define A ''");
4224   verifyFormat("#define A ''qqq");
4225   verifyFormat("#define A `qqq");
4226   verifyFormat("f(\"aaaa, bbbb, \"\\\"ccccc\\\"\");");
4227   EXPECT_EQ("const char *c = STRINGIFY(\n"
4228             "\\na : b);",
4229             format("const char * c = STRINGIFY(\n"
4230                    "\\na : b);"));
4231 
4232   verifyFormat("a\r\\");
4233   verifyFormat("a\v\\");
4234   verifyFormat("a\f\\");
4235 }
4236 
4237 TEST_F(FormatTest, IndentsPPDirectiveWithPPIndentWidth) {
4238   FormatStyle style = getChromiumStyle(FormatStyle::LK_Cpp);
4239   style.IndentWidth = 4;
4240   style.PPIndentWidth = 1;
4241 
4242   style.IndentPPDirectives = FormatStyle::PPDIS_None;
4243   verifyFormat("#ifdef __linux__\n"
4244                "void foo() {\n"
4245                "    int x = 0;\n"
4246                "}\n"
4247                "#define FOO\n"
4248                "#endif\n"
4249                "void bar() {\n"
4250                "    int y = 0;\n"
4251                "}\n",
4252                style);
4253 
4254   style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
4255   verifyFormat("#ifdef __linux__\n"
4256                "void foo() {\n"
4257                "    int x = 0;\n"
4258                "}\n"
4259                "# define FOO foo\n"
4260                "#endif\n"
4261                "void bar() {\n"
4262                "    int y = 0;\n"
4263                "}\n",
4264                style);
4265 
4266   style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
4267   verifyFormat("#ifdef __linux__\n"
4268                "void foo() {\n"
4269                "    int x = 0;\n"
4270                "}\n"
4271                " #define FOO foo\n"
4272                "#endif\n"
4273                "void bar() {\n"
4274                "    int y = 0;\n"
4275                "}\n",
4276                style);
4277 }
4278 
4279 TEST_F(FormatTest, IndentsPPDirectiveInReducedSpace) {
4280   verifyFormat("#define A(BB)", getLLVMStyleWithColumns(13));
4281   verifyFormat("#define A( \\\n    BB)", getLLVMStyleWithColumns(12));
4282   verifyFormat("#define A( \\\n    A, B)", getLLVMStyleWithColumns(12));
4283   // FIXME: We never break before the macro name.
4284   verifyFormat("#define AA( \\\n    B)", getLLVMStyleWithColumns(12));
4285 
4286   verifyFormat("#define A A\n#define A A");
4287   verifyFormat("#define A(X) A\n#define A A");
4288 
4289   verifyFormat("#define Something Other", getLLVMStyleWithColumns(23));
4290   verifyFormat("#define Something    \\\n  Other", getLLVMStyleWithColumns(22));
4291 }
4292 
4293 TEST_F(FormatTest, HandlePreprocessorDirectiveContext) {
4294   EXPECT_EQ("// somecomment\n"
4295             "#include \"a.h\"\n"
4296             "#define A(  \\\n"
4297             "    A, B)\n"
4298             "#include \"b.h\"\n"
4299             "// somecomment\n",
4300             format("  // somecomment\n"
4301                    "  #include \"a.h\"\n"
4302                    "#define A(A,\\\n"
4303                    "    B)\n"
4304                    "    #include \"b.h\"\n"
4305                    " // somecomment\n",
4306                    getLLVMStyleWithColumns(13)));
4307 }
4308 
4309 TEST_F(FormatTest, LayoutSingleHash) { EXPECT_EQ("#\na;", format("#\na;")); }
4310 
4311 TEST_F(FormatTest, LayoutCodeInMacroDefinitions) {
4312   EXPECT_EQ("#define A    \\\n"
4313             "  c;         \\\n"
4314             "  e;\n"
4315             "f;",
4316             format("#define A c; e;\n"
4317                    "f;",
4318                    getLLVMStyleWithColumns(14)));
4319 }
4320 
4321 TEST_F(FormatTest, LayoutRemainingTokens) { EXPECT_EQ("{}", format("{}")); }
4322 
4323 TEST_F(FormatTest, MacroDefinitionInsideStatement) {
4324   EXPECT_EQ("int x,\n"
4325             "#define A\n"
4326             "    y;",
4327             format("int x,\n#define A\ny;"));
4328 }
4329 
4330 TEST_F(FormatTest, HashInMacroDefinition) {
4331   EXPECT_EQ("#define A(c) L#c", format("#define A(c) L#c", getLLVMStyle()));
4332   verifyFormat("#define A \\\n  b #c;", getLLVMStyleWithColumns(11));
4333   verifyFormat("#define A  \\\n"
4334                "  {        \\\n"
4335                "    f(#c); \\\n"
4336                "  }",
4337                getLLVMStyleWithColumns(11));
4338 
4339   verifyFormat("#define A(X)         \\\n"
4340                "  void function##X()",
4341                getLLVMStyleWithColumns(22));
4342 
4343   verifyFormat("#define A(a, b, c)   \\\n"
4344                "  void a##b##c()",
4345                getLLVMStyleWithColumns(22));
4346 
4347   verifyFormat("#define A void # ## #", getLLVMStyleWithColumns(22));
4348 }
4349 
4350 TEST_F(FormatTest, RespectWhitespaceInMacroDefinitions) {
4351   EXPECT_EQ("#define A (x)", format("#define A (x)"));
4352   EXPECT_EQ("#define A(x)", format("#define A(x)"));
4353 
4354   FormatStyle Style = getLLVMStyle();
4355   Style.SpaceBeforeParens = FormatStyle::SBPO_Never;
4356   verifyFormat("#define true ((foo)1)", Style);
4357   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
4358   verifyFormat("#define false((foo)0)", Style);
4359 }
4360 
4361 TEST_F(FormatTest, EmptyLinesInMacroDefinitions) {
4362   EXPECT_EQ("#define A b;", format("#define A \\\n"
4363                                    "          \\\n"
4364                                    "  b;",
4365                                    getLLVMStyleWithColumns(25)));
4366   EXPECT_EQ("#define A \\\n"
4367             "          \\\n"
4368             "  a;      \\\n"
4369             "  b;",
4370             format("#define A \\\n"
4371                    "          \\\n"
4372                    "  a;      \\\n"
4373                    "  b;",
4374                    getLLVMStyleWithColumns(11)));
4375   EXPECT_EQ("#define A \\\n"
4376             "  a;      \\\n"
4377             "          \\\n"
4378             "  b;",
4379             format("#define A \\\n"
4380                    "  a;      \\\n"
4381                    "          \\\n"
4382                    "  b;",
4383                    getLLVMStyleWithColumns(11)));
4384 }
4385 
4386 TEST_F(FormatTest, MacroDefinitionsWithIncompleteCode) {
4387   verifyIncompleteFormat("#define A :");
4388   verifyFormat("#define SOMECASES  \\\n"
4389                "  case 1:          \\\n"
4390                "  case 2\n",
4391                getLLVMStyleWithColumns(20));
4392   verifyFormat("#define MACRO(a) \\\n"
4393                "  if (a)         \\\n"
4394                "    f();         \\\n"
4395                "  else           \\\n"
4396                "    g()",
4397                getLLVMStyleWithColumns(18));
4398   verifyFormat("#define A template <typename T>");
4399   verifyIncompleteFormat("#define STR(x) #x\n"
4400                          "f(STR(this_is_a_string_literal{));");
4401   verifyFormat("#pragma omp threadprivate( \\\n"
4402                "    y)), // expected-warning",
4403                getLLVMStyleWithColumns(28));
4404   verifyFormat("#d, = };");
4405   verifyFormat("#if \"a");
4406   verifyIncompleteFormat("({\n"
4407                          "#define b     \\\n"
4408                          "  }           \\\n"
4409                          "  a\n"
4410                          "a",
4411                          getLLVMStyleWithColumns(15));
4412   verifyFormat("#define A     \\\n"
4413                "  {           \\\n"
4414                "    {\n"
4415                "#define B     \\\n"
4416                "  }           \\\n"
4417                "  }",
4418                getLLVMStyleWithColumns(15));
4419   verifyNoCrash("#if a\na(\n#else\n#endif\n{a");
4420   verifyNoCrash("a={0,1\n#if a\n#else\n;\n#endif\n}");
4421   verifyNoCrash("#if a\na(\n#else\n#endif\n) a {a,b,c,d,f,g};");
4422   verifyNoCrash("#ifdef A\n a(\n #else\n #endif\n) = []() {      \n)}");
4423 }
4424 
4425 TEST_F(FormatTest, MacrosWithoutTrailingSemicolon) {
4426   verifyFormat("SOME_TYPE_NAME abc;"); // Gated on the newline.
4427   EXPECT_EQ("class A : public QObject {\n"
4428             "  Q_OBJECT\n"
4429             "\n"
4430             "  A() {}\n"
4431             "};",
4432             format("class A  :  public QObject {\n"
4433                    "     Q_OBJECT\n"
4434                    "\n"
4435                    "  A() {\n}\n"
4436                    "}  ;"));
4437   EXPECT_EQ("MACRO\n"
4438             "/*static*/ int i;",
4439             format("MACRO\n"
4440                    " /*static*/ int   i;"));
4441   EXPECT_EQ("SOME_MACRO\n"
4442             "namespace {\n"
4443             "void f();\n"
4444             "} // namespace",
4445             format("SOME_MACRO\n"
4446                    "  namespace    {\n"
4447                    "void   f(  );\n"
4448                    "} // namespace"));
4449   // Only if the identifier contains at least 5 characters.
4450   EXPECT_EQ("HTTP f();", format("HTTP\nf();"));
4451   EXPECT_EQ("MACRO\nf();", format("MACRO\nf();"));
4452   // Only if everything is upper case.
4453   EXPECT_EQ("class A : public QObject {\n"
4454             "  Q_Object A() {}\n"
4455             "};",
4456             format("class A  :  public QObject {\n"
4457                    "     Q_Object\n"
4458                    "  A() {\n}\n"
4459                    "}  ;"));
4460 
4461   // Only if the next line can actually start an unwrapped line.
4462   EXPECT_EQ("SOME_WEIRD_LOG_MACRO << SomeThing;",
4463             format("SOME_WEIRD_LOG_MACRO\n"
4464                    "<< SomeThing;"));
4465 
4466   verifyFormat("VISIT_GL_CALL(GenBuffers, void, (GLsizei n, GLuint* buffers), "
4467                "(n, buffers))\n",
4468                getChromiumStyle(FormatStyle::LK_Cpp));
4469 
4470   // See PR41483
4471   EXPECT_EQ("/**/ FOO(a)\n"
4472             "FOO(b)",
4473             format("/**/ FOO(a)\n"
4474                    "FOO(b)"));
4475 }
4476 
4477 TEST_F(FormatTest, MacroCallsWithoutTrailingSemicolon) {
4478   EXPECT_EQ("INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
4479             "INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
4480             "INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
4481             "class X {};\n"
4482             "INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
4483             "int *createScopDetectionPass() { return 0; }",
4484             format("  INITIALIZE_PASS_BEGIN(ScopDetection, \"polly-detect\")\n"
4485                    "  INITIALIZE_AG_DEPENDENCY(AliasAnalysis)\n"
4486                    "  INITIALIZE_PASS_DEPENDENCY(DominatorTree)\n"
4487                    "  class X {};\n"
4488                    "  INITIALIZE_PASS_END(ScopDetection, \"polly-detect\")\n"
4489                    "  int *createScopDetectionPass() { return 0; }"));
4490   // FIXME: We could probably treat IPC_BEGIN_MESSAGE_MAP/IPC_END_MESSAGE_MAP as
4491   // braces, so that inner block is indented one level more.
4492   EXPECT_EQ("int q() {\n"
4493             "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
4494             "  IPC_MESSAGE_HANDLER(xxx, qqq)\n"
4495             "  IPC_END_MESSAGE_MAP()\n"
4496             "}",
4497             format("int q() {\n"
4498                    "  IPC_BEGIN_MESSAGE_MAP(WebKitTestController, message)\n"
4499                    "    IPC_MESSAGE_HANDLER(xxx, qqq)\n"
4500                    "  IPC_END_MESSAGE_MAP()\n"
4501                    "}"));
4502 
4503   // Same inside macros.
4504   EXPECT_EQ("#define LIST(L) \\\n"
4505             "  L(A)          \\\n"
4506             "  L(B)          \\\n"
4507             "  L(C)",
4508             format("#define LIST(L) \\\n"
4509                    "  L(A) \\\n"
4510                    "  L(B) \\\n"
4511                    "  L(C)",
4512                    getGoogleStyle()));
4513 
4514   // These must not be recognized as macros.
4515   EXPECT_EQ("int q() {\n"
4516             "  f(x);\n"
4517             "  f(x) {}\n"
4518             "  f(x)->g();\n"
4519             "  f(x)->*g();\n"
4520             "  f(x).g();\n"
4521             "  f(x) = x;\n"
4522             "  f(x) += x;\n"
4523             "  f(x) -= x;\n"
4524             "  f(x) *= x;\n"
4525             "  f(x) /= x;\n"
4526             "  f(x) %= x;\n"
4527             "  f(x) &= x;\n"
4528             "  f(x) |= x;\n"
4529             "  f(x) ^= x;\n"
4530             "  f(x) >>= x;\n"
4531             "  f(x) <<= x;\n"
4532             "  f(x)[y].z();\n"
4533             "  LOG(INFO) << x;\n"
4534             "  ifstream(x) >> x;\n"
4535             "}\n",
4536             format("int q() {\n"
4537                    "  f(x)\n;\n"
4538                    "  f(x)\n {}\n"
4539                    "  f(x)\n->g();\n"
4540                    "  f(x)\n->*g();\n"
4541                    "  f(x)\n.g();\n"
4542                    "  f(x)\n = x;\n"
4543                    "  f(x)\n += x;\n"
4544                    "  f(x)\n -= x;\n"
4545                    "  f(x)\n *= x;\n"
4546                    "  f(x)\n /= x;\n"
4547                    "  f(x)\n %= x;\n"
4548                    "  f(x)\n &= x;\n"
4549                    "  f(x)\n |= x;\n"
4550                    "  f(x)\n ^= x;\n"
4551                    "  f(x)\n >>= x;\n"
4552                    "  f(x)\n <<= x;\n"
4553                    "  f(x)\n[y].z();\n"
4554                    "  LOG(INFO)\n << x;\n"
4555                    "  ifstream(x)\n >> x;\n"
4556                    "}\n"));
4557   EXPECT_EQ("int q() {\n"
4558             "  F(x)\n"
4559             "  if (1) {\n"
4560             "  }\n"
4561             "  F(x)\n"
4562             "  while (1) {\n"
4563             "  }\n"
4564             "  F(x)\n"
4565             "  G(x);\n"
4566             "  F(x)\n"
4567             "  try {\n"
4568             "    Q();\n"
4569             "  } catch (...) {\n"
4570             "  }\n"
4571             "}\n",
4572             format("int q() {\n"
4573                    "F(x)\n"
4574                    "if (1) {}\n"
4575                    "F(x)\n"
4576                    "while (1) {}\n"
4577                    "F(x)\n"
4578                    "G(x);\n"
4579                    "F(x)\n"
4580                    "try { Q(); } catch (...) {}\n"
4581                    "}\n"));
4582   EXPECT_EQ("class A {\n"
4583             "  A() : t(0) {}\n"
4584             "  A(int i) noexcept() : {}\n"
4585             "  A(X x)\n" // FIXME: function-level try blocks are broken.
4586             "  try : t(0) {\n"
4587             "  } catch (...) {\n"
4588             "  }\n"
4589             "};",
4590             format("class A {\n"
4591                    "  A()\n : t(0) {}\n"
4592                    "  A(int i)\n noexcept() : {}\n"
4593                    "  A(X x)\n"
4594                    "  try : t(0) {} catch (...) {}\n"
4595                    "};"));
4596   FormatStyle Style = getLLVMStyle();
4597   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
4598   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Always;
4599   Style.BraceWrapping.AfterFunction = true;
4600   EXPECT_EQ("void f()\n"
4601             "try\n"
4602             "{\n"
4603             "}",
4604             format("void f() try {\n"
4605                    "}",
4606                    Style));
4607   EXPECT_EQ("class SomeClass {\n"
4608             "public:\n"
4609             "  SomeClass() EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
4610             "};",
4611             format("class SomeClass {\n"
4612                    "public:\n"
4613                    "  SomeClass()\n"
4614                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
4615                    "};"));
4616   EXPECT_EQ("class SomeClass {\n"
4617             "public:\n"
4618             "  SomeClass()\n"
4619             "      EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
4620             "};",
4621             format("class SomeClass {\n"
4622                    "public:\n"
4623                    "  SomeClass()\n"
4624                    "  EXCLUSIVE_LOCK_FUNCTION(mu_);\n"
4625                    "};",
4626                    getLLVMStyleWithColumns(40)));
4627 
4628   verifyFormat("MACRO(>)");
4629 
4630   // Some macros contain an implicit semicolon.
4631   Style = getLLVMStyle();
4632   Style.StatementMacros.push_back("FOO");
4633   verifyFormat("FOO(a) int b = 0;");
4634   verifyFormat("FOO(a)\n"
4635                "int b = 0;",
4636                Style);
4637   verifyFormat("FOO(a);\n"
4638                "int b = 0;",
4639                Style);
4640   verifyFormat("FOO(argc, argv, \"4.0.2\")\n"
4641                "int b = 0;",
4642                Style);
4643   verifyFormat("FOO()\n"
4644                "int b = 0;",
4645                Style);
4646   verifyFormat("FOO\n"
4647                "int b = 0;",
4648                Style);
4649   verifyFormat("void f() {\n"
4650                "  FOO(a)\n"
4651                "  return a;\n"
4652                "}",
4653                Style);
4654   verifyFormat("FOO(a)\n"
4655                "FOO(b)",
4656                Style);
4657   verifyFormat("int a = 0;\n"
4658                "FOO(b)\n"
4659                "int c = 0;",
4660                Style);
4661   verifyFormat("int a = 0;\n"
4662                "int x = FOO(a)\n"
4663                "int b = 0;",
4664                Style);
4665   verifyFormat("void foo(int a) { FOO(a) }\n"
4666                "uint32_t bar() {}",
4667                Style);
4668 }
4669 
4670 TEST_F(FormatTest, LayoutMacroDefinitionsStatementsSpanningBlocks) {
4671   verifyFormat("#define A \\\n"
4672                "  f({     \\\n"
4673                "    g();  \\\n"
4674                "  });",
4675                getLLVMStyleWithColumns(11));
4676 }
4677 
4678 TEST_F(FormatTest, IndentPreprocessorDirectives) {
4679   FormatStyle Style = getLLVMStyle();
4680   Style.IndentPPDirectives = FormatStyle::PPDIS_None;
4681   Style.ColumnLimit = 40;
4682   verifyFormat("#ifdef _WIN32\n"
4683                "#define A 0\n"
4684                "#ifdef VAR2\n"
4685                "#define B 1\n"
4686                "#include <someheader.h>\n"
4687                "#define MACRO                          \\\n"
4688                "  some_very_long_func_aaaaaaaaaa();\n"
4689                "#endif\n"
4690                "#else\n"
4691                "#define A 1\n"
4692                "#endif",
4693                Style);
4694   Style.IndentPPDirectives = FormatStyle::PPDIS_AfterHash;
4695   verifyFormat("#ifdef _WIN32\n"
4696                "#  define A 0\n"
4697                "#  ifdef VAR2\n"
4698                "#    define B 1\n"
4699                "#    include <someheader.h>\n"
4700                "#    define MACRO                      \\\n"
4701                "      some_very_long_func_aaaaaaaaaa();\n"
4702                "#  endif\n"
4703                "#else\n"
4704                "#  define A 1\n"
4705                "#endif",
4706                Style);
4707   verifyFormat("#if A\n"
4708                "#  define MACRO                        \\\n"
4709                "    void a(int x) {                    \\\n"
4710                "      b();                             \\\n"
4711                "      c();                             \\\n"
4712                "      d();                             \\\n"
4713                "      e();                             \\\n"
4714                "      f();                             \\\n"
4715                "    }\n"
4716                "#endif",
4717                Style);
4718   // Comments before include guard.
4719   verifyFormat("// file comment\n"
4720                "// file comment\n"
4721                "#ifndef HEADER_H\n"
4722                "#define HEADER_H\n"
4723                "code();\n"
4724                "#endif",
4725                Style);
4726   // Test with include guards.
4727   verifyFormat("#ifndef HEADER_H\n"
4728                "#define HEADER_H\n"
4729                "code();\n"
4730                "#endif",
4731                Style);
4732   // Include guards must have a #define with the same variable immediately
4733   // after #ifndef.
4734   verifyFormat("#ifndef NOT_GUARD\n"
4735                "#  define FOO\n"
4736                "code();\n"
4737                "#endif",
4738                Style);
4739 
4740   // Include guards must cover the entire file.
4741   verifyFormat("code();\n"
4742                "code();\n"
4743                "#ifndef NOT_GUARD\n"
4744                "#  define NOT_GUARD\n"
4745                "code();\n"
4746                "#endif",
4747                Style);
4748   verifyFormat("#ifndef NOT_GUARD\n"
4749                "#  define NOT_GUARD\n"
4750                "code();\n"
4751                "#endif\n"
4752                "code();",
4753                Style);
4754   // Test with trailing blank lines.
4755   verifyFormat("#ifndef HEADER_H\n"
4756                "#define HEADER_H\n"
4757                "code();\n"
4758                "#endif\n",
4759                Style);
4760   // Include guards don't have #else.
4761   verifyFormat("#ifndef NOT_GUARD\n"
4762                "#  define NOT_GUARD\n"
4763                "code();\n"
4764                "#else\n"
4765                "#endif",
4766                Style);
4767   verifyFormat("#ifndef NOT_GUARD\n"
4768                "#  define NOT_GUARD\n"
4769                "code();\n"
4770                "#elif FOO\n"
4771                "#endif",
4772                Style);
4773   // Non-identifier #define after potential include guard.
4774   verifyFormat("#ifndef FOO\n"
4775                "#  define 1\n"
4776                "#endif\n",
4777                Style);
4778   // #if closes past last non-preprocessor line.
4779   verifyFormat("#ifndef FOO\n"
4780                "#define FOO\n"
4781                "#if 1\n"
4782                "int i;\n"
4783                "#  define A 0\n"
4784                "#endif\n"
4785                "#endif\n",
4786                Style);
4787   // Don't crash if there is an #elif directive without a condition.
4788   verifyFormat("#if 1\n"
4789                "int x;\n"
4790                "#elif\n"
4791                "int y;\n"
4792                "#else\n"
4793                "int z;\n"
4794                "#endif",
4795                Style);
4796   // FIXME: This doesn't handle the case where there's code between the
4797   // #ifndef and #define but all other conditions hold. This is because when
4798   // the #define line is parsed, UnwrappedLineParser::Lines doesn't hold the
4799   // previous code line yet, so we can't detect it.
4800   EXPECT_EQ("#ifndef NOT_GUARD\n"
4801             "code();\n"
4802             "#define NOT_GUARD\n"
4803             "code();\n"
4804             "#endif",
4805             format("#ifndef NOT_GUARD\n"
4806                    "code();\n"
4807                    "#  define NOT_GUARD\n"
4808                    "code();\n"
4809                    "#endif",
4810                    Style));
4811   // FIXME: This doesn't handle cases where legitimate preprocessor lines may
4812   // be outside an include guard. Examples are #pragma once and
4813   // #pragma GCC diagnostic, or anything else that does not change the meaning
4814   // of the file if it's included multiple times.
4815   EXPECT_EQ("#ifdef WIN32\n"
4816             "#  pragma once\n"
4817             "#endif\n"
4818             "#ifndef HEADER_H\n"
4819             "#  define HEADER_H\n"
4820             "code();\n"
4821             "#endif",
4822             format("#ifdef WIN32\n"
4823                    "#  pragma once\n"
4824                    "#endif\n"
4825                    "#ifndef HEADER_H\n"
4826                    "#define HEADER_H\n"
4827                    "code();\n"
4828                    "#endif",
4829                    Style));
4830   // FIXME: This does not detect when there is a single non-preprocessor line
4831   // in front of an include-guard-like structure where other conditions hold
4832   // because ScopedLineState hides the line.
4833   EXPECT_EQ("code();\n"
4834             "#ifndef HEADER_H\n"
4835             "#define HEADER_H\n"
4836             "code();\n"
4837             "#endif",
4838             format("code();\n"
4839                    "#ifndef HEADER_H\n"
4840                    "#  define HEADER_H\n"
4841                    "code();\n"
4842                    "#endif",
4843                    Style));
4844   // Keep comments aligned with #, otherwise indent comments normally. These
4845   // tests cannot use verifyFormat because messUp manipulates leading
4846   // whitespace.
4847   {
4848     const char *Expected = ""
4849                            "void f() {\n"
4850                            "#if 1\n"
4851                            "// Preprocessor aligned.\n"
4852                            "#  define A 0\n"
4853                            "  // Code. Separated by blank line.\n"
4854                            "\n"
4855                            "#  define B 0\n"
4856                            "  // Code. Not aligned with #\n"
4857                            "#  define C 0\n"
4858                            "#endif";
4859     const char *ToFormat = ""
4860                            "void f() {\n"
4861                            "#if 1\n"
4862                            "// Preprocessor aligned.\n"
4863                            "#  define A 0\n"
4864                            "// Code. Separated by blank line.\n"
4865                            "\n"
4866                            "#  define B 0\n"
4867                            "   // Code. Not aligned with #\n"
4868                            "#  define C 0\n"
4869                            "#endif";
4870     EXPECT_EQ(Expected, format(ToFormat, Style));
4871     EXPECT_EQ(Expected, format(Expected, Style));
4872   }
4873   // Keep block quotes aligned.
4874   {
4875     const char *Expected = ""
4876                            "void f() {\n"
4877                            "#if 1\n"
4878                            "/* Preprocessor aligned. */\n"
4879                            "#  define A 0\n"
4880                            "  /* Code. Separated by blank line. */\n"
4881                            "\n"
4882                            "#  define B 0\n"
4883                            "  /* Code. Not aligned with # */\n"
4884                            "#  define C 0\n"
4885                            "#endif";
4886     const char *ToFormat = ""
4887                            "void f() {\n"
4888                            "#if 1\n"
4889                            "/* Preprocessor aligned. */\n"
4890                            "#  define A 0\n"
4891                            "/* Code. Separated by blank line. */\n"
4892                            "\n"
4893                            "#  define B 0\n"
4894                            "   /* Code. Not aligned with # */\n"
4895                            "#  define C 0\n"
4896                            "#endif";
4897     EXPECT_EQ(Expected, format(ToFormat, Style));
4898     EXPECT_EQ(Expected, format(Expected, Style));
4899   }
4900   // Keep comments aligned with un-indented directives.
4901   {
4902     const char *Expected = ""
4903                            "void f() {\n"
4904                            "// Preprocessor aligned.\n"
4905                            "#define A 0\n"
4906                            "  // Code. Separated by blank line.\n"
4907                            "\n"
4908                            "#define B 0\n"
4909                            "  // Code. Not aligned with #\n"
4910                            "#define C 0\n";
4911     const char *ToFormat = ""
4912                            "void f() {\n"
4913                            "// Preprocessor aligned.\n"
4914                            "#define A 0\n"
4915                            "// Code. Separated by blank line.\n"
4916                            "\n"
4917                            "#define B 0\n"
4918                            "   // Code. Not aligned with #\n"
4919                            "#define C 0\n";
4920     EXPECT_EQ(Expected, format(ToFormat, Style));
4921     EXPECT_EQ(Expected, format(Expected, Style));
4922   }
4923   // Test AfterHash with tabs.
4924   {
4925     FormatStyle Tabbed = Style;
4926     Tabbed.UseTab = FormatStyle::UT_Always;
4927     Tabbed.IndentWidth = 8;
4928     Tabbed.TabWidth = 8;
4929     verifyFormat("#ifdef _WIN32\n"
4930                  "#\tdefine A 0\n"
4931                  "#\tifdef VAR2\n"
4932                  "#\t\tdefine B 1\n"
4933                  "#\t\tinclude <someheader.h>\n"
4934                  "#\t\tdefine MACRO          \\\n"
4935                  "\t\t\tsome_very_long_func_aaaaaaaaaa();\n"
4936                  "#\tendif\n"
4937                  "#else\n"
4938                  "#\tdefine A 1\n"
4939                  "#endif",
4940                  Tabbed);
4941   }
4942 
4943   // Regression test: Multiline-macro inside include guards.
4944   verifyFormat("#ifndef HEADER_H\n"
4945                "#define HEADER_H\n"
4946                "#define A()        \\\n"
4947                "  int i;           \\\n"
4948                "  int j;\n"
4949                "#endif // HEADER_H",
4950                getLLVMStyleWithColumns(20));
4951 
4952   Style.IndentPPDirectives = FormatStyle::PPDIS_BeforeHash;
4953   // Basic before hash indent tests
4954   verifyFormat("#ifdef _WIN32\n"
4955                "  #define A 0\n"
4956                "  #ifdef VAR2\n"
4957                "    #define B 1\n"
4958                "    #include <someheader.h>\n"
4959                "    #define MACRO                      \\\n"
4960                "      some_very_long_func_aaaaaaaaaa();\n"
4961                "  #endif\n"
4962                "#else\n"
4963                "  #define A 1\n"
4964                "#endif",
4965                Style);
4966   verifyFormat("#if A\n"
4967                "  #define MACRO                        \\\n"
4968                "    void a(int x) {                    \\\n"
4969                "      b();                             \\\n"
4970                "      c();                             \\\n"
4971                "      d();                             \\\n"
4972                "      e();                             \\\n"
4973                "      f();                             \\\n"
4974                "    }\n"
4975                "#endif",
4976                Style);
4977   // Keep comments aligned with indented directives. These
4978   // tests cannot use verifyFormat because messUp manipulates leading
4979   // whitespace.
4980   {
4981     const char *Expected = "void f() {\n"
4982                            "// Aligned to preprocessor.\n"
4983                            "#if 1\n"
4984                            "  // Aligned to code.\n"
4985                            "  int a;\n"
4986                            "  #if 1\n"
4987                            "    // Aligned to preprocessor.\n"
4988                            "    #define A 0\n"
4989                            "  // Aligned to code.\n"
4990                            "  int b;\n"
4991                            "  #endif\n"
4992                            "#endif\n"
4993                            "}";
4994     const char *ToFormat = "void f() {\n"
4995                            "// Aligned to preprocessor.\n"
4996                            "#if 1\n"
4997                            "// Aligned to code.\n"
4998                            "int a;\n"
4999                            "#if 1\n"
5000                            "// Aligned to preprocessor.\n"
5001                            "#define A 0\n"
5002                            "// Aligned to code.\n"
5003                            "int b;\n"
5004                            "#endif\n"
5005                            "#endif\n"
5006                            "}";
5007     EXPECT_EQ(Expected, format(ToFormat, Style));
5008     EXPECT_EQ(Expected, format(Expected, Style));
5009   }
5010   {
5011     const char *Expected = "void f() {\n"
5012                            "/* Aligned to preprocessor. */\n"
5013                            "#if 1\n"
5014                            "  /* Aligned to code. */\n"
5015                            "  int a;\n"
5016                            "  #if 1\n"
5017                            "    /* Aligned to preprocessor. */\n"
5018                            "    #define A 0\n"
5019                            "  /* Aligned to code. */\n"
5020                            "  int b;\n"
5021                            "  #endif\n"
5022                            "#endif\n"
5023                            "}";
5024     const char *ToFormat = "void f() {\n"
5025                            "/* Aligned to preprocessor. */\n"
5026                            "#if 1\n"
5027                            "/* Aligned to code. */\n"
5028                            "int a;\n"
5029                            "#if 1\n"
5030                            "/* Aligned to preprocessor. */\n"
5031                            "#define A 0\n"
5032                            "/* Aligned to code. */\n"
5033                            "int b;\n"
5034                            "#endif\n"
5035                            "#endif\n"
5036                            "}";
5037     EXPECT_EQ(Expected, format(ToFormat, Style));
5038     EXPECT_EQ(Expected, format(Expected, Style));
5039   }
5040 
5041   // Test single comment before preprocessor
5042   verifyFormat("// Comment\n"
5043                "\n"
5044                "#if 1\n"
5045                "#endif",
5046                Style);
5047 }
5048 
5049 TEST_F(FormatTest, FormatHashIfNotAtStartOfLine) {
5050   verifyFormat("{\n  { a #c; }\n}");
5051 }
5052 
5053 TEST_F(FormatTest, FormatUnbalancedStructuralElements) {
5054   EXPECT_EQ("#define A \\\n  {       \\\n    {\nint i;",
5055             format("#define A { {\nint i;", getLLVMStyleWithColumns(11)));
5056   EXPECT_EQ("#define A \\\n  }       \\\n  }\nint i;",
5057             format("#define A } }\nint i;", getLLVMStyleWithColumns(11)));
5058 }
5059 
5060 TEST_F(FormatTest, EscapedNewlines) {
5061   FormatStyle Narrow = getLLVMStyleWithColumns(11);
5062   EXPECT_EQ("#define A \\\n  int i;  \\\n  int j;",
5063             format("#define A \\\nint i;\\\n  int j;", Narrow));
5064   EXPECT_EQ("#define A\n\nint i;", format("#define A \\\n\n int i;"));
5065   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
5066   EXPECT_EQ("/* \\  \\  \\\n */", format("\\\n/* \\  \\  \\\n */"));
5067   EXPECT_EQ("<a\n\\\\\n>", format("<a\n\\\\\n>"));
5068 
5069   FormatStyle AlignLeft = getLLVMStyle();
5070   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
5071   EXPECT_EQ("#define MACRO(x) \\\n"
5072             "private:         \\\n"
5073             "  int x(int a);\n",
5074             format("#define MACRO(x) \\\n"
5075                    "private:         \\\n"
5076                    "  int x(int a);\n",
5077                    AlignLeft));
5078 
5079   // CRLF line endings
5080   EXPECT_EQ("#define A \\\r\n  int i;  \\\r\n  int j;",
5081             format("#define A \\\r\nint i;\\\r\n  int j;", Narrow));
5082   EXPECT_EQ("#define A\r\n\r\nint i;", format("#define A \\\r\n\r\n int i;"));
5083   EXPECT_EQ("template <class T> f();", format("\\\ntemplate <class T> f();"));
5084   EXPECT_EQ("/* \\  \\  \\\r\n */", format("\\\r\n/* \\  \\  \\\r\n */"));
5085   EXPECT_EQ("<a\r\n\\\\\r\n>", format("<a\r\n\\\\\r\n>"));
5086   EXPECT_EQ("#define MACRO(x) \\\r\n"
5087             "private:         \\\r\n"
5088             "  int x(int a);\r\n",
5089             format("#define MACRO(x) \\\r\n"
5090                    "private:         \\\r\n"
5091                    "  int x(int a);\r\n",
5092                    AlignLeft));
5093 
5094   FormatStyle DontAlign = getLLVMStyle();
5095   DontAlign.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
5096   DontAlign.MaxEmptyLinesToKeep = 3;
5097   // FIXME: can't use verifyFormat here because the newline before
5098   // "public:" is not inserted the first time it's reformatted
5099   EXPECT_EQ("#define A \\\n"
5100             "  class Foo { \\\n"
5101             "    void bar(); \\\n"
5102             "\\\n"
5103             "\\\n"
5104             "\\\n"
5105             "  public: \\\n"
5106             "    void baz(); \\\n"
5107             "  };",
5108             format("#define A \\\n"
5109                    "  class Foo { \\\n"
5110                    "    void bar(); \\\n"
5111                    "\\\n"
5112                    "\\\n"
5113                    "\\\n"
5114                    "  public: \\\n"
5115                    "    void baz(); \\\n"
5116                    "  };",
5117                    DontAlign));
5118 }
5119 
5120 TEST_F(FormatTest, CalculateSpaceOnConsecutiveLinesInMacro) {
5121   verifyFormat("#define A \\\n"
5122                "  int v(  \\\n"
5123                "      a); \\\n"
5124                "  int i;",
5125                getLLVMStyleWithColumns(11));
5126 }
5127 
5128 TEST_F(FormatTest, MixingPreprocessorDirectivesAndNormalCode) {
5129   EXPECT_EQ(
5130       "#define ALooooooooooooooooooooooooooooooooooooooongMacro("
5131       "                      \\\n"
5132       "    aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
5133       "\n"
5134       "AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
5135       "    aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n",
5136       format("  #define   ALooooooooooooooooooooooooooooooooooooooongMacro("
5137              "\\\n"
5138              "aLoooooooooooooooooooooooongFuuuuuuuuuuuuuunctiooooooooo)\n"
5139              "  \n"
5140              "   AlooooooooooooooooooooooooooooooooooooooongCaaaaaaaaaal(\n"
5141              "  aLooooooooooooooooooooooonPaaaaaaaaaaaaaaaaaaaaarmmmm);\n"));
5142 }
5143 
5144 TEST_F(FormatTest, LayoutStatementsAroundPreprocessorDirectives) {
5145   EXPECT_EQ("int\n"
5146             "#define A\n"
5147             "    a;",
5148             format("int\n#define A\na;"));
5149   verifyFormat("functionCallTo(\n"
5150                "    someOtherFunction(\n"
5151                "        withSomeParameters, whichInSequence,\n"
5152                "        areLongerThanALine(andAnotherCall,\n"
5153                "#define A B\n"
5154                "                           withMoreParamters,\n"
5155                "                           whichStronglyInfluenceTheLayout),\n"
5156                "        andMoreParameters),\n"
5157                "    trailing);",
5158                getLLVMStyleWithColumns(69));
5159   verifyFormat("Foo::Foo()\n"
5160                "#ifdef BAR\n"
5161                "    : baz(0)\n"
5162                "#endif\n"
5163                "{\n"
5164                "}");
5165   verifyFormat("void f() {\n"
5166                "  if (true)\n"
5167                "#ifdef A\n"
5168                "    f(42);\n"
5169                "  x();\n"
5170                "#else\n"
5171                "    g();\n"
5172                "  x();\n"
5173                "#endif\n"
5174                "}");
5175   verifyFormat("void f(param1, param2,\n"
5176                "       param3,\n"
5177                "#ifdef A\n"
5178                "       param4(param5,\n"
5179                "#ifdef A1\n"
5180                "              param6,\n"
5181                "#ifdef A2\n"
5182                "              param7),\n"
5183                "#else\n"
5184                "              param8),\n"
5185                "       param9,\n"
5186                "#endif\n"
5187                "       param10,\n"
5188                "#endif\n"
5189                "       param11)\n"
5190                "#else\n"
5191                "       param12)\n"
5192                "#endif\n"
5193                "{\n"
5194                "  x();\n"
5195                "}",
5196                getLLVMStyleWithColumns(28));
5197   verifyFormat("#if 1\n"
5198                "int i;");
5199   verifyFormat("#if 1\n"
5200                "#endif\n"
5201                "#if 1\n"
5202                "#else\n"
5203                "#endif\n");
5204   verifyFormat("DEBUG({\n"
5205                "  return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5206                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;\n"
5207                "});\n"
5208                "#if a\n"
5209                "#else\n"
5210                "#endif");
5211 
5212   verifyIncompleteFormat("void f(\n"
5213                          "#if A\n"
5214                          ");\n"
5215                          "#else\n"
5216                          "#endif");
5217 }
5218 
5219 TEST_F(FormatTest, GraciouslyHandleIncorrectPreprocessorConditions) {
5220   verifyFormat("#endif\n"
5221                "#if B");
5222 }
5223 
5224 TEST_F(FormatTest, FormatsJoinedLinesOnSubsequentRuns) {
5225   FormatStyle SingleLine = getLLVMStyle();
5226   SingleLine.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_WithoutElse;
5227   verifyFormat("#if 0\n"
5228                "#elif 1\n"
5229                "#endif\n"
5230                "void foo() {\n"
5231                "  if (test) foo2();\n"
5232                "}",
5233                SingleLine);
5234 }
5235 
5236 TEST_F(FormatTest, LayoutBlockInsideParens) {
5237   verifyFormat("functionCall({ int i; });");
5238   verifyFormat("functionCall({\n"
5239                "  int i;\n"
5240                "  int j;\n"
5241                "});");
5242   verifyFormat("functionCall(\n"
5243                "    {\n"
5244                "      int i;\n"
5245                "      int j;\n"
5246                "    },\n"
5247                "    aaaa, bbbb, cccc);");
5248   verifyFormat("functionA(functionB({\n"
5249                "            int i;\n"
5250                "            int j;\n"
5251                "          }),\n"
5252                "          aaaa, bbbb, cccc);");
5253   verifyFormat("functionCall(\n"
5254                "    {\n"
5255                "      int i;\n"
5256                "      int j;\n"
5257                "    },\n"
5258                "    aaaa, bbbb, // comment\n"
5259                "    cccc);");
5260   verifyFormat("functionA(functionB({\n"
5261                "            int i;\n"
5262                "            int j;\n"
5263                "          }),\n"
5264                "          aaaa, bbbb, // comment\n"
5265                "          cccc);");
5266   verifyFormat("functionCall(aaaa, bbbb, { int i; });");
5267   verifyFormat("functionCall(aaaa, bbbb, {\n"
5268                "  int i;\n"
5269                "  int j;\n"
5270                "});");
5271   verifyFormat(
5272       "Aaa(\n" // FIXME: There shouldn't be a linebreak here.
5273       "    {\n"
5274       "      int i; // break\n"
5275       "    },\n"
5276       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
5277       "                                     ccccccccccccccccc));");
5278   verifyFormat("DEBUG({\n"
5279                "  if (a)\n"
5280                "    f();\n"
5281                "});");
5282 }
5283 
5284 TEST_F(FormatTest, LayoutBlockInsideStatement) {
5285   EXPECT_EQ("SOME_MACRO { int i; }\n"
5286             "int i;",
5287             format("  SOME_MACRO  {int i;}  int i;"));
5288 }
5289 
5290 TEST_F(FormatTest, LayoutNestedBlocks) {
5291   verifyFormat("void AddOsStrings(unsigned bitmask) {\n"
5292                "  struct s {\n"
5293                "    int i;\n"
5294                "  };\n"
5295                "  s kBitsToOs[] = {{10}};\n"
5296                "  for (int i = 0; i < 10; ++i)\n"
5297                "    return;\n"
5298                "}");
5299   verifyFormat("call(parameter, {\n"
5300                "  something();\n"
5301                "  // Comment using all columns.\n"
5302                "  somethingelse();\n"
5303                "});",
5304                getLLVMStyleWithColumns(40));
5305   verifyFormat("DEBUG( //\n"
5306                "    { f(); }, a);");
5307   verifyFormat("DEBUG( //\n"
5308                "    {\n"
5309                "      f(); //\n"
5310                "    },\n"
5311                "    a);");
5312 
5313   EXPECT_EQ("call(parameter, {\n"
5314             "  something();\n"
5315             "  // Comment too\n"
5316             "  // looooooooooong.\n"
5317             "  somethingElse();\n"
5318             "});",
5319             format("call(parameter, {\n"
5320                    "  something();\n"
5321                    "  // Comment too looooooooooong.\n"
5322                    "  somethingElse();\n"
5323                    "});",
5324                    getLLVMStyleWithColumns(29)));
5325   EXPECT_EQ("DEBUG({ int i; });", format("DEBUG({ int   i; });"));
5326   EXPECT_EQ("DEBUG({ // comment\n"
5327             "  int i;\n"
5328             "});",
5329             format("DEBUG({ // comment\n"
5330                    "int  i;\n"
5331                    "});"));
5332   EXPECT_EQ("DEBUG({\n"
5333             "  int i;\n"
5334             "\n"
5335             "  // comment\n"
5336             "  int j;\n"
5337             "});",
5338             format("DEBUG({\n"
5339                    "  int  i;\n"
5340                    "\n"
5341                    "  // comment\n"
5342                    "  int  j;\n"
5343                    "});"));
5344 
5345   verifyFormat("DEBUG({\n"
5346                "  if (a)\n"
5347                "    return;\n"
5348                "});");
5349   verifyGoogleFormat("DEBUG({\n"
5350                      "  if (a) return;\n"
5351                      "});");
5352   FormatStyle Style = getGoogleStyle();
5353   Style.ColumnLimit = 45;
5354   verifyFormat("Debug(\n"
5355                "    aaaaa,\n"
5356                "    {\n"
5357                "      if (aaaaaaaaaaaaaaaaaaaaaaaa) return;\n"
5358                "    },\n"
5359                "    a);",
5360                Style);
5361 
5362   verifyFormat("SomeFunction({MACRO({ return output; }), b});");
5363 
5364   verifyNoCrash("^{v^{a}}");
5365 }
5366 
5367 TEST_F(FormatTest, FormatNestedBlocksInMacros) {
5368   EXPECT_EQ("#define MACRO()                     \\\n"
5369             "  Debug(aaa, /* force line break */ \\\n"
5370             "        {                           \\\n"
5371             "          int i;                    \\\n"
5372             "          int j;                    \\\n"
5373             "        })",
5374             format("#define   MACRO()   Debug(aaa,  /* force line break */ \\\n"
5375                    "          {  int   i;  int  j;   })",
5376                    getGoogleStyle()));
5377 
5378   EXPECT_EQ("#define A                                       \\\n"
5379             "  [] {                                          \\\n"
5380             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
5381             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
5382             "  }",
5383             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
5384                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
5385                    getGoogleStyle()));
5386 }
5387 
5388 TEST_F(FormatTest, PutEmptyBlocksIntoOneLine) {
5389   EXPECT_EQ("{}", format("{}"));
5390   verifyFormat("enum E {};");
5391   verifyFormat("enum E {}");
5392   FormatStyle Style = getLLVMStyle();
5393   Style.SpaceInEmptyBlock = true;
5394   EXPECT_EQ("void f() { }", format("void f() {}", Style));
5395   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
5396   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
5397 }
5398 
5399 TEST_F(FormatTest, FormatBeginBlockEndMacros) {
5400   FormatStyle Style = getLLVMStyle();
5401   Style.MacroBlockBegin = "^[A-Z_]+_BEGIN$";
5402   Style.MacroBlockEnd = "^[A-Z_]+_END$";
5403   verifyFormat("FOO_BEGIN\n"
5404                "  FOO_ENTRY\n"
5405                "FOO_END",
5406                Style);
5407   verifyFormat("FOO_BEGIN\n"
5408                "  NESTED_FOO_BEGIN\n"
5409                "    NESTED_FOO_ENTRY\n"
5410                "  NESTED_FOO_END\n"
5411                "FOO_END",
5412                Style);
5413   verifyFormat("FOO_BEGIN(Foo, Bar)\n"
5414                "  int x;\n"
5415                "  x = 1;\n"
5416                "FOO_END(Baz)",
5417                Style);
5418 }
5419 
5420 //===----------------------------------------------------------------------===//
5421 // Line break tests.
5422 //===----------------------------------------------------------------------===//
5423 
5424 TEST_F(FormatTest, PreventConfusingIndents) {
5425   verifyFormat(
5426       "void f() {\n"
5427       "  SomeLongMethodName(SomeReallyLongMethod(CallOtherReallyLongMethod(\n"
5428       "                         parameter, parameter, parameter)),\n"
5429       "                     SecondLongCall(parameter));\n"
5430       "}");
5431   verifyFormat(
5432       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5433       "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
5434       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5435       "    aaaaaaaaaaaaaaaaaaaaaaaa);");
5436   verifyFormat(
5437       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5438       "    [aaaaaaaaaaaaaaaaaaaaaaaa\n"
5439       "         [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
5440       "         [aaaaaaaaaaaaaaaaaaaaaaaa]];");
5441   verifyFormat(
5442       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
5443       "    aaaaaaaaaaaaaaaaaaaaaaaa<\n"
5444       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>,\n"
5445       "    aaaaaaaaaaaaaaaaaaaaaaaa>;");
5446   verifyFormat("int a = bbbb && ccc &&\n"
5447                "        fffff(\n"
5448                "#define A Just forcing a new line\n"
5449                "            ddd);");
5450 }
5451 
5452 TEST_F(FormatTest, LineBreakingInBinaryExpressions) {
5453   verifyFormat(
5454       "bool aaaaaaa =\n"
5455       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() ||\n"
5456       "    bbbbbbbb();");
5457   verifyFormat(
5458       "bool aaaaaaa =\n"
5459       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaa).aaaaaaaaaaaaaaaaaaa() or\n"
5460       "    bbbbbbbb();");
5461 
5462   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
5463                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb &&\n"
5464                "    ccccccccc == ddddddddddd;");
5465   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaa =\n"
5466                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa != bbbbbbbbbbbbbbbbbb and\n"
5467                "    ccccccccc == ddddddddddd;");
5468   verifyFormat(
5469       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
5470       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa not_eq bbbbbbbbbbbbbbbbbb and\n"
5471       "    ccccccccc == ddddddddddd;");
5472 
5473   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
5474                "                 aaaaaa) &&\n"
5475                "         bbbbbb && cccccc;");
5476   verifyFormat("aaaaaa = aaaaaaa(aaaaaaa, // break\n"
5477                "                 aaaaaa) >>\n"
5478                "         bbbbbb;");
5479   verifyFormat("aa = Whitespaces.addUntouchableComment(\n"
5480                "    SourceMgr.getSpellingColumnNumber(\n"
5481                "        TheLine.Last->FormatTok.Tok.getLocation()) -\n"
5482                "    1);");
5483 
5484   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5485                "     bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaaaaaaa\n"
5486                "    cccccc) {\n}");
5487   verifyFormat("if constexpr ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5488                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
5489                "              cccccc) {\n}");
5490   verifyFormat("if CONSTEXPR ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5491                "               bbbbbbbbbbbbbbbbbb) && // aaaaaaaaaaa\n"
5492                "              cccccc) {\n}");
5493   verifyFormat("b = a &&\n"
5494                "    // Comment\n"
5495                "    b.c && d;");
5496 
5497   // If the LHS of a comparison is not a binary expression itself, the
5498   // additional linebreak confuses many people.
5499   verifyFormat(
5500       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5501       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) > 5) {\n"
5502       "}");
5503   verifyFormat(
5504       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5505       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
5506       "}");
5507   verifyFormat(
5508       "if (aaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaa(\n"
5509       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
5510       "}");
5511   verifyFormat(
5512       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5513       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) <=> 5) {\n"
5514       "}");
5515   // Even explicit parentheses stress the precedence enough to make the
5516   // additional break unnecessary.
5517   verifyFormat("if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5518                "     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) == 5) {\n"
5519                "}");
5520   // This cases is borderline, but with the indentation it is still readable.
5521   verifyFormat(
5522       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5523       "        aaaaaaaaaaaaaaa) > aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5524       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
5525       "}",
5526       getLLVMStyleWithColumns(75));
5527 
5528   // If the LHS is a binary expression, we should still use the additional break
5529   // as otherwise the formatting hides the operator precedence.
5530   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5531                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
5532                "    5) {\n"
5533                "}");
5534   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5535                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa <=>\n"
5536                "    5) {\n"
5537                "}");
5538 
5539   FormatStyle OnePerLine = getLLVMStyle();
5540   OnePerLine.BinPackParameters = false;
5541   verifyFormat(
5542       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5543       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
5544       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}",
5545       OnePerLine);
5546 
5547   verifyFormat("int i = someFunction(aaaaaaa, 0)\n"
5548                "                .aaa(aaaaaaaaaaaaa) *\n"
5549                "            aaaaaaa +\n"
5550                "        aaaaaaa;",
5551                getLLVMStyleWithColumns(40));
5552 }
5553 
5554 TEST_F(FormatTest, ExpressionIndentation) {
5555   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5556                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5557                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
5558                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
5559                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
5560                "                     bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb &&\n"
5561                "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
5562                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >\n"
5563                "                 ccccccccccccccccccccccccccccccccccccccccc;");
5564   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
5565                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5566                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
5567                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
5568   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5569                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
5570                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
5571                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
5572   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ==\n"
5573                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *\n"
5574                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5575                "        bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
5576   verifyFormat("if () {\n"
5577                "} else if (aaaaa && bbbbb > // break\n"
5578                "                        ccccc) {\n"
5579                "}");
5580   verifyFormat("if () {\n"
5581                "} else if constexpr (aaaaa && bbbbb > // break\n"
5582                "                                  ccccc) {\n"
5583                "}");
5584   verifyFormat("if () {\n"
5585                "} else if CONSTEXPR (aaaaa && bbbbb > // break\n"
5586                "                                  ccccc) {\n"
5587                "}");
5588   verifyFormat("if () {\n"
5589                "} else if (aaaaa &&\n"
5590                "           bbbbb > // break\n"
5591                "               ccccc &&\n"
5592                "           ddddd) {\n"
5593                "}");
5594 
5595   // Presence of a trailing comment used to change indentation of b.
5596   verifyFormat("return aaaaaaaaaaaaaaaaaaa +\n"
5597                "       b;\n"
5598                "return aaaaaaaaaaaaaaaaaaa +\n"
5599                "       b; //",
5600                getLLVMStyleWithColumns(30));
5601 }
5602 
5603 TEST_F(FormatTest, ExpressionIndentationBreakingBeforeOperators) {
5604   // Not sure what the best system is here. Like this, the LHS can be found
5605   // immediately above an operator (everything with the same or a higher
5606   // indent). The RHS is aligned right of the operator and so compasses
5607   // everything until something with the same indent as the operator is found.
5608   // FIXME: Is this a good system?
5609   FormatStyle Style = getLLVMStyle();
5610   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
5611   verifyFormat(
5612       "bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5613       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5614       "                     + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5615       "                 == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5616       "                            * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5617       "                        + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5618       "             && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5619       "                        * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5620       "                    > ccccccccccccccccccccccccccccccccccccccccc;",
5621       Style);
5622   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5623                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5624                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5625                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
5626                Style);
5627   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5628                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5629                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5630                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
5631                Style);
5632   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5633                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5634                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5635                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
5636                Style);
5637   verifyFormat("if () {\n"
5638                "} else if (aaaaa\n"
5639                "           && bbbbb // break\n"
5640                "                  > ccccc) {\n"
5641                "}",
5642                Style);
5643   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5644                "       && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
5645                Style);
5646   verifyFormat("return (a)\n"
5647                "       // comment\n"
5648                "       + b;",
5649                Style);
5650   verifyFormat(
5651       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5652       "                 * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5653       "             + cc;",
5654       Style);
5655 
5656   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5657                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
5658                Style);
5659 
5660   // Forced by comments.
5661   verifyFormat(
5662       "unsigned ContentSize =\n"
5663       "    sizeof(int16_t)   // DWARF ARange version number\n"
5664       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
5665       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
5666       "    + sizeof(int8_t); // Segment Size (in bytes)");
5667 
5668   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
5669                "       == boost::fusion::at_c<1>(iiii).second;",
5670                Style);
5671 
5672   Style.ColumnLimit = 60;
5673   verifyFormat("zzzzzzzzzz\n"
5674                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5675                "      >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
5676                Style);
5677 
5678   Style.ColumnLimit = 80;
5679   Style.IndentWidth = 4;
5680   Style.TabWidth = 4;
5681   Style.UseTab = FormatStyle::UT_Always;
5682   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5683   Style.AlignOperands = FormatStyle::OAS_DontAlign;
5684   EXPECT_EQ("return someVeryVeryLongConditionThatBarelyFitsOnALine\n"
5685             "\t&& (someOtherLongishConditionPart1\n"
5686             "\t\t|| someOtherEvenLongerNestedConditionPart2);",
5687             format("return someVeryVeryLongConditionThatBarelyFitsOnALine && "
5688                    "(someOtherLongishConditionPart1 || "
5689                    "someOtherEvenLongerNestedConditionPart2);",
5690                    Style));
5691 }
5692 
5693 TEST_F(FormatTest, ExpressionIndentationStrictAlign) {
5694   FormatStyle Style = getLLVMStyle();
5695   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
5696   Style.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
5697 
5698   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5699                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5700                "                   + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5701                "              == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5702                "                         * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5703                "                     + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5704                "          && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5705                "                     * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5706                "                 > ccccccccccccccccccccccccccccccccccccccccc;",
5707                Style);
5708   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5709                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5710                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5711                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
5712                Style);
5713   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5714                "        + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5715                "              * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5716                "    == bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
5717                Style);
5718   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5719                "    == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5720                "               * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5721                "           + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}",
5722                Style);
5723   verifyFormat("if () {\n"
5724                "} else if (aaaaa\n"
5725                "           && bbbbb // break\n"
5726                "                  > ccccc) {\n"
5727                "}",
5728                Style);
5729   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5730                "    && bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
5731                Style);
5732   verifyFormat("return (a)\n"
5733                "     // comment\n"
5734                "     + b;",
5735                Style);
5736   verifyFormat(
5737       "int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5738       "               * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5739       "           + cc;",
5740       Style);
5741   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
5742                "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
5743                "                        : 3333333333333333;",
5744                Style);
5745   verifyFormat(
5746       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
5747       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
5748       "                                             : eeeeeeeeeeeeeeeeee)\n"
5749       "     : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
5750       "                        : 3333333333333333;",
5751       Style);
5752   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5753                "    = aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
5754                Style);
5755 
5756   verifyFormat("return boost::fusion::at_c<0>(iiii).second\n"
5757                "    == boost::fusion::at_c<1>(iiii).second;",
5758                Style);
5759 
5760   Style.ColumnLimit = 60;
5761   verifyFormat("zzzzzzzzzzzzz\n"
5762                "    = bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5763                "   >> aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa);",
5764                Style);
5765 
5766   // Forced by comments.
5767   Style.ColumnLimit = 80;
5768   verifyFormat(
5769       "unsigned ContentSize\n"
5770       "    = sizeof(int16_t) // DWARF ARange version number\n"
5771       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
5772       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
5773       "    + sizeof(int8_t); // Segment Size (in bytes)",
5774       Style);
5775 
5776   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
5777   verifyFormat(
5778       "unsigned ContentSize =\n"
5779       "    sizeof(int16_t)   // DWARF ARange version number\n"
5780       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
5781       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
5782       "    + sizeof(int8_t); // Segment Size (in bytes)",
5783       Style);
5784 
5785   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
5786   verifyFormat(
5787       "unsigned ContentSize =\n"
5788       "    sizeof(int16_t)   // DWARF ARange version number\n"
5789       "    + sizeof(int32_t) // Offset of CU in the .debug_info section\n"
5790       "    + sizeof(int8_t)  // Pointer Size (in bytes)\n"
5791       "    + sizeof(int8_t); // Segment Size (in bytes)",
5792       Style);
5793 }
5794 
5795 TEST_F(FormatTest, EnforcedOperatorWraps) {
5796   // Here we'd like to wrap after the || operators, but a comment is forcing an
5797   // earlier wrap.
5798   verifyFormat("bool x = aaaaa //\n"
5799                "         || bbbbb\n"
5800                "         //\n"
5801                "         || cccc;");
5802 }
5803 
5804 TEST_F(FormatTest, NoOperandAlignment) {
5805   FormatStyle Style = getLLVMStyle();
5806   Style.AlignOperands = FormatStyle::OAS_DontAlign;
5807   verifyFormat("aaaaaaaaaaaaaa(aaaaaaaaaaaa,\n"
5808                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
5809                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
5810                Style);
5811   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
5812   verifyFormat("bool value = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5813                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5814                "            + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5815                "        == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5816                "                * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5817                "            + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5818                "    && aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5819                "            * aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5820                "        > ccccccccccccccccccccccccccccccccccccccccc;",
5821                Style);
5822 
5823   verifyFormat("int aaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5824                "        * bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5825                "    + cc;",
5826                Style);
5827   verifyFormat("int a = aa\n"
5828                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
5829                "        * cccccccccccccccccccccccccccccccccccc;\n",
5830                Style);
5831 
5832   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
5833   verifyFormat("return (a > b\n"
5834                "    // comment1\n"
5835                "    // comment2\n"
5836                "    || c);",
5837                Style);
5838 }
5839 
5840 TEST_F(FormatTest, BreakingBeforeNonAssigmentOperators) {
5841   FormatStyle Style = getLLVMStyle();
5842   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
5843   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
5844                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
5845                "    + bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
5846                Style);
5847 }
5848 
5849 TEST_F(FormatTest, AllowBinPackingInsideArguments) {
5850   FormatStyle Style = getLLVMStyle();
5851   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_NonAssignment;
5852   Style.BinPackArguments = false;
5853   Style.ColumnLimit = 40;
5854   verifyFormat("void test() {\n"
5855                "  someFunction(\n"
5856                "      this + argument + is + quite\n"
5857                "      + long + so + it + gets + wrapped\n"
5858                "      + but + remains + bin - packed);\n"
5859                "}",
5860                Style);
5861   verifyFormat("void test() {\n"
5862                "  someFunction(arg1,\n"
5863                "               this + argument + is\n"
5864                "                   + quite + long + so\n"
5865                "                   + it + gets + wrapped\n"
5866                "                   + but + remains + bin\n"
5867                "                   - packed,\n"
5868                "               arg3);\n"
5869                "}",
5870                Style);
5871   verifyFormat("void test() {\n"
5872                "  someFunction(\n"
5873                "      arg1,\n"
5874                "      this + argument + has\n"
5875                "          + anotherFunc(nested,\n"
5876                "                        calls + whose\n"
5877                "                            + arguments\n"
5878                "                            + are + also\n"
5879                "                            + wrapped,\n"
5880                "                        in + addition)\n"
5881                "          + to + being + bin - packed,\n"
5882                "      arg3);\n"
5883                "}",
5884                Style);
5885 
5886   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
5887   verifyFormat("void test() {\n"
5888                "  someFunction(\n"
5889                "      arg1,\n"
5890                "      this + argument + has +\n"
5891                "          anotherFunc(nested,\n"
5892                "                      calls + whose +\n"
5893                "                          arguments +\n"
5894                "                          are + also +\n"
5895                "                          wrapped,\n"
5896                "                      in + addition) +\n"
5897                "          to + being + bin - packed,\n"
5898                "      arg3);\n"
5899                "}",
5900                Style);
5901 }
5902 
5903 TEST_F(FormatTest, ConstructorInitializers) {
5904   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
5905   verifyFormat("Constructor() : Inttializer(FitsOnTheLine) {}",
5906                getLLVMStyleWithColumns(45));
5907   verifyFormat("Constructor()\n"
5908                "    : Inttializer(FitsOnTheLine) {}",
5909                getLLVMStyleWithColumns(44));
5910   verifyFormat("Constructor()\n"
5911                "    : Inttializer(FitsOnTheLine) {}",
5912                getLLVMStyleWithColumns(43));
5913 
5914   verifyFormat("template <typename T>\n"
5915                "Constructor() : Initializer(FitsOnTheLine) {}",
5916                getLLVMStyleWithColumns(45));
5917 
5918   verifyFormat(
5919       "SomeClass::Constructor()\n"
5920       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
5921 
5922   verifyFormat(
5923       "SomeClass::Constructor()\n"
5924       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5925       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}");
5926   verifyFormat(
5927       "SomeClass::Constructor()\n"
5928       "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5929       "      aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}");
5930   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5931                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
5932                "    : aaaaaaaaaa(aaaaaa) {}");
5933 
5934   verifyFormat("Constructor()\n"
5935                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5936                "      aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
5937                "                               aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
5938                "      aaaaaaaaaaaaaaaaaaaaaaa() {}");
5939 
5940   verifyFormat("Constructor()\n"
5941                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5942                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5943 
5944   verifyFormat("Constructor(int Parameter = 0)\n"
5945                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
5946                "      aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}");
5947   verifyFormat("Constructor()\n"
5948                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
5949                "}",
5950                getLLVMStyleWithColumns(60));
5951   verifyFormat("Constructor()\n"
5952                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
5953                "          aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}");
5954 
5955   // Here a line could be saved by splitting the second initializer onto two
5956   // lines, but that is not desirable.
5957   verifyFormat("Constructor()\n"
5958                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
5959                "      aaaaaaaaaaa(aaaaaaaaaaa),\n"
5960                "      aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
5961 
5962   FormatStyle OnePerLine = getLLVMStyle();
5963   OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_Never;
5964   verifyFormat("MyClass::MyClass()\n"
5965                "    : a(a),\n"
5966                "      b(b),\n"
5967                "      c(c) {}",
5968                OnePerLine);
5969   verifyFormat("MyClass::MyClass()\n"
5970                "    : a(a), // comment\n"
5971                "      b(b),\n"
5972                "      c(c) {}",
5973                OnePerLine);
5974   verifyFormat("MyClass::MyClass(int a)\n"
5975                "    : b(a),      // comment\n"
5976                "      c(a + 1) { // lined up\n"
5977                "}",
5978                OnePerLine);
5979   verifyFormat("Constructor()\n"
5980                "    : a(b, b, b) {}",
5981                OnePerLine);
5982   OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
5983   OnePerLine.AllowAllParametersOfDeclarationOnNextLine = false;
5984   verifyFormat("SomeClass::Constructor()\n"
5985                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5986                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5987                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5988                OnePerLine);
5989   verifyFormat("SomeClass::Constructor()\n"
5990                "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
5991                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
5992                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
5993                OnePerLine);
5994   verifyFormat("MyClass::MyClass(int var)\n"
5995                "    : some_var_(var),            // 4 space indent\n"
5996                "      some_other_var_(var + 1) { // lined up\n"
5997                "}",
5998                OnePerLine);
5999   verifyFormat("Constructor()\n"
6000                "    : aaaaa(aaaaaa),\n"
6001                "      aaaaa(aaaaaa),\n"
6002                "      aaaaa(aaaaaa),\n"
6003                "      aaaaa(aaaaaa),\n"
6004                "      aaaaa(aaaaaa) {}",
6005                OnePerLine);
6006   verifyFormat("Constructor()\n"
6007                "    : aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
6008                "            aaaaaaaaaaaaaaaaaaaaaa) {}",
6009                OnePerLine);
6010   OnePerLine.BinPackParameters = false;
6011   verifyFormat(
6012       "Constructor()\n"
6013       "    : aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6014       "          aaaaaaaaaaa().aaa(),\n"
6015       "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6016       OnePerLine);
6017   OnePerLine.ColumnLimit = 60;
6018   verifyFormat("Constructor()\n"
6019                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
6020                "      bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
6021                OnePerLine);
6022 
6023   EXPECT_EQ("Constructor()\n"
6024             "    : // Comment forcing unwanted break.\n"
6025             "      aaaa(aaaa) {}",
6026             format("Constructor() :\n"
6027                    "    // Comment forcing unwanted break.\n"
6028                    "    aaaa(aaaa) {}"));
6029 }
6030 
6031 TEST_F(FormatTest, AllowAllConstructorInitializersOnNextLine) {
6032   FormatStyle Style = getLLVMStyle();
6033   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
6034   Style.ColumnLimit = 60;
6035   Style.BinPackParameters = false;
6036 
6037   for (int i = 0; i < 4; ++i) {
6038     // Test all combinations of parameters that should not have an effect.
6039     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
6040     Style.AllowAllArgumentsOnNextLine = i & 2;
6041 
6042     Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
6043     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
6044     verifyFormat("Constructor()\n"
6045                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
6046                  Style);
6047     verifyFormat("Constructor() : a(a), b(b) {}", Style);
6048 
6049     Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine;
6050     verifyFormat("Constructor()\n"
6051                  "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
6052                  "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
6053                  Style);
6054     verifyFormat("Constructor() : a(a), b(b) {}", Style);
6055 
6056     Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
6057     Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
6058     verifyFormat("Constructor()\n"
6059                  "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
6060                  Style);
6061 
6062     Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine;
6063     verifyFormat("Constructor()\n"
6064                  "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
6065                  "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
6066                  Style);
6067 
6068     Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
6069     Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
6070     verifyFormat("Constructor() :\n"
6071                  "    aaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
6072                  Style);
6073 
6074     Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine;
6075     verifyFormat("Constructor() :\n"
6076                  "    aaaaaaaaaaaaaaaaaa(a),\n"
6077                  "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
6078                  Style);
6079   }
6080 
6081   // Test interactions between AllowAllParametersOfDeclarationOnNextLine and
6082   // AllowAllConstructorInitializersOnNextLine in all
6083   // BreakConstructorInitializers modes
6084   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
6085   Style.AllowAllParametersOfDeclarationOnNextLine = true;
6086   verifyFormat("SomeClassWithALongName::Constructor(\n"
6087                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
6088                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
6089                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
6090                Style);
6091 
6092   Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
6093   verifyFormat("SomeClassWithALongName::Constructor(\n"
6094                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
6095                "    int bbbbbbbbbbbbb,\n"
6096                "    int cccccccccccccccc)\n"
6097                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
6098                Style);
6099 
6100   Style.AllowAllParametersOfDeclarationOnNextLine = false;
6101   Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine;
6102   verifyFormat("SomeClassWithALongName::Constructor(\n"
6103                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
6104                "    int bbbbbbbbbbbbb)\n"
6105                "    : aaaaaaaaaaaaaaaaaaaa(a)\n"
6106                "    , bbbbbbbbbbbbbbbbbbbbb(b) {}",
6107                Style);
6108 
6109   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
6110 
6111   Style.AllowAllParametersOfDeclarationOnNextLine = true;
6112   verifyFormat("SomeClassWithALongName::Constructor(\n"
6113                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb)\n"
6114                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
6115                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
6116                Style);
6117 
6118   Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
6119   verifyFormat("SomeClassWithALongName::Constructor(\n"
6120                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
6121                "    int bbbbbbbbbbbbb,\n"
6122                "    int cccccccccccccccc)\n"
6123                "    : aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
6124                Style);
6125 
6126   Style.AllowAllParametersOfDeclarationOnNextLine = false;
6127   Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine;
6128   verifyFormat("SomeClassWithALongName::Constructor(\n"
6129                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
6130                "    int bbbbbbbbbbbbb)\n"
6131                "    : aaaaaaaaaaaaaaaaaaaa(a),\n"
6132                "      bbbbbbbbbbbbbbbbbbbbb(b) {}",
6133                Style);
6134 
6135   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
6136   Style.AllowAllParametersOfDeclarationOnNextLine = true;
6137   verifyFormat("SomeClassWithALongName::Constructor(\n"
6138                "    int aaaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbbb) :\n"
6139                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
6140                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
6141                Style);
6142 
6143   Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
6144   verifyFormat("SomeClassWithALongName::Constructor(\n"
6145                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
6146                "    int bbbbbbbbbbbbb,\n"
6147                "    int cccccccccccccccc) :\n"
6148                "    aaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbb(b) {}",
6149                Style);
6150 
6151   Style.AllowAllParametersOfDeclarationOnNextLine = false;
6152   Style.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine;
6153   verifyFormat("SomeClassWithALongName::Constructor(\n"
6154                "    int aaaaaaaaaaaaaaaaaaaaaaaa,\n"
6155                "    int bbbbbbbbbbbbb) :\n"
6156                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
6157                "    bbbbbbbbbbbbbbbbbbbbb(b) {}",
6158                Style);
6159 }
6160 
6161 TEST_F(FormatTest, AllowAllArgumentsOnNextLine) {
6162   FormatStyle Style = getLLVMStyle();
6163   Style.ColumnLimit = 60;
6164   Style.BinPackArguments = false;
6165   for (int i = 0; i < 4; ++i) {
6166     // Test all combinations of parameters that should not have an effect.
6167     Style.AllowAllParametersOfDeclarationOnNextLine = i & 1;
6168     Style.PackConstructorInitializers =
6169         i & 2 ? FormatStyle::PCIS_BinPack : FormatStyle::PCIS_Never;
6170 
6171     Style.AllowAllArgumentsOnNextLine = true;
6172     verifyFormat("void foo() {\n"
6173                  "  FunctionCallWithReallyLongName(\n"
6174                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb);\n"
6175                  "}",
6176                  Style);
6177     Style.AllowAllArgumentsOnNextLine = false;
6178     verifyFormat("void foo() {\n"
6179                  "  FunctionCallWithReallyLongName(\n"
6180                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6181                  "      bbbbbbbbbbbb);\n"
6182                  "}",
6183                  Style);
6184 
6185     Style.AllowAllArgumentsOnNextLine = true;
6186     verifyFormat("void foo() {\n"
6187                  "  auto VariableWithReallyLongName = {\n"
6188                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbb};\n"
6189                  "}",
6190                  Style);
6191     Style.AllowAllArgumentsOnNextLine = false;
6192     verifyFormat("void foo() {\n"
6193                  "  auto VariableWithReallyLongName = {\n"
6194                  "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6195                  "      bbbbbbbbbbbb};\n"
6196                  "}",
6197                  Style);
6198   }
6199 
6200   // This parameter should not affect declarations.
6201   Style.BinPackParameters = false;
6202   Style.AllowAllArgumentsOnNextLine = false;
6203   Style.AllowAllParametersOfDeclarationOnNextLine = true;
6204   verifyFormat("void FunctionCallWithReallyLongName(\n"
6205                "    int aaaaaaaaaaaaaaaaaaaaaaa, int bbbbbbbbbbbb);",
6206                Style);
6207   Style.AllowAllParametersOfDeclarationOnNextLine = false;
6208   verifyFormat("void FunctionCallWithReallyLongName(\n"
6209                "    int aaaaaaaaaaaaaaaaaaaaaaa,\n"
6210                "    int bbbbbbbbbbbb);",
6211                Style);
6212 }
6213 
6214 TEST_F(FormatTest, AllowAllArgumentsOnNextLineDontAlign) {
6215   // Check that AllowAllArgumentsOnNextLine is respected for both BAS_DontAlign
6216   // and BAS_Align.
6217   auto Style = getLLVMStyle();
6218   Style.ColumnLimit = 35;
6219   StringRef Input = "functionCall(paramA, paramB, paramC);\n"
6220                     "void functionDecl(int A, int B, int C);";
6221   Style.AllowAllArgumentsOnNextLine = false;
6222   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6223   EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
6224                       "    paramC);\n"
6225                       "void functionDecl(int A, int B,\n"
6226                       "    int C);"),
6227             format(Input, Style));
6228   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6229   EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
6230                       "             paramC);\n"
6231                       "void functionDecl(int A, int B,\n"
6232                       "                  int C);"),
6233             format(Input, Style));
6234   // However, BAS_AlwaysBreak should take precedence over
6235   // AllowAllArgumentsOnNextLine.
6236   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6237   EXPECT_EQ(StringRef("functionCall(\n"
6238                       "    paramA, paramB, paramC);\n"
6239                       "void functionDecl(\n"
6240                       "    int A, int B, int C);"),
6241             format(Input, Style));
6242 
6243   // When AllowAllArgumentsOnNextLine is set, we prefer breaking before the
6244   // first argument.
6245   Style.AllowAllArgumentsOnNextLine = true;
6246   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
6247   EXPECT_EQ(StringRef("functionCall(\n"
6248                       "    paramA, paramB, paramC);\n"
6249                       "void functionDecl(\n"
6250                       "    int A, int B, int C);"),
6251             format(Input, Style));
6252   // It wouldn't fit on one line with aligned parameters so this setting
6253   // doesn't change anything for BAS_Align.
6254   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
6255   EXPECT_EQ(StringRef("functionCall(paramA, paramB,\n"
6256                       "             paramC);\n"
6257                       "void functionDecl(int A, int B,\n"
6258                       "                  int C);"),
6259             format(Input, Style));
6260   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
6261   EXPECT_EQ(StringRef("functionCall(\n"
6262                       "    paramA, paramB, paramC);\n"
6263                       "void functionDecl(\n"
6264                       "    int A, int B, int C);"),
6265             format(Input, Style));
6266 }
6267 
6268 TEST_F(FormatTest, BreakConstructorInitializersAfterColon) {
6269   FormatStyle Style = getLLVMStyle();
6270   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
6271 
6272   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}");
6273   verifyFormat("Constructor() : Initializer(FitsOnTheLine) {}",
6274                getStyleWithColumns(Style, 45));
6275   verifyFormat("Constructor() :\n"
6276                "    Initializer(FitsOnTheLine) {}",
6277                getStyleWithColumns(Style, 44));
6278   verifyFormat("Constructor() :\n"
6279                "    Initializer(FitsOnTheLine) {}",
6280                getStyleWithColumns(Style, 43));
6281 
6282   verifyFormat("template <typename T>\n"
6283                "Constructor() : Initializer(FitsOnTheLine) {}",
6284                getStyleWithColumns(Style, 50));
6285   Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
6286   verifyFormat(
6287       "SomeClass::Constructor() :\n"
6288       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
6289       Style);
6290 
6291   Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack;
6292   verifyFormat(
6293       "SomeClass::Constructor() :\n"
6294       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
6295       Style);
6296 
6297   verifyFormat(
6298       "SomeClass::Constructor() :\n"
6299       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6300       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6301       Style);
6302   verifyFormat(
6303       "SomeClass::Constructor() :\n"
6304       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6305       "    aaaaaaaaaaaaaaa(aaaaaaaaaaaa) {}",
6306       Style);
6307   verifyFormat("Constructor(aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6308                "            aaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
6309                "    aaaaaaaaaa(aaaaaa) {}",
6310                Style);
6311 
6312   verifyFormat("Constructor() :\n"
6313                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6314                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6315                "                             aaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6316                "    aaaaaaaaaaaaaaaaaaaaaaa() {}",
6317                Style);
6318 
6319   verifyFormat("Constructor() :\n"
6320                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6321                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6322                Style);
6323 
6324   verifyFormat("Constructor(int Parameter = 0) :\n"
6325                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa),\n"
6326                "    aaaaaaaaaaaa(aaaaaaaaaaaaaaaaa) {}",
6327                Style);
6328   verifyFormat("Constructor() :\n"
6329                "    aaaaaaaaaaaaaaaaaaaaaa(a), bbbbbbbbbbbbbbbbbbbbbbbb(b) {\n"
6330                "}",
6331                getStyleWithColumns(Style, 60));
6332   verifyFormat("Constructor() :\n"
6333                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6334                "        aaaaaaaaaaaaaaaaaaaaaaaaa(aaaa, aaaa)) {}",
6335                Style);
6336 
6337   // Here a line could be saved by splitting the second initializer onto two
6338   // lines, but that is not desirable.
6339   verifyFormat("Constructor() :\n"
6340                "    aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaa),\n"
6341                "    aaaaaaaaaaa(aaaaaaaaaaa),\n"
6342                "    aaaaaaaaaaaaaaaaaaaaat(aaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6343                Style);
6344 
6345   FormatStyle OnePerLine = Style;
6346   OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_CurrentLine;
6347   verifyFormat("SomeClass::Constructor() :\n"
6348                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6349                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6350                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6351                OnePerLine);
6352   verifyFormat("SomeClass::Constructor() :\n"
6353                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa), // Some comment\n"
6354                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
6355                "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
6356                OnePerLine);
6357   verifyFormat("MyClass::MyClass(int var) :\n"
6358                "    some_var_(var),            // 4 space indent\n"
6359                "    some_other_var_(var + 1) { // lined up\n"
6360                "}",
6361                OnePerLine);
6362   verifyFormat("Constructor() :\n"
6363                "    aaaaa(aaaaaa),\n"
6364                "    aaaaa(aaaaaa),\n"
6365                "    aaaaa(aaaaaa),\n"
6366                "    aaaaa(aaaaaa),\n"
6367                "    aaaaa(aaaaaa) {}",
6368                OnePerLine);
6369   verifyFormat("Constructor() :\n"
6370                "    aaaaa(aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa,\n"
6371                "          aaaaaaaaaaaaaaaaaaaaaa) {}",
6372                OnePerLine);
6373   OnePerLine.BinPackParameters = false;
6374   verifyFormat("Constructor() :\n"
6375                "    aaaaaaaaaaaaaaaaaaaaaaaa(\n"
6376                "        aaaaaaaaaaa().aaa(),\n"
6377                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6378                OnePerLine);
6379   OnePerLine.ColumnLimit = 60;
6380   verifyFormat("Constructor() :\n"
6381                "    aaaaaaaaaaaaaaaaaaaa(a),\n"
6382                "    bbbbbbbbbbbbbbbbbbbbbbbb(b) {}",
6383                OnePerLine);
6384 
6385   EXPECT_EQ("Constructor() :\n"
6386             "    // Comment forcing unwanted break.\n"
6387             "    aaaa(aaaa) {}",
6388             format("Constructor() :\n"
6389                    "    // Comment forcing unwanted break.\n"
6390                    "    aaaa(aaaa) {}",
6391                    Style));
6392 
6393   Style.ColumnLimit = 0;
6394   verifyFormat("SomeClass::Constructor() :\n"
6395                "    a(a) {}",
6396                Style);
6397   verifyFormat("SomeClass::Constructor() noexcept :\n"
6398                "    a(a) {}",
6399                Style);
6400   verifyFormat("SomeClass::Constructor() :\n"
6401                "    a(a), b(b), c(c) {}",
6402                Style);
6403   verifyFormat("SomeClass::Constructor() :\n"
6404                "    a(a) {\n"
6405                "  foo();\n"
6406                "  bar();\n"
6407                "}",
6408                Style);
6409 
6410   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
6411   verifyFormat("SomeClass::Constructor() :\n"
6412                "    a(a), b(b), c(c) {\n"
6413                "}",
6414                Style);
6415   verifyFormat("SomeClass::Constructor() :\n"
6416                "    a(a) {\n"
6417                "}",
6418                Style);
6419 
6420   Style.ColumnLimit = 80;
6421   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
6422   Style.ConstructorInitializerIndentWidth = 2;
6423   verifyFormat("SomeClass::Constructor() : a(a), b(b), c(c) {}", Style);
6424   verifyFormat("SomeClass::Constructor() :\n"
6425                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6426                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}",
6427                Style);
6428 
6429   // `ConstructorInitializerIndentWidth` actually applies to InheritanceList as
6430   // well
6431   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
6432   verifyFormat(
6433       "class SomeClass\n"
6434       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6435       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
6436       Style);
6437   Style.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
6438   verifyFormat(
6439       "class SomeClass\n"
6440       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6441       "  , public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
6442       Style);
6443   Style.BreakInheritanceList = FormatStyle::BILS_AfterColon;
6444   verifyFormat(
6445       "class SomeClass :\n"
6446       "  public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6447       "  public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
6448       Style);
6449   Style.BreakInheritanceList = FormatStyle::BILS_AfterComma;
6450   verifyFormat(
6451       "class SomeClass\n"
6452       "  : public aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6453       "    public bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {};",
6454       Style);
6455 }
6456 
6457 #ifndef EXPENSIVE_CHECKS
6458 // Expensive checks enables libstdc++ checking which includes validating the
6459 // state of ranges used in std::priority_queue - this blows out the
6460 // runtime/scalability of the function and makes this test unacceptably slow.
6461 TEST_F(FormatTest, MemoizationTests) {
6462   // This breaks if the memoization lookup does not take \c Indent and
6463   // \c LastSpace into account.
6464   verifyFormat(
6465       "extern CFRunLoopTimerRef\n"
6466       "CFRunLoopTimerCreate(CFAllocatorRef allocato, CFAbsoluteTime fireDate,\n"
6467       "                     CFTimeInterval interval, CFOptionFlags flags,\n"
6468       "                     CFIndex order, CFRunLoopTimerCallBack callout,\n"
6469       "                     CFRunLoopTimerContext *context) {}");
6470 
6471   // Deep nesting somewhat works around our memoization.
6472   verifyFormat(
6473       "aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
6474       "    aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
6475       "        aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
6476       "            aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(aaaaa(\n"
6477       "                aaaaa())))))))))))))))))))))))))))))))))))))));",
6478       getLLVMStyleWithColumns(65));
6479   verifyFormat(
6480       "aaaaa(\n"
6481       "    aaaaa,\n"
6482       "    aaaaa(\n"
6483       "        aaaaa,\n"
6484       "        aaaaa(\n"
6485       "            aaaaa,\n"
6486       "            aaaaa(\n"
6487       "                aaaaa,\n"
6488       "                aaaaa(\n"
6489       "                    aaaaa,\n"
6490       "                    aaaaa(\n"
6491       "                        aaaaa,\n"
6492       "                        aaaaa(\n"
6493       "                            aaaaa,\n"
6494       "                            aaaaa(\n"
6495       "                                aaaaa,\n"
6496       "                                aaaaa(\n"
6497       "                                    aaaaa,\n"
6498       "                                    aaaaa(\n"
6499       "                                        aaaaa,\n"
6500       "                                        aaaaa(\n"
6501       "                                            aaaaa,\n"
6502       "                                            aaaaa(\n"
6503       "                                                aaaaa,\n"
6504       "                                                aaaaa))))))))))));",
6505       getLLVMStyleWithColumns(65));
6506   verifyFormat(
6507       "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"
6508       "                                  a),\n"
6509       "                                a),\n"
6510       "                              a),\n"
6511       "                            a),\n"
6512       "                          a),\n"
6513       "                        a),\n"
6514       "                      a),\n"
6515       "                    a),\n"
6516       "                  a),\n"
6517       "                a),\n"
6518       "              a),\n"
6519       "            a),\n"
6520       "          a),\n"
6521       "        a),\n"
6522       "      a),\n"
6523       "    a),\n"
6524       "  a)",
6525       getLLVMStyleWithColumns(65));
6526 
6527   // This test takes VERY long when memoization is broken.
6528   FormatStyle OnePerLine = getLLVMStyle();
6529   OnePerLine.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
6530   OnePerLine.BinPackParameters = false;
6531   std::string input = "Constructor()\n"
6532                       "    : aaaa(a,\n";
6533   for (unsigned i = 0, e = 80; i != e; ++i) {
6534     input += "           a,\n";
6535   }
6536   input += "           a) {}";
6537   verifyFormat(input, OnePerLine);
6538 }
6539 #endif
6540 
6541 TEST_F(FormatTest, BreaksAsHighAsPossible) {
6542   verifyFormat(
6543       "void f() {\n"
6544       "  if ((aaaaaaaaaaaaaaaaaaaaaaaaaaaaa && aaaaaaaaaaaaaaaaaaaaaaaaaa) ||\n"
6545       "      (bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb && bbbbbbbbbbbbbbbbbbbbbbbbbb))\n"
6546       "    f();\n"
6547       "}");
6548   verifyFormat("if (Intervals[i].getRange().getFirst() <\n"
6549                "    Intervals[i - 1].getRange().getLast()) {\n}");
6550 }
6551 
6552 TEST_F(FormatTest, BreaksFunctionDeclarations) {
6553   // Principially, we break function declarations in a certain order:
6554   // 1) break amongst arguments.
6555   verifyFormat("Aaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccc,\n"
6556                "                              Cccccccccccccc cccccccccccccc);");
6557   verifyFormat("template <class TemplateIt>\n"
6558                "SomeReturnType SomeFunction(TemplateIt begin, TemplateIt end,\n"
6559                "                            TemplateIt *stop) {}");
6560 
6561   // 2) break after return type.
6562   verifyFormat(
6563       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6564       "bbbbbbbbbbbbbb(Cccccccccccccc cccccccccccccccccccccccccc);",
6565       getGoogleStyle());
6566 
6567   // 3) break after (.
6568   verifyFormat(
6569       "Aaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbbbbbb(\n"
6570       "    Cccccccccccccccccccccccccccccc cccccccccccccccccccccccccccccccc);",
6571       getGoogleStyle());
6572 
6573   // 4) break before after nested name specifiers.
6574   verifyFormat(
6575       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6576       "SomeClasssssssssssssssssssssssssssssssssssssss::\n"
6577       "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc);",
6578       getGoogleStyle());
6579 
6580   // However, there are exceptions, if a sufficient amount of lines can be
6581   // saved.
6582   // FIXME: The precise cut-offs wrt. the number of saved lines might need some
6583   // more adjusting.
6584   verifyFormat("Aaaaaaaaaaaaaaaaaa bbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
6585                "                                  Cccccccccccccc cccccccccc,\n"
6586                "                                  Cccccccccccccc cccccccccc,\n"
6587                "                                  Cccccccccccccc cccccccccc,\n"
6588                "                                  Cccccccccccccc cccccccccc);");
6589   verifyFormat(
6590       "Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6591       "bbbbbbbbbbb(Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
6592       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
6593       "            Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);",
6594       getGoogleStyle());
6595   verifyFormat(
6596       "Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(Cccccccccccccc cccccccccc,\n"
6597       "                                          Cccccccccccccc cccccccccc,\n"
6598       "                                          Cccccccccccccc cccccccccc,\n"
6599       "                                          Cccccccccccccc cccccccccc,\n"
6600       "                                          Cccccccccccccc cccccccccc,\n"
6601       "                                          Cccccccccccccc cccccccccc,\n"
6602       "                                          Cccccccccccccc cccccccccc);");
6603   verifyFormat("Aaaaaaaaaa bbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
6604                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
6605                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
6606                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc,\n"
6607                "    Cccccccccccccc cccccccccc, Cccccccccccccc cccccccccc);");
6608 
6609   // Break after multi-line parameters.
6610   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6611                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6612                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6613                "    bbbb bbbb);");
6614   verifyFormat("void SomeLoooooooooooongFunction(\n"
6615                "    std::unique_ptr<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
6616                "        aaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6617                "    int bbbbbbbbbbbbb);");
6618 
6619   // Treat overloaded operators like other functions.
6620   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
6621                "operator>(const SomeLoooooooooooooooooooooooooogType &other);");
6622   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
6623                "operator>>(const SomeLooooooooooooooooooooooooogType &other);");
6624   verifyFormat("SomeLoooooooooooooooooooooooooogType\n"
6625                "operator<<(const SomeLooooooooooooooooooooooooogType &other);");
6626   verifyGoogleFormat(
6627       "SomeLoooooooooooooooooooooooooooooogType operator>>(\n"
6628       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
6629   verifyGoogleFormat(
6630       "SomeLoooooooooooooooooooooooooooooogType operator<<(\n"
6631       "    const SomeLooooooooogType &a, const SomeLooooooooogType &b);");
6632   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6633                "    int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa = 1);");
6634   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa\n"
6635                "aaaaaaaaaaaaaaaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaa = 1);");
6636   verifyGoogleFormat(
6637       "typename aaaaaaaaaa<aaaaaa>::aaaaaaaaaaa\n"
6638       "aaaaaaaaaa<aaaaaa>::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6639       "    bool *aaaaaaaaaaaaaaaaaa, bool *aa) {}");
6640   verifyGoogleFormat("template <typename T>\n"
6641                      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6642                      "aaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaaaaa(\n"
6643                      "    aaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaa);");
6644 
6645   FormatStyle Style = getLLVMStyle();
6646   Style.PointerAlignment = FormatStyle::PAS_Left;
6647   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6648                "    aaaaaaaaaaaaaaaaaaaaaaaaa* const aaaaaaaaaaaa) {}",
6649                Style);
6650   verifyFormat("void aaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*\n"
6651                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6652                Style);
6653 }
6654 
6655 TEST_F(FormatTest, DontBreakBeforeQualifiedOperator) {
6656   // Regression test for https://bugs.llvm.org/show_bug.cgi?id=40516:
6657   // Prefer keeping `::` followed by `operator` together.
6658   EXPECT_EQ("const aaaa::bbbbbbb &\n"
6659             "ccccccccc::operator++() {\n"
6660             "  stuff();\n"
6661             "}",
6662             format("const aaaa::bbbbbbb\n"
6663                    "&ccccccccc::operator++() { stuff(); }",
6664                    getLLVMStyleWithColumns(40)));
6665 }
6666 
6667 TEST_F(FormatTest, TrailingReturnType) {
6668   verifyFormat("auto foo() -> int;\n");
6669   // correct trailing return type spacing
6670   verifyFormat("auto operator->() -> int;\n");
6671   verifyFormat("auto operator++(int) -> int;\n");
6672 
6673   verifyFormat("struct S {\n"
6674                "  auto bar() const -> int;\n"
6675                "};");
6676   verifyFormat("template <size_t Order, typename T>\n"
6677                "auto load_img(const std::string &filename)\n"
6678                "    -> alias::tensor<Order, T, mem::tag::cpu> {}");
6679   verifyFormat("auto SomeFunction(A aaaaaaaaaaaaaaaaaaaaa) const\n"
6680                "    -> decltype(f(aaaaaaaaaaaaaaaaaaaaa)) {}");
6681   verifyFormat("auto doSomething(Aaaaaa *aaaaaa) -> decltype(aaaaaa->f()) {}");
6682   verifyFormat("template <typename T>\n"
6683                "auto aaaaaaaaaaaaaaaaaaaaaa(T t)\n"
6684                "    -> decltype(eaaaaaaaaaaaaaaa<T>(t.a).aaaaaaaa());");
6685 
6686   // Not trailing return types.
6687   verifyFormat("void f() { auto a = b->c(); }");
6688 }
6689 
6690 TEST_F(FormatTest, DeductionGuides) {
6691   verifyFormat("template <class T> A(const T &, const T &) -> A<T &>;");
6692   verifyFormat("template <class T> explicit A(T &, T &&) -> A<T>;");
6693   verifyFormat("template <class... Ts> S(Ts...) -> S<Ts...>;");
6694   verifyFormat(
6695       "template <class... T>\n"
6696       "array(T &&...t) -> array<std::common_type_t<T...>, sizeof...(T)>;");
6697   verifyFormat("template <class T> A() -> A<decltype(p->foo<3>())>;");
6698   verifyFormat("template <class T> A() -> A<decltype(foo<traits<1>>)>;");
6699   verifyFormat("template <class T> A() -> A<sizeof(p->foo<1>)>;");
6700   verifyFormat("template <class T> A() -> A<(3 < 2)>;");
6701   verifyFormat("template <class T> A() -> A<((3) < (2))>;");
6702   verifyFormat("template <class T> x() -> x<1>;");
6703   verifyFormat("template <class T> explicit x(T &) -> x<1>;");
6704 
6705   // Ensure not deduction guides.
6706   verifyFormat("c()->f<int>();");
6707   verifyFormat("x()->foo<1>;");
6708   verifyFormat("x = p->foo<3>();");
6709   verifyFormat("x()->x<1>();");
6710   verifyFormat("x()->x<1>;");
6711 }
6712 
6713 TEST_F(FormatTest, BreaksFunctionDeclarationsWithTrailingTokens) {
6714   // Avoid breaking before trailing 'const' or other trailing annotations, if
6715   // they are not function-like.
6716   FormatStyle Style = getGoogleStyle();
6717   Style.ColumnLimit = 47;
6718   verifyFormat("void someLongFunction(\n"
6719                "    int someLoooooooooooooongParameter) const {\n}",
6720                getLLVMStyleWithColumns(47));
6721   verifyFormat("LoooooongReturnType\n"
6722                "someLoooooooongFunction() const {}",
6723                getLLVMStyleWithColumns(47));
6724   verifyFormat("LoooooongReturnType someLoooooooongFunction()\n"
6725                "    const {}",
6726                Style);
6727   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
6728                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE;");
6729   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
6730                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) OVERRIDE FINAL;");
6731   verifyFormat("void SomeFunction(aaaaa aaaaaaaaaaaaaaaaaaaa,\n"
6732                "                  aaaaa aaaaaaaaaaaaaaaaaaaa) override final;");
6733   verifyFormat("virtual void aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa,\n"
6734                "                   aaaaaaaaaaa aaaaa) const override;");
6735   verifyGoogleFormat(
6736       "virtual void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
6737       "    const override;");
6738 
6739   // Even if the first parameter has to be wrapped.
6740   verifyFormat("void someLongFunction(\n"
6741                "    int someLongParameter) const {}",
6742                getLLVMStyleWithColumns(46));
6743   verifyFormat("void someLongFunction(\n"
6744                "    int someLongParameter) const {}",
6745                Style);
6746   verifyFormat("void someLongFunction(\n"
6747                "    int someLongParameter) override {}",
6748                Style);
6749   verifyFormat("void someLongFunction(\n"
6750                "    int someLongParameter) OVERRIDE {}",
6751                Style);
6752   verifyFormat("void someLongFunction(\n"
6753                "    int someLongParameter) final {}",
6754                Style);
6755   verifyFormat("void someLongFunction(\n"
6756                "    int someLongParameter) FINAL {}",
6757                Style);
6758   verifyFormat("void someLongFunction(\n"
6759                "    int parameter) const override {}",
6760                Style);
6761 
6762   Style.BreakBeforeBraces = FormatStyle::BS_Allman;
6763   verifyFormat("void someLongFunction(\n"
6764                "    int someLongParameter) const\n"
6765                "{\n"
6766                "}",
6767                Style);
6768 
6769   Style.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
6770   verifyFormat("void someLongFunction(\n"
6771                "    int someLongParameter) const\n"
6772                "  {\n"
6773                "  }",
6774                Style);
6775 
6776   // Unless these are unknown annotations.
6777   verifyFormat("void SomeFunction(aaaaaaaaaa aaaaaaaaaaaaaaa,\n"
6778                "                  aaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6779                "    LONG_AND_UGLY_ANNOTATION;");
6780 
6781   // Breaking before function-like trailing annotations is fine to keep them
6782   // close to their arguments.
6783   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
6784                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
6785   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
6786                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa);");
6787   verifyFormat("void aaaaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) const\n"
6788                "    LOCKS_EXCLUDED(aaaaaaaaaaaaa) {}");
6789   verifyGoogleFormat("void aaaaaaaaaaaaaa(aaaaaaaa aaa) override\n"
6790                      "    AAAAAAAAAAAAAAAAAAAAAAAA(aaaaaaaaaaaaaaa);");
6791   verifyFormat("SomeFunction([](int i) LOCKS_EXCLUDED(a) {});");
6792 
6793   verifyFormat(
6794       "void aaaaaaaaaaaaaaaaaa()\n"
6795       "    __attribute__((aaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaa,\n"
6796       "                   aaaaaaaaaaaaaaaaaaaaaaaaa));");
6797   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6798                "    __attribute__((unused));");
6799   verifyGoogleFormat(
6800       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6801       "    GUARDED_BY(aaaaaaaaaaaa);");
6802   verifyGoogleFormat(
6803       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6804       "    GUARDED_BY(aaaaaaaaaaaa);");
6805   verifyGoogleFormat(
6806       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
6807       "    aaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
6808   verifyGoogleFormat(
6809       "bool aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa GUARDED_BY(aaaaaaaaaaaa) =\n"
6810       "    aaaaaaaaaaaaaaaaaaaaaaaaa;");
6811 }
6812 
6813 TEST_F(FormatTest, FunctionAnnotations) {
6814   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
6815                "int OldFunction(const string &parameter) {}");
6816   verifyFormat("DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
6817                "string OldFunction(const string &parameter) {}");
6818   verifyFormat("template <typename T>\n"
6819                "DEPRECATED(\"Use NewClass::NewFunction instead.\")\n"
6820                "string OldFunction(const string &parameter) {}");
6821 
6822   // Not function annotations.
6823   verifyFormat("ASSERT(\"aaaaa\") << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
6824                "                << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb");
6825   verifyFormat("TEST_F(ThisIsATestFixtureeeeeeeeeeeee,\n"
6826                "       ThisIsATestWithAReallyReallyReallyReallyLongName) {}");
6827   verifyFormat("MACRO(abc).function() // wrap\n"
6828                "    << abc;");
6829   verifyFormat("MACRO(abc)->function() // wrap\n"
6830                "    << abc;");
6831   verifyFormat("MACRO(abc)::function() // wrap\n"
6832                "    << abc;");
6833 }
6834 
6835 TEST_F(FormatTest, BreaksDesireably) {
6836   verifyFormat("if (aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
6837                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa) ||\n"
6838                "    aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa)) {\n}");
6839   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6840                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)) {\n"
6841                "}");
6842 
6843   verifyFormat(
6844       "aaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6845       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}");
6846 
6847   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6848                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6849                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
6850 
6851   verifyFormat(
6852       "aaaaaaaa(aaaaaaaaaaaaa,\n"
6853       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6854       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
6855       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6856       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));");
6857 
6858   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
6859                "    (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6860 
6861   verifyFormat(
6862       "void f() {\n"
6863       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
6864       "                                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
6865       "}");
6866   verifyFormat(
6867       "aaaaaa(new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6868       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
6869   verifyFormat(
6870       "aaaaaa(aaa, new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6871       "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaa));");
6872   verifyFormat(
6873       "aaaaaa(aaa,\n"
6874       "       new Aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6875       "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
6876       "       aaaa);");
6877   verifyFormat("aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa +\n"
6878                "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6879                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6880 
6881   // Indent consistently independent of call expression and unary operator.
6882   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
6883                "    dddddddddddddddddddddddddddddd));");
6884   verifyFormat("aaaaaaaaaaa(!bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
6885                "    dddddddddddddddddddddddddddddd));");
6886   verifyFormat("aaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbb.ccccccccccccccccc(\n"
6887                "    dddddddddddddddddddddddddddddd));");
6888 
6889   // This test case breaks on an incorrect memoization, i.e. an optimization not
6890   // taking into account the StopAt value.
6891   verifyFormat(
6892       "return aaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
6893       "       aaaaaaaaaaa(aaaaaaaaa) || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
6894       "       aaaaaaaaaaaaaaaaaaaaaaaaa || aaaaaaaaaaaaaaaaaaaaaaa ||\n"
6895       "       (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
6896 
6897   verifyFormat("{\n  {\n    {\n"
6898                "      Annotation.SpaceRequiredBefore =\n"
6899                "          Line.Tokens[i - 1].Tok.isNot(tok::l_paren) &&\n"
6900                "          Line.Tokens[i - 1].Tok.isNot(tok::l_square);\n"
6901                "    }\n  }\n}");
6902 
6903   // Break on an outer level if there was a break on an inner level.
6904   EXPECT_EQ("f(g(h(a, // comment\n"
6905             "      b, c),\n"
6906             "    d, e),\n"
6907             "  x, y);",
6908             format("f(g(h(a, // comment\n"
6909                    "    b, c), d, e), x, y);"));
6910 
6911   // Prefer breaking similar line breaks.
6912   verifyFormat(
6913       "const int kTrackingOptions = NSTrackingMouseMoved |\n"
6914       "                             NSTrackingMouseEnteredAndExited |\n"
6915       "                             NSTrackingActiveAlways;");
6916 }
6917 
6918 TEST_F(FormatTest, FormatsDeclarationsOnePerLine) {
6919   FormatStyle NoBinPacking = getGoogleStyle();
6920   NoBinPacking.BinPackParameters = false;
6921   NoBinPacking.BinPackArguments = true;
6922   verifyFormat("void f() {\n"
6923                "  f(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaa,\n"
6924                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
6925                "}",
6926                NoBinPacking);
6927   verifyFormat("void f(int aaaaaaaaaaaaaaaaaaaa,\n"
6928                "       int aaaaaaaaaaaaaaaaaaaa,\n"
6929                "       int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
6930                NoBinPacking);
6931 
6932   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
6933   verifyFormat("void aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6934                "                        vector<int> bbbbbbbbbbbbbbb);",
6935                NoBinPacking);
6936   // FIXME: This behavior difference is probably not wanted. However, currently
6937   // we cannot distinguish BreakBeforeParameter being set because of the wrapped
6938   // template arguments from BreakBeforeParameter being set because of the
6939   // one-per-line formatting.
6940   verifyFormat(
6941       "void fffffffffff(aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa,\n"
6942       "                                             aaaaaaaaaa> aaaaaaaaaa);",
6943       NoBinPacking);
6944   verifyFormat(
6945       "void fffffffffff(\n"
6946       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaa>\n"
6947       "        aaaaaaaaaa);");
6948 }
6949 
6950 TEST_F(FormatTest, FormatsOneParameterPerLineIfNecessary) {
6951   FormatStyle NoBinPacking = getGoogleStyle();
6952   NoBinPacking.BinPackParameters = false;
6953   NoBinPacking.BinPackArguments = false;
6954   verifyFormat("f(aaaaaaaaaaaaaaaaaaaa,\n"
6955                "  aaaaaaaaaaaaaaaaaaaa,\n"
6956                "  aaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaa);",
6957                NoBinPacking);
6958   verifyFormat("aaaaaaa(aaaaaaaaaaaaa,\n"
6959                "        aaaaaaaaaaaaa,\n"
6960                "        aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));",
6961                NoBinPacking);
6962   verifyFormat(
6963       "aaaaaaaa(aaaaaaaaaaaaa,\n"
6964       "         aaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6965       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)),\n"
6966       "         aaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6967       "             aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)));",
6968       NoBinPacking);
6969   verifyFormat("aaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
6970                "    .aaaaaaaaaaaaaaaaaa();",
6971                NoBinPacking);
6972   verifyFormat("void f() {\n"
6973                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
6974                "      aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaa);\n"
6975                "}",
6976                NoBinPacking);
6977 
6978   verifyFormat(
6979       "aaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
6980       "             aaaaaaaaaaaa,\n"
6981       "             aaaaaaaaaaaa);",
6982       NoBinPacking);
6983   verifyFormat(
6984       "somefunction(someotherFunction(ddddddddddddddddddddddddddddddddddd,\n"
6985       "                               ddddddddddddddddddddddddddddd),\n"
6986       "             test);",
6987       NoBinPacking);
6988 
6989   verifyFormat("std::vector<aaaaaaaaaaaaaaaaaaaaaaa,\n"
6990                "            aaaaaaaaaaaaaaaaaaaaaaa,\n"
6991                "            aaaaaaaaaaaaaaaaaaaaaaa>\n"
6992                "    aaaaaaaaaaaaaaaaaa;",
6993                NoBinPacking);
6994   verifyFormat("a(\"a\"\n"
6995                "  \"a\",\n"
6996                "  a);");
6997 
6998   NoBinPacking.AllowAllParametersOfDeclarationOnNextLine = false;
6999   verifyFormat("void aaaaaaaaaa(aaaaaaaaa,\n"
7000                "                aaaaaaaaa,\n"
7001                "                aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7002                NoBinPacking);
7003   verifyFormat(
7004       "void f() {\n"
7005       "  aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaa, aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa)\n"
7006       "      .aaaaaaa();\n"
7007       "}",
7008       NoBinPacking);
7009   verifyFormat(
7010       "template <class SomeType, class SomeOtherType>\n"
7011       "SomeType SomeFunction(SomeType Type, SomeOtherType OtherType) {}",
7012       NoBinPacking);
7013 }
7014 
7015 TEST_F(FormatTest, AdaptiveOnePerLineFormatting) {
7016   FormatStyle Style = getLLVMStyleWithColumns(15);
7017   Style.ExperimentalAutoDetectBinPacking = true;
7018   EXPECT_EQ("aaa(aaaa,\n"
7019             "    aaaa,\n"
7020             "    aaaa);\n"
7021             "aaa(aaaa,\n"
7022             "    aaaa,\n"
7023             "    aaaa);",
7024             format("aaa(aaaa,\n" // one-per-line
7025                    "  aaaa,\n"
7026                    "    aaaa  );\n"
7027                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
7028                    Style));
7029   EXPECT_EQ("aaa(aaaa, aaaa,\n"
7030             "    aaaa);\n"
7031             "aaa(aaaa, aaaa,\n"
7032             "    aaaa);",
7033             format("aaa(aaaa,  aaaa,\n" // bin-packed
7034                    "    aaaa  );\n"
7035                    "aaa(aaaa,  aaaa,  aaaa);", // inconclusive
7036                    Style));
7037 }
7038 
7039 TEST_F(FormatTest, FormatsBuilderPattern) {
7040   verifyFormat("return llvm::StringSwitch<Reference::Kind>(name)\n"
7041                "    .StartsWith(\".eh_frame_hdr\", ORDER_EH_FRAMEHDR)\n"
7042                "    .StartsWith(\".eh_frame\", ORDER_EH_FRAME)\n"
7043                "    .StartsWith(\".init\", ORDER_INIT)\n"
7044                "    .StartsWith(\".fini\", ORDER_FINI)\n"
7045                "    .StartsWith(\".hash\", ORDER_HASH)\n"
7046                "    .Default(ORDER_TEXT);\n");
7047 
7048   verifyFormat("return aaaaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa() <\n"
7049                "       aaaaaaaaaaaaaaa->aaaaa().aaaaaaaaaaaaa().aaaaaa();");
7050   verifyFormat("aaaaaaa->aaaaaaa\n"
7051                "    ->aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7052                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7053                "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
7054   verifyFormat(
7055       "aaaaaaa->aaaaaaa\n"
7056       "    ->aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7057       "    ->aaaaaaaa(aaaaaaaaaaaaaaa);");
7058   verifyFormat(
7059       "aaaaaaaaaaaaaaaaaaa()->aaaaaa(bbbbb)->aaaaaaaaaaaaaaaaaaa( // break\n"
7060       "    aaaaaaaaaaaaaa);");
7061   verifyFormat(
7062       "aaaaaaaaaaaaaaaaaaaaaaa *aaaaaaaaa =\n"
7063       "    aaaaaa->aaaaaaaaaaaa()\n"
7064       "        ->aaaaaaaaaaaaaaaa(\n"
7065       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7066       "        ->aaaaaaaaaaaaaaaaa();");
7067   verifyGoogleFormat(
7068       "void f() {\n"
7069       "  someo->Add((new util::filetools::Handler(dir))\n"
7070       "                 ->OnEvent1(NewPermanentCallback(\n"
7071       "                     this, &HandlerHolderClass::EventHandlerCBA))\n"
7072       "                 ->OnEvent2(NewPermanentCallback(\n"
7073       "                     this, &HandlerHolderClass::EventHandlerCBB))\n"
7074       "                 ->OnEvent3(NewPermanentCallback(\n"
7075       "                     this, &HandlerHolderClass::EventHandlerCBC))\n"
7076       "                 ->OnEvent5(NewPermanentCallback(\n"
7077       "                     this, &HandlerHolderClass::EventHandlerCBD))\n"
7078       "                 ->OnEvent6(NewPermanentCallback(\n"
7079       "                     this, &HandlerHolderClass::EventHandlerCBE)));\n"
7080       "}");
7081 
7082   verifyFormat(
7083       "aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa().aaaaaaaaaaa();");
7084   verifyFormat("aaaaaaaaaaaaaaa()\n"
7085                "    .aaaaaaaaaaaaaaa()\n"
7086                "    .aaaaaaaaaaaaaaa()\n"
7087                "    .aaaaaaaaaaaaaaa()\n"
7088                "    .aaaaaaaaaaaaaaa();");
7089   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
7090                "    .aaaaaaaaaaaaaaa()\n"
7091                "    .aaaaaaaaaaaaaaa()\n"
7092                "    .aaaaaaaaaaaaaaa();");
7093   verifyFormat("aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
7094                "    .aaaaaaaaaaaaaaa.aaaaaaaaaaaaaaa()\n"
7095                "    .aaaaaaaaaaaaaaa();");
7096   verifyFormat("aaaaaaaaaaaaa->aaaaaaaaaaaaaaaaaaaaaaaa()\n"
7097                "    ->aaaaaaaaaaaaaae(0)\n"
7098                "    ->aaaaaaaaaaaaaaa();");
7099 
7100   // Don't linewrap after very short segments.
7101   verifyFormat("a().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7102                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7103                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7104   verifyFormat("aa().aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7105                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7106                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7107   verifyFormat("aaa()\n"
7108                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7109                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7110                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
7111 
7112   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
7113                "    .aaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
7114                "    .has<bbbbbbbbbbbbbbbbbbbbb>();");
7115   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaa()\n"
7116                "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
7117                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>();");
7118 
7119   // Prefer not to break after empty parentheses.
7120   verifyFormat("FirstToken->WhitespaceRange.getBegin().getLocWithOffset(\n"
7121                "    First->LastNewlineOffset);");
7122 
7123   // Prefer not to create "hanging" indents.
7124   verifyFormat(
7125       "return !soooooooooooooome_map\n"
7126       "            .insert(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7127       "            .second;");
7128   verifyFormat(
7129       "return aaaaaaaaaaaaaaaa\n"
7130       "    .aaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa)\n"
7131       "    .aaaa(aaaaaaaaaaaaaa);");
7132   // No hanging indent here.
7133   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa.aaaaaaaaaaaaaaa(\n"
7134                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7135   verifyFormat("aaaaaaaaaaaaaaaa.aaaaaaaaaaaaaa().aaaaaaaaaaaaaaa(\n"
7136                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7137   verifyFormat("aaaaaaaaaaaaaaaaaa.aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
7138                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7139                getLLVMStyleWithColumns(60));
7140   verifyFormat("aaaaaaaaaaaaaaaaaa\n"
7141                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa)\n"
7142                "    .aaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7143                getLLVMStyleWithColumns(59));
7144   verifyFormat("aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7145                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7146                "    .aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7147 
7148   // Dont break if only closing statements before member call
7149   verifyFormat("test() {\n"
7150                "  ([]() -> {\n"
7151                "    int b = 32;\n"
7152                "    return 3;\n"
7153                "  }).foo();\n"
7154                "}");
7155   verifyFormat("test() {\n"
7156                "  (\n"
7157                "      []() -> {\n"
7158                "        int b = 32;\n"
7159                "        return 3;\n"
7160                "      },\n"
7161                "      foo, bar)\n"
7162                "      .foo();\n"
7163                "}");
7164   verifyFormat("test() {\n"
7165                "  ([]() -> {\n"
7166                "    int b = 32;\n"
7167                "    return 3;\n"
7168                "  })\n"
7169                "      .foo()\n"
7170                "      .bar();\n"
7171                "}");
7172   verifyFormat("test() {\n"
7173                "  ([]() -> {\n"
7174                "    int b = 32;\n"
7175                "    return 3;\n"
7176                "  })\n"
7177                "      .foo(\"aaaaaaaaaaaaaaaaa\"\n"
7178                "           \"bbbb\");\n"
7179                "}",
7180                getLLVMStyleWithColumns(30));
7181 }
7182 
7183 TEST_F(FormatTest, BreaksAccordingToOperatorPrecedence) {
7184   verifyFormat(
7185       "if (aaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
7186       "    bbbbbbbbbbbbbbbbbbbbbbbbb && ccccccccccccccccccccccccc) {\n}");
7187   verifyFormat(
7188       "if (aaaaaaaaaaaaaaaaaaaaaaaaa or\n"
7189       "    bbbbbbbbbbbbbbbbbbbbbbbbb and cccccccccccccccccccccccc) {\n}");
7190 
7191   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa && bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
7192                "    ccccccccccccccccccccccccc) {\n}");
7193   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa and bbbbbbbbbbbbbbbbbbbbbbbb or\n"
7194                "    ccccccccccccccccccccccccc) {\n}");
7195 
7196   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb ||\n"
7197                "    ccccccccccccccccccccccccc) {\n}");
7198   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb or\n"
7199                "    ccccccccccccccccccccccccc) {\n}");
7200 
7201   verifyFormat(
7202       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa || bbbbbbbbbbbbbbbbbbbbbbbbb) &&\n"
7203       "    ccccccccccccccccccccccccc) {\n}");
7204   verifyFormat(
7205       "if ((aaaaaaaaaaaaaaaaaaaaaaaaa or bbbbbbbbbbbbbbbbbbbbbbbbb) and\n"
7206       "    ccccccccccccccccccccccccc) {\n}");
7207 
7208   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA ||\n"
7209                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB ||\n"
7210                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC ||\n"
7211                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
7212   verifyFormat("return aaaa & AAAAAAAAAAAAAAAAAAAAAAAAAAAAA or\n"
7213                "       bbbb & BBBBBBBBBBBBBBBBBBBBBBBBBBBBB or\n"
7214                "       cccc & CCCCCCCCCCCCCCCCCCCCCCCCCC or\n"
7215                "       dddd & DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD;");
7216 
7217   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa ||\n"
7218                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) &&\n"
7219                "    aaaaaaaaaaaaaaa != aa) {\n}");
7220   verifyFormat("if ((aaaaaaaaaa != aaaaaaaaaaaaaaa or\n"
7221                "     aaaaaaaaaaaaaaaaaaaaaaaa() >= aaaaaaaaaaaaaaaaaaaa) and\n"
7222                "    aaaaaaaaaaaaaaa != aa) {\n}");
7223 }
7224 
7225 TEST_F(FormatTest, BreaksAfterAssignments) {
7226   verifyFormat(
7227       "unsigned Cost =\n"
7228       "    TTI.getMemoryOpCost(I->getOpcode(), VectorTy, SI->getAlignment(),\n"
7229       "                        SI->getPointerAddressSpaceee());\n");
7230   verifyFormat(
7231       "CharSourceRange LineRange = CharSourceRange::getTokenRange(\n"
7232       "    Line.Tokens.front().Tok.getLo(), Line.Tokens.back().Tok.getLoc());");
7233 
7234   verifyFormat(
7235       "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaa = aaaaaaaaaaaaaa(0).aaaa().aaaaaaaaa(\n"
7236       "    aaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaa);");
7237   verifyFormat("unsigned OriginalStartColumn =\n"
7238                "    SourceMgr.getSpellingColumnNumber(\n"
7239                "        Current.FormatTok.getStartOfNonWhitespace()) -\n"
7240                "    1;");
7241 }
7242 
7243 TEST_F(FormatTest, ConfigurableBreakAssignmentPenalty) {
7244   FormatStyle Style = getLLVMStyle();
7245   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7246                "    bbbbbbbbbbbbbbbbbbbbbbbbbb + cccccccccccccccccccccccccc;",
7247                Style);
7248 
7249   Style.PenaltyBreakAssignment = 20;
7250   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaa = bbbbbbbbbbbbbbbbbbbbbbbbbb +\n"
7251                "                                 cccccccccccccccccccccccccc;",
7252                Style);
7253 }
7254 
7255 TEST_F(FormatTest, AlignsAfterAssignments) {
7256   verifyFormat(
7257       "int Result = aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7258       "             aaaaaaaaaaaaaaaaaaaaaaaaa;");
7259   verifyFormat(
7260       "Result += aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7261       "          aaaaaaaaaaaaaaaaaaaaaaaaa;");
7262   verifyFormat(
7263       "Result >>= aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7264       "           aaaaaaaaaaaaaaaaaaaaaaaaa;");
7265   verifyFormat(
7266       "int Result = (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7267       "              aaaaaaaaaaaaaaaaaaaaaaaaa);");
7268   verifyFormat(
7269       "double LooooooooooooooooooooooooongResult = aaaaaaaaaaaaaaaaaaaaaaaa +\n"
7270       "                                            aaaaaaaaaaaaaaaaaaaaaaaa +\n"
7271       "                                            aaaaaaaaaaaaaaaaaaaaaaaa;");
7272 }
7273 
7274 TEST_F(FormatTest, AlignsAfterReturn) {
7275   verifyFormat(
7276       "return aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7277       "       aaaaaaaaaaaaaaaaaaaaaaaaa;");
7278   verifyFormat(
7279       "return (aaaaaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7280       "        aaaaaaaaaaaaaaaaaaaaaaaaa);");
7281   verifyFormat(
7282       "return aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
7283       "       aaaaaaaaaaaaaaaaaaaaaa();");
7284   verifyFormat(
7285       "return (aaaaaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa >=\n"
7286       "        aaaaaaaaaaaaaaaaaaaaaa());");
7287   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7288                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7289   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7290                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) &&\n"
7291                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7292   verifyFormat("return\n"
7293                "    // true if code is one of a or b.\n"
7294                "    code == a || code == b;");
7295 }
7296 
7297 TEST_F(FormatTest, AlignsAfterOpenBracket) {
7298   verifyFormat(
7299       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
7300       "                                                aaaaaaaaa aaaaaaa) {}");
7301   verifyFormat(
7302       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
7303       "                                               aaaaaaaaaaa aaaaaaaaa);");
7304   verifyFormat(
7305       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
7306       "                                             aaaaaaaaaaaaaaaaaaaaa));");
7307   FormatStyle Style = getLLVMStyle();
7308   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7309   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7310                "    aaaaaaaaaaa aaaaaaaa, aaaaaaaaa aaaaaaa) {}",
7311                Style);
7312   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
7313                "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaa aaaaaaaaa);",
7314                Style);
7315   verifyFormat("SomeLongVariableName->someFunction(\n"
7316                "    foooooooo(aaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaa));",
7317                Style);
7318   verifyFormat(
7319       "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaa aaaaaaaa,\n"
7320       "    aaaaaaaaa aaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
7321       Style);
7322   verifyFormat(
7323       "SomeLongVariableName->someVeryLongFunctionName(aaaaaaaaaaa aaaaaaaaa,\n"
7324       "    aaaaaaaaaaa aaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7325       Style);
7326   verifyFormat(
7327       "SomeLongVariableName->someFunction(foooooooo(aaaaaaaaaaaaaaa,\n"
7328       "    aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
7329       Style);
7330 
7331   verifyFormat("bbbbbbbbbbbb(aaaaaaaaaaaaaaaaaaaaaaaa, //\n"
7332                "    ccccccc(aaaaaaaaaaaaaaaaa,         //\n"
7333                "        b));",
7334                Style);
7335 
7336   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
7337   Style.BinPackArguments = false;
7338   Style.BinPackParameters = false;
7339   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7340                "    aaaaaaaaaaa aaaaaaaa,\n"
7341                "    aaaaaaaaa aaaaaaa,\n"
7342                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {}",
7343                Style);
7344   verifyFormat("SomeLongVariableName->someVeryLongFunctionName(\n"
7345                "    aaaaaaaaaaa aaaaaaaaa,\n"
7346                "    aaaaaaaaaaa aaaaaaaaa,\n"
7347                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7348                Style);
7349   verifyFormat("SomeLongVariableName->someFunction(foooooooo(\n"
7350                "    aaaaaaaaaaaaaaa,\n"
7351                "    aaaaaaaaaaaaaaaaaaaaa,\n"
7352                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa));",
7353                Style);
7354   verifyFormat(
7355       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa(\n"
7356       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
7357       Style);
7358   verifyFormat(
7359       "aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaa.aaaaaaaaaa(\n"
7360       "    aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)));",
7361       Style);
7362   verifyFormat(
7363       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
7364       "    aaaaaaaaaaaaaaaaaaaaa(\n"
7365       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)),\n"
7366       "    aaaaaaaaaaaaaaaa);",
7367       Style);
7368   verifyFormat(
7369       "aaaaaaaaaaaaaaaaaaaaaaaa(\n"
7370       "    aaaaaaaaaaaaaaaaaaaaa(\n"
7371       "        aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa)) &&\n"
7372       "    aaaaaaaaaaaaaaaa);",
7373       Style);
7374 }
7375 
7376 TEST_F(FormatTest, ParenthesesAndOperandAlignment) {
7377   FormatStyle Style = getLLVMStyleWithColumns(40);
7378   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
7379                "          bbbbbbbbbbbbbbbbbbbbbb);",
7380                Style);
7381   Style.AlignAfterOpenBracket = FormatStyle::BAS_Align;
7382   Style.AlignOperands = FormatStyle::OAS_DontAlign;
7383   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
7384                "          bbbbbbbbbbbbbbbbbbbbbb);",
7385                Style);
7386   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7387   Style.AlignOperands = FormatStyle::OAS_Align;
7388   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
7389                "          bbbbbbbbbbbbbbbbbbbbbb);",
7390                Style);
7391   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
7392   Style.AlignOperands = FormatStyle::OAS_DontAlign;
7393   verifyFormat("int a = f(aaaaaaaaaaaaaaaaaaaaaa &&\n"
7394                "    bbbbbbbbbbbbbbbbbbbbbb);",
7395                Style);
7396 }
7397 
7398 TEST_F(FormatTest, BreaksConditionalExpressions) {
7399   verifyFormat(
7400       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7401       "                               ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7402       "                               : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7403   verifyFormat(
7404       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
7405       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7406       "                                : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7407   verifyFormat(
7408       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7409       "                                   : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7410   verifyFormat("aaaa(aaaaaaaaa, aaaaaaaaa,\n"
7411                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7412                "             : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7413   verifyFormat(
7414       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa)\n"
7415       "                                                    : aaaaaaaaaaaaa);");
7416   verifyFormat(
7417       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7418       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7419       "                                    : aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7420       "                   aaaaaaaaaaaaa);");
7421   verifyFormat(
7422       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7423       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7424       "                   aaaaaaaaaaaaa);");
7425   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7426                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7427                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7428                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7429                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7430   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7431                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7432                "           ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7433                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
7434                "           : aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7435                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
7436                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7437   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7438                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7439                "           ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7440                "                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
7441                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);");
7442   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7443                "    ? aaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7444                "    : aaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7445   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
7446                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7447                "        ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7448                "        : aaaaaaaaaaaaaaaa;");
7449   verifyFormat(
7450       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7451       "    ? aaaaaaaaaaaaaaa\n"
7452       "    : aaaaaaaaaaaaaaa;");
7453   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
7454                "          aaaaaaaaa\n"
7455                "      ? b\n"
7456                "      : c);");
7457   verifyFormat("return aaaa == bbbb\n"
7458                "           // comment\n"
7459                "           ? aaaa\n"
7460                "           : bbbb;");
7461   verifyFormat("unsigned Indent =\n"
7462                "    format(TheLine.First,\n"
7463                "           IndentForLevel[TheLine.Level] >= 0\n"
7464                "               ? IndentForLevel[TheLine.Level]\n"
7465                "               : TheLine * 2,\n"
7466                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
7467                getLLVMStyleWithColumns(60));
7468   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
7469                "                  ? aaaaaaaaaaaaaaa\n"
7470                "                  : bbbbbbbbbbbbbbb //\n"
7471                "                        ? ccccccccccccccc\n"
7472                "                        : ddddddddddddddd;");
7473   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa //\n"
7474                "                  ? aaaaaaaaaaaaaaa\n"
7475                "                  : (bbbbbbbbbbbbbbb //\n"
7476                "                         ? ccccccccccccccc\n"
7477                "                         : ddddddddddddddd);");
7478   verifyFormat(
7479       "int aaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7480       "                                      ? aaaaaaaaaaaaaaaaaaaaaaaaa +\n"
7481       "                                            aaaaaaaaaaaaaaaaaaaaa +\n"
7482       "                                            aaaaaaaaaaaaaaaaaaaaa\n"
7483       "                                      : aaaaaaaaaa;");
7484   verifyFormat(
7485       "aaaaaa = aaaaaaaaaaaa ? aaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7486       "                                   : aaaaaaaaaaaaaaaaaaaaaa\n"
7487       "                      : aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
7488 
7489   FormatStyle NoBinPacking = getLLVMStyle();
7490   NoBinPacking.BinPackArguments = false;
7491   verifyFormat(
7492       "void f() {\n"
7493       "  g(aaa,\n"
7494       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
7495       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7496       "        ? aaaaaaaaaaaaaaa\n"
7497       "        : aaaaaaaaaaaaaaa);\n"
7498       "}",
7499       NoBinPacking);
7500   verifyFormat(
7501       "void f() {\n"
7502       "  g(aaa,\n"
7503       "    aaaaaaaaaa == aaaaaaaaaa ? aaaa : aaaaa,\n"
7504       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7505       "        ?: aaaaaaaaaaaaaaa);\n"
7506       "}",
7507       NoBinPacking);
7508 
7509   verifyFormat("SomeFunction(aaaaaaaaaaaaaaaaa,\n"
7510                "             // comment.\n"
7511                "             ccccccccccccccccccccccccccccccccccccccc\n"
7512                "                 ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7513                "                 : bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);");
7514 
7515   // Assignments in conditional expressions. Apparently not uncommon :-(.
7516   verifyFormat("return a != b\n"
7517                "           // comment\n"
7518                "           ? a = b\n"
7519                "           : a = b;");
7520   verifyFormat("return a != b\n"
7521                "           // comment\n"
7522                "           ? a = a != b\n"
7523                "                     // comment\n"
7524                "                     ? a = b\n"
7525                "                     : a\n"
7526                "           : a;\n");
7527   verifyFormat("return a != b\n"
7528                "           // comment\n"
7529                "           ? a\n"
7530                "           : a = a != b\n"
7531                "                     // comment\n"
7532                "                     ? a = b\n"
7533                "                     : a;");
7534 
7535   // Chained conditionals
7536   FormatStyle Style = getLLVMStyle();
7537   Style.ColumnLimit = 70;
7538   Style.AlignOperands = FormatStyle::OAS_Align;
7539   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
7540                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7541                "                        : 3333333333333333;",
7542                Style);
7543   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
7544                "       : bbbbbbbbbb     ? 2222222222222222\n"
7545                "                        : 3333333333333333;",
7546                Style);
7547   verifyFormat("return aaaaaaaaaa         ? 1111111111111111\n"
7548                "       : bbbbbbbbbbbbbbbb ? 2222222222222222\n"
7549                "                          : 3333333333333333;",
7550                Style);
7551   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
7552                "       : bbbbbbbbbbbbbb ? 222222\n"
7553                "                        : 333333;",
7554                Style);
7555   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
7556                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7557                "       : cccccccccccccc ? 3333333333333333\n"
7558                "                        : 4444444444444444;",
7559                Style);
7560   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc)\n"
7561                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7562                "                        : 3333333333333333;",
7563                Style);
7564   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
7565                "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7566                "                        : (aaa ? bbb : ccc);",
7567                Style);
7568   verifyFormat(
7569       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7570       "                                             : cccccccccccccccccc)\n"
7571       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7572       "                        : 3333333333333333;",
7573       Style);
7574   verifyFormat(
7575       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7576       "                                             : cccccccccccccccccc)\n"
7577       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7578       "                        : 3333333333333333;",
7579       Style);
7580   verifyFormat(
7581       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7582       "                                             : dddddddddddddddddd)\n"
7583       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7584       "                        : 3333333333333333;",
7585       Style);
7586   verifyFormat(
7587       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7588       "                                             : dddddddddddddddddd)\n"
7589       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7590       "                        : 3333333333333333;",
7591       Style);
7592   verifyFormat(
7593       "return aaaaaaaaa        ? 1111111111111111\n"
7594       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7595       "                        : a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7596       "                                             : dddddddddddddddddd)\n",
7597       Style);
7598   verifyFormat(
7599       "return aaaaaaaaaaaaaaaa ? 1111111111111111\n"
7600       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7601       "                        : (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7602       "                                             : cccccccccccccccccc);",
7603       Style);
7604   verifyFormat(
7605       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7606       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
7607       "                                             : eeeeeeeeeeeeeeeeee)\n"
7608       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7609       "                        : 3333333333333333;",
7610       Style);
7611   verifyFormat(
7612       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaa    ? bbbbbbbbbbbbbbbbbb\n"
7613       "                           : ccccccccccccccc ? dddddddddddddddddd\n"
7614       "                                             : eeeeeeeeeeeeeeeeee)\n"
7615       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7616       "                        : 3333333333333333;",
7617       Style);
7618   verifyFormat(
7619       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7620       "                           : cccccccccccc    ? dddddddddddddddddd\n"
7621       "                                             : eeeeeeeeeeeeeeeeee)\n"
7622       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7623       "                        : 3333333333333333;",
7624       Style);
7625   verifyFormat(
7626       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7627       "                                             : cccccccccccccccccc\n"
7628       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7629       "                        : 3333333333333333;",
7630       Style);
7631   verifyFormat(
7632       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7633       "                          : cccccccccccccccc ? dddddddddddddddddd\n"
7634       "                                             : eeeeeeeeeeeeeeeeee\n"
7635       "       : bbbbbbbbbbbbbb ? 2222222222222222\n"
7636       "                        : 3333333333333333;",
7637       Style);
7638   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa\n"
7639                "           ? (aaaaaaaaaaaaaaaaaa   ? bbbbbbbbbbbbbbbbbb\n"
7640                "              : cccccccccccccccccc ? dddddddddddddddddd\n"
7641                "                                   : eeeeeeeeeeeeeeeeee)\n"
7642                "       : bbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
7643                "                             : 3333333333333333;",
7644                Style);
7645   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaa\n"
7646                "           ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb\n"
7647                "             : cccccccccccccccc ? dddddddddddddddddd\n"
7648                "                                : eeeeeeeeeeeeeeeeee\n"
7649                "       : bbbbbbbbbbbbbbbbbbbbbbb ? 2222222222222222\n"
7650                "                                 : 3333333333333333;",
7651                Style);
7652 
7653   Style.AlignOperands = FormatStyle::OAS_DontAlign;
7654   Style.BreakBeforeTernaryOperators = false;
7655   // FIXME: Aligning the question marks is weird given DontAlign.
7656   // Consider disabling this alignment in this case. Also check whether this
7657   // will render the adjustment from https://reviews.llvm.org/D82199
7658   // unnecessary.
7659   verifyFormat("int x = aaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa :\n"
7660                "    bbbb                ? cccccccccccccccccc :\n"
7661                "                          ddddd;\n",
7662                Style);
7663 
7664   EXPECT_EQ(
7665       "MMMMMMMMMMMMMMMMMMMMMMMMMMM = A ?\n"
7666       "    /*\n"
7667       "     */\n"
7668       "    function() {\n"
7669       "      try {\n"
7670       "        return JJJJJJJJJJJJJJ(\n"
7671       "            pppppppppppppppppppppppppppppppppppppppppppppppppp);\n"
7672       "      }\n"
7673       "    } :\n"
7674       "    function() {};",
7675       format(
7676           "MMMMMMMMMMMMMMMMMMMMMMMMMMM = A ?\n"
7677           "     /*\n"
7678           "      */\n"
7679           "     function() {\n"
7680           "      try {\n"
7681           "        return JJJJJJJJJJJJJJ(\n"
7682           "            pppppppppppppppppppppppppppppppppppppppppppppppppp);\n"
7683           "      }\n"
7684           "    } :\n"
7685           "    function() {};",
7686           getGoogleStyle(FormatStyle::LK_JavaScript)));
7687 }
7688 
7689 TEST_F(FormatTest, BreaksConditionalExpressionsAfterOperator) {
7690   FormatStyle Style = getLLVMStyle();
7691   Style.BreakBeforeTernaryOperators = false;
7692   Style.ColumnLimit = 70;
7693   verifyFormat(
7694       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
7695       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
7696       "                               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7697       Style);
7698   verifyFormat(
7699       "aaaa(aaaaaaaaaa, aaaaaaaa,\n"
7700       "     aaaaaaaaaaaaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
7701       "                                  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7702       Style);
7703   verifyFormat(
7704       "aaaa(aaaaaaaaaaaaaaaaaaaa, aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
7705       "                                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7706       Style);
7707   verifyFormat("aaaa(aaaaaaaa, aaaaaaaaaa,\n"
7708                "     aaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
7709                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7710                Style);
7711   verifyFormat(
7712       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa ? aaaa(aaaaaa) :\n"
7713       "                                                      aaaaaaaaaaaaa);",
7714       Style);
7715   verifyFormat(
7716       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7717       "                   aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
7718       "                                      aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7719       "                   aaaaaaaaaaaaa);",
7720       Style);
7721   verifyFormat(
7722       "aaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7723       "                   aaaaaaaaaaaaaaaa ?: aaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7724       "                   aaaaaaaaaaaaa);",
7725       Style);
7726   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
7727                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7728                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
7729                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7730                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7731                Style);
7732   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7733                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
7734                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7735                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) :\n"
7736                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7737                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
7738                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7739                Style);
7740   verifyFormat("aaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
7741                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?:\n"
7742                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
7743                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa),\n"
7744                "       aaaaaaaaaaaaaaaaaaaaaaaaaaa);",
7745                Style);
7746   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
7747                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
7748                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7749                Style);
7750   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaa =\n"
7751                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
7752                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa :\n"
7753                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
7754                Style);
7755   verifyFormat(
7756       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa == aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
7757       "    aaaaaaaaaaaaaaa :\n"
7758       "    aaaaaaaaaaaaaaa;",
7759       Style);
7760   verifyFormat("f(aaaaaaaaaaaaaaaa == // force break\n"
7761                "          aaaaaaaaa ?\n"
7762                "      b :\n"
7763                "      c);",
7764                Style);
7765   verifyFormat("unsigned Indent =\n"
7766                "    format(TheLine.First,\n"
7767                "           IndentForLevel[TheLine.Level] >= 0 ?\n"
7768                "               IndentForLevel[TheLine.Level] :\n"
7769                "               TheLine * 2,\n"
7770                "           TheLine.InPPDirective, PreviousEndOfLineColumn);",
7771                Style);
7772   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
7773                "                  aaaaaaaaaaaaaaa :\n"
7774                "                  bbbbbbbbbbbbbbb ? //\n"
7775                "                      ccccccccccccccc :\n"
7776                "                      ddddddddddddddd;",
7777                Style);
7778   verifyFormat("bool aaaaaa = aaaaaaaaaaaaa ? //\n"
7779                "                  aaaaaaaaaaaaaaa :\n"
7780                "                  (bbbbbbbbbbbbbbb ? //\n"
7781                "                       ccccccccccccccc :\n"
7782                "                       ddddddddddddddd);",
7783                Style);
7784   verifyFormat("int i = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
7785                "            /*bbbbbbbbbbbbbbb=*/bbbbbbbbbbbbbbbbbbbbbbbbb :\n"
7786                "            ccccccccccccccccccccccccccc;",
7787                Style);
7788   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa ?\n"
7789                "           aaaaa :\n"
7790                "           bbbbbbbbbbbbbbb + cccccccccccccccc;",
7791                Style);
7792 
7793   // Chained conditionals
7794   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
7795                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7796                "                          3333333333333333;",
7797                Style);
7798   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
7799                "       bbbbbbbbbb       ? 2222222222222222 :\n"
7800                "                          3333333333333333;",
7801                Style);
7802   verifyFormat("return aaaaaaaaaa       ? 1111111111111111 :\n"
7803                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7804                "                          3333333333333333;",
7805                Style);
7806   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
7807                "       bbbbbbbbbbbbbbbb ? 222222 :\n"
7808                "                          333333;",
7809                Style);
7810   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
7811                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7812                "       cccccccccccccccc ? 3333333333333333 :\n"
7813                "                          4444444444444444;",
7814                Style);
7815   verifyFormat("return aaaaaaaaaaaaaaaa ? (aaa ? bbb : ccc) :\n"
7816                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7817                "                          3333333333333333;",
7818                Style);
7819   verifyFormat("return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
7820                "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7821                "                          (aaa ? bbb : ccc);",
7822                Style);
7823   verifyFormat(
7824       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7825       "                                               cccccccccccccccccc) :\n"
7826       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7827       "                          3333333333333333;",
7828       Style);
7829   verifyFormat(
7830       "return aaaaaaaaa        ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7831       "                                               cccccccccccccccccc) :\n"
7832       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7833       "                          3333333333333333;",
7834       Style);
7835   verifyFormat(
7836       "return aaaaaaaaa        ? a = (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7837       "                                               dddddddddddddddddd) :\n"
7838       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7839       "                          3333333333333333;",
7840       Style);
7841   verifyFormat(
7842       "return aaaaaaaaa        ? a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7843       "                                               dddddddddddddddddd) :\n"
7844       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7845       "                          3333333333333333;",
7846       Style);
7847   verifyFormat(
7848       "return aaaaaaaaa        ? 1111111111111111 :\n"
7849       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7850       "                          a + (aaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7851       "                                               dddddddddddddddddd)\n",
7852       Style);
7853   verifyFormat(
7854       "return aaaaaaaaaaaaaaaa ? 1111111111111111 :\n"
7855       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7856       "                          (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7857       "                                               cccccccccccccccccc);",
7858       Style);
7859   verifyFormat(
7860       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7861       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
7862       "                                               eeeeeeeeeeeeeeeeee) :\n"
7863       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7864       "                          3333333333333333;",
7865       Style);
7866   verifyFormat(
7867       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7868       "                           ccccccccccccc     ? dddddddddddddddddd :\n"
7869       "                                               eeeeeeeeeeeeeeeeee) :\n"
7870       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7871       "                          3333333333333333;",
7872       Style);
7873   verifyFormat(
7874       "return aaaaaaaaaaaaaaaa ? (aaaaaaaaaaaaa     ? bbbbbbbbbbbbbbbbbb :\n"
7875       "                           ccccccccccccccccc ? dddddddddddddddddd :\n"
7876       "                                               eeeeeeeeeeeeeeeeee) :\n"
7877       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7878       "                          3333333333333333;",
7879       Style);
7880   verifyFormat(
7881       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7882       "                                               cccccccccccccccccc :\n"
7883       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7884       "                          3333333333333333;",
7885       Style);
7886   verifyFormat(
7887       "return aaaaaaaaaaaaaaaa ? aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7888       "                          cccccccccccccccccc ? dddddddddddddddddd :\n"
7889       "                                               eeeeeeeeeeeeeeeeee :\n"
7890       "       bbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7891       "                          3333333333333333;",
7892       Style);
7893   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
7894                "           (aaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7895                "            cccccccccccccccccc ? dddddddddddddddddd :\n"
7896                "                                 eeeeeeeeeeeeeeeeee) :\n"
7897                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7898                "                               3333333333333333;",
7899                Style);
7900   verifyFormat("return aaaaaaaaaaaaaaaaaaaaa ?\n"
7901                "           aaaaaaaaaaaaaaaaaaaa ? bbbbbbbbbbbbbbbbbb :\n"
7902                "           cccccccccccccccccccc ? dddddddddddddddddd :\n"
7903                "                                  eeeeeeeeeeeeeeeeee :\n"
7904                "       bbbbbbbbbbbbbbbbbbbbb ? 2222222222222222 :\n"
7905                "                               3333333333333333;",
7906                Style);
7907 }
7908 
7909 TEST_F(FormatTest, DeclarationsOfMultipleVariables) {
7910   verifyFormat("bool aaaaaaaaaaaaaaaaa = aaaaaa->aaaaaaaaaaaaaaaaa(),\n"
7911                "     aaaaaaaaaaa = aaaaaa->aaaaaaaaaaa();");
7912   verifyFormat("bool a = true, b = false;");
7913 
7914   verifyFormat("bool aaaaaaaaaaaaaaaaaaaaaaaaa =\n"
7915                "         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaa),\n"
7916                "     bbbbbbbbbbbbbbbbbbbbbbbbb =\n"
7917                "         bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(bbbbbbbbbbbbbbbb);");
7918   verifyFormat(
7919       "bool aaaaaaaaaaaaaaaaaaaaa =\n"
7920       "         bbbbbbbbbbbbbbbbbbbbbbbbbbbb && cccccccccccccccccccccccccccc,\n"
7921       "     d = e && f;");
7922   verifyFormat("aaaaaaaaa a = aaaaaaaaaaaaaaaaaaaa, b = bbbbbbbbbbbbbbbbbbbb,\n"
7923                "          c = cccccccccccccccccccc, d = dddddddddddddddddddd;");
7924   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
7925                "          *c = ccccccccccccccccccc, *d = ddddddddddddddddddd;");
7926   verifyFormat("aaaaaaaaa ***a = aaaaaaaaaaaaaaaaaaa, ***b = bbbbbbbbbbbbbbb,\n"
7927                "          ***c = ccccccccccccccccccc, ***d = ddddddddddddddd;");
7928 
7929   FormatStyle Style = getGoogleStyle();
7930   Style.PointerAlignment = FormatStyle::PAS_Left;
7931   Style.DerivePointerAlignment = false;
7932   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
7933                "    *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaa,\n"
7934                "    *b = bbbbbbbbbbbbbbbbbbb;",
7935                Style);
7936   verifyFormat("aaaaaaaaa *a = aaaaaaaaaaaaaaaaaaa, *b = bbbbbbbbbbbbbbbbbbb,\n"
7937                "          *b = bbbbbbbbbbbbbbbbbbb, *d = ddddddddddddddddddd;",
7938                Style);
7939   verifyFormat("vector<int*> a, b;", Style);
7940   verifyFormat("for (int *p, *q; p != q; p = p->next) {\n}", Style);
7941 }
7942 
7943 TEST_F(FormatTest, ConditionalExpressionsInBrackets) {
7944   verifyFormat("arr[foo ? bar : baz];");
7945   verifyFormat("f()[foo ? bar : baz];");
7946   verifyFormat("(a + b)[foo ? bar : baz];");
7947   verifyFormat("arr[foo ? (4 > 5 ? 4 : 5) : 5 < 5 ? 5 : 7];");
7948 }
7949 
7950 TEST_F(FormatTest, AlignsStringLiterals) {
7951   verifyFormat("loooooooooooooooooooooooooongFunction(\"short literal \"\n"
7952                "                                      \"short literal\");");
7953   verifyFormat(
7954       "looooooooooooooooooooooooongFunction(\n"
7955       "    \"short literal\"\n"
7956       "    \"looooooooooooooooooooooooooooooooooooooooooooooooong literal\");");
7957   verifyFormat("someFunction(\"Always break between multi-line\"\n"
7958                "             \" string literals\",\n"
7959                "             and, other, parameters);");
7960   EXPECT_EQ("fun + \"1243\" /* comment */\n"
7961             "      \"5678\";",
7962             format("fun + \"1243\" /* comment */\n"
7963                    "    \"5678\";",
7964                    getLLVMStyleWithColumns(28)));
7965   EXPECT_EQ(
7966       "aaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
7967       "         \"aaaaaaaaaaaaaaaaaaaaa\"\n"
7968       "         \"aaaaaaaaaaaaaaaa\";",
7969       format("aaaaaa ="
7970              "\"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaaaa "
7971              "aaaaaaaaaaaaaaaaaaaaa\" "
7972              "\"aaaaaaaaaaaaaaaa\";"));
7973   verifyFormat("a = a + \"a\"\n"
7974                "        \"a\"\n"
7975                "        \"a\";");
7976   verifyFormat("f(\"a\", \"b\"\n"
7977                "       \"c\");");
7978 
7979   verifyFormat(
7980       "#define LL_FORMAT \"ll\"\n"
7981       "printf(\"aaaaa: %d, bbbbbb: %\" LL_FORMAT \"d, cccccccc: %\" LL_FORMAT\n"
7982       "       \"d, ddddddddd: %\" LL_FORMAT \"d\");");
7983 
7984   verifyFormat("#define A(X)          \\\n"
7985                "  \"aaaaa\" #X \"bbbbbb\" \\\n"
7986                "  \"ccccc\"",
7987                getLLVMStyleWithColumns(23));
7988   verifyFormat("#define A \"def\"\n"
7989                "f(\"abc\" A \"ghi\"\n"
7990                "  \"jkl\");");
7991 
7992   verifyFormat("f(L\"a\"\n"
7993                "  L\"b\");");
7994   verifyFormat("#define A(X)            \\\n"
7995                "  L\"aaaaa\" #X L\"bbbbbb\" \\\n"
7996                "  L\"ccccc\"",
7997                getLLVMStyleWithColumns(25));
7998 
7999   verifyFormat("f(@\"a\"\n"
8000                "  @\"b\");");
8001   verifyFormat("NSString s = @\"a\"\n"
8002                "             @\"b\"\n"
8003                "             @\"c\";");
8004   verifyFormat("NSString s = @\"a\"\n"
8005                "              \"b\"\n"
8006                "              \"c\";");
8007 }
8008 
8009 TEST_F(FormatTest, ReturnTypeBreakingStyle) {
8010   FormatStyle Style = getLLVMStyle();
8011   // No declarations or definitions should be moved to own line.
8012   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_None;
8013   verifyFormat("class A {\n"
8014                "  int f() { return 1; }\n"
8015                "  int g();\n"
8016                "};\n"
8017                "int f() { return 1; }\n"
8018                "int g();\n",
8019                Style);
8020 
8021   // All declarations and definitions should have the return type moved to its
8022   // own line.
8023   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
8024   Style.TypenameMacros = {"LIST"};
8025   verifyFormat("SomeType\n"
8026                "funcdecl(LIST(uint64_t));",
8027                Style);
8028   verifyFormat("class E {\n"
8029                "  int\n"
8030                "  f() {\n"
8031                "    return 1;\n"
8032                "  }\n"
8033                "  int\n"
8034                "  g();\n"
8035                "};\n"
8036                "int\n"
8037                "f() {\n"
8038                "  return 1;\n"
8039                "}\n"
8040                "int\n"
8041                "g();\n",
8042                Style);
8043 
8044   // Top-level definitions, and no kinds of declarations should have the
8045   // return type moved to its own line.
8046   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevelDefinitions;
8047   verifyFormat("class B {\n"
8048                "  int f() { return 1; }\n"
8049                "  int g();\n"
8050                "};\n"
8051                "int\n"
8052                "f() {\n"
8053                "  return 1;\n"
8054                "}\n"
8055                "int g();\n",
8056                Style);
8057 
8058   // Top-level definitions and declarations should have the return type moved
8059   // to its own line.
8060   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_TopLevel;
8061   verifyFormat("class C {\n"
8062                "  int f() { return 1; }\n"
8063                "  int g();\n"
8064                "};\n"
8065                "int\n"
8066                "f() {\n"
8067                "  return 1;\n"
8068                "}\n"
8069                "int\n"
8070                "g();\n",
8071                Style);
8072 
8073   // All definitions should have the return type moved to its own line, but no
8074   // kinds of declarations.
8075   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_AllDefinitions;
8076   verifyFormat("class D {\n"
8077                "  int\n"
8078                "  f() {\n"
8079                "    return 1;\n"
8080                "  }\n"
8081                "  int g();\n"
8082                "};\n"
8083                "int\n"
8084                "f() {\n"
8085                "  return 1;\n"
8086                "}\n"
8087                "int g();\n",
8088                Style);
8089   verifyFormat("const char *\n"
8090                "f(void) {\n" // Break here.
8091                "  return \"\";\n"
8092                "}\n"
8093                "const char *bar(void);\n", // No break here.
8094                Style);
8095   verifyFormat("template <class T>\n"
8096                "T *\n"
8097                "f(T &c) {\n" // Break here.
8098                "  return NULL;\n"
8099                "}\n"
8100                "template <class T> T *f(T &c);\n", // No break here.
8101                Style);
8102   verifyFormat("class C {\n"
8103                "  int\n"
8104                "  operator+() {\n"
8105                "    return 1;\n"
8106                "  }\n"
8107                "  int\n"
8108                "  operator()() {\n"
8109                "    return 1;\n"
8110                "  }\n"
8111                "};\n",
8112                Style);
8113   verifyFormat("void\n"
8114                "A::operator()() {}\n"
8115                "void\n"
8116                "A::operator>>() {}\n"
8117                "void\n"
8118                "A::operator+() {}\n"
8119                "void\n"
8120                "A::operator*() {}\n"
8121                "void\n"
8122                "A::operator->() {}\n"
8123                "void\n"
8124                "A::operator void *() {}\n"
8125                "void\n"
8126                "A::operator void &() {}\n"
8127                "void\n"
8128                "A::operator void &&() {}\n"
8129                "void\n"
8130                "A::operator char *() {}\n"
8131                "void\n"
8132                "A::operator[]() {}\n"
8133                "void\n"
8134                "A::operator!() {}\n"
8135                "void\n"
8136                "A::operator**() {}\n"
8137                "void\n"
8138                "A::operator<Foo> *() {}\n"
8139                "void\n"
8140                "A::operator<Foo> **() {}\n"
8141                "void\n"
8142                "A::operator<Foo> &() {}\n"
8143                "void\n"
8144                "A::operator void **() {}\n",
8145                Style);
8146   verifyFormat("constexpr auto\n"
8147                "operator()() const -> reference {}\n"
8148                "constexpr auto\n"
8149                "operator>>() const -> reference {}\n"
8150                "constexpr auto\n"
8151                "operator+() const -> reference {}\n"
8152                "constexpr auto\n"
8153                "operator*() const -> reference {}\n"
8154                "constexpr auto\n"
8155                "operator->() const -> reference {}\n"
8156                "constexpr auto\n"
8157                "operator++() const -> reference {}\n"
8158                "constexpr auto\n"
8159                "operator void *() const -> reference {}\n"
8160                "constexpr auto\n"
8161                "operator void **() const -> reference {}\n"
8162                "constexpr auto\n"
8163                "operator void *() const -> reference {}\n"
8164                "constexpr auto\n"
8165                "operator void &() const -> reference {}\n"
8166                "constexpr auto\n"
8167                "operator void &&() const -> reference {}\n"
8168                "constexpr auto\n"
8169                "operator char *() const -> reference {}\n"
8170                "constexpr auto\n"
8171                "operator!() const -> reference {}\n"
8172                "constexpr auto\n"
8173                "operator[]() const -> reference {}\n",
8174                Style);
8175   verifyFormat("void *operator new(std::size_t s);", // No break here.
8176                Style);
8177   verifyFormat("void *\n"
8178                "operator new(std::size_t s) {}",
8179                Style);
8180   verifyFormat("void *\n"
8181                "operator delete[](void *ptr) {}",
8182                Style);
8183   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
8184   verifyFormat("const char *\n"
8185                "f(void)\n" // Break here.
8186                "{\n"
8187                "  return \"\";\n"
8188                "}\n"
8189                "const char *bar(void);\n", // No break here.
8190                Style);
8191   verifyFormat("template <class T>\n"
8192                "T *\n"     // Problem here: no line break
8193                "f(T &c)\n" // Break here.
8194                "{\n"
8195                "  return NULL;\n"
8196                "}\n"
8197                "template <class T> T *f(T &c);\n", // No break here.
8198                Style);
8199   verifyFormat("int\n"
8200                "foo(A<bool> a)\n"
8201                "{\n"
8202                "  return a;\n"
8203                "}\n",
8204                Style);
8205   verifyFormat("int\n"
8206                "foo(A<8> a)\n"
8207                "{\n"
8208                "  return a;\n"
8209                "}\n",
8210                Style);
8211   verifyFormat("int\n"
8212                "foo(A<B<bool>, 8> a)\n"
8213                "{\n"
8214                "  return a;\n"
8215                "}\n",
8216                Style);
8217   verifyFormat("int\n"
8218                "foo(A<B<8>, bool> a)\n"
8219                "{\n"
8220                "  return a;\n"
8221                "}\n",
8222                Style);
8223   verifyFormat("int\n"
8224                "foo(A<B<bool>, bool> a)\n"
8225                "{\n"
8226                "  return a;\n"
8227                "}\n",
8228                Style);
8229   verifyFormat("int\n"
8230                "foo(A<B<8>, 8> a)\n"
8231                "{\n"
8232                "  return a;\n"
8233                "}\n",
8234                Style);
8235 
8236   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
8237   Style.BraceWrapping.AfterFunction = true;
8238   verifyFormat("int f(i);\n" // No break here.
8239                "int\n"       // Break here.
8240                "f(i)\n"
8241                "{\n"
8242                "  return i + 1;\n"
8243                "}\n"
8244                "int\n" // Break here.
8245                "f(i)\n"
8246                "{\n"
8247                "  return i + 1;\n"
8248                "};",
8249                Style);
8250   verifyFormat("int f(a, b, c);\n" // No break here.
8251                "int\n"             // Break here.
8252                "f(a, b, c)\n"      // Break here.
8253                "short a, b;\n"
8254                "float c;\n"
8255                "{\n"
8256                "  return a + b < c;\n"
8257                "}\n"
8258                "int\n"        // Break here.
8259                "f(a, b, c)\n" // Break here.
8260                "short a, b;\n"
8261                "float c;\n"
8262                "{\n"
8263                "  return a + b < c;\n"
8264                "};",
8265                Style);
8266   verifyFormat("byte *\n" // Break here.
8267                "f(a)\n"   // Break here.
8268                "byte a[];\n"
8269                "{\n"
8270                "  return a;\n"
8271                "}",
8272                Style);
8273   verifyFormat("bool f(int a, int) override;\n"
8274                "Bar g(int a, Bar) final;\n"
8275                "Bar h(a, Bar) final;",
8276                Style);
8277   verifyFormat("int\n"
8278                "f(a)",
8279                Style);
8280 
8281   // The return breaking style doesn't affect:
8282   // * function and object definitions with attribute-like macros
8283   verifyFormat("Tttttttttttttttttttttttt ppppppppppppppp\n"
8284                "    ABSL_GUARDED_BY(mutex) = {};",
8285                getGoogleStyleWithColumns(40));
8286   verifyFormat("Tttttttttttttttttttttttt ppppppppppppppp\n"
8287                "    ABSL_GUARDED_BY(mutex);  // comment",
8288                getGoogleStyleWithColumns(40));
8289   verifyFormat("Tttttttttttttttttttttttt ppppppppppppppp\n"
8290                "    ABSL_GUARDED_BY(mutex1)\n"
8291                "        ABSL_GUARDED_BY(mutex2);",
8292                getGoogleStyleWithColumns(40));
8293   verifyFormat("Tttttt f(int a, int b)\n"
8294                "    ABSL_GUARDED_BY(mutex1)\n"
8295                "        ABSL_GUARDED_BY(mutex2);",
8296                getGoogleStyleWithColumns(40));
8297   // * typedefs
8298   verifyFormat("typedef ATTR(X) char x;", getGoogleStyle());
8299 
8300   Style = getGNUStyle();
8301 
8302   // Test for comments at the end of function declarations.
8303   verifyFormat("void\n"
8304                "foo (int a, /*abc*/ int b) // def\n"
8305                "{\n"
8306                "}\n",
8307                Style);
8308 
8309   verifyFormat("void\n"
8310                "foo (int a, /* abc */ int b) /* def */\n"
8311                "{\n"
8312                "}\n",
8313                Style);
8314 
8315   // Definitions that should not break after return type
8316   verifyFormat("void foo (int a, int b); // def\n", Style);
8317   verifyFormat("void foo (int a, int b); /* def */\n", Style);
8318   verifyFormat("void foo (int a, int b);\n", Style);
8319 }
8320 
8321 TEST_F(FormatTest, AlwaysBreakBeforeMultilineStrings) {
8322   FormatStyle NoBreak = getLLVMStyle();
8323   NoBreak.AlwaysBreakBeforeMultilineStrings = false;
8324   FormatStyle Break = getLLVMStyle();
8325   Break.AlwaysBreakBeforeMultilineStrings = true;
8326   verifyFormat("aaaa = \"bbbb\"\n"
8327                "       \"cccc\";",
8328                NoBreak);
8329   verifyFormat("aaaa =\n"
8330                "    \"bbbb\"\n"
8331                "    \"cccc\";",
8332                Break);
8333   verifyFormat("aaaa(\"bbbb\"\n"
8334                "     \"cccc\");",
8335                NoBreak);
8336   verifyFormat("aaaa(\n"
8337                "    \"bbbb\"\n"
8338                "    \"cccc\");",
8339                Break);
8340   verifyFormat("aaaa(qqq, \"bbbb\"\n"
8341                "          \"cccc\");",
8342                NoBreak);
8343   verifyFormat("aaaa(qqq,\n"
8344                "     \"bbbb\"\n"
8345                "     \"cccc\");",
8346                Break);
8347   verifyFormat("aaaa(qqq,\n"
8348                "     L\"bbbb\"\n"
8349                "     L\"cccc\");",
8350                Break);
8351   verifyFormat("aaaaa(aaaaaa, aaaaaaa(\"aaaa\"\n"
8352                "                      \"bbbb\"));",
8353                Break);
8354   verifyFormat("string s = someFunction(\n"
8355                "    \"abc\"\n"
8356                "    \"abc\");",
8357                Break);
8358 
8359   // As we break before unary operators, breaking right after them is bad.
8360   verifyFormat("string foo = abc ? \"x\"\n"
8361                "                   \"blah blah blah blah blah blah\"\n"
8362                "                 : \"y\";",
8363                Break);
8364 
8365   // Don't break if there is no column gain.
8366   verifyFormat("f(\"aaaa\"\n"
8367                "  \"bbbb\");",
8368                Break);
8369 
8370   // Treat literals with escaped newlines like multi-line string literals.
8371   EXPECT_EQ("x = \"a\\\n"
8372             "b\\\n"
8373             "c\";",
8374             format("x = \"a\\\n"
8375                    "b\\\n"
8376                    "c\";",
8377                    NoBreak));
8378   EXPECT_EQ("xxxx =\n"
8379             "    \"a\\\n"
8380             "b\\\n"
8381             "c\";",
8382             format("xxxx = \"a\\\n"
8383                    "b\\\n"
8384                    "c\";",
8385                    Break));
8386 
8387   EXPECT_EQ("NSString *const kString =\n"
8388             "    @\"aaaa\"\n"
8389             "    @\"bbbb\";",
8390             format("NSString *const kString = @\"aaaa\"\n"
8391                    "@\"bbbb\";",
8392                    Break));
8393 
8394   Break.ColumnLimit = 0;
8395   verifyFormat("const char *hello = \"hello llvm\";", Break);
8396 }
8397 
8398 TEST_F(FormatTest, AlignsPipes) {
8399   verifyFormat(
8400       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8401       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8402       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8403   verifyFormat(
8404       "aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaa\n"
8405       "                     << aaaaaaaaaaaaaaaaaaaa;");
8406   verifyFormat(
8407       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8408       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8409   verifyFormat(
8410       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()\n"
8411       "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8412   verifyFormat(
8413       "llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"\n"
8414       "                \"bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\"\n"
8415       "             << \"ccccccccccccccccccccccccccccccccccccccccccccccccc\";");
8416   verifyFormat(
8417       "aaaaaaaa << (aaaaaaaaaaaaaaaaaaa << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8418       "                                 << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
8419       "         << aaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8420   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8421                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8422                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
8423                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8424   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaaaaaa: \"\n"
8425                "             << aaaaaaaaaaaaaaaaa(aaaaaaaa, aaaaaaaaaaa);");
8426   verifyFormat(
8427       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8428       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8429   verifyFormat(
8430       "auto Diag = diag() << aaaaaaaaaaaaaaaa(aaaaaaaaaaaa, aaaaaaaaaaaaa,\n"
8431       "                                       aaaaaaaaaaaaaaaaaaaaaaaaaa);");
8432 
8433   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \"\n"
8434                "             << aaaaaaaa.aaaaaaaaaaaa(aaa)->aaaaaaaaaaaaaa();");
8435   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8436                "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8437                "                    aaaaaaaaaaaaaaaaaaaaa)\n"
8438                "             << aaaaaaaaaaaaaaaaaaaaaaaaaa;");
8439   verifyFormat("LOG_IF(aaa == //\n"
8440                "       bbb)\n"
8441                "    << a << b;");
8442 
8443   // But sometimes, breaking before the first "<<" is desirable.
8444   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
8445                "    << aaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaa);");
8446   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbb)\n"
8447                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8448                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8449   verifyFormat("SemaRef.Diag(Loc, diag::note_for_range_begin_end)\n"
8450                "    << BEF << IsTemplate << Description << E->getType();");
8451   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
8452                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8453                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8454   verifyFormat("Diag(aaaaaaaaaaaaaaaaaaaa, aaaaaaaa)\n"
8455                "    << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8456                "           aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
8457                "    << aaa;");
8458 
8459   verifyFormat(
8460       "llvm::errs() << aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8461       "                    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
8462 
8463   // Incomplete string literal.
8464   EXPECT_EQ("llvm::errs() << \"\n"
8465             "             << a;",
8466             format("llvm::errs() << \"\n<<a;"));
8467 
8468   verifyFormat("void f() {\n"
8469                "  CHECK_EQ(aaaa, (*bbbbbbbbb)->cccccc)\n"
8470                "      << \"qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\";\n"
8471                "}");
8472 
8473   // Handle 'endl'.
8474   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << endl\n"
8475                "             << bbbbbbbbbbbbbbbbbbbbbb << endl;");
8476   verifyFormat("llvm::errs() << endl << bbbbbbbbbbbbbbbbbbbbbb << endl;");
8477 
8478   // Handle '\n'.
8479   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \"\\n\"\n"
8480                "             << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
8481   verifyFormat("llvm::errs() << aaaaaaaaaaaaaaaaaaaaaa << \'\\n\'\n"
8482                "             << bbbbbbbbbbbbbbbbbbbbbb << \'\\n\';");
8483   verifyFormat("llvm::errs() << aaaa << \"aaaaaaaaaaaaaaaaaa\\n\"\n"
8484                "             << bbbb << \"bbbbbbbbbbbbbbbbbb\\n\";");
8485   verifyFormat("llvm::errs() << \"\\n\" << bbbbbbbbbbbbbbbbbbbbbb << \"\\n\";");
8486 }
8487 
8488 TEST_F(FormatTest, KeepStringLabelValuePairsOnALine) {
8489   verifyFormat("return out << \"somepacket = {\\n\"\n"
8490                "           << \" aaaaaa = \" << pkt.aaaaaa << \"\\n\"\n"
8491                "           << \" bbbb = \" << pkt.bbbb << \"\\n\"\n"
8492                "           << \" cccccc = \" << pkt.cccccc << \"\\n\"\n"
8493                "           << \" ddd = [\" << pkt.ddd << \"]\\n\"\n"
8494                "           << \"}\";");
8495 
8496   verifyFormat("llvm::outs() << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
8497                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa\n"
8498                "             << \"aaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaa;");
8499   verifyFormat(
8500       "llvm::outs() << \"aaaaaaaaaaaaaaaaa = \" << aaaaaaaaaaaaaaaaa\n"
8501       "             << \"bbbbbbbbbbbbbbbbb = \" << bbbbbbbbbbbbbbbbb\n"
8502       "             << \"ccccccccccccccccc = \" << ccccccccccccccccc\n"
8503       "             << \"ddddddddddddddddd = \" << ddddddddddddddddd\n"
8504       "             << \"eeeeeeeeeeeeeeeee = \" << eeeeeeeeeeeeeeeee;");
8505   verifyFormat("llvm::outs() << aaaaaaaaaaaaaaaaaaaaaaaa << \"=\"\n"
8506                "             << bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
8507   verifyFormat(
8508       "void f() {\n"
8509       "  llvm::outs() << \"aaaaaaaaaaaaaaaaaaaa: \"\n"
8510       "               << aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaa);\n"
8511       "}");
8512 
8513   // Breaking before the first "<<" is generally not desirable.
8514   verifyFormat(
8515       "llvm::errs()\n"
8516       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8517       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8518       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8519       "    << \"aaaaaaaaaaaaaaaaaaa: \" << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
8520       getLLVMStyleWithColumns(70));
8521   verifyFormat("llvm::errs() << \"aaaaaaaaaaaaaaaaaaa: \"\n"
8522                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8523                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
8524                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8525                "             << \"aaaaaaaaaaaaaaaaaaa: \"\n"
8526                "             << aaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
8527                getLLVMStyleWithColumns(70));
8528 
8529   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
8530                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa +\n"
8531                "           \"aaaaaaaaaaaaaaaa: \" + aaaaaaaaaaaaaaaa;");
8532   verifyFormat("string v = StrCat(\"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
8533                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa,\n"
8534                "                  \"aaaaaaaaaaaaaaaa: \", aaaaaaaaaaaaaaaa);");
8535   verifyFormat("string v = \"aaaaaaaaaaaaaaaa: \" +\n"
8536                "           (aaaa + aaaa);",
8537                getLLVMStyleWithColumns(40));
8538   verifyFormat("string v = StrCat(\"aaaaaaaaaaaa: \" +\n"
8539                "                  (aaaaaaa + aaaaa));",
8540                getLLVMStyleWithColumns(40));
8541   verifyFormat(
8542       "string v = StrCat(\"aaaaaaaaaaaaaaaaaaaaaaaaaaa: \",\n"
8543       "                  SomeFunction(aaaaaaaaaaaa, aaaaaaaa.aaaaaaa),\n"
8544       "                  bbbbbbbbbbbbbbbbbbbbbbb);");
8545 }
8546 
8547 TEST_F(FormatTest, UnderstandsEquals) {
8548   verifyFormat(
8549       "aaaaaaaaaaaaaaaaa =\n"
8550       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
8551   verifyFormat(
8552       "if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8553       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
8554   verifyFormat(
8555       "if (a) {\n"
8556       "  f();\n"
8557       "} else if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8558       "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
8559       "}");
8560 
8561   verifyFormat("if (int aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
8562                "        100000000 + 10000000) {\n}");
8563 }
8564 
8565 TEST_F(FormatTest, WrapsAtFunctionCallsIfNecessary) {
8566   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
8567                "    .looooooooooooooooooooooooooooooooooooooongFunction();");
8568 
8569   verifyFormat("LoooooooooooooooooooooooooooooooooooooongObject\n"
8570                "    ->looooooooooooooooooooooooooooooooooooooongFunction();");
8571 
8572   verifyFormat(
8573       "LooooooooooooooooooooooooooooooooongObject->shortFunction(Parameter1,\n"
8574       "                                                          Parameter2);");
8575 
8576   verifyFormat(
8577       "ShortObject->shortFunction(\n"
8578       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter1,\n"
8579       "    LooooooooooooooooooooooooooooooooooooooooooooooongParameter2);");
8580 
8581   verifyFormat("loooooooooooooongFunction(\n"
8582                "    LoooooooooooooongObject->looooooooooooooooongFunction());");
8583 
8584   verifyFormat(
8585       "function(LoooooooooooooooooooooooooooooooooooongObject\n"
8586       "             ->loooooooooooooooooooooooooooooooooooooooongFunction());");
8587 
8588   verifyFormat("EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
8589                "    .WillRepeatedly(Return(SomeValue));");
8590   verifyFormat("void f() {\n"
8591                "  EXPECT_CALL(SomeObject, SomeFunction(Parameter))\n"
8592                "      .Times(2)\n"
8593                "      .WillRepeatedly(Return(SomeValue));\n"
8594                "}");
8595   verifyFormat("SomeMap[std::pair(aaaaaaaaaaaa, bbbbbbbbbbbbbbb)].insert(\n"
8596                "    ccccccccccccccccccccccc);");
8597   verifyFormat("aaaaa(aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8598                "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
8599                "          .aaaaa(aaaaa),\n"
8600                "      aaaaaaaaaaaaaaaaaaaaa);");
8601   verifyFormat("void f() {\n"
8602                "  aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8603                "      aaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa)->aaaaaaaaa());\n"
8604                "}");
8605   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8606                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
8607                "    .aaaaaaaaaaaaaaa(aa(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8608                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8609                "                        aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
8610   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8611                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8612                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8613                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa()) {\n"
8614                "}");
8615 
8616   // Here, it is not necessary to wrap at "." or "->".
8617   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaa) ||\n"
8618                "    aaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n}");
8619   verifyFormat(
8620       "aaaaaaaaaaa->aaaaaaaaa(\n"
8621       "    aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8622       "    aaaaaaaaaaaaaaaaaa->aaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaa));\n");
8623 
8624   verifyFormat(
8625       "aaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8626       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa().aaaaaaaaaaaaaaaaa());");
8627   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() *\n"
8628                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
8629   verifyFormat("a->aaaaaa()->aaaaaaaaaaa(aaaaaaaa()->aaaaaa()->aaaaa() ||\n"
8630                "                         aaaaaaaaa()->aaaaaa()->aaaaa());");
8631 
8632   verifyFormat("aaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8633                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
8634                "    .a();");
8635 
8636   FormatStyle NoBinPacking = getLLVMStyle();
8637   NoBinPacking.BinPackParameters = false;
8638   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
8639                "    .aaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaa)\n"
8640                "    .aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa,\n"
8641                "                         aaaaaaaaaaaaaaaaaaa,\n"
8642                "                         aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
8643                NoBinPacking);
8644 
8645   // If there is a subsequent call, change to hanging indentation.
8646   verifyFormat(
8647       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8648       "                         aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa))\n"
8649       "    .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
8650   verifyFormat(
8651       "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8652       "    aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa));");
8653   verifyFormat("aaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8654                "                 aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
8655                "                 .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
8656   verifyFormat("aaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8657                "               aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
8658                "               .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
8659 }
8660 
8661 TEST_F(FormatTest, WrapsTemplateDeclarations) {
8662   verifyFormat("template <typename T>\n"
8663                "virtual void loooooooooooongFunction(int Param1, int Param2);");
8664   verifyFormat("template <typename T>\n"
8665                "// T should be one of {A, B}.\n"
8666                "virtual void loooooooooooongFunction(int Param1, int Param2);");
8667   verifyFormat(
8668       "template <typename T>\n"
8669       "using comment_to_xml_conversion = comment_to_xml_conversion<T, int>;");
8670   verifyFormat("template <typename T>\n"
8671                "void f(int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram1,\n"
8672                "       int Paaaaaaaaaaaaaaaaaaaaaaaaaaaaaaram2);");
8673   verifyFormat(
8674       "template <typename T>\n"
8675       "void looooooooooooooooooooongFunction(int Paaaaaaaaaaaaaaaaaaaaram1,\n"
8676       "                                      int Paaaaaaaaaaaaaaaaaaaaram2);");
8677   verifyFormat(
8678       "template <typename T>\n"
8679       "aaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa,\n"
8680       "                    aaaaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaaaaa,\n"
8681       "                    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8682   verifyFormat("template <typename T>\n"
8683                "void aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8684                "    int aaaaaaaaaaaaaaaaaaaaaa);");
8685   verifyFormat(
8686       "template <typename T1, typename T2 = char, typename T3 = char,\n"
8687       "          typename T4 = char>\n"
8688       "void f();");
8689   verifyFormat("template <typename aaaaaaaaaaa, typename bbbbbbbbbbbbb,\n"
8690                "          template <typename> class cccccccccccccccccccccc,\n"
8691                "          typename ddddddddddddd>\n"
8692                "class C {};");
8693   verifyFormat(
8694       "aaaaaaaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>(\n"
8695       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
8696 
8697   verifyFormat("void f() {\n"
8698                "  a<aaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaa>(\n"
8699                "      a(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaa));\n"
8700                "}");
8701 
8702   verifyFormat("template <typename T> class C {};");
8703   verifyFormat("template <typename T> void f();");
8704   verifyFormat("template <typename T> void f() {}");
8705   verifyFormat(
8706       "aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
8707       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8708       "              aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> *aaaa =\n"
8709       "    new aaaaaaaaaaaaa<aaaaaaaaaa, aaaaaaaaaaa,\n"
8710       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8711       "                      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>(\n"
8712       "        bbbbbbbbbbbbbbbbbbbbbbbb);",
8713       getLLVMStyleWithColumns(72));
8714   EXPECT_EQ("static_cast<A< //\n"
8715             "    B> *>(\n"
8716             "\n"
8717             ");",
8718             format("static_cast<A<//\n"
8719                    "    B>*>(\n"
8720                    "\n"
8721                    "    );"));
8722   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8723                "    const typename aaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaa);");
8724 
8725   FormatStyle AlwaysBreak = getLLVMStyle();
8726   AlwaysBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
8727   verifyFormat("template <typename T>\nclass C {};", AlwaysBreak);
8728   verifyFormat("template <typename T>\nvoid f();", AlwaysBreak);
8729   verifyFormat("template <typename T>\nvoid f() {}", AlwaysBreak);
8730   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8731                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
8732                "    ccccccccccccccccccccccccccccccccccccccccccccccc);");
8733   verifyFormat("template <template <typename> class Fooooooo,\n"
8734                "          template <typename> class Baaaaaaar>\n"
8735                "struct C {};",
8736                AlwaysBreak);
8737   verifyFormat("template <typename T> // T can be A, B or C.\n"
8738                "struct C {};",
8739                AlwaysBreak);
8740   verifyFormat("template <enum E> class A {\n"
8741                "public:\n"
8742                "  E *f();\n"
8743                "};");
8744 
8745   FormatStyle NeverBreak = getLLVMStyle();
8746   NeverBreak.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_No;
8747   verifyFormat("template <typename T> class C {};", NeverBreak);
8748   verifyFormat("template <typename T> void f();", NeverBreak);
8749   verifyFormat("template <typename T> void f() {}", NeverBreak);
8750   verifyFormat("template <typename T>\nvoid foo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
8751                "bbbbbbbbbbbbbbbbbbbb) {}",
8752                NeverBreak);
8753   verifyFormat("void aaaaaaaaaaaaaaaaaaa<aaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8754                "                         bbbbbbbbbbbbbbbbbbbbbbbbbbbb>(\n"
8755                "    ccccccccccccccccccccccccccccccccccccccccccccccc);",
8756                NeverBreak);
8757   verifyFormat("template <template <typename> class Fooooooo,\n"
8758                "          template <typename> class Baaaaaaar>\n"
8759                "struct C {};",
8760                NeverBreak);
8761   verifyFormat("template <typename T> // T can be A, B or C.\n"
8762                "struct C {};",
8763                NeverBreak);
8764   verifyFormat("template <enum E> class A {\n"
8765                "public:\n"
8766                "  E *f();\n"
8767                "};",
8768                NeverBreak);
8769   NeverBreak.PenaltyBreakTemplateDeclaration = 100;
8770   verifyFormat("template <typename T> void\nfoo(aaaaaaaaaaaaaaaaaaaaaaaaaa "
8771                "bbbbbbbbbbbbbbbbbbbb) {}",
8772                NeverBreak);
8773 }
8774 
8775 TEST_F(FormatTest, WrapsTemplateDeclarationsWithComments) {
8776   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
8777   Style.ColumnLimit = 60;
8778   EXPECT_EQ("// Baseline - no comments.\n"
8779             "template <\n"
8780             "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
8781             "void f() {}",
8782             format("// Baseline - no comments.\n"
8783                    "template <\n"
8784                    "    typename aaaaaaaaaaaaaaaaaaaaaa<bbbbbbbbbbbb>::value>\n"
8785                    "void f() {}",
8786                    Style));
8787 
8788   EXPECT_EQ("template <\n"
8789             "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
8790             "void f() {}",
8791             format("template <\n"
8792                    "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
8793                    "void f() {}",
8794                    Style));
8795 
8796   EXPECT_EQ(
8797       "template <\n"
8798       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> /* line */\n"
8799       "void f() {}",
8800       format("template <typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  /* line */\n"
8801              "void f() {}",
8802              Style));
8803 
8804   EXPECT_EQ(
8805       "template <\n"
8806       "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value>  // trailing\n"
8807       "                                               // multiline\n"
8808       "void f() {}",
8809       format("template <\n"
8810              "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing\n"
8811              "                                              // multiline\n"
8812              "void f() {}",
8813              Style));
8814 
8815   EXPECT_EQ(
8816       "template <typename aaaaaaaaaa<\n"
8817       "    bbbbbbbbbbbb>::value>  // trailing loooong\n"
8818       "void f() {}",
8819       format(
8820           "template <\n"
8821           "    typename aaaaaaaaaa<bbbbbbbbbbbb>::value> // trailing loooong\n"
8822           "void f() {}",
8823           Style));
8824 }
8825 
8826 TEST_F(FormatTest, WrapsTemplateParameters) {
8827   FormatStyle Style = getLLVMStyle();
8828   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
8829   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
8830   verifyFormat(
8831       "template <typename... a> struct q {};\n"
8832       "extern q<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
8833       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
8834       "    y;",
8835       Style);
8836   Style.AlignAfterOpenBracket = FormatStyle::BAS_DontAlign;
8837   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
8838   verifyFormat(
8839       "template <typename... a> struct r {};\n"
8840       "extern r<aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa,\n"
8841       "    aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa>\n"
8842       "    y;",
8843       Style);
8844   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
8845   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
8846   verifyFormat("template <typename... a> struct s {};\n"
8847                "extern s<\n"
8848                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
8849                "aaaaaaaaaaaaaaaaaaaaaa,\n"
8850                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
8851                "aaaaaaaaaaaaaaaaaaaaaa>\n"
8852                "    y;",
8853                Style);
8854   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
8855   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
8856   verifyFormat("template <typename... a> struct t {};\n"
8857                "extern t<\n"
8858                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
8859                "aaaaaaaaaaaaaaaaaaaaaa,\n"
8860                "    aaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaa, "
8861                "aaaaaaaaaaaaaaaaaaaaaa>\n"
8862                "    y;",
8863                Style);
8864 }
8865 
8866 TEST_F(FormatTest, WrapsAtNestedNameSpecifiers) {
8867   verifyFormat(
8868       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
8869       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
8870   verifyFormat(
8871       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
8872       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8873       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa());");
8874 
8875   // FIXME: Should we have the extra indent after the second break?
8876   verifyFormat(
8877       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
8878       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
8879       "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
8880 
8881   verifyFormat(
8882       "aaaaaaaaaaaaaaa(bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb::\n"
8883       "                    cccccccccccccccccccccccccccccccccccccccccccccc());");
8884 
8885   // Breaking at nested name specifiers is generally not desirable.
8886   verifyFormat(
8887       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8888       "    aaaaaaaaaaaaaaaaaaaaaaa);");
8889 
8890   verifyFormat("aaaaaaaaaaaaaaaaaa(aaaaaaaa,\n"
8891                "                   aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
8892                "                       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
8893                "                   aaaaaaaaaaaaaaaaaaaaa);",
8894                getLLVMStyleWithColumns(74));
8895 
8896   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa::\n"
8897                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8898                "        .aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa();");
8899 }
8900 
8901 TEST_F(FormatTest, UnderstandsTemplateParameters) {
8902   verifyFormat("A<int> a;");
8903   verifyFormat("A<A<A<int>>> a;");
8904   verifyFormat("A<A<A<int, 2>, 3>, 4> a;");
8905   verifyFormat("bool x = a < 1 || 2 > a;");
8906   verifyFormat("bool x = 5 < f<int>();");
8907   verifyFormat("bool x = f<int>() > 5;");
8908   verifyFormat("bool x = 5 < a<int>::x;");
8909   verifyFormat("bool x = a < 4 ? a > 2 : false;");
8910   verifyFormat("bool x = f() ? a < 2 : a > 2;");
8911 
8912   verifyGoogleFormat("A<A<int>> a;");
8913   verifyGoogleFormat("A<A<A<int>>> a;");
8914   verifyGoogleFormat("A<A<A<A<int>>>> a;");
8915   verifyGoogleFormat("A<A<int> > a;");
8916   verifyGoogleFormat("A<A<A<int> > > a;");
8917   verifyGoogleFormat("A<A<A<A<int> > > > a;");
8918   verifyGoogleFormat("A<::A<int>> a;");
8919   verifyGoogleFormat("A<::A> a;");
8920   verifyGoogleFormat("A< ::A> a;");
8921   verifyGoogleFormat("A< ::A<int> > a;");
8922   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A> >> a;", getGoogleStyle()));
8923   EXPECT_EQ("A<A<A<A>>> a;", format("A<A<A<A>> > a;", getGoogleStyle()));
8924   EXPECT_EQ("A<::A<int>> a;", format("A< ::A<int>> a;", getGoogleStyle()));
8925   EXPECT_EQ("A<::A<int>> a;", format("A<::A<int> > a;", getGoogleStyle()));
8926   EXPECT_EQ("auto x = [] { A<A<A<A>>> a; };",
8927             format("auto x=[]{A<A<A<A> >> a;};", getGoogleStyle()));
8928 
8929   verifyFormat("A<A<int>> a;", getChromiumStyle(FormatStyle::LK_Cpp));
8930 
8931   // template closer followed by a token that starts with > or =
8932   verifyFormat("bool b = a<1> > 1;");
8933   verifyFormat("bool b = a<1> >= 1;");
8934   verifyFormat("int i = a<1> >> 1;");
8935   FormatStyle Style = getLLVMStyle();
8936   Style.SpaceBeforeAssignmentOperators = false;
8937   verifyFormat("bool b= a<1> == 1;", Style);
8938   verifyFormat("a<int> = 1;", Style);
8939   verifyFormat("a<int> >>= 1;", Style);
8940 
8941   verifyFormat("test < a | b >> c;");
8942   verifyFormat("test<test<a | b>> c;");
8943   verifyFormat("test >> a >> b;");
8944   verifyFormat("test << a >> b;");
8945 
8946   verifyFormat("f<int>();");
8947   verifyFormat("template <typename T> void f() {}");
8948   verifyFormat("struct A<std::enable_if<sizeof(T2) < sizeof(int32)>::type>;");
8949   verifyFormat("struct A<std::enable_if<sizeof(T2) ? sizeof(int32) : "
8950                "sizeof(char)>::type>;");
8951   verifyFormat("template <class T> struct S<std::is_arithmetic<T>{}> {};");
8952   verifyFormat("f(a.operator()<A>());");
8953   verifyFormat("f(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
8954                "      .template operator()<A>());",
8955                getLLVMStyleWithColumns(35));
8956 
8957   // Not template parameters.
8958   verifyFormat("return a < b && c > d;");
8959   verifyFormat("void f() {\n"
8960                "  while (a < b && c > d) {\n"
8961                "  }\n"
8962                "}");
8963   verifyFormat("template <typename... Types>\n"
8964                "typename enable_if<0 < sizeof...(Types)>::type Foo() {}");
8965 
8966   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
8967                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaa >> aaaaa);",
8968                getLLVMStyleWithColumns(60));
8969   verifyFormat("static_assert(is_convertible<A &&, B>::value, \"AAA\");");
8970   verifyFormat("Constructor(A... a) : a_(X<A>{std::forward<A>(a)}...) {}");
8971   verifyFormat("< < < < < < < < < < < < < < < < < < < < < < < < < < < < < <");
8972   verifyFormat("some_templated_type<decltype([](int i) { return i; })>");
8973 }
8974 
8975 TEST_F(FormatTest, UnderstandsShiftOperators) {
8976   verifyFormat("if (i < x >> 1)");
8977   verifyFormat("while (i < x >> 1)");
8978   verifyFormat("for (unsigned i = 0; i < i; ++i, v = v >> 1)");
8979   verifyFormat("for (unsigned i = 0; i < x >> 1; ++i, v = v >> 1)");
8980   verifyFormat(
8981       "for (std::vector<int>::iterator i = 0; i < x >> 1; ++i, v = v >> 1)");
8982   verifyFormat("Foo.call<Bar<Function>>()");
8983   verifyFormat("if (Foo.call<Bar<Function>>() == 0)");
8984   verifyFormat("for (std::vector<std::pair<int>>::iterator i = 0; i < x >> 1; "
8985                "++i, v = v >> 1)");
8986   verifyFormat("if (w<u<v<x>>, 1>::t)");
8987 }
8988 
8989 TEST_F(FormatTest, BitshiftOperatorWidth) {
8990   EXPECT_EQ("int a = 1 << 2; /* foo\n"
8991             "                   bar */",
8992             format("int    a=1<<2;  /* foo\n"
8993                    "                   bar */"));
8994 
8995   EXPECT_EQ("int b = 256 >> 1; /* foo\n"
8996             "                     bar */",
8997             format("int  b  =256>>1 ;  /* foo\n"
8998                    "                      bar */"));
8999 }
9000 
9001 TEST_F(FormatTest, UnderstandsBinaryOperators) {
9002   verifyFormat("COMPARE(a, ==, b);");
9003   verifyFormat("auto s = sizeof...(Ts) - 1;");
9004 }
9005 
9006 TEST_F(FormatTest, UnderstandsPointersToMembers) {
9007   verifyFormat("int A::*x;");
9008   verifyFormat("int (S::*func)(void *);");
9009   verifyFormat("void f() { int (S::*func)(void *); }");
9010   verifyFormat("typedef bool *(Class::*Member)() const;");
9011   verifyFormat("void f() {\n"
9012                "  (a->*f)();\n"
9013                "  a->*x;\n"
9014                "  (a.*f)();\n"
9015                "  ((*a).*f)();\n"
9016                "  a.*x;\n"
9017                "}");
9018   verifyFormat("void f() {\n"
9019                "  (a->*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
9020                "      aaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb);\n"
9021                "}");
9022   verifyFormat(
9023       "(aaaaaaaaaa->*bbbbbbb)(\n"
9024       "    aaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa));");
9025   FormatStyle Style = getLLVMStyle();
9026   Style.PointerAlignment = FormatStyle::PAS_Left;
9027   verifyFormat("typedef bool* (Class::*Member)() const;", Style);
9028 }
9029 
9030 TEST_F(FormatTest, UnderstandsUnaryOperators) {
9031   verifyFormat("int a = -2;");
9032   verifyFormat("f(-1, -2, -3);");
9033   verifyFormat("a[-1] = 5;");
9034   verifyFormat("int a = 5 + -2;");
9035   verifyFormat("if (i == -1) {\n}");
9036   verifyFormat("if (i != -1) {\n}");
9037   verifyFormat("if (i > -1) {\n}");
9038   verifyFormat("if (i < -1) {\n}");
9039   verifyFormat("++(a->f());");
9040   verifyFormat("--(a->f());");
9041   verifyFormat("(a->f())++;");
9042   verifyFormat("a[42]++;");
9043   verifyFormat("if (!(a->f())) {\n}");
9044   verifyFormat("if (!+i) {\n}");
9045   verifyFormat("~&a;");
9046 
9047   verifyFormat("a-- > b;");
9048   verifyFormat("b ? -a : c;");
9049   verifyFormat("n * sizeof char16;");
9050   verifyFormat("n * alignof char16;", getGoogleStyle());
9051   verifyFormat("sizeof(char);");
9052   verifyFormat("alignof(char);", getGoogleStyle());
9053 
9054   verifyFormat("return -1;");
9055   verifyFormat("throw -1;");
9056   verifyFormat("switch (a) {\n"
9057                "case -1:\n"
9058                "  break;\n"
9059                "}");
9060   verifyFormat("#define X -1");
9061   verifyFormat("#define X -kConstant");
9062 
9063   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {-5, +3};");
9064   verifyFormat("const NSPoint kBrowserFrameViewPatternOffset = {+5, -3};");
9065 
9066   verifyFormat("int a = /* confusing comment */ -1;");
9067   // FIXME: The space after 'i' is wrong, but hopefully, this is a rare case.
9068   verifyFormat("int a = i /* confusing comment */++;");
9069 
9070   verifyFormat("co_yield -1;");
9071   verifyFormat("co_return -1;");
9072 
9073   // Check that * is not treated as a binary operator when we set
9074   // PointerAlignment as PAS_Left after a keyword and not a declaration.
9075   FormatStyle PASLeftStyle = getLLVMStyle();
9076   PASLeftStyle.PointerAlignment = FormatStyle::PAS_Left;
9077   verifyFormat("co_return *a;", PASLeftStyle);
9078   verifyFormat("co_await *a;", PASLeftStyle);
9079   verifyFormat("co_yield *a", PASLeftStyle);
9080   verifyFormat("return *a;", PASLeftStyle);
9081 }
9082 
9083 TEST_F(FormatTest, DoesNotIndentRelativeToUnaryOperators) {
9084   verifyFormat("if (!aaaaaaaaaa( // break\n"
9085                "        aaaaa)) {\n"
9086                "}");
9087   verifyFormat("aaaaaaaaaa(!aaaaaaaaaa( // break\n"
9088                "    aaaaa));");
9089   verifyFormat("*aaa = aaaaaaa( // break\n"
9090                "    bbbbbb);");
9091 }
9092 
9093 TEST_F(FormatTest, UnderstandsOverloadedOperators) {
9094   verifyFormat("bool operator<();");
9095   verifyFormat("bool operator>();");
9096   verifyFormat("bool operator=();");
9097   verifyFormat("bool operator==();");
9098   verifyFormat("bool operator!=();");
9099   verifyFormat("int operator+();");
9100   verifyFormat("int operator++();");
9101   verifyFormat("int operator++(int) volatile noexcept;");
9102   verifyFormat("bool operator,();");
9103   verifyFormat("bool operator();");
9104   verifyFormat("bool operator()();");
9105   verifyFormat("bool operator[]();");
9106   verifyFormat("operator bool();");
9107   verifyFormat("operator int();");
9108   verifyFormat("operator void *();");
9109   verifyFormat("operator SomeType<int>();");
9110   verifyFormat("operator SomeType<int, int>();");
9111   verifyFormat("operator SomeType<SomeType<int>>();");
9112   verifyFormat("void *operator new(std::size_t size);");
9113   verifyFormat("void *operator new[](std::size_t size);");
9114   verifyFormat("void operator delete(void *ptr);");
9115   verifyFormat("void operator delete[](void *ptr);");
9116   verifyFormat("template <typename AAAAAAA, typename BBBBBBB>\n"
9117                "AAAAAAA operator/(const AAAAAAA &a, BBBBBBB &b);");
9118   verifyFormat("aaaaaaaaaaaaaaaaaaaaaa operator,(\n"
9119                "    aaaaaaaaaaaaaaaaaaaaa &aaaaaaaaaaaaaaaaaaaaaaaaaa) const;");
9120 
9121   verifyFormat(
9122       "ostream &operator<<(ostream &OutputStream,\n"
9123       "                    SomeReallyLongType WithSomeReallyLongValue);");
9124   verifyFormat("bool operator<(const aaaaaaaaaaaaaaaaaaaaa &left,\n"
9125                "               const aaaaaaaaaaaaaaaaaaaaa &right) {\n"
9126                "  return left.group < right.group;\n"
9127                "}");
9128   verifyFormat("SomeType &operator=(const SomeType &S);");
9129   verifyFormat("f.template operator()<int>();");
9130 
9131   verifyGoogleFormat("operator void*();");
9132   verifyGoogleFormat("operator SomeType<SomeType<int>>();");
9133   verifyGoogleFormat("operator ::A();");
9134 
9135   verifyFormat("using A::operator+;");
9136   verifyFormat("inline A operator^(const A &lhs, const A &rhs) {}\n"
9137                "int i;");
9138 
9139   // Calling an operator as a member function.
9140   verifyFormat("void f() { a.operator*(); }");
9141   verifyFormat("void f() { a.operator*(b & b); }");
9142   verifyFormat("void f() { a->operator&(a * b); }");
9143   verifyFormat("void f() { NS::a.operator+(*b * *b); }");
9144   // TODO: Calling an operator as a non-member function is hard to distinguish.
9145   // https://llvm.org/PR50629
9146   // verifyFormat("void f() { operator*(a & a); }");
9147   // verifyFormat("void f() { operator&(a, b * b); }");
9148 }
9149 
9150 TEST_F(FormatTest, UnderstandsFunctionRefQualification) {
9151   verifyFormat("Deleted &operator=(const Deleted &) & = default;");
9152   verifyFormat("Deleted &operator=(const Deleted &) && = delete;");
9153   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;");
9154   verifyFormat("SomeType MemberFunction(const Deleted &) && = delete;");
9155   verifyFormat("Deleted &operator=(const Deleted &) &;");
9156   verifyFormat("Deleted &operator=(const Deleted &) &&;");
9157   verifyFormat("SomeType MemberFunction(const Deleted &) &;");
9158   verifyFormat("SomeType MemberFunction(const Deleted &) &&;");
9159   verifyFormat("SomeType MemberFunction(const Deleted &) && {}");
9160   verifyFormat("SomeType MemberFunction(const Deleted &) && final {}");
9161   verifyFormat("SomeType MemberFunction(const Deleted &) && override {}");
9162   verifyFormat("void Fn(T const &) const &;");
9163   verifyFormat("void Fn(T const volatile &&) const volatile &&;");
9164   verifyFormat("template <typename T>\n"
9165                "void F(T) && = delete;",
9166                getGoogleStyle());
9167 
9168   FormatStyle AlignLeft = getLLVMStyle();
9169   AlignLeft.PointerAlignment = FormatStyle::PAS_Left;
9170   verifyFormat("void A::b() && {}", AlignLeft);
9171   verifyFormat("Deleted& operator=(const Deleted&) & = default;", AlignLeft);
9172   verifyFormat("SomeType MemberFunction(const Deleted&) & = delete;",
9173                AlignLeft);
9174   verifyFormat("Deleted& operator=(const Deleted&) &;", AlignLeft);
9175   verifyFormat("SomeType MemberFunction(const Deleted&) &;", AlignLeft);
9176   verifyFormat("auto Function(T t) & -> void {}", AlignLeft);
9177   verifyFormat("auto Function(T... t) & -> void {}", AlignLeft);
9178   verifyFormat("auto Function(T) & -> void {}", AlignLeft);
9179   verifyFormat("auto Function(T) & -> void;", AlignLeft);
9180   verifyFormat("void Fn(T const&) const&;", AlignLeft);
9181   verifyFormat("void Fn(T const volatile&&) const volatile&&;", AlignLeft);
9182 
9183   FormatStyle Spaces = getLLVMStyle();
9184   Spaces.SpacesInCStyleCastParentheses = true;
9185   verifyFormat("Deleted &operator=(const Deleted &) & = default;", Spaces);
9186   verifyFormat("SomeType MemberFunction(const Deleted &) & = delete;", Spaces);
9187   verifyFormat("Deleted &operator=(const Deleted &) &;", Spaces);
9188   verifyFormat("SomeType MemberFunction(const Deleted &) &;", Spaces);
9189 
9190   Spaces.SpacesInCStyleCastParentheses = false;
9191   Spaces.SpacesInParentheses = true;
9192   verifyFormat("Deleted &operator=( const Deleted & ) & = default;", Spaces);
9193   verifyFormat("SomeType MemberFunction( const Deleted & ) & = delete;",
9194                Spaces);
9195   verifyFormat("Deleted &operator=( const Deleted & ) &;", Spaces);
9196   verifyFormat("SomeType MemberFunction( const Deleted & ) &;", Spaces);
9197 
9198   FormatStyle BreakTemplate = getLLVMStyle();
9199   BreakTemplate.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
9200 
9201   verifyFormat("struct f {\n"
9202                "  template <class T>\n"
9203                "  int &foo(const std::string &str) &noexcept {}\n"
9204                "};",
9205                BreakTemplate);
9206 
9207   verifyFormat("struct f {\n"
9208                "  template <class T>\n"
9209                "  int &foo(const std::string &str) &&noexcept {}\n"
9210                "};",
9211                BreakTemplate);
9212 
9213   verifyFormat("struct f {\n"
9214                "  template <class T>\n"
9215                "  int &foo(const std::string &str) const &noexcept {}\n"
9216                "};",
9217                BreakTemplate);
9218 
9219   verifyFormat("struct f {\n"
9220                "  template <class T>\n"
9221                "  int &foo(const std::string &str) const &noexcept {}\n"
9222                "};",
9223                BreakTemplate);
9224 
9225   verifyFormat("struct f {\n"
9226                "  template <class T>\n"
9227                "  auto foo(const std::string &str) &&noexcept -> int & {}\n"
9228                "};",
9229                BreakTemplate);
9230 
9231   FormatStyle AlignLeftBreakTemplate = getLLVMStyle();
9232   AlignLeftBreakTemplate.AlwaysBreakTemplateDeclarations =
9233       FormatStyle::BTDS_Yes;
9234   AlignLeftBreakTemplate.PointerAlignment = FormatStyle::PAS_Left;
9235 
9236   verifyFormat("struct f {\n"
9237                "  template <class T>\n"
9238                "  int& foo(const std::string& str) & noexcept {}\n"
9239                "};",
9240                AlignLeftBreakTemplate);
9241 
9242   verifyFormat("struct f {\n"
9243                "  template <class T>\n"
9244                "  int& foo(const std::string& str) && noexcept {}\n"
9245                "};",
9246                AlignLeftBreakTemplate);
9247 
9248   verifyFormat("struct f {\n"
9249                "  template <class T>\n"
9250                "  int& foo(const std::string& str) const& noexcept {}\n"
9251                "};",
9252                AlignLeftBreakTemplate);
9253 
9254   verifyFormat("struct f {\n"
9255                "  template <class T>\n"
9256                "  int& foo(const std::string& str) const&& noexcept {}\n"
9257                "};",
9258                AlignLeftBreakTemplate);
9259 
9260   verifyFormat("struct f {\n"
9261                "  template <class T>\n"
9262                "  auto foo(const std::string& str) && noexcept -> int& {}\n"
9263                "};",
9264                AlignLeftBreakTemplate);
9265 
9266   // The `&` in `Type&` should not be confused with a trailing `&` of
9267   // DEPRECATED(reason) member function.
9268   verifyFormat("struct f {\n"
9269                "  template <class T>\n"
9270                "  DEPRECATED(reason)\n"
9271                "  Type &foo(arguments) {}\n"
9272                "};",
9273                BreakTemplate);
9274 
9275   verifyFormat("struct f {\n"
9276                "  template <class T>\n"
9277                "  DEPRECATED(reason)\n"
9278                "  Type& foo(arguments) {}\n"
9279                "};",
9280                AlignLeftBreakTemplate);
9281 
9282   verifyFormat("void (*foopt)(int) = &func;");
9283 }
9284 
9285 TEST_F(FormatTest, UnderstandsNewAndDelete) {
9286   verifyFormat("void f() {\n"
9287                "  A *a = new A;\n"
9288                "  A *a = new (placement) A;\n"
9289                "  delete a;\n"
9290                "  delete (A *)a;\n"
9291                "}");
9292   verifyFormat("new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
9293                "    typename aaaaaaaaaaaaaaaaaaaaaaaa();");
9294   verifyFormat("auto aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
9295                "    new (aaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaa))\n"
9296                "        typename aaaaaaaaaaaaaaaaaaaaaaaa();");
9297   verifyFormat("delete[] h->p;");
9298 }
9299 
9300 TEST_F(FormatTest, UnderstandsUsesOfStarAndAmp) {
9301   verifyFormat("int *f(int *a) {}");
9302   verifyFormat("int main(int argc, char **argv) {}");
9303   verifyFormat("Test::Test(int b) : a(b * b) {}");
9304   verifyIndependentOfContext("f(a, *a);");
9305   verifyFormat("void g() { f(*a); }");
9306   verifyIndependentOfContext("int a = b * 10;");
9307   verifyIndependentOfContext("int a = 10 * b;");
9308   verifyIndependentOfContext("int a = b * c;");
9309   verifyIndependentOfContext("int a += b * c;");
9310   verifyIndependentOfContext("int a -= b * c;");
9311   verifyIndependentOfContext("int a *= b * c;");
9312   verifyIndependentOfContext("int a /= b * c;");
9313   verifyIndependentOfContext("int a = *b;");
9314   verifyIndependentOfContext("int a = *b * c;");
9315   verifyIndependentOfContext("int a = b * *c;");
9316   verifyIndependentOfContext("int a = b * (10);");
9317   verifyIndependentOfContext("S << b * (10);");
9318   verifyIndependentOfContext("return 10 * b;");
9319   verifyIndependentOfContext("return *b * *c;");
9320   verifyIndependentOfContext("return a & ~b;");
9321   verifyIndependentOfContext("f(b ? *c : *d);");
9322   verifyIndependentOfContext("int a = b ? *c : *d;");
9323   verifyIndependentOfContext("*b = a;");
9324   verifyIndependentOfContext("a * ~b;");
9325   verifyIndependentOfContext("a * !b;");
9326   verifyIndependentOfContext("a * +b;");
9327   verifyIndependentOfContext("a * -b;");
9328   verifyIndependentOfContext("a * ++b;");
9329   verifyIndependentOfContext("a * --b;");
9330   verifyIndependentOfContext("a[4] * b;");
9331   verifyIndependentOfContext("a[a * a] = 1;");
9332   verifyIndependentOfContext("f() * b;");
9333   verifyIndependentOfContext("a * [self dostuff];");
9334   verifyIndependentOfContext("int x = a * (a + b);");
9335   verifyIndependentOfContext("(a *)(a + b);");
9336   verifyIndependentOfContext("*(int *)(p & ~3UL) = 0;");
9337   verifyIndependentOfContext("int *pa = (int *)&a;");
9338   verifyIndependentOfContext("return sizeof(int **);");
9339   verifyIndependentOfContext("return sizeof(int ******);");
9340   verifyIndependentOfContext("return (int **&)a;");
9341   verifyIndependentOfContext("f((*PointerToArray)[10]);");
9342   verifyFormat("void f(Type (*parameter)[10]) {}");
9343   verifyFormat("void f(Type (&parameter)[10]) {}");
9344   verifyGoogleFormat("return sizeof(int**);");
9345   verifyIndependentOfContext("Type **A = static_cast<Type **>(P);");
9346   verifyGoogleFormat("Type** A = static_cast<Type**>(P);");
9347   verifyFormat("auto a = [](int **&, int ***) {};");
9348   verifyFormat("auto PointerBinding = [](const char *S) {};");
9349   verifyFormat("typedef typeof(int(int, int)) *MyFunc;");
9350   verifyFormat("[](const decltype(*a) &value) {}");
9351   verifyFormat("[](const typeof(*a) &value) {}");
9352   verifyFormat("[](const _Atomic(a *) &value) {}");
9353   verifyFormat("[](const __underlying_type(a) &value) {}");
9354   verifyFormat("decltype(a * b) F();");
9355   verifyFormat("typeof(a * b) F();");
9356   verifyFormat("#define MACRO() [](A *a) { return 1; }");
9357   verifyFormat("Constructor() : member([](A *a, B *b) {}) {}");
9358   verifyIndependentOfContext("typedef void (*f)(int *a);");
9359   verifyIndependentOfContext("int i{a * b};");
9360   verifyIndependentOfContext("aaa && aaa->f();");
9361   verifyIndependentOfContext("int x = ~*p;");
9362   verifyFormat("Constructor() : a(a), area(width * height) {}");
9363   verifyFormat("Constructor() : a(a), area(a, width * height) {}");
9364   verifyGoogleFormat("MACRO Constructor(const int& i) : a(a), b(b) {}");
9365   verifyFormat("void f() { f(a, c * d); }");
9366   verifyFormat("void f() { f(new a(), c * d); }");
9367   verifyFormat("void f(const MyOverride &override);");
9368   verifyFormat("void f(const MyFinal &final);");
9369   verifyIndependentOfContext("bool a = f() && override.f();");
9370   verifyIndependentOfContext("bool a = f() && final.f();");
9371 
9372   verifyIndependentOfContext("InvalidRegions[*R] = 0;");
9373 
9374   verifyIndependentOfContext("A<int *> a;");
9375   verifyIndependentOfContext("A<int **> a;");
9376   verifyIndependentOfContext("A<int *, int *> a;");
9377   verifyIndependentOfContext("A<int *[]> a;");
9378   verifyIndependentOfContext(
9379       "const char *const p = reinterpret_cast<const char *const>(q);");
9380   verifyIndependentOfContext("A<int **, int **> a;");
9381   verifyIndependentOfContext("void f(int *a = d * e, int *b = c * d);");
9382   verifyFormat("for (char **a = b; *a; ++a) {\n}");
9383   verifyFormat("for (; a && b;) {\n}");
9384   verifyFormat("bool foo = true && [] { return false; }();");
9385 
9386   verifyFormat(
9387       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
9388       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaa, *aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
9389 
9390   verifyGoogleFormat("int const* a = &b;");
9391   verifyGoogleFormat("**outparam = 1;");
9392   verifyGoogleFormat("*outparam = a * b;");
9393   verifyGoogleFormat("int main(int argc, char** argv) {}");
9394   verifyGoogleFormat("A<int*> a;");
9395   verifyGoogleFormat("A<int**> a;");
9396   verifyGoogleFormat("A<int*, int*> a;");
9397   verifyGoogleFormat("A<int**, int**> a;");
9398   verifyGoogleFormat("f(b ? *c : *d);");
9399   verifyGoogleFormat("int a = b ? *c : *d;");
9400   verifyGoogleFormat("Type* t = **x;");
9401   verifyGoogleFormat("Type* t = *++*x;");
9402   verifyGoogleFormat("*++*x;");
9403   verifyGoogleFormat("Type* t = const_cast<T*>(&*x);");
9404   verifyGoogleFormat("Type* t = x++ * y;");
9405   verifyGoogleFormat(
9406       "const char* const p = reinterpret_cast<const char* const>(q);");
9407   verifyGoogleFormat("void f(int i = 0, SomeType** temps = NULL);");
9408   verifyGoogleFormat("void f(Bar* a = nullptr, Bar* b);");
9409   verifyGoogleFormat("template <typename T>\n"
9410                      "void f(int i = 0, SomeType** temps = NULL);");
9411 
9412   FormatStyle Left = getLLVMStyle();
9413   Left.PointerAlignment = FormatStyle::PAS_Left;
9414   verifyFormat("x = *a(x) = *a(y);", Left);
9415   verifyFormat("for (;; *a = b) {\n}", Left);
9416   verifyFormat("return *this += 1;", Left);
9417   verifyFormat("throw *x;", Left);
9418   verifyFormat("delete *x;", Left);
9419   verifyFormat("typedef typeof(int(int, int))* MyFuncPtr;", Left);
9420   verifyFormat("[](const decltype(*a)* ptr) {}", Left);
9421   verifyFormat("[](const typeof(*a)* ptr) {}", Left);
9422   verifyFormat("[](const _Atomic(a*)* ptr) {}", Left);
9423   verifyFormat("[](const __underlying_type(a)* ptr) {}", Left);
9424   verifyFormat("typedef typeof /*comment*/ (int(int, int))* MyFuncPtr;", Left);
9425   verifyFormat("auto x(A&&, B&&, C&&) -> D;", Left);
9426   verifyFormat("auto x = [](A&&, B&&, C&&) -> D {};", Left);
9427   verifyFormat("template <class T> X(T&&, T&&, T&&) -> X<T>;", Left);
9428 
9429   verifyIndependentOfContext("a = *(x + y);");
9430   verifyIndependentOfContext("a = &(x + y);");
9431   verifyIndependentOfContext("*(x + y).call();");
9432   verifyIndependentOfContext("&(x + y)->call();");
9433   verifyFormat("void f() { &(*I).first; }");
9434 
9435   verifyIndependentOfContext("f(b * /* confusing comment */ ++c);");
9436   verifyFormat(
9437       "int *MyValues = {\n"
9438       "    *A, // Operator detection might be confused by the '{'\n"
9439       "    *BB // Operator detection might be confused by previous comment\n"
9440       "};");
9441 
9442   verifyIndependentOfContext("if (int *a = &b)");
9443   verifyIndependentOfContext("if (int &a = *b)");
9444   verifyIndependentOfContext("if (a & b[i])");
9445   verifyIndependentOfContext("if constexpr (a & b[i])");
9446   verifyIndependentOfContext("if CONSTEXPR (a & b[i])");
9447   verifyIndependentOfContext("if (a * (b * c))");
9448   verifyIndependentOfContext("if constexpr (a * (b * c))");
9449   verifyIndependentOfContext("if CONSTEXPR (a * (b * c))");
9450   verifyIndependentOfContext("if (a::b::c::d & b[i])");
9451   verifyIndependentOfContext("if (*b[i])");
9452   verifyIndependentOfContext("if (int *a = (&b))");
9453   verifyIndependentOfContext("while (int *a = &b)");
9454   verifyIndependentOfContext("while (a * (b * c))");
9455   verifyIndependentOfContext("size = sizeof *a;");
9456   verifyIndependentOfContext("if (a && (b = c))");
9457   verifyFormat("void f() {\n"
9458                "  for (const int &v : Values) {\n"
9459                "  }\n"
9460                "}");
9461   verifyFormat("for (int i = a * a; i < 10; ++i) {\n}");
9462   verifyFormat("for (int i = 0; i < a * a; ++i) {\n}");
9463   verifyGoogleFormat("for (int i = 0; i * 2 < z; i *= 2) {\n}");
9464 
9465   verifyFormat("#define A (!a * b)");
9466   verifyFormat("#define MACRO     \\\n"
9467                "  int *i = a * b; \\\n"
9468                "  void f(a *b);",
9469                getLLVMStyleWithColumns(19));
9470 
9471   verifyIndependentOfContext("A = new SomeType *[Length];");
9472   verifyIndependentOfContext("A = new SomeType *[Length]();");
9473   verifyIndependentOfContext("T **t = new T *;");
9474   verifyIndependentOfContext("T **t = new T *();");
9475   verifyGoogleFormat("A = new SomeType*[Length]();");
9476   verifyGoogleFormat("A = new SomeType*[Length];");
9477   verifyGoogleFormat("T** t = new T*;");
9478   verifyGoogleFormat("T** t = new T*();");
9479 
9480   verifyFormat("STATIC_ASSERT((a & b) == 0);");
9481   verifyFormat("STATIC_ASSERT(0 == (a & b));");
9482   verifyFormat("template <bool a, bool b> "
9483                "typename t::if<x && y>::type f() {}");
9484   verifyFormat("template <int *y> f() {}");
9485   verifyFormat("vector<int *> v;");
9486   verifyFormat("vector<int *const> v;");
9487   verifyFormat("vector<int *const **const *> v;");
9488   verifyFormat("vector<int *volatile> v;");
9489   verifyFormat("vector<a *_Nonnull> v;");
9490   verifyFormat("vector<a *_Nullable> v;");
9491   verifyFormat("vector<a *_Null_unspecified> v;");
9492   verifyFormat("vector<a *__ptr32> v;");
9493   verifyFormat("vector<a *__ptr64> v;");
9494   verifyFormat("vector<a *__capability> v;");
9495   FormatStyle TypeMacros = getLLVMStyle();
9496   TypeMacros.TypenameMacros = {"LIST"};
9497   verifyFormat("vector<LIST(uint64_t)> v;", TypeMacros);
9498   verifyFormat("vector<LIST(uint64_t) *> v;", TypeMacros);
9499   verifyFormat("vector<LIST(uint64_t) **> v;", TypeMacros);
9500   verifyFormat("vector<LIST(uint64_t) *attr> v;", TypeMacros);
9501   verifyFormat("vector<A(uint64_t) * attr> v;", TypeMacros); // multiplication
9502 
9503   FormatStyle CustomQualifier = getLLVMStyle();
9504   // Add identifiers that should not be parsed as a qualifier by default.
9505   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
9506   CustomQualifier.AttributeMacros.push_back("_My_qualifier");
9507   CustomQualifier.AttributeMacros.push_back("my_other_qualifier");
9508   verifyFormat("vector<a * __my_qualifier> parse_as_multiply;");
9509   verifyFormat("vector<a *__my_qualifier> v;", CustomQualifier);
9510   verifyFormat("vector<a * _My_qualifier> parse_as_multiply;");
9511   verifyFormat("vector<a *_My_qualifier> v;", CustomQualifier);
9512   verifyFormat("vector<a * my_other_qualifier> parse_as_multiply;");
9513   verifyFormat("vector<a *my_other_qualifier> v;", CustomQualifier);
9514   verifyFormat("vector<a * _NotAQualifier> v;");
9515   verifyFormat("vector<a * __not_a_qualifier> v;");
9516   verifyFormat("vector<a * b> v;");
9517   verifyFormat("foo<b && false>();");
9518   verifyFormat("foo<b & 1>();");
9519   verifyFormat("decltype(*::std::declval<const T &>()) void F();");
9520   verifyFormat("typeof(*::std::declval<const T &>()) void F();");
9521   verifyFormat("_Atomic(*::std::declval<const T &>()) void F();");
9522   verifyFormat("__underlying_type(*::std::declval<const T &>()) void F();");
9523   verifyFormat(
9524       "template <class T, class = typename std::enable_if<\n"
9525       "                       std::is_integral<T>::value &&\n"
9526       "                       (sizeof(T) > 1 || sizeof(T) < 8)>::type>\n"
9527       "void F();",
9528       getLLVMStyleWithColumns(70));
9529   verifyFormat("template <class T,\n"
9530                "          class = typename std::enable_if<\n"
9531                "              std::is_integral<T>::value &&\n"
9532                "              (sizeof(T) > 1 || sizeof(T) < 8)>::type,\n"
9533                "          class U>\n"
9534                "void F();",
9535                getLLVMStyleWithColumns(70));
9536   verifyFormat(
9537       "template <class T,\n"
9538       "          class = typename ::std::enable_if<\n"
9539       "              ::std::is_array<T>{} && ::std::is_array<T>{}>::type>\n"
9540       "void F();",
9541       getGoogleStyleWithColumns(68));
9542 
9543   verifyIndependentOfContext("MACRO(int *i);");
9544   verifyIndependentOfContext("MACRO(auto *a);");
9545   verifyIndependentOfContext("MACRO(const A *a);");
9546   verifyIndependentOfContext("MACRO(_Atomic(A) *a);");
9547   verifyIndependentOfContext("MACRO(decltype(A) *a);");
9548   verifyIndependentOfContext("MACRO(typeof(A) *a);");
9549   verifyIndependentOfContext("MACRO(__underlying_type(A) *a);");
9550   verifyIndependentOfContext("MACRO(A *const a);");
9551   verifyIndependentOfContext("MACRO(A *restrict a);");
9552   verifyIndependentOfContext("MACRO(A *__restrict__ a);");
9553   verifyIndependentOfContext("MACRO(A *__restrict a);");
9554   verifyIndependentOfContext("MACRO(A *volatile a);");
9555   verifyIndependentOfContext("MACRO(A *__volatile a);");
9556   verifyIndependentOfContext("MACRO(A *__volatile__ a);");
9557   verifyIndependentOfContext("MACRO(A *_Nonnull a);");
9558   verifyIndependentOfContext("MACRO(A *_Nullable a);");
9559   verifyIndependentOfContext("MACRO(A *_Null_unspecified a);");
9560   verifyIndependentOfContext("MACRO(A *__attribute__((foo)) a);");
9561   verifyIndependentOfContext("MACRO(A *__attribute((foo)) a);");
9562   verifyIndependentOfContext("MACRO(A *[[clang::attr]] a);");
9563   verifyIndependentOfContext("MACRO(A *[[clang::attr(\"foo\")]] a);");
9564   verifyIndependentOfContext("MACRO(A *__ptr32 a);");
9565   verifyIndependentOfContext("MACRO(A *__ptr64 a);");
9566   verifyIndependentOfContext("MACRO(A *__capability);");
9567   verifyIndependentOfContext("MACRO(A &__capability);");
9568   verifyFormat("MACRO(A *__my_qualifier);");               // type declaration
9569   verifyFormat("void f() { MACRO(A * __my_qualifier); }"); // multiplication
9570   // If we add __my_qualifier to AttributeMacros it should always be parsed as
9571   // a type declaration:
9572   verifyFormat("MACRO(A *__my_qualifier);", CustomQualifier);
9573   verifyFormat("void f() { MACRO(A *__my_qualifier); }", CustomQualifier);
9574   // Also check that TypenameMacros prevents parsing it as multiplication:
9575   verifyIndependentOfContext("MACRO(LIST(uint64_t) * a);"); // multiplication
9576   verifyIndependentOfContext("MACRO(LIST(uint64_t) *a);", TypeMacros); // type
9577 
9578   verifyIndependentOfContext("MACRO('0' <= c && c <= '9');");
9579   verifyFormat("void f() { f(float{1}, a * a); }");
9580   verifyFormat("void f() { f(float(1), a * a); }");
9581 
9582   verifyFormat("f((void (*)(int))g);");
9583   verifyFormat("f((void (&)(int))g);");
9584   verifyFormat("f((void (^)(int))g);");
9585 
9586   // FIXME: Is there a way to make this work?
9587   // verifyIndependentOfContext("MACRO(A *a);");
9588   verifyFormat("MACRO(A &B);");
9589   verifyFormat("MACRO(A *B);");
9590   verifyFormat("void f() { MACRO(A * B); }");
9591   verifyFormat("void f() { MACRO(A & B); }");
9592 
9593   // This lambda was mis-formatted after D88956 (treating it as a binop):
9594   verifyFormat("auto x = [](const decltype(x) &ptr) {};");
9595   verifyFormat("auto x = [](const decltype(x) *ptr) {};");
9596   verifyFormat("#define lambda [](const decltype(x) &ptr) {}");
9597   verifyFormat("#define lambda [](const decltype(x) *ptr) {}");
9598 
9599   verifyFormat("DatumHandle const *operator->() const { return input_; }");
9600   verifyFormat("return options != nullptr && operator==(*options);");
9601 
9602   EXPECT_EQ("#define OP(x)                                    \\\n"
9603             "  ostream &operator<<(ostream &s, const A &a) {  \\\n"
9604             "    return s << a.DebugString();                 \\\n"
9605             "  }",
9606             format("#define OP(x) \\\n"
9607                    "  ostream &operator<<(ostream &s, const A &a) { \\\n"
9608                    "    return s << a.DebugString(); \\\n"
9609                    "  }",
9610                    getLLVMStyleWithColumns(50)));
9611 
9612   // FIXME: We cannot handle this case yet; we might be able to figure out that
9613   // foo<x> d > v; doesn't make sense.
9614   verifyFormat("foo<a<b && c> d> v;");
9615 
9616   FormatStyle PointerMiddle = getLLVMStyle();
9617   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
9618   verifyFormat("delete *x;", PointerMiddle);
9619   verifyFormat("int * x;", PointerMiddle);
9620   verifyFormat("int *[] x;", PointerMiddle);
9621   verifyFormat("template <int * y> f() {}", PointerMiddle);
9622   verifyFormat("int * f(int * a) {}", PointerMiddle);
9623   verifyFormat("int main(int argc, char ** argv) {}", PointerMiddle);
9624   verifyFormat("Test::Test(int b) : a(b * b) {}", PointerMiddle);
9625   verifyFormat("A<int *> a;", PointerMiddle);
9626   verifyFormat("A<int **> a;", PointerMiddle);
9627   verifyFormat("A<int *, int *> a;", PointerMiddle);
9628   verifyFormat("A<int *[]> a;", PointerMiddle);
9629   verifyFormat("A = new SomeType *[Length]();", PointerMiddle);
9630   verifyFormat("A = new SomeType *[Length];", PointerMiddle);
9631   verifyFormat("T ** t = new T *;", PointerMiddle);
9632 
9633   // Member function reference qualifiers aren't binary operators.
9634   verifyFormat("string // break\n"
9635                "operator()() & {}");
9636   verifyFormat("string // break\n"
9637                "operator()() && {}");
9638   verifyGoogleFormat("template <typename T>\n"
9639                      "auto x() & -> int {}");
9640 
9641   // Should be binary operators when used as an argument expression (overloaded
9642   // operator invoked as a member function).
9643   verifyFormat("void f() { a.operator()(a * a); }");
9644   verifyFormat("void f() { a->operator()(a & a); }");
9645   verifyFormat("void f() { a.operator()(*a & *a); }");
9646   verifyFormat("void f() { a->operator()(*a * *a); }");
9647 }
9648 
9649 TEST_F(FormatTest, UnderstandsAttributes) {
9650   verifyFormat("SomeType s __attribute__((unused)) (InitValue);");
9651   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa __attribute__((unused))\n"
9652                "aaaaaaaaaaaaaaaaaaaaaaa(int i);");
9653   FormatStyle AfterType = getLLVMStyle();
9654   AfterType.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
9655   verifyFormat("__attribute__((nodebug)) void\n"
9656                "foo() {}\n",
9657                AfterType);
9658   verifyFormat("__unused void\n"
9659                "foo() {}",
9660                AfterType);
9661 
9662   FormatStyle CustomAttrs = getLLVMStyle();
9663   CustomAttrs.AttributeMacros.push_back("__unused");
9664   CustomAttrs.AttributeMacros.push_back("__attr1");
9665   CustomAttrs.AttributeMacros.push_back("__attr2");
9666   CustomAttrs.AttributeMacros.push_back("no_underscore_attr");
9667   verifyFormat("vector<SomeType *__attribute((foo))> v;");
9668   verifyFormat("vector<SomeType *__attribute__((foo))> v;");
9669   verifyFormat("vector<SomeType * __not_attribute__((foo))> v;");
9670   // Check that it is parsed as a multiplication without AttributeMacros and
9671   // as a pointer qualifier when we add __attr1/__attr2 to AttributeMacros.
9672   verifyFormat("vector<SomeType * __attr1> v;");
9673   verifyFormat("vector<SomeType __attr1 *> v;");
9674   verifyFormat("vector<SomeType __attr1 *const> v;");
9675   verifyFormat("vector<SomeType __attr1 * __attr2> v;");
9676   verifyFormat("vector<SomeType *__attr1> v;", CustomAttrs);
9677   verifyFormat("vector<SomeType *__attr2> v;", CustomAttrs);
9678   verifyFormat("vector<SomeType *no_underscore_attr> v;", CustomAttrs);
9679   verifyFormat("vector<SomeType __attr1 *> v;", CustomAttrs);
9680   verifyFormat("vector<SomeType __attr1 *const> v;", CustomAttrs);
9681   verifyFormat("vector<SomeType __attr1 *__attr2> v;", CustomAttrs);
9682   verifyFormat("vector<SomeType __attr1 *no_underscore_attr> v;", CustomAttrs);
9683 
9684   // Check that these are not parsed as function declarations:
9685   CustomAttrs.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9686   CustomAttrs.BreakBeforeBraces = FormatStyle::BS_Allman;
9687   verifyFormat("SomeType s(InitValue);", CustomAttrs);
9688   verifyFormat("SomeType s{InitValue};", CustomAttrs);
9689   verifyFormat("SomeType *__unused s(InitValue);", CustomAttrs);
9690   verifyFormat("SomeType *__unused s{InitValue};", CustomAttrs);
9691   verifyFormat("SomeType s __unused(InitValue);", CustomAttrs);
9692   verifyFormat("SomeType s __unused{InitValue};", CustomAttrs);
9693   verifyFormat("SomeType *__capability s(InitValue);", CustomAttrs);
9694   verifyFormat("SomeType *__capability s{InitValue};", CustomAttrs);
9695 }
9696 
9697 TEST_F(FormatTest, UnderstandsPointerQualifiersInCast) {
9698   // Check that qualifiers on pointers don't break parsing of casts.
9699   verifyFormat("x = (foo *const)*v;");
9700   verifyFormat("x = (foo *volatile)*v;");
9701   verifyFormat("x = (foo *restrict)*v;");
9702   verifyFormat("x = (foo *__attribute__((foo)))*v;");
9703   verifyFormat("x = (foo *_Nonnull)*v;");
9704   verifyFormat("x = (foo *_Nullable)*v;");
9705   verifyFormat("x = (foo *_Null_unspecified)*v;");
9706   verifyFormat("x = (foo *_Nonnull)*v;");
9707   verifyFormat("x = (foo *[[clang::attr]])*v;");
9708   verifyFormat("x = (foo *[[clang::attr(\"foo\")]])*v;");
9709   verifyFormat("x = (foo *__ptr32)*v;");
9710   verifyFormat("x = (foo *__ptr64)*v;");
9711   verifyFormat("x = (foo *__capability)*v;");
9712 
9713   // Check that we handle multiple trailing qualifiers and skip them all to
9714   // determine that the expression is a cast to a pointer type.
9715   FormatStyle LongPointerRight = getLLVMStyleWithColumns(999);
9716   FormatStyle LongPointerLeft = getLLVMStyleWithColumns(999);
9717   LongPointerLeft.PointerAlignment = FormatStyle::PAS_Left;
9718   StringRef AllQualifiers =
9719       "const volatile restrict __attribute__((foo)) _Nonnull _Null_unspecified "
9720       "_Nonnull [[clang::attr]] __ptr32 __ptr64 __capability";
9721   verifyFormat(("x = (foo *" + AllQualifiers + ")*v;").str(), LongPointerRight);
9722   verifyFormat(("x = (foo* " + AllQualifiers + ")*v;").str(), LongPointerLeft);
9723 
9724   // Also check that address-of is not parsed as a binary bitwise-and:
9725   verifyFormat("x = (foo *const)&v;");
9726   verifyFormat(("x = (foo *" + AllQualifiers + ")&v;").str(), LongPointerRight);
9727   verifyFormat(("x = (foo* " + AllQualifiers + ")&v;").str(), LongPointerLeft);
9728 
9729   // Check custom qualifiers:
9730   FormatStyle CustomQualifier = getLLVMStyleWithColumns(999);
9731   CustomQualifier.AttributeMacros.push_back("__my_qualifier");
9732   verifyFormat("x = (foo * __my_qualifier) * v;"); // not parsed as qualifier.
9733   verifyFormat("x = (foo *__my_qualifier)*v;", CustomQualifier);
9734   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)*v;").str(),
9735                CustomQualifier);
9736   verifyFormat(("x = (foo *" + AllQualifiers + " __my_qualifier)&v;").str(),
9737                CustomQualifier);
9738 
9739   // Check that unknown identifiers result in binary operator parsing:
9740   verifyFormat("x = (foo * __unknown_qualifier) * v;");
9741   verifyFormat("x = (foo * __unknown_qualifier) & v;");
9742 }
9743 
9744 TEST_F(FormatTest, UnderstandsSquareAttributes) {
9745   verifyFormat("SomeType s [[unused]] (InitValue);");
9746   verifyFormat("SomeType s [[gnu::unused]] (InitValue);");
9747   verifyFormat("SomeType s [[using gnu: unused]] (InitValue);");
9748   verifyFormat("[[gsl::suppress(\"clang-tidy-check-name\")]] void f() {}");
9749   verifyFormat("void f() [[deprecated(\"so sorry\")]];");
9750   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
9751                "    [[unused]] aaaaaaaaaaaaaaaaaaaaaaa(int i);");
9752   verifyFormat("[[nodiscard]] bool f() { return false; }");
9753   verifyFormat("class [[nodiscard]] f {\npublic:\n  f() {}\n}");
9754   verifyFormat("class [[deprecated(\"so sorry\")]] f {\npublic:\n  f() {}\n}");
9755   verifyFormat("class [[gnu::unused]] f {\npublic:\n  f() {}\n}");
9756 
9757   // Make sure we do not mistake attributes for array subscripts.
9758   verifyFormat("int a() {}\n"
9759                "[[unused]] int b() {}\n");
9760   verifyFormat("NSArray *arr;\n"
9761                "arr[[Foo() bar]];");
9762 
9763   // On the other hand, we still need to correctly find array subscripts.
9764   verifyFormat("int a = std::vector<int>{1, 2, 3}[0];");
9765 
9766   // Make sure that we do not mistake Objective-C method inside array literals
9767   // as attributes, even if those method names are also keywords.
9768   verifyFormat("@[ [foo bar] ];");
9769   verifyFormat("@[ [NSArray class] ];");
9770   verifyFormat("@[ [foo enum] ];");
9771 
9772   verifyFormat("template <typename T> [[nodiscard]] int a() { return 1; }");
9773 
9774   // Make sure we do not parse attributes as lambda introducers.
9775   FormatStyle MultiLineFunctions = getLLVMStyle();
9776   MultiLineFunctions.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
9777   verifyFormat("[[unused]] int b() {\n"
9778                "  return 42;\n"
9779                "}\n",
9780                MultiLineFunctions);
9781 }
9782 
9783 TEST_F(FormatTest, AttributeClass) {
9784   FormatStyle Style = getChromiumStyle(FormatStyle::LK_Cpp);
9785   verifyFormat("class S {\n"
9786                "  S(S&&) = default;\n"
9787                "};",
9788                Style);
9789   verifyFormat("class [[nodiscard]] S {\n"
9790                "  S(S&&) = default;\n"
9791                "};",
9792                Style);
9793   verifyFormat("class __attribute((maybeunused)) S {\n"
9794                "  S(S&&) = default;\n"
9795                "};",
9796                Style);
9797   verifyFormat("struct S {\n"
9798                "  S(S&&) = default;\n"
9799                "};",
9800                Style);
9801   verifyFormat("struct [[nodiscard]] S {\n"
9802                "  S(S&&) = default;\n"
9803                "};",
9804                Style);
9805 }
9806 
9807 TEST_F(FormatTest, AttributesAfterMacro) {
9808   FormatStyle Style = getLLVMStyle();
9809   verifyFormat("MACRO;\n"
9810                "__attribute__((maybe_unused)) int foo() {\n"
9811                "  //...\n"
9812                "}");
9813 
9814   verifyFormat("MACRO;\n"
9815                "[[nodiscard]] int foo() {\n"
9816                "  //...\n"
9817                "}");
9818 
9819   EXPECT_EQ("MACRO\n\n"
9820             "__attribute__((maybe_unused)) int foo() {\n"
9821             "  //...\n"
9822             "}",
9823             format("MACRO\n\n"
9824                    "__attribute__((maybe_unused)) int foo() {\n"
9825                    "  //...\n"
9826                    "}"));
9827 
9828   EXPECT_EQ("MACRO\n\n"
9829             "[[nodiscard]] int foo() {\n"
9830             "  //...\n"
9831             "}",
9832             format("MACRO\n\n"
9833                    "[[nodiscard]] int foo() {\n"
9834                    "  //...\n"
9835                    "}"));
9836 }
9837 
9838 TEST_F(FormatTest, AttributePenaltyBreaking) {
9839   FormatStyle Style = getLLVMStyle();
9840   verifyFormat("void ABCDEFGH::ABCDEFGHIJKLMN(\n"
9841                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
9842                Style);
9843   verifyFormat("void ABCDEFGH::ABCDEFGHIJK(\n"
9844                "    [[maybe_unused]] const shared_ptr<ALongTypeName> &C d) {}",
9845                Style);
9846   verifyFormat("void ABCDEFGH::ABCDEFGH([[maybe_unused]] const "
9847                "shared_ptr<ALongTypeName> &C d) {\n}",
9848                Style);
9849 }
9850 
9851 TEST_F(FormatTest, UnderstandsEllipsis) {
9852   FormatStyle Style = getLLVMStyle();
9853   verifyFormat("int printf(const char *fmt, ...);");
9854   verifyFormat("template <class... Ts> void Foo(Ts... ts) { Foo(ts...); }");
9855   verifyFormat("template <class... Ts> void Foo(Ts *...ts) {}");
9856 
9857   verifyFormat("template <int *...PP> a;", Style);
9858 
9859   Style.PointerAlignment = FormatStyle::PAS_Left;
9860   verifyFormat("template <class... Ts> void Foo(Ts*... ts) {}", Style);
9861 
9862   verifyFormat("template <int*... PP> a;", Style);
9863 
9864   Style.PointerAlignment = FormatStyle::PAS_Middle;
9865   verifyFormat("template <int *... PP> a;", Style);
9866 }
9867 
9868 TEST_F(FormatTest, AdaptivelyFormatsPointersAndReferences) {
9869   EXPECT_EQ("int *a;\n"
9870             "int *a;\n"
9871             "int *a;",
9872             format("int *a;\n"
9873                    "int* a;\n"
9874                    "int *a;",
9875                    getGoogleStyle()));
9876   EXPECT_EQ("int* a;\n"
9877             "int* a;\n"
9878             "int* a;",
9879             format("int* a;\n"
9880                    "int* a;\n"
9881                    "int *a;",
9882                    getGoogleStyle()));
9883   EXPECT_EQ("int *a;\n"
9884             "int *a;\n"
9885             "int *a;",
9886             format("int *a;\n"
9887                    "int * a;\n"
9888                    "int *  a;",
9889                    getGoogleStyle()));
9890   EXPECT_EQ("auto x = [] {\n"
9891             "  int *a;\n"
9892             "  int *a;\n"
9893             "  int *a;\n"
9894             "};",
9895             format("auto x=[]{int *a;\n"
9896                    "int * a;\n"
9897                    "int *  a;};",
9898                    getGoogleStyle()));
9899 }
9900 
9901 TEST_F(FormatTest, UnderstandsRvalueReferences) {
9902   verifyFormat("int f(int &&a) {}");
9903   verifyFormat("int f(int a, char &&b) {}");
9904   verifyFormat("void f() { int &&a = b; }");
9905   verifyGoogleFormat("int f(int a, char&& b) {}");
9906   verifyGoogleFormat("void f() { int&& a = b; }");
9907 
9908   verifyIndependentOfContext("A<int &&> a;");
9909   verifyIndependentOfContext("A<int &&, int &&> a;");
9910   verifyGoogleFormat("A<int&&> a;");
9911   verifyGoogleFormat("A<int&&, int&&> a;");
9912 
9913   // Not rvalue references:
9914   verifyFormat("template <bool B, bool C> class A {\n"
9915                "  static_assert(B && C, \"Something is wrong\");\n"
9916                "};");
9917   verifyGoogleFormat("#define IF(a, b, c) if (a && (b == c))");
9918   verifyGoogleFormat("#define WHILE(a, b, c) while (a && (b == c))");
9919   verifyFormat("#define A(a, b) (a && b)");
9920 }
9921 
9922 TEST_F(FormatTest, FormatsBinaryOperatorsPrecedingEquals) {
9923   verifyFormat("void f() {\n"
9924                "  x[aaaaaaaaa -\n"
9925                "    b] = 23;\n"
9926                "}",
9927                getLLVMStyleWithColumns(15));
9928 }
9929 
9930 TEST_F(FormatTest, FormatsCasts) {
9931   verifyFormat("Type *A = static_cast<Type *>(P);");
9932   verifyFormat("Type *A = (Type *)P;");
9933   verifyFormat("Type *A = (vector<Type *, int *>)P;");
9934   verifyFormat("int a = (int)(2.0f);");
9935   verifyFormat("int a = (int)2.0f;");
9936   verifyFormat("x[(int32)y];");
9937   verifyFormat("x = (int32)y;");
9938   verifyFormat("#define AA(X) sizeof(((X *)NULL)->a)");
9939   verifyFormat("int a = (int)*b;");
9940   verifyFormat("int a = (int)2.0f;");
9941   verifyFormat("int a = (int)~0;");
9942   verifyFormat("int a = (int)++a;");
9943   verifyFormat("int a = (int)sizeof(int);");
9944   verifyFormat("int a = (int)+2;");
9945   verifyFormat("my_int a = (my_int)2.0f;");
9946   verifyFormat("my_int a = (my_int)sizeof(int);");
9947   verifyFormat("return (my_int)aaa;");
9948   verifyFormat("#define x ((int)-1)");
9949   verifyFormat("#define LENGTH(x, y) (x) - (y) + 1");
9950   verifyFormat("#define p(q) ((int *)&q)");
9951   verifyFormat("fn(a)(b) + 1;");
9952 
9953   verifyFormat("void f() { my_int a = (my_int)*b; }");
9954   verifyFormat("void f() { return P ? (my_int)*P : (my_int)0; }");
9955   verifyFormat("my_int a = (my_int)~0;");
9956   verifyFormat("my_int a = (my_int)++a;");
9957   verifyFormat("my_int a = (my_int)-2;");
9958   verifyFormat("my_int a = (my_int)1;");
9959   verifyFormat("my_int a = (my_int *)1;");
9960   verifyFormat("my_int a = (const my_int)-1;");
9961   verifyFormat("my_int a = (const my_int *)-1;");
9962   verifyFormat("my_int a = (my_int)(my_int)-1;");
9963   verifyFormat("my_int a = (ns::my_int)-2;");
9964   verifyFormat("case (my_int)ONE:");
9965   verifyFormat("auto x = (X)this;");
9966   // Casts in Obj-C style calls used to not be recognized as such.
9967   verifyFormat("int a = [(type*)[((type*)val) arg] arg];", getGoogleStyle());
9968 
9969   // FIXME: single value wrapped with paren will be treated as cast.
9970   verifyFormat("void f(int i = (kValue)*kMask) {}");
9971 
9972   verifyFormat("{ (void)F; }");
9973 
9974   // Don't break after a cast's
9975   verifyFormat("int aaaaaaaaaaaaaaaaaaaaaaaaaaa =\n"
9976                "    (aaaaaaaaaaaaaaaaaaaaaaaaaa *)(aaaaaaaaaaaaaaaaaaaaaa +\n"
9977                "                                   bbbbbbbbbbbbbbbbbbbbbb);");
9978 
9979   // These are not casts.
9980   verifyFormat("void f(int *) {}");
9981   verifyFormat("f(foo)->b;");
9982   verifyFormat("f(foo).b;");
9983   verifyFormat("f(foo)(b);");
9984   verifyFormat("f(foo)[b];");
9985   verifyFormat("[](foo) { return 4; }(bar);");
9986   verifyFormat("(*funptr)(foo)[4];");
9987   verifyFormat("funptrs[4](foo)[4];");
9988   verifyFormat("void f(int *);");
9989   verifyFormat("void f(int *) = 0;");
9990   verifyFormat("void f(SmallVector<int>) {}");
9991   verifyFormat("void f(SmallVector<int>);");
9992   verifyFormat("void f(SmallVector<int>) = 0;");
9993   verifyFormat("void f(int i = (kA * kB) & kMask) {}");
9994   verifyFormat("int a = sizeof(int) * b;");
9995   verifyFormat("int a = alignof(int) * b;", getGoogleStyle());
9996   verifyFormat("template <> void f<int>(int i) SOME_ANNOTATION;");
9997   verifyFormat("f(\"%\" SOME_MACRO(ll) \"d\");");
9998   verifyFormat("aaaaa &operator=(const aaaaa &) LLVM_DELETED_FUNCTION;");
9999 
10000   // These are not casts, but at some point were confused with casts.
10001   verifyFormat("virtual void foo(int *) override;");
10002   verifyFormat("virtual void foo(char &) const;");
10003   verifyFormat("virtual void foo(int *a, char *) const;");
10004   verifyFormat("int a = sizeof(int *) + b;");
10005   verifyFormat("int a = alignof(int *) + b;", getGoogleStyle());
10006   verifyFormat("bool b = f(g<int>) && c;");
10007   verifyFormat("typedef void (*f)(int i) func;");
10008   verifyFormat("void operator++(int) noexcept;");
10009   verifyFormat("void operator++(int &) noexcept;");
10010   verifyFormat("void operator delete(void *, std::size_t, const std::nothrow_t "
10011                "&) noexcept;");
10012   verifyFormat(
10013       "void operator delete(std::size_t, const std::nothrow_t &) noexcept;");
10014   verifyFormat("void operator delete(const std::nothrow_t &) noexcept;");
10015   verifyFormat("void operator delete(std::nothrow_t &) noexcept;");
10016   verifyFormat("void operator delete(nothrow_t &) noexcept;");
10017   verifyFormat("void operator delete(foo &) noexcept;");
10018   verifyFormat("void operator delete(foo) noexcept;");
10019   verifyFormat("void operator delete(int) noexcept;");
10020   verifyFormat("void operator delete(int &) noexcept;");
10021   verifyFormat("void operator delete(int &) volatile noexcept;");
10022   verifyFormat("void operator delete(int &) const");
10023   verifyFormat("void operator delete(int &) = default");
10024   verifyFormat("void operator delete(int &) = delete");
10025   verifyFormat("void operator delete(int &) [[noreturn]]");
10026   verifyFormat("void operator delete(int &) throw();");
10027   verifyFormat("void operator delete(int &) throw(int);");
10028   verifyFormat("auto operator delete(int &) -> int;");
10029   verifyFormat("auto operator delete(int &) override");
10030   verifyFormat("auto operator delete(int &) final");
10031 
10032   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa *foo = (aaaaaaaaaaaaaaaaa *)\n"
10033                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;");
10034   // FIXME: The indentation here is not ideal.
10035   verifyFormat(
10036       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10037       "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = (*cccccccccccccccc)\n"
10038       "        [dddddddddddddddddddddddddddddddddddddddddddddddddddddddd];");
10039 }
10040 
10041 TEST_F(FormatTest, FormatsFunctionTypes) {
10042   verifyFormat("A<bool()> a;");
10043   verifyFormat("A<SomeType()> a;");
10044   verifyFormat("A<void (*)(int, std::string)> a;");
10045   verifyFormat("A<void *(int)>;");
10046   verifyFormat("void *(*a)(int *, SomeType *);");
10047   verifyFormat("int (*func)(void *);");
10048   verifyFormat("void f() { int (*func)(void *); }");
10049   verifyFormat("template <class CallbackClass>\n"
10050                "using MyCallback = void (CallbackClass::*)(SomeObject *Data);");
10051 
10052   verifyGoogleFormat("A<void*(int*, SomeType*)>;");
10053   verifyGoogleFormat("void* (*a)(int);");
10054   verifyGoogleFormat(
10055       "template <class CallbackClass>\n"
10056       "using MyCallback = void (CallbackClass::*)(SomeObject* Data);");
10057 
10058   // Other constructs can look somewhat like function types:
10059   verifyFormat("A<sizeof(*x)> a;");
10060   verifyFormat("#define DEREF_AND_CALL_F(x) f(*x)");
10061   verifyFormat("some_var = function(*some_pointer_var)[0];");
10062   verifyFormat("void f() { function(*some_pointer_var)[0] = 10; }");
10063   verifyFormat("int x = f(&h)();");
10064   verifyFormat("returnsFunction(&param1, &param2)(param);");
10065   verifyFormat("std::function<\n"
10066                "    LooooooooooongTemplatedType<\n"
10067                "        SomeType>*(\n"
10068                "        LooooooooooooooooongType type)>\n"
10069                "    function;",
10070                getGoogleStyleWithColumns(40));
10071 }
10072 
10073 TEST_F(FormatTest, FormatsPointersToArrayTypes) {
10074   verifyFormat("A (*foo_)[6];");
10075   verifyFormat("vector<int> (*foo_)[6];");
10076 }
10077 
10078 TEST_F(FormatTest, BreaksLongVariableDeclarations) {
10079   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
10080                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
10081   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType const\n"
10082                "    LoooooooooooooooooooooooooooooooooooooooongVariable;");
10083   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
10084                "    *LoooooooooooooooooooooooooooooooooooooooongVariable;");
10085 
10086   // Different ways of ()-initializiation.
10087   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
10088                "    LoooooooooooooooooooooooooooooooooooooooongVariable(1);");
10089   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
10090                "    LoooooooooooooooooooooooooooooooooooooooongVariable(a);");
10091   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
10092                "    LoooooooooooooooooooooooooooooooooooooooongVariable({});");
10093   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType\n"
10094                "    LoooooooooooooooooooooooooooooooooooooongVariable([A a]);");
10095 
10096   // Lambdas should not confuse the variable declaration heuristic.
10097   verifyFormat("LooooooooooooooooongType\n"
10098                "    variable(nullptr, [](A *a) {});",
10099                getLLVMStyleWithColumns(40));
10100 }
10101 
10102 TEST_F(FormatTest, BreaksLongDeclarations) {
10103   verifyFormat("typedef LoooooooooooooooooooooooooooooooooooooooongType\n"
10104                "    AnotherNameForTheLongType;");
10105   verifyFormat("typedef LongTemplateType<aaaaaaaaaaaaaaaaaaa()>\n"
10106                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
10107   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
10108                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
10109   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType *\n"
10110                "LoooooooooooooooooooooooooooooooongFunctionDeclaration();");
10111   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
10112                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
10113   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType MACRO\n"
10114                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
10115   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
10116                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
10117   verifyFormat("decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
10118                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
10119   verifyFormat("typeof(LoooooooooooooooooooooooooooooooooooooooooongName)\n"
10120                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
10121   verifyFormat("_Atomic(LooooooooooooooooooooooooooooooooooooooooongName)\n"
10122                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
10123   verifyFormat("__underlying_type(LooooooooooooooooooooooooooooooongName)\n"
10124                "LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}");
10125   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
10126                "LooooooooooooooooooooooooooongFunctionDeclaration(T... t);");
10127   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
10128                "LooooooooooooooooooooooooooongFunctionDeclaration(T /*t*/) {}");
10129   FormatStyle Indented = getLLVMStyle();
10130   Indented.IndentWrappedFunctionNames = true;
10131   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
10132                "    LoooooooooooooooooooooooooooooooongFunctionDeclaration();",
10133                Indented);
10134   verifyFormat(
10135       "LoooooooooooooooooooooooooooooooooooooooongReturnType\n"
10136       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
10137       Indented);
10138   verifyFormat(
10139       "LoooooooooooooooooooooooooooooooooooooooongReturnType const\n"
10140       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
10141       Indented);
10142   verifyFormat(
10143       "decltype(LoooooooooooooooooooooooooooooooooooooooongName)\n"
10144       "    LooooooooooooooooooooooooooooooooooongFunctionDefinition() {}",
10145       Indented);
10146 
10147   // FIXME: Without the comment, this breaks after "(".
10148   verifyFormat("LoooooooooooooooooooooooooooooooooooooooongType  // break\n"
10149                "    (*LoooooooooooooooooooooooooooongFunctionTypeVarialbe)();",
10150                getGoogleStyle());
10151 
10152   verifyFormat("int *someFunction(int LoooooooooooooooooooongParam1,\n"
10153                "                  int LoooooooooooooooooooongParam2) {}");
10154   verifyFormat(
10155       "TypeSpecDecl *TypeSpecDecl::Create(ASTContext &C, DeclContext *DC,\n"
10156       "                                   SourceLocation L, IdentifierIn *II,\n"
10157       "                                   Type *T) {}");
10158   verifyFormat("ReallyLongReturnType<TemplateParam1, TemplateParam2>\n"
10159                "ReallyReaaallyLongFunctionName(\n"
10160                "    const std::string &SomeParameter,\n"
10161                "    const SomeType<string, SomeOtherTemplateParameter>\n"
10162                "        &ReallyReallyLongParameterName,\n"
10163                "    const SomeType<string, SomeOtherTemplateParameter>\n"
10164                "        &AnotherLongParameterName) {}");
10165   verifyFormat("template <typename A>\n"
10166                "SomeLoooooooooooooooooooooongType<\n"
10167                "    typename some_namespace::SomeOtherType<A>::Type>\n"
10168                "Function() {}");
10169 
10170   verifyGoogleFormat(
10171       "aaaaaaaaaaaaaaaa::aaaaaaaaaaaaaaaa<aaaaaaaaaaaaa, aaaaaaaaaaaa>\n"
10172       "    aaaaaaaaaaaaaaaaaaaaaaa;");
10173   verifyGoogleFormat(
10174       "TypeSpecDecl* TypeSpecDecl::Create(ASTContext& C, DeclContext* DC,\n"
10175       "                                   SourceLocation L) {}");
10176   verifyGoogleFormat(
10177       "some_namespace::LongReturnType\n"
10178       "long_namespace::SomeVeryLongClass::SomeVeryLongFunction(\n"
10179       "    int first_long_parameter, int second_parameter) {}");
10180 
10181   verifyGoogleFormat("template <typename T>\n"
10182                      "aaaaaaaa::aaaaa::aaaaaa<T, aaaaaaaaaaaaaaaaaaaaaaaaa>\n"
10183                      "aaaaaaaaaaaaaaaaaaaaaaaa<T>::aaaaaaa() {}");
10184   verifyGoogleFormat("A<A<A>> aaaaaaaaaa(int aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
10185                      "                   int aaaaaaaaaaaaaaaaaaaaaaa);");
10186 
10187   verifyFormat("typedef size_t (*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa)(\n"
10188                "    const aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
10189                "        *aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
10190   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10191                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>\n"
10192                "        aaaaaaaaaaaaaaaaaaaaaaaa);");
10193   verifyFormat("void aaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
10194                "    vector<aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<\n"
10195                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>>\n"
10196                "        aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
10197 
10198   verifyFormat("template <typename T> // Templates on own line.\n"
10199                "static int            // Some comment.\n"
10200                "MyFunction(int a);",
10201                getLLVMStyle());
10202 }
10203 
10204 TEST_F(FormatTest, FormatsAccessModifiers) {
10205   FormatStyle Style = getLLVMStyle();
10206   EXPECT_EQ(Style.EmptyLineBeforeAccessModifier,
10207             FormatStyle::ELBAMS_LogicalBlock);
10208   verifyFormat("struct foo {\n"
10209                "private:\n"
10210                "  void f() {}\n"
10211                "\n"
10212                "private:\n"
10213                "  int i;\n"
10214                "\n"
10215                "protected:\n"
10216                "  int j;\n"
10217                "};\n",
10218                Style);
10219   verifyFormat("struct foo {\n"
10220                "private:\n"
10221                "  void f() {}\n"
10222                "\n"
10223                "private:\n"
10224                "  int i;\n"
10225                "\n"
10226                "protected:\n"
10227                "  int j;\n"
10228                "};\n",
10229                "struct foo {\n"
10230                "private:\n"
10231                "  void f() {}\n"
10232                "private:\n"
10233                "  int i;\n"
10234                "protected:\n"
10235                "  int j;\n"
10236                "};\n",
10237                Style);
10238   verifyFormat("struct foo { /* comment */\n"
10239                "private:\n"
10240                "  int i;\n"
10241                "  // comment\n"
10242                "private:\n"
10243                "  int j;\n"
10244                "};\n",
10245                Style);
10246   verifyFormat("struct foo {\n"
10247                "#ifdef FOO\n"
10248                "#endif\n"
10249                "private:\n"
10250                "  int i;\n"
10251                "#ifdef FOO\n"
10252                "private:\n"
10253                "#endif\n"
10254                "  int j;\n"
10255                "};\n",
10256                Style);
10257   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
10258   verifyFormat("struct foo {\n"
10259                "private:\n"
10260                "  void f() {}\n"
10261                "private:\n"
10262                "  int i;\n"
10263                "protected:\n"
10264                "  int j;\n"
10265                "};\n",
10266                Style);
10267   verifyFormat("struct foo {\n"
10268                "private:\n"
10269                "  void f() {}\n"
10270                "private:\n"
10271                "  int i;\n"
10272                "protected:\n"
10273                "  int j;\n"
10274                "};\n",
10275                "struct foo {\n"
10276                "\n"
10277                "private:\n"
10278                "  void f() {}\n"
10279                "\n"
10280                "private:\n"
10281                "  int i;\n"
10282                "\n"
10283                "protected:\n"
10284                "  int j;\n"
10285                "};\n",
10286                Style);
10287   verifyFormat("struct foo { /* comment */\n"
10288                "private:\n"
10289                "  int i;\n"
10290                "  // comment\n"
10291                "private:\n"
10292                "  int j;\n"
10293                "};\n",
10294                "struct foo { /* comment */\n"
10295                "\n"
10296                "private:\n"
10297                "  int i;\n"
10298                "  // comment\n"
10299                "\n"
10300                "private:\n"
10301                "  int j;\n"
10302                "};\n",
10303                Style);
10304   verifyFormat("struct foo {\n"
10305                "#ifdef FOO\n"
10306                "#endif\n"
10307                "private:\n"
10308                "  int i;\n"
10309                "#ifdef FOO\n"
10310                "private:\n"
10311                "#endif\n"
10312                "  int j;\n"
10313                "};\n",
10314                "struct foo {\n"
10315                "#ifdef FOO\n"
10316                "#endif\n"
10317                "\n"
10318                "private:\n"
10319                "  int i;\n"
10320                "#ifdef FOO\n"
10321                "\n"
10322                "private:\n"
10323                "#endif\n"
10324                "  int j;\n"
10325                "};\n",
10326                Style);
10327   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
10328   verifyFormat("struct foo {\n"
10329                "private:\n"
10330                "  void f() {}\n"
10331                "\n"
10332                "private:\n"
10333                "  int i;\n"
10334                "\n"
10335                "protected:\n"
10336                "  int j;\n"
10337                "};\n",
10338                Style);
10339   verifyFormat("struct foo {\n"
10340                "private:\n"
10341                "  void f() {}\n"
10342                "\n"
10343                "private:\n"
10344                "  int i;\n"
10345                "\n"
10346                "protected:\n"
10347                "  int j;\n"
10348                "};\n",
10349                "struct foo {\n"
10350                "private:\n"
10351                "  void f() {}\n"
10352                "private:\n"
10353                "  int i;\n"
10354                "protected:\n"
10355                "  int j;\n"
10356                "};\n",
10357                Style);
10358   verifyFormat("struct foo { /* comment */\n"
10359                "private:\n"
10360                "  int i;\n"
10361                "  // comment\n"
10362                "\n"
10363                "private:\n"
10364                "  int j;\n"
10365                "};\n",
10366                "struct foo { /* comment */\n"
10367                "private:\n"
10368                "  int i;\n"
10369                "  // comment\n"
10370                "\n"
10371                "private:\n"
10372                "  int j;\n"
10373                "};\n",
10374                Style);
10375   verifyFormat("struct foo {\n"
10376                "#ifdef FOO\n"
10377                "#endif\n"
10378                "\n"
10379                "private:\n"
10380                "  int i;\n"
10381                "#ifdef FOO\n"
10382                "\n"
10383                "private:\n"
10384                "#endif\n"
10385                "  int j;\n"
10386                "};\n",
10387                "struct foo {\n"
10388                "#ifdef FOO\n"
10389                "#endif\n"
10390                "private:\n"
10391                "  int i;\n"
10392                "#ifdef FOO\n"
10393                "private:\n"
10394                "#endif\n"
10395                "  int j;\n"
10396                "};\n",
10397                Style);
10398   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;
10399   EXPECT_EQ("struct foo {\n"
10400             "\n"
10401             "private:\n"
10402             "  void f() {}\n"
10403             "\n"
10404             "private:\n"
10405             "  int i;\n"
10406             "\n"
10407             "protected:\n"
10408             "  int j;\n"
10409             "};\n",
10410             format("struct foo {\n"
10411                    "\n"
10412                    "private:\n"
10413                    "  void f() {}\n"
10414                    "\n"
10415                    "private:\n"
10416                    "  int i;\n"
10417                    "\n"
10418                    "protected:\n"
10419                    "  int j;\n"
10420                    "};\n",
10421                    Style));
10422   verifyFormat("struct foo {\n"
10423                "private:\n"
10424                "  void f() {}\n"
10425                "private:\n"
10426                "  int i;\n"
10427                "protected:\n"
10428                "  int j;\n"
10429                "};\n",
10430                Style);
10431   EXPECT_EQ("struct foo { /* comment */\n"
10432             "\n"
10433             "private:\n"
10434             "  int i;\n"
10435             "  // comment\n"
10436             "\n"
10437             "private:\n"
10438             "  int j;\n"
10439             "};\n",
10440             format("struct foo { /* comment */\n"
10441                    "\n"
10442                    "private:\n"
10443                    "  int i;\n"
10444                    "  // comment\n"
10445                    "\n"
10446                    "private:\n"
10447                    "  int j;\n"
10448                    "};\n",
10449                    Style));
10450   verifyFormat("struct foo { /* comment */\n"
10451                "private:\n"
10452                "  int i;\n"
10453                "  // comment\n"
10454                "private:\n"
10455                "  int j;\n"
10456                "};\n",
10457                Style);
10458   EXPECT_EQ("struct foo {\n"
10459             "#ifdef FOO\n"
10460             "#endif\n"
10461             "\n"
10462             "private:\n"
10463             "  int i;\n"
10464             "#ifdef FOO\n"
10465             "\n"
10466             "private:\n"
10467             "#endif\n"
10468             "  int j;\n"
10469             "};\n",
10470             format("struct foo {\n"
10471                    "#ifdef FOO\n"
10472                    "#endif\n"
10473                    "\n"
10474                    "private:\n"
10475                    "  int i;\n"
10476                    "#ifdef FOO\n"
10477                    "\n"
10478                    "private:\n"
10479                    "#endif\n"
10480                    "  int j;\n"
10481                    "};\n",
10482                    Style));
10483   verifyFormat("struct foo {\n"
10484                "#ifdef FOO\n"
10485                "#endif\n"
10486                "private:\n"
10487                "  int i;\n"
10488                "#ifdef FOO\n"
10489                "private:\n"
10490                "#endif\n"
10491                "  int j;\n"
10492                "};\n",
10493                Style);
10494 
10495   FormatStyle NoEmptyLines = getLLVMStyle();
10496   NoEmptyLines.MaxEmptyLinesToKeep = 0;
10497   verifyFormat("struct foo {\n"
10498                "private:\n"
10499                "  void f() {}\n"
10500                "\n"
10501                "private:\n"
10502                "  int i;\n"
10503                "\n"
10504                "public:\n"
10505                "protected:\n"
10506                "  int j;\n"
10507                "};\n",
10508                NoEmptyLines);
10509 
10510   NoEmptyLines.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
10511   verifyFormat("struct foo {\n"
10512                "private:\n"
10513                "  void f() {}\n"
10514                "private:\n"
10515                "  int i;\n"
10516                "public:\n"
10517                "protected:\n"
10518                "  int j;\n"
10519                "};\n",
10520                NoEmptyLines);
10521 
10522   NoEmptyLines.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
10523   verifyFormat("struct foo {\n"
10524                "private:\n"
10525                "  void f() {}\n"
10526                "\n"
10527                "private:\n"
10528                "  int i;\n"
10529                "\n"
10530                "public:\n"
10531                "\n"
10532                "protected:\n"
10533                "  int j;\n"
10534                "};\n",
10535                NoEmptyLines);
10536 }
10537 
10538 TEST_F(FormatTest, FormatsAfterAccessModifiers) {
10539 
10540   FormatStyle Style = getLLVMStyle();
10541   EXPECT_EQ(Style.EmptyLineAfterAccessModifier, FormatStyle::ELAAMS_Never);
10542   verifyFormat("struct foo {\n"
10543                "private:\n"
10544                "  void f() {}\n"
10545                "\n"
10546                "private:\n"
10547                "  int i;\n"
10548                "\n"
10549                "protected:\n"
10550                "  int j;\n"
10551                "};\n",
10552                Style);
10553 
10554   // Check if lines are removed.
10555   verifyFormat("struct foo {\n"
10556                "private:\n"
10557                "  void f() {}\n"
10558                "\n"
10559                "private:\n"
10560                "  int i;\n"
10561                "\n"
10562                "protected:\n"
10563                "  int j;\n"
10564                "};\n",
10565                "struct foo {\n"
10566                "private:\n"
10567                "\n"
10568                "  void f() {}\n"
10569                "\n"
10570                "private:\n"
10571                "\n"
10572                "  int i;\n"
10573                "\n"
10574                "protected:\n"
10575                "\n"
10576                "  int j;\n"
10577                "};\n",
10578                Style);
10579 
10580   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
10581   verifyFormat("struct foo {\n"
10582                "private:\n"
10583                "\n"
10584                "  void f() {}\n"
10585                "\n"
10586                "private:\n"
10587                "\n"
10588                "  int i;\n"
10589                "\n"
10590                "protected:\n"
10591                "\n"
10592                "  int j;\n"
10593                "};\n",
10594                Style);
10595 
10596   // Check if lines are added.
10597   verifyFormat("struct foo {\n"
10598                "private:\n"
10599                "\n"
10600                "  void f() {}\n"
10601                "\n"
10602                "private:\n"
10603                "\n"
10604                "  int i;\n"
10605                "\n"
10606                "protected:\n"
10607                "\n"
10608                "  int j;\n"
10609                "};\n",
10610                "struct foo {\n"
10611                "private:\n"
10612                "  void f() {}\n"
10613                "\n"
10614                "private:\n"
10615                "  int i;\n"
10616                "\n"
10617                "protected:\n"
10618                "  int j;\n"
10619                "};\n",
10620                Style);
10621 
10622   // Leave tests rely on the code layout, test::messUp can not be used.
10623   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
10624   Style.MaxEmptyLinesToKeep = 0u;
10625   verifyFormat("struct foo {\n"
10626                "private:\n"
10627                "  void f() {}\n"
10628                "\n"
10629                "private:\n"
10630                "  int i;\n"
10631                "\n"
10632                "protected:\n"
10633                "  int j;\n"
10634                "};\n",
10635                Style);
10636 
10637   // Check if MaxEmptyLinesToKeep is respected.
10638   EXPECT_EQ("struct foo {\n"
10639             "private:\n"
10640             "  void f() {}\n"
10641             "\n"
10642             "private:\n"
10643             "  int i;\n"
10644             "\n"
10645             "protected:\n"
10646             "  int j;\n"
10647             "};\n",
10648             format("struct foo {\n"
10649                    "private:\n"
10650                    "\n\n\n"
10651                    "  void f() {}\n"
10652                    "\n"
10653                    "private:\n"
10654                    "\n\n\n"
10655                    "  int i;\n"
10656                    "\n"
10657                    "protected:\n"
10658                    "\n\n\n"
10659                    "  int j;\n"
10660                    "};\n",
10661                    Style));
10662 
10663   Style.MaxEmptyLinesToKeep = 1u;
10664   EXPECT_EQ("struct foo {\n"
10665             "private:\n"
10666             "\n"
10667             "  void f() {}\n"
10668             "\n"
10669             "private:\n"
10670             "\n"
10671             "  int i;\n"
10672             "\n"
10673             "protected:\n"
10674             "\n"
10675             "  int j;\n"
10676             "};\n",
10677             format("struct foo {\n"
10678                    "private:\n"
10679                    "\n"
10680                    "  void f() {}\n"
10681                    "\n"
10682                    "private:\n"
10683                    "\n"
10684                    "  int i;\n"
10685                    "\n"
10686                    "protected:\n"
10687                    "\n"
10688                    "  int j;\n"
10689                    "};\n",
10690                    Style));
10691   // Check if no lines are kept.
10692   EXPECT_EQ("struct foo {\n"
10693             "private:\n"
10694             "  void f() {}\n"
10695             "\n"
10696             "private:\n"
10697             "  int i;\n"
10698             "\n"
10699             "protected:\n"
10700             "  int j;\n"
10701             "};\n",
10702             format("struct foo {\n"
10703                    "private:\n"
10704                    "  void f() {}\n"
10705                    "\n"
10706                    "private:\n"
10707                    "  int i;\n"
10708                    "\n"
10709                    "protected:\n"
10710                    "  int j;\n"
10711                    "};\n",
10712                    Style));
10713   // Check if MaxEmptyLinesToKeep is respected.
10714   EXPECT_EQ("struct foo {\n"
10715             "private:\n"
10716             "\n"
10717             "  void f() {}\n"
10718             "\n"
10719             "private:\n"
10720             "\n"
10721             "  int i;\n"
10722             "\n"
10723             "protected:\n"
10724             "\n"
10725             "  int j;\n"
10726             "};\n",
10727             format("struct foo {\n"
10728                    "private:\n"
10729                    "\n\n\n"
10730                    "  void f() {}\n"
10731                    "\n"
10732                    "private:\n"
10733                    "\n\n\n"
10734                    "  int i;\n"
10735                    "\n"
10736                    "protected:\n"
10737                    "\n\n\n"
10738                    "  int j;\n"
10739                    "};\n",
10740                    Style));
10741 
10742   Style.MaxEmptyLinesToKeep = 10u;
10743   EXPECT_EQ("struct foo {\n"
10744             "private:\n"
10745             "\n\n\n"
10746             "  void f() {}\n"
10747             "\n"
10748             "private:\n"
10749             "\n\n\n"
10750             "  int i;\n"
10751             "\n"
10752             "protected:\n"
10753             "\n\n\n"
10754             "  int j;\n"
10755             "};\n",
10756             format("struct foo {\n"
10757                    "private:\n"
10758                    "\n\n\n"
10759                    "  void f() {}\n"
10760                    "\n"
10761                    "private:\n"
10762                    "\n\n\n"
10763                    "  int i;\n"
10764                    "\n"
10765                    "protected:\n"
10766                    "\n\n\n"
10767                    "  int j;\n"
10768                    "};\n",
10769                    Style));
10770 
10771   // Test with comments.
10772   Style = getLLVMStyle();
10773   verifyFormat("struct foo {\n"
10774                "private:\n"
10775                "  // comment\n"
10776                "  void f() {}\n"
10777                "\n"
10778                "private: /* comment */\n"
10779                "  int i;\n"
10780                "};\n",
10781                Style);
10782   verifyFormat("struct foo {\n"
10783                "private:\n"
10784                "  // comment\n"
10785                "  void f() {}\n"
10786                "\n"
10787                "private: /* comment */\n"
10788                "  int i;\n"
10789                "};\n",
10790                "struct foo {\n"
10791                "private:\n"
10792                "\n"
10793                "  // comment\n"
10794                "  void f() {}\n"
10795                "\n"
10796                "private: /* comment */\n"
10797                "\n"
10798                "  int i;\n"
10799                "};\n",
10800                Style);
10801 
10802   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
10803   verifyFormat("struct foo {\n"
10804                "private:\n"
10805                "\n"
10806                "  // comment\n"
10807                "  void f() {}\n"
10808                "\n"
10809                "private: /* comment */\n"
10810                "\n"
10811                "  int i;\n"
10812                "};\n",
10813                "struct foo {\n"
10814                "private:\n"
10815                "  // comment\n"
10816                "  void f() {}\n"
10817                "\n"
10818                "private: /* comment */\n"
10819                "  int i;\n"
10820                "};\n",
10821                Style);
10822   verifyFormat("struct foo {\n"
10823                "private:\n"
10824                "\n"
10825                "  // comment\n"
10826                "  void f() {}\n"
10827                "\n"
10828                "private: /* comment */\n"
10829                "\n"
10830                "  int i;\n"
10831                "};\n",
10832                Style);
10833 
10834   // Test with preprocessor defines.
10835   Style = getLLVMStyle();
10836   verifyFormat("struct foo {\n"
10837                "private:\n"
10838                "#ifdef FOO\n"
10839                "#endif\n"
10840                "  void f() {}\n"
10841                "};\n",
10842                Style);
10843   verifyFormat("struct foo {\n"
10844                "private:\n"
10845                "#ifdef FOO\n"
10846                "#endif\n"
10847                "  void f() {}\n"
10848                "};\n",
10849                "struct foo {\n"
10850                "private:\n"
10851                "\n"
10852                "#ifdef FOO\n"
10853                "#endif\n"
10854                "  void f() {}\n"
10855                "};\n",
10856                Style);
10857 
10858   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
10859   verifyFormat("struct foo {\n"
10860                "private:\n"
10861                "\n"
10862                "#ifdef FOO\n"
10863                "#endif\n"
10864                "  void f() {}\n"
10865                "};\n",
10866                "struct foo {\n"
10867                "private:\n"
10868                "#ifdef FOO\n"
10869                "#endif\n"
10870                "  void f() {}\n"
10871                "};\n",
10872                Style);
10873   verifyFormat("struct foo {\n"
10874                "private:\n"
10875                "\n"
10876                "#ifdef FOO\n"
10877                "#endif\n"
10878                "  void f() {}\n"
10879                "};\n",
10880                Style);
10881 }
10882 
10883 TEST_F(FormatTest, FormatsAfterAndBeforeAccessModifiersInteraction) {
10884   // Combined tests of EmptyLineAfterAccessModifier and
10885   // EmptyLineBeforeAccessModifier.
10886   FormatStyle Style = getLLVMStyle();
10887   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
10888   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
10889   verifyFormat("struct foo {\n"
10890                "private:\n"
10891                "\n"
10892                "protected:\n"
10893                "};\n",
10894                Style);
10895 
10896   Style.MaxEmptyLinesToKeep = 10u;
10897   // Both remove all new lines.
10898   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
10899   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
10900   verifyFormat("struct foo {\n"
10901                "private:\n"
10902                "protected:\n"
10903                "};\n",
10904                "struct foo {\n"
10905                "private:\n"
10906                "\n\n\n"
10907                "protected:\n"
10908                "};\n",
10909                Style);
10910 
10911   // Leave tests rely on the code layout, test::messUp can not be used.
10912   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;
10913   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
10914   Style.MaxEmptyLinesToKeep = 10u;
10915   EXPECT_EQ("struct foo {\n"
10916             "private:\n"
10917             "\n\n\n"
10918             "protected:\n"
10919             "};\n",
10920             format("struct foo {\n"
10921                    "private:\n"
10922                    "\n\n\n"
10923                    "protected:\n"
10924                    "};\n",
10925                    Style));
10926   Style.MaxEmptyLinesToKeep = 3u;
10927   EXPECT_EQ("struct foo {\n"
10928             "private:\n"
10929             "\n\n\n"
10930             "protected:\n"
10931             "};\n",
10932             format("struct foo {\n"
10933                    "private:\n"
10934                    "\n\n\n"
10935                    "protected:\n"
10936                    "};\n",
10937                    Style));
10938   Style.MaxEmptyLinesToKeep = 1u;
10939   EXPECT_EQ("struct foo {\n"
10940             "private:\n"
10941             "\n\n\n"
10942             "protected:\n"
10943             "};\n",
10944             format("struct foo {\n"
10945                    "private:\n"
10946                    "\n\n\n"
10947                    "protected:\n"
10948                    "};\n",
10949                    Style)); // Based on new lines in original document and not
10950                             // on the setting.
10951 
10952   Style.MaxEmptyLinesToKeep = 10u;
10953   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
10954   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
10955   // Newlines are kept if they are greater than zero,
10956   // test::messUp removes all new lines which changes the logic
10957   EXPECT_EQ("struct foo {\n"
10958             "private:\n"
10959             "\n\n\n"
10960             "protected:\n"
10961             "};\n",
10962             format("struct foo {\n"
10963                    "private:\n"
10964                    "\n\n\n"
10965                    "protected:\n"
10966                    "};\n",
10967                    Style));
10968 
10969   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;
10970   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
10971   // test::messUp removes all new lines which changes the logic
10972   EXPECT_EQ("struct foo {\n"
10973             "private:\n"
10974             "\n\n\n"
10975             "protected:\n"
10976             "};\n",
10977             format("struct foo {\n"
10978                    "private:\n"
10979                    "\n\n\n"
10980                    "protected:\n"
10981                    "};\n",
10982                    Style));
10983 
10984   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Leave;
10985   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
10986   EXPECT_EQ("struct foo {\n"
10987             "private:\n"
10988             "\n\n\n"
10989             "protected:\n"
10990             "};\n",
10991             format("struct foo {\n"
10992                    "private:\n"
10993                    "\n\n\n"
10994                    "protected:\n"
10995                    "};\n",
10996                    Style)); // test::messUp removes all new lines which changes
10997                             // the logic.
10998 
10999   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
11000   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
11001   verifyFormat("struct foo {\n"
11002                "private:\n"
11003                "protected:\n"
11004                "};\n",
11005                "struct foo {\n"
11006                "private:\n"
11007                "\n\n\n"
11008                "protected:\n"
11009                "};\n",
11010                Style);
11011 
11012   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Always;
11013   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
11014   EXPECT_EQ("struct foo {\n"
11015             "private:\n"
11016             "\n\n\n"
11017             "protected:\n"
11018             "};\n",
11019             format("struct foo {\n"
11020                    "private:\n"
11021                    "\n\n\n"
11022                    "protected:\n"
11023                    "};\n",
11024                    Style)); // test::messUp removes all new lines which changes
11025                             // the logic.
11026 
11027   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_Never;
11028   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
11029   verifyFormat("struct foo {\n"
11030                "private:\n"
11031                "protected:\n"
11032                "};\n",
11033                "struct foo {\n"
11034                "private:\n"
11035                "\n\n\n"
11036                "protected:\n"
11037                "};\n",
11038                Style);
11039 
11040   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
11041   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Always;
11042   verifyFormat("struct foo {\n"
11043                "private:\n"
11044                "protected:\n"
11045                "};\n",
11046                "struct foo {\n"
11047                "private:\n"
11048                "\n\n\n"
11049                "protected:\n"
11050                "};\n",
11051                Style);
11052 
11053   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
11054   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Leave;
11055   verifyFormat("struct foo {\n"
11056                "private:\n"
11057                "protected:\n"
11058                "};\n",
11059                "struct foo {\n"
11060                "private:\n"
11061                "\n\n\n"
11062                "protected:\n"
11063                "};\n",
11064                Style);
11065 
11066   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
11067   Style.EmptyLineAfterAccessModifier = FormatStyle::ELAAMS_Never;
11068   verifyFormat("struct foo {\n"
11069                "private:\n"
11070                "protected:\n"
11071                "};\n",
11072                "struct foo {\n"
11073                "private:\n"
11074                "\n\n\n"
11075                "protected:\n"
11076                "};\n",
11077                Style);
11078 }
11079 
11080 TEST_F(FormatTest, FormatsArrays) {
11081   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
11082                "                         [bbbbbbbbbbbbbbbbbbbbbbbbb] = c;");
11083   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa(aaaaaaaaaaaa)]\n"
11084                "                         [bbbbbbbbbbb(bbbbbbbbbbbb)] = c;");
11085   verifyFormat("if (aaaaaaaaaaaaaaaaaaaaaaaa &&\n"
11086                "    aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaa][aaaaaaaaaaaaa]) {\n}");
11087   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11088                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
11089   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11090                "    [a][bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = cccccccc;");
11091   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
11092                "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]\n"
11093                "    [bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb] = ccccccccccc;");
11094   verifyFormat(
11095       "llvm::outs() << \"aaaaaaaaaaaa: \"\n"
11096       "             << (*aaaaaaaiaaaaaaa)[aaaaaaaaaaaaaaaaaaaaaaaaa]\n"
11097       "                                  [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa];");
11098   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaaaaaaa][a]\n"
11099                "    .aaaaaaaaaaaaaaaaaaaaaa();");
11100 
11101   verifyGoogleFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa<int>\n"
11102                      "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa[aaaaaaaaaaaa];");
11103   verifyFormat(
11104       "aaaaaaaaaaa aaaaaaaaaaaaaaa = aaaaaaaaaaaaaaaaaaaaaaaaaa->aaaaaaaaa[0]\n"
11105       "                                  .aaaaaaa[0]\n"
11106       "                                  .aaaaaaaaaaaaaaaaaaaaaa();");
11107   verifyFormat("a[::b::c];");
11108 
11109   verifyNoCrash("a[,Y?)]", getLLVMStyleWithColumns(10));
11110 
11111   FormatStyle NoColumnLimit = getLLVMStyleWithColumns(0);
11112   verifyFormat("aaaaa[bbbbbb].cccccc()", NoColumnLimit);
11113 }
11114 
11115 TEST_F(FormatTest, LineStartsWithSpecialCharacter) {
11116   verifyFormat("(a)->b();");
11117   verifyFormat("--a;");
11118 }
11119 
11120 TEST_F(FormatTest, HandlesIncludeDirectives) {
11121   verifyFormat("#include <string>\n"
11122                "#include <a/b/c.h>\n"
11123                "#include \"a/b/string\"\n"
11124                "#include \"string.h\"\n"
11125                "#include \"string.h\"\n"
11126                "#include <a-a>\n"
11127                "#include < path with space >\n"
11128                "#include_next <test.h>"
11129                "#include \"abc.h\" // this is included for ABC\n"
11130                "#include \"some long include\" // with a comment\n"
11131                "#include \"some very long include path\"\n"
11132                "#include <some/very/long/include/path>\n",
11133                getLLVMStyleWithColumns(35));
11134   EXPECT_EQ("#include \"a.h\"", format("#include  \"a.h\""));
11135   EXPECT_EQ("#include <a>", format("#include<a>"));
11136 
11137   verifyFormat("#import <string>");
11138   verifyFormat("#import <a/b/c.h>");
11139   verifyFormat("#import \"a/b/string\"");
11140   verifyFormat("#import \"string.h\"");
11141   verifyFormat("#import \"string.h\"");
11142   verifyFormat("#if __has_include(<strstream>)\n"
11143                "#include <strstream>\n"
11144                "#endif");
11145 
11146   verifyFormat("#define MY_IMPORT <a/b>");
11147 
11148   verifyFormat("#if __has_include(<a/b>)");
11149   verifyFormat("#if __has_include_next(<a/b>)");
11150   verifyFormat("#define F __has_include(<a/b>)");
11151   verifyFormat("#define F __has_include_next(<a/b>)");
11152 
11153   // Protocol buffer definition or missing "#".
11154   verifyFormat("import \"aaaaaaaaaaaaaaaaa/aaaaaaaaaaaaaaa\";",
11155                getLLVMStyleWithColumns(30));
11156 
11157   FormatStyle Style = getLLVMStyle();
11158   Style.AlwaysBreakBeforeMultilineStrings = true;
11159   Style.ColumnLimit = 0;
11160   verifyFormat("#import \"abc.h\"", Style);
11161 
11162   // But 'import' might also be a regular C++ namespace.
11163   verifyFormat("import::SomeFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
11164                "                     aaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
11165 }
11166 
11167 //===----------------------------------------------------------------------===//
11168 // Error recovery tests.
11169 //===----------------------------------------------------------------------===//
11170 
11171 TEST_F(FormatTest, IncompleteParameterLists) {
11172   FormatStyle NoBinPacking = getLLVMStyle();
11173   NoBinPacking.BinPackParameters = false;
11174   verifyFormat("void aaaaaaaaaaaaaaaaaa(int level,\n"
11175                "                        double *min_x,\n"
11176                "                        double *max_x,\n"
11177                "                        double *min_y,\n"
11178                "                        double *max_y,\n"
11179                "                        double *min_z,\n"
11180                "                        double *max_z, ) {}",
11181                NoBinPacking);
11182 }
11183 
11184 TEST_F(FormatTest, IncorrectCodeTrailingStuff) {
11185   verifyFormat("void f() { return; }\n42");
11186   verifyFormat("void f() {\n"
11187                "  if (0)\n"
11188                "    return;\n"
11189                "}\n"
11190                "42");
11191   verifyFormat("void f() { return }\n42");
11192   verifyFormat("void f() {\n"
11193                "  if (0)\n"
11194                "    return\n"
11195                "}\n"
11196                "42");
11197 }
11198 
11199 TEST_F(FormatTest, IncorrectCodeMissingSemicolon) {
11200   EXPECT_EQ("void f() { return }", format("void  f ( )  {  return  }"));
11201   EXPECT_EQ("void f() {\n"
11202             "  if (a)\n"
11203             "    return\n"
11204             "}",
11205             format("void  f  (  )  {  if  ( a )  return  }"));
11206   EXPECT_EQ("namespace N {\n"
11207             "void f()\n"
11208             "}",
11209             format("namespace  N  {  void f()  }"));
11210   EXPECT_EQ("namespace N {\n"
11211             "void f() {}\n"
11212             "void g()\n"
11213             "} // namespace N",
11214             format("namespace N  { void f( ) { } void g( ) }"));
11215 }
11216 
11217 TEST_F(FormatTest, IndentationWithinColumnLimitNotPossible) {
11218   verifyFormat("int aaaaaaaa =\n"
11219                "    // Overlylongcomment\n"
11220                "    b;",
11221                getLLVMStyleWithColumns(20));
11222   verifyFormat("function(\n"
11223                "    ShortArgument,\n"
11224                "    LoooooooooooongArgument);\n",
11225                getLLVMStyleWithColumns(20));
11226 }
11227 
11228 TEST_F(FormatTest, IncorrectAccessSpecifier) {
11229   verifyFormat("public:");
11230   verifyFormat("class A {\n"
11231                "public\n"
11232                "  void f() {}\n"
11233                "};");
11234   verifyFormat("public\n"
11235                "int qwerty;");
11236   verifyFormat("public\n"
11237                "B {}");
11238   verifyFormat("public\n"
11239                "{}");
11240   verifyFormat("public\n"
11241                "B { int x; }");
11242 }
11243 
11244 TEST_F(FormatTest, IncorrectCodeUnbalancedBraces) {
11245   verifyFormat("{");
11246   verifyFormat("#})");
11247   verifyNoCrash("(/**/[:!] ?[).");
11248 }
11249 
11250 TEST_F(FormatTest, IncorrectUnbalancedBracesInMacrosWithUnicode) {
11251   // Found by oss-fuzz:
11252   // https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=8212
11253   FormatStyle Style = getGoogleStyle(FormatStyle::LK_Cpp);
11254   Style.ColumnLimit = 60;
11255   verifyNoCrash(
11256       "\x23\x47\xff\x20\x28\xff\x3c\xff\x3f\xff\x20\x2f\x7b\x7a\xff\x20"
11257       "\xff\xff\xff\xca\xb5\xff\xff\xff\xff\x3a\x7b\x7d\xff\x20\xff\x20"
11258       "\xff\x74\xff\x20\x7d\x7d\xff\x7b\x3a\xff\x20\x71\xff\x20\xff\x0a",
11259       Style);
11260 }
11261 
11262 TEST_F(FormatTest, IncorrectCodeDoNoWhile) {
11263   verifyFormat("do {\n}");
11264   verifyFormat("do {\n}\n"
11265                "f();");
11266   verifyFormat("do {\n}\n"
11267                "wheeee(fun);");
11268   verifyFormat("do {\n"
11269                "  f();\n"
11270                "}");
11271 }
11272 
11273 TEST_F(FormatTest, IncorrectCodeMissingParens) {
11274   verifyFormat("if {\n  foo;\n  foo();\n}");
11275   verifyFormat("switch {\n  foo;\n  foo();\n}");
11276   verifyIncompleteFormat("for {\n  foo;\n  foo();\n}");
11277   verifyFormat("while {\n  foo;\n  foo();\n}");
11278   verifyFormat("do {\n  foo;\n  foo();\n} while;");
11279 }
11280 
11281 TEST_F(FormatTest, DoesNotTouchUnwrappedLinesWithErrors) {
11282   verifyIncompleteFormat("namespace {\n"
11283                          "class Foo { Foo (\n"
11284                          "};\n"
11285                          "} // namespace");
11286 }
11287 
11288 TEST_F(FormatTest, IncorrectCodeErrorDetection) {
11289   EXPECT_EQ("{\n  {}\n", format("{\n{\n}\n"));
11290   EXPECT_EQ("{\n  {}\n", format("{\n  {\n}\n"));
11291   EXPECT_EQ("{\n  {}\n", format("{\n  {\n  }\n"));
11292   EXPECT_EQ("{\n  {}\n}\n}\n", format("{\n  {\n    }\n  }\n}\n"));
11293 
11294   EXPECT_EQ("{\n"
11295             "  {\n"
11296             "    breakme(\n"
11297             "        qwe);\n"
11298             "  }\n",
11299             format("{\n"
11300                    "    {\n"
11301                    " breakme(qwe);\n"
11302                    "}\n",
11303                    getLLVMStyleWithColumns(10)));
11304 }
11305 
11306 TEST_F(FormatTest, LayoutCallsInsideBraceInitializers) {
11307   verifyFormat("int x = {\n"
11308                "    avariable,\n"
11309                "    b(alongervariable)};",
11310                getLLVMStyleWithColumns(25));
11311 }
11312 
11313 TEST_F(FormatTest, LayoutBraceInitializersInReturnStatement) {
11314   verifyFormat("return (a)(b){1, 2, 3};");
11315 }
11316 
11317 TEST_F(FormatTest, LayoutCxx11BraceInitializers) {
11318   verifyFormat("vector<int> x{1, 2, 3, 4};");
11319   verifyFormat("vector<int> x{\n"
11320                "    1,\n"
11321                "    2,\n"
11322                "    3,\n"
11323                "    4,\n"
11324                "};");
11325   verifyFormat("vector<T> x{{}, {}, {}, {}};");
11326   verifyFormat("f({1, 2});");
11327   verifyFormat("auto v = Foo{-1};");
11328   verifyFormat("f({1, 2}, {{2, 3}, {4, 5}}, c, {d});");
11329   verifyFormat("Class::Class : member{1, 2, 3} {}");
11330   verifyFormat("new vector<int>{1, 2, 3};");
11331   verifyFormat("new int[3]{1, 2, 3};");
11332   verifyFormat("new int{1};");
11333   verifyFormat("return {arg1, arg2};");
11334   verifyFormat("return {arg1, SomeType{parameter}};");
11335   verifyFormat("int count = set<int>{f(), g(), h()}.size();");
11336   verifyFormat("new T{arg1, arg2};");
11337   verifyFormat("f(MyMap[{composite, key}]);");
11338   verifyFormat("class Class {\n"
11339                "  T member = {arg1, arg2};\n"
11340                "};");
11341   verifyFormat("vector<int> foo = {::SomeGlobalFunction()};");
11342   verifyFormat("const struct A a = {.a = 1, .b = 2};");
11343   verifyFormat("const struct A a = {[0] = 1, [1] = 2};");
11344   verifyFormat("static_assert(std::is_integral<int>{} + 0, \"\");");
11345   verifyFormat("int a = std::is_integral<int>{} + 0;");
11346 
11347   verifyFormat("int foo(int i) { return fo1{}(i); }");
11348   verifyFormat("int foo(int i) { return fo1{}(i); }");
11349   verifyFormat("auto i = decltype(x){};");
11350   verifyFormat("auto i = typeof(x){};");
11351   verifyFormat("auto i = _Atomic(x){};");
11352   verifyFormat("std::vector<int> v = {1, 0 /* comment */};");
11353   verifyFormat("Node n{1, Node{1000}, //\n"
11354                "       2};");
11355   verifyFormat("Aaaa aaaaaaa{\n"
11356                "    {\n"
11357                "        aaaa,\n"
11358                "    },\n"
11359                "};");
11360   verifyFormat("class C : public D {\n"
11361                "  SomeClass SC{2};\n"
11362                "};");
11363   verifyFormat("class C : public A {\n"
11364                "  class D : public B {\n"
11365                "    void f() { int i{2}; }\n"
11366                "  };\n"
11367                "};");
11368   verifyFormat("#define A {a, a},");
11369 
11370   // Avoid breaking between equal sign and opening brace
11371   FormatStyle AvoidBreakingFirstArgument = getLLVMStyle();
11372   AvoidBreakingFirstArgument.PenaltyBreakBeforeFirstCallParameter = 200;
11373   verifyFormat("const std::unordered_map<std::string, int> MyHashTable =\n"
11374                "    {{\"aaaaaaaaaaaaaaaaaaaaa\", 0},\n"
11375                "     {\"bbbbbbbbbbbbbbbbbbbbb\", 1},\n"
11376                "     {\"ccccccccccccccccccccc\", 2}};",
11377                AvoidBreakingFirstArgument);
11378 
11379   // Binpacking only if there is no trailing comma
11380   verifyFormat("const Aaaaaa aaaaa = {aaaaaaaaaa, bbbbbbbbbb,\n"
11381                "                      cccccccccc, dddddddddd};",
11382                getLLVMStyleWithColumns(50));
11383   verifyFormat("const Aaaaaa aaaaa = {\n"
11384                "    aaaaaaaaaaa,\n"
11385                "    bbbbbbbbbbb,\n"
11386                "    ccccccccccc,\n"
11387                "    ddddddddddd,\n"
11388                "};",
11389                getLLVMStyleWithColumns(50));
11390 
11391   // Cases where distinguising braced lists and blocks is hard.
11392   verifyFormat("vector<int> v{12} GUARDED_BY(mutex);");
11393   verifyFormat("void f() {\n"
11394                "  return; // comment\n"
11395                "}\n"
11396                "SomeType t;");
11397   verifyFormat("void f() {\n"
11398                "  if (a) {\n"
11399                "    f();\n"
11400                "  }\n"
11401                "}\n"
11402                "SomeType t;");
11403 
11404   // In combination with BinPackArguments = false.
11405   FormatStyle NoBinPacking = getLLVMStyle();
11406   NoBinPacking.BinPackArguments = false;
11407   verifyFormat("const Aaaaaa aaaaa = {aaaaa,\n"
11408                "                      bbbbb,\n"
11409                "                      ccccc,\n"
11410                "                      ddddd,\n"
11411                "                      eeeee,\n"
11412                "                      ffffff,\n"
11413                "                      ggggg,\n"
11414                "                      hhhhhh,\n"
11415                "                      iiiiii,\n"
11416                "                      jjjjjj,\n"
11417                "                      kkkkkk};",
11418                NoBinPacking);
11419   verifyFormat("const Aaaaaa aaaaa = {\n"
11420                "    aaaaa,\n"
11421                "    bbbbb,\n"
11422                "    ccccc,\n"
11423                "    ddddd,\n"
11424                "    eeeee,\n"
11425                "    ffffff,\n"
11426                "    ggggg,\n"
11427                "    hhhhhh,\n"
11428                "    iiiiii,\n"
11429                "    jjjjjj,\n"
11430                "    kkkkkk,\n"
11431                "};",
11432                NoBinPacking);
11433   verifyFormat(
11434       "const Aaaaaa aaaaa = {\n"
11435       "    aaaaa,  bbbbb,  ccccc,  ddddd,  eeeee,  ffffff, ggggg, hhhhhh,\n"
11436       "    iiiiii, jjjjjj, kkkkkk, aaaaa,  bbbbb,  ccccc,  ddddd, eeeee,\n"
11437       "    ffffff, ggggg,  hhhhhh, iiiiii, jjjjjj, kkkkkk,\n"
11438       "};",
11439       NoBinPacking);
11440 
11441   NoBinPacking.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
11442   EXPECT_EQ("static uint8 CddDp83848Reg[] = {\n"
11443             "    CDDDP83848_BMCR_REGISTER,\n"
11444             "    CDDDP83848_BMSR_REGISTER,\n"
11445             "    CDDDP83848_RBR_REGISTER};",
11446             format("static uint8 CddDp83848Reg[] = {CDDDP83848_BMCR_REGISTER,\n"
11447                    "                                CDDDP83848_BMSR_REGISTER,\n"
11448                    "                                CDDDP83848_RBR_REGISTER};",
11449                    NoBinPacking));
11450 
11451   // FIXME: The alignment of these trailing comments might be bad. Then again,
11452   // this might be utterly useless in real code.
11453   verifyFormat("Constructor::Constructor()\n"
11454                "    : some_value{         //\n"
11455                "                 aaaaaaa, //\n"
11456                "                 bbbbbbb} {}");
11457 
11458   // In braced lists, the first comment is always assumed to belong to the
11459   // first element. Thus, it can be moved to the next or previous line as
11460   // appropriate.
11461   EXPECT_EQ("function({// First element:\n"
11462             "          1,\n"
11463             "          // Second element:\n"
11464             "          2});",
11465             format("function({\n"
11466                    "    // First element:\n"
11467                    "    1,\n"
11468                    "    // Second element:\n"
11469                    "    2});"));
11470   EXPECT_EQ("std::vector<int> MyNumbers{\n"
11471             "    // First element:\n"
11472             "    1,\n"
11473             "    // Second element:\n"
11474             "    2};",
11475             format("std::vector<int> MyNumbers{// First element:\n"
11476                    "                           1,\n"
11477                    "                           // Second element:\n"
11478                    "                           2};",
11479                    getLLVMStyleWithColumns(30)));
11480   // A trailing comma should still lead to an enforced line break and no
11481   // binpacking.
11482   EXPECT_EQ("vector<int> SomeVector = {\n"
11483             "    // aaa\n"
11484             "    1,\n"
11485             "    2,\n"
11486             "};",
11487             format("vector<int> SomeVector = { // aaa\n"
11488                    "    1, 2, };"));
11489 
11490   // C++11 brace initializer list l-braces should not be treated any differently
11491   // when breaking before lambda bodies is enabled
11492   FormatStyle BreakBeforeLambdaBody = getLLVMStyle();
11493   BreakBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
11494   BreakBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
11495   BreakBeforeLambdaBody.AlwaysBreakBeforeMultilineStrings = true;
11496   verifyFormat(
11497       "std::runtime_error{\n"
11498       "    \"Long string which will force a break onto the next line...\"};",
11499       BreakBeforeLambdaBody);
11500 
11501   FormatStyle ExtraSpaces = getLLVMStyle();
11502   ExtraSpaces.Cpp11BracedListStyle = false;
11503   ExtraSpaces.ColumnLimit = 75;
11504   verifyFormat("vector<int> x{ 1, 2, 3, 4 };", ExtraSpaces);
11505   verifyFormat("vector<T> x{ {}, {}, {}, {} };", ExtraSpaces);
11506   verifyFormat("f({ 1, 2 });", ExtraSpaces);
11507   verifyFormat("auto v = Foo{ 1 };", ExtraSpaces);
11508   verifyFormat("f({ 1, 2 }, { { 2, 3 }, { 4, 5 } }, c, { d });", ExtraSpaces);
11509   verifyFormat("Class::Class : member{ 1, 2, 3 } {}", ExtraSpaces);
11510   verifyFormat("new vector<int>{ 1, 2, 3 };", ExtraSpaces);
11511   verifyFormat("new int[3]{ 1, 2, 3 };", ExtraSpaces);
11512   verifyFormat("return { arg1, arg2 };", ExtraSpaces);
11513   verifyFormat("return { arg1, SomeType{ parameter } };", ExtraSpaces);
11514   verifyFormat("int count = set<int>{ f(), g(), h() }.size();", ExtraSpaces);
11515   verifyFormat("new T{ arg1, arg2 };", ExtraSpaces);
11516   verifyFormat("f(MyMap[{ composite, key }]);", ExtraSpaces);
11517   verifyFormat("class Class {\n"
11518                "  T member = { arg1, arg2 };\n"
11519                "};",
11520                ExtraSpaces);
11521   verifyFormat(
11522       "foo = aaaaaaaaaaa ? vector<int>{ aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
11523       "                                 aaaaaaaaaaaaaaaaaaaa, aaaaa }\n"
11524       "                  : vector<int>{ bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
11525       "                                 bbbbbbbbbbbbbbbbbbbb, bbbbb };",
11526       ExtraSpaces);
11527   verifyFormat("DoSomethingWithVector({} /* No data */);", ExtraSpaces);
11528   verifyFormat("DoSomethingWithVector({ {} /* No data */ }, { { 1, 2 } });",
11529                ExtraSpaces);
11530   verifyFormat(
11531       "someFunction(OtherParam,\n"
11532       "             BracedList{ // comment 1 (Forcing interesting break)\n"
11533       "                         param1, param2,\n"
11534       "                         // comment 2\n"
11535       "                         param3, param4 });",
11536       ExtraSpaces);
11537   verifyFormat(
11538       "std::this_thread::sleep_for(\n"
11539       "    std::chrono::nanoseconds{ std::chrono::seconds{ 1 } } / 5);",
11540       ExtraSpaces);
11541   verifyFormat("std::vector<MyValues> aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa{\n"
11542                "    aaaaaaa,\n"
11543                "    aaaaaaaaaa,\n"
11544                "    aaaaa,\n"
11545                "    aaaaaaaaaaaaaaa,\n"
11546                "    aaa,\n"
11547                "    aaaaaaaaaa,\n"
11548                "    a,\n"
11549                "    aaaaaaaaaaaaaaaaaaaaa,\n"
11550                "    aaaaaaaaaaaa,\n"
11551                "    aaaaaaaaaaaaaaaaaaa + aaaaaaaaaaaaaaaaaaa,\n"
11552                "    aaaaaaa,\n"
11553                "    a};");
11554   verifyFormat("vector<int> foo = { ::SomeGlobalFunction() };", ExtraSpaces);
11555   verifyFormat("const struct A a = { .a = 1, .b = 2 };", ExtraSpaces);
11556   verifyFormat("const struct A a = { [0] = 1, [1] = 2 };", ExtraSpaces);
11557 
11558   // Avoid breaking between initializer/equal sign and opening brace
11559   ExtraSpaces.PenaltyBreakBeforeFirstCallParameter = 200;
11560   verifyFormat("const std::unordered_map<std::string, int> MyHashTable = {\n"
11561                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
11562                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
11563                "  { \"ccccccccccccccccccccc\", 2 }\n"
11564                "};",
11565                ExtraSpaces);
11566   verifyFormat("const std::unordered_map<std::string, int> MyHashTable{\n"
11567                "  { \"aaaaaaaaaaaaaaaaaaaaa\", 0 },\n"
11568                "  { \"bbbbbbbbbbbbbbbbbbbbb\", 1 },\n"
11569                "  { \"ccccccccccccccccccccc\", 2 }\n"
11570                "};",
11571                ExtraSpaces);
11572 
11573   FormatStyle SpaceBeforeBrace = getLLVMStyle();
11574   SpaceBeforeBrace.SpaceBeforeCpp11BracedList = true;
11575   verifyFormat("vector<int> x {1, 2, 3, 4};", SpaceBeforeBrace);
11576   verifyFormat("f({}, {{}, {}}, MyMap[{k, v}]);", SpaceBeforeBrace);
11577 
11578   FormatStyle SpaceBetweenBraces = getLLVMStyle();
11579   SpaceBetweenBraces.SpacesInAngles = FormatStyle::SIAS_Always;
11580   SpaceBetweenBraces.SpacesInParentheses = true;
11581   SpaceBetweenBraces.SpacesInSquareBrackets = true;
11582   verifyFormat("vector< int > x{ 1, 2, 3, 4 };", SpaceBetweenBraces);
11583   verifyFormat("f( {}, { {}, {} }, MyMap[ { k, v } ] );", SpaceBetweenBraces);
11584   verifyFormat("vector< int > x{ // comment 1\n"
11585                "                 1, 2, 3, 4 };",
11586                SpaceBetweenBraces);
11587   SpaceBetweenBraces.ColumnLimit = 20;
11588   EXPECT_EQ("vector< int > x{\n"
11589             "    1, 2, 3, 4 };",
11590             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
11591   SpaceBetweenBraces.ColumnLimit = 24;
11592   EXPECT_EQ("vector< int > x{ 1, 2,\n"
11593             "                 3, 4 };",
11594             format("vector<int>x{1,2,3,4};", SpaceBetweenBraces));
11595   EXPECT_EQ("vector< int > x{\n"
11596             "    1,\n"
11597             "    2,\n"
11598             "    3,\n"
11599             "    4,\n"
11600             "};",
11601             format("vector<int>x{1,2,3,4,};", SpaceBetweenBraces));
11602   verifyFormat("vector< int > x{};", SpaceBetweenBraces);
11603   SpaceBetweenBraces.SpaceInEmptyParentheses = true;
11604   verifyFormat("vector< int > x{ };", SpaceBetweenBraces);
11605 }
11606 
11607 TEST_F(FormatTest, FormatsBracedListsInColumnLayout) {
11608   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11609                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11610                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11611                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11612                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11613                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
11614   verifyFormat("vector<int> x = {1, 22, 333, 4444, 55555, 666666, 7777777, //\n"
11615                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11616                "                 1, 22, 333, 4444, 55555, //\n"
11617                "                 1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11618                "                 1, 22, 333, 4444, 55555, 666666, 7777777};");
11619   verifyFormat(
11620       "vector<int> x = {1,       22, 333, 4444, 55555, 666666, 7777777,\n"
11621       "                 1,       22, 333, 4444, 55555, 666666, 7777777,\n"
11622       "                 1,       22, 333, 4444, 55555, 666666, // comment\n"
11623       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
11624       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
11625       "                 7777777, 1,  22,  333,  4444,  55555,  666666,\n"
11626       "                 7777777};");
11627   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
11628                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
11629                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
11630   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
11631                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
11632                "    // Separating comment.\n"
11633                "    X86::R8, X86::R9, X86::R10, X86::R11, 0};");
11634   verifyFormat("static const uint16_t CallerSavedRegs64Bittttt[] = {\n"
11635                "    // Leading comment\n"
11636                "    X86::RAX, X86::RDX, X86::RCX, X86::RSI, X86::RDI,\n"
11637                "    X86::R8,  X86::R9,  X86::R10, X86::R11, 0};");
11638   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
11639                "                 1, 1, 1, 1};",
11640                getLLVMStyleWithColumns(39));
11641   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
11642                "                 1, 1, 1, 1};",
11643                getLLVMStyleWithColumns(38));
11644   verifyFormat("vector<int> aaaaaaaaaaaaaaaaaaaaaa = {\n"
11645                "    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};",
11646                getLLVMStyleWithColumns(43));
11647   verifyFormat(
11648       "static unsigned SomeValues[10][3] = {\n"
11649       "    {1, 4, 0},  {4, 9, 0},  {4, 5, 9},  {8, 5, 4}, {1, 8, 4},\n"
11650       "    {10, 1, 6}, {11, 0, 9}, {2, 11, 9}, {5, 2, 9}, {11, 2, 7}};");
11651   verifyFormat("static auto fields = new vector<string>{\n"
11652                "    \"aaaaaaaaaaaaa\",\n"
11653                "    \"aaaaaaaaaaaaa\",\n"
11654                "    \"aaaaaaaaaaaa\",\n"
11655                "    \"aaaaaaaaaaaaaa\",\n"
11656                "    \"aaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
11657                "    \"aaaaaaaaaaaa\",\n"
11658                "    \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",\n"
11659                "};");
11660   verifyFormat("vector<int> x = {1, 2, 3, 4, aaaaaaaaaaaaaaaaa, 6};");
11661   verifyFormat("vector<int> x = {1, aaaaaaaaaaaaaaaaaaaaaa,\n"
11662                "                 2, bbbbbbbbbbbbbbbbbbbbbb,\n"
11663                "                 3, cccccccccccccccccccccc};",
11664                getLLVMStyleWithColumns(60));
11665 
11666   // Trailing commas.
11667   verifyFormat("vector<int> x = {\n"
11668                "    1, 1, 1, 1, 1, 1, 1, 1,\n"
11669                "};",
11670                getLLVMStyleWithColumns(39));
11671   verifyFormat("vector<int> x = {\n"
11672                "    1, 1, 1, 1, 1, 1, 1, 1, //\n"
11673                "};",
11674                getLLVMStyleWithColumns(39));
11675   verifyFormat("vector<int> x = {1, 1, 1, 1,\n"
11676                "                 1, 1, 1, 1,\n"
11677                "                 /**/ /**/};",
11678                getLLVMStyleWithColumns(39));
11679 
11680   // Trailing comment in the first line.
11681   verifyFormat("vector<int> iiiiiiiiiiiiiii = {                      //\n"
11682                "    1111111111, 2222222222, 33333333333, 4444444444, //\n"
11683                "    111111111,  222222222,  3333333333,  444444444,  //\n"
11684                "    11111111,   22222222,   333333333,   44444444};");
11685   // Trailing comment in the last line.
11686   verifyFormat("int aaaaa[] = {\n"
11687                "    1, 2, 3, // comment\n"
11688                "    4, 5, 6  // comment\n"
11689                "};");
11690 
11691   // With nested lists, we should either format one item per line or all nested
11692   // lists one on line.
11693   // FIXME: For some nested lists, we can do better.
11694   verifyFormat("return {{aaaaaaaaaaaaaaaaaaaaa},\n"
11695                "        {aaaaaaaaaaaaaaaaaaa},\n"
11696                "        {aaaaaaaaaaaaaaaaaaaaa},\n"
11697                "        {aaaaaaaaaaaaaaaaa}};",
11698                getLLVMStyleWithColumns(60));
11699   verifyFormat(
11700       "SomeStruct my_struct_array = {\n"
11701       "    {aaaaaa, aaaaaaaa, aaaaaaaaaa, aaaaaaaaa, aaaaaaaaa, aaaaaaaaaa,\n"
11702       "     aaaaaaaaaaaaa, aaaaaaa, aaa},\n"
11703       "    {aaa, aaa},\n"
11704       "    {aaa, aaa},\n"
11705       "    {aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaaa, aaa},\n"
11706       "    {aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaa,\n"
11707       "     aaaaaaaaaaaa, a, aaaaaaaaaa, aaaaaaaaa, aaa}};");
11708 
11709   // No column layout should be used here.
11710   verifyFormat("aaaaaaaaaaaaaaa = {aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0, 0,\n"
11711                "                   bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb};");
11712 
11713   verifyNoCrash("a<,");
11714 
11715   // No braced initializer here.
11716   verifyFormat("void f() {\n"
11717                "  struct Dummy {};\n"
11718                "  f(v);\n"
11719                "}");
11720 
11721   // Long lists should be formatted in columns even if they are nested.
11722   verifyFormat(
11723       "vector<int> x = function({1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11724       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11725       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11726       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11727       "                          1, 22, 333, 4444, 55555, 666666, 7777777,\n"
11728       "                          1, 22, 333, 4444, 55555, 666666, 7777777});");
11729 
11730   // Allow "single-column" layout even if that violates the column limit. There
11731   // isn't going to be a better way.
11732   verifyFormat("std::vector<int> a = {\n"
11733                "    aaaaaaaa,\n"
11734                "    aaaaaaaa,\n"
11735                "    aaaaaaaa,\n"
11736                "    aaaaaaaa,\n"
11737                "    aaaaaaaaaa,\n"
11738                "    aaaaaaaa,\n"
11739                "    aaaaaaaaaaaaaaaaaaaaaaaaaaa};",
11740                getLLVMStyleWithColumns(30));
11741   verifyFormat("vector<int> aaaa = {\n"
11742                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
11743                "    aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
11744                "    aaaaaa.aaaaaaa,\n"
11745                "    aaaaaa.aaaaaaa,\n"
11746                "    aaaaaa.aaaaaaa,\n"
11747                "    aaaaaa.aaaaaaa,\n"
11748                "};");
11749 
11750   // Don't create hanging lists.
11751   verifyFormat("someFunction(Param, {List1, List2,\n"
11752                "                     List3});",
11753                getLLVMStyleWithColumns(35));
11754   verifyFormat("someFunction(Param, Param,\n"
11755                "             {List1, List2,\n"
11756                "              List3});",
11757                getLLVMStyleWithColumns(35));
11758   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaa, {},\n"
11759                "                               aaaaaaaaaaaaaaaaaaaaaaa);");
11760 }
11761 
11762 TEST_F(FormatTest, PullTrivialFunctionDefinitionsIntoSingleLine) {
11763   FormatStyle DoNotMerge = getLLVMStyle();
11764   DoNotMerge.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
11765 
11766   verifyFormat("void f() { return 42; }");
11767   verifyFormat("void f() {\n"
11768                "  return 42;\n"
11769                "}",
11770                DoNotMerge);
11771   verifyFormat("void f() {\n"
11772                "  // Comment\n"
11773                "}");
11774   verifyFormat("{\n"
11775                "#error {\n"
11776                "  int a;\n"
11777                "}");
11778   verifyFormat("{\n"
11779                "  int a;\n"
11780                "#error {\n"
11781                "}");
11782   verifyFormat("void f() {} // comment");
11783   verifyFormat("void f() { int a; } // comment");
11784   verifyFormat("void f() {\n"
11785                "} // comment",
11786                DoNotMerge);
11787   verifyFormat("void f() {\n"
11788                "  int a;\n"
11789                "} // comment",
11790                DoNotMerge);
11791   verifyFormat("void f() {\n"
11792                "} // comment",
11793                getLLVMStyleWithColumns(15));
11794 
11795   verifyFormat("void f() { return 42; }", getLLVMStyleWithColumns(23));
11796   verifyFormat("void f() {\n  return 42;\n}", getLLVMStyleWithColumns(22));
11797 
11798   verifyFormat("void f() {}", getLLVMStyleWithColumns(11));
11799   verifyFormat("void f() {\n}", getLLVMStyleWithColumns(10));
11800   verifyFormat("class C {\n"
11801                "  C()\n"
11802                "      : iiiiiiii(nullptr),\n"
11803                "        kkkkkkk(nullptr),\n"
11804                "        mmmmmmm(nullptr),\n"
11805                "        nnnnnnn(nullptr) {}\n"
11806                "};",
11807                getGoogleStyle());
11808 
11809   FormatStyle NoColumnLimit = getLLVMStyle();
11810   NoColumnLimit.ColumnLimit = 0;
11811   EXPECT_EQ("A() : b(0) {}", format("A():b(0){}", NoColumnLimit));
11812   EXPECT_EQ("class C {\n"
11813             "  A() : b(0) {}\n"
11814             "};",
11815             format("class C{A():b(0){}};", NoColumnLimit));
11816   EXPECT_EQ("A()\n"
11817             "    : b(0) {\n"
11818             "}",
11819             format("A()\n:b(0)\n{\n}", NoColumnLimit));
11820 
11821   FormatStyle DoNotMergeNoColumnLimit = NoColumnLimit;
11822   DoNotMergeNoColumnLimit.AllowShortFunctionsOnASingleLine =
11823       FormatStyle::SFS_None;
11824   EXPECT_EQ("A()\n"
11825             "    : b(0) {\n"
11826             "}",
11827             format("A():b(0){}", DoNotMergeNoColumnLimit));
11828   EXPECT_EQ("A()\n"
11829             "    : b(0) {\n"
11830             "}",
11831             format("A()\n:b(0)\n{\n}", DoNotMergeNoColumnLimit));
11832 
11833   verifyFormat("#define A          \\\n"
11834                "  void f() {       \\\n"
11835                "    int i;         \\\n"
11836                "  }",
11837                getLLVMStyleWithColumns(20));
11838   verifyFormat("#define A           \\\n"
11839                "  void f() { int i; }",
11840                getLLVMStyleWithColumns(21));
11841   verifyFormat("#define A            \\\n"
11842                "  void f() {         \\\n"
11843                "    int i;           \\\n"
11844                "  }                  \\\n"
11845                "  int j;",
11846                getLLVMStyleWithColumns(22));
11847   verifyFormat("#define A             \\\n"
11848                "  void f() { int i; } \\\n"
11849                "  int j;",
11850                getLLVMStyleWithColumns(23));
11851 }
11852 
11853 TEST_F(FormatTest, PullEmptyFunctionDefinitionsIntoSingleLine) {
11854   FormatStyle MergeEmptyOnly = getLLVMStyle();
11855   MergeEmptyOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
11856   verifyFormat("class C {\n"
11857                "  int f() {}\n"
11858                "};",
11859                MergeEmptyOnly);
11860   verifyFormat("class C {\n"
11861                "  int f() {\n"
11862                "    return 42;\n"
11863                "  }\n"
11864                "};",
11865                MergeEmptyOnly);
11866   verifyFormat("int f() {}", MergeEmptyOnly);
11867   verifyFormat("int f() {\n"
11868                "  return 42;\n"
11869                "}",
11870                MergeEmptyOnly);
11871 
11872   // Also verify behavior when BraceWrapping.AfterFunction = true
11873   MergeEmptyOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
11874   MergeEmptyOnly.BraceWrapping.AfterFunction = true;
11875   verifyFormat("int f() {}", MergeEmptyOnly);
11876   verifyFormat("class C {\n"
11877                "  int f() {}\n"
11878                "};",
11879                MergeEmptyOnly);
11880 }
11881 
11882 TEST_F(FormatTest, PullInlineFunctionDefinitionsIntoSingleLine) {
11883   FormatStyle MergeInlineOnly = getLLVMStyle();
11884   MergeInlineOnly.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
11885   verifyFormat("class C {\n"
11886                "  int f() { return 42; }\n"
11887                "};",
11888                MergeInlineOnly);
11889   verifyFormat("int f() {\n"
11890                "  return 42;\n"
11891                "}",
11892                MergeInlineOnly);
11893 
11894   // SFS_Inline implies SFS_Empty
11895   verifyFormat("class C {\n"
11896                "  int f() {}\n"
11897                "};",
11898                MergeInlineOnly);
11899   verifyFormat("int f() {}", MergeInlineOnly);
11900 
11901   // Also verify behavior when BraceWrapping.AfterFunction = true
11902   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
11903   MergeInlineOnly.BraceWrapping.AfterFunction = true;
11904   verifyFormat("class C {\n"
11905                "  int f() { return 42; }\n"
11906                "};",
11907                MergeInlineOnly);
11908   verifyFormat("int f()\n"
11909                "{\n"
11910                "  return 42;\n"
11911                "}",
11912                MergeInlineOnly);
11913 
11914   // SFS_Inline implies SFS_Empty
11915   verifyFormat("int f() {}", MergeInlineOnly);
11916   verifyFormat("class C {\n"
11917                "  int f() {}\n"
11918                "};",
11919                MergeInlineOnly);
11920 }
11921 
11922 TEST_F(FormatTest, PullInlineOnlyFunctionDefinitionsIntoSingleLine) {
11923   FormatStyle MergeInlineOnly = getLLVMStyle();
11924   MergeInlineOnly.AllowShortFunctionsOnASingleLine =
11925       FormatStyle::SFS_InlineOnly;
11926   verifyFormat("class C {\n"
11927                "  int f() { return 42; }\n"
11928                "};",
11929                MergeInlineOnly);
11930   verifyFormat("int f() {\n"
11931                "  return 42;\n"
11932                "}",
11933                MergeInlineOnly);
11934 
11935   // SFS_InlineOnly does not imply SFS_Empty
11936   verifyFormat("class C {\n"
11937                "  int f() {}\n"
11938                "};",
11939                MergeInlineOnly);
11940   verifyFormat("int f() {\n"
11941                "}",
11942                MergeInlineOnly);
11943 
11944   // Also verify behavior when BraceWrapping.AfterFunction = true
11945   MergeInlineOnly.BreakBeforeBraces = FormatStyle::BS_Custom;
11946   MergeInlineOnly.BraceWrapping.AfterFunction = true;
11947   verifyFormat("class C {\n"
11948                "  int f() { return 42; }\n"
11949                "};",
11950                MergeInlineOnly);
11951   verifyFormat("int f()\n"
11952                "{\n"
11953                "  return 42;\n"
11954                "}",
11955                MergeInlineOnly);
11956 
11957   // SFS_InlineOnly does not imply SFS_Empty
11958   verifyFormat("int f()\n"
11959                "{\n"
11960                "}",
11961                MergeInlineOnly);
11962   verifyFormat("class C {\n"
11963                "  int f() {}\n"
11964                "};",
11965                MergeInlineOnly);
11966 }
11967 
11968 TEST_F(FormatTest, SplitEmptyFunction) {
11969   FormatStyle Style = getLLVMStyle();
11970   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
11971   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
11972   Style.BraceWrapping.AfterFunction = true;
11973   Style.BraceWrapping.SplitEmptyFunction = false;
11974   Style.ColumnLimit = 40;
11975 
11976   verifyFormat("int f()\n"
11977                "{}",
11978                Style);
11979   verifyFormat("int f()\n"
11980                "{\n"
11981                "  return 42;\n"
11982                "}",
11983                Style);
11984   verifyFormat("int f()\n"
11985                "{\n"
11986                "  // some comment\n"
11987                "}",
11988                Style);
11989 
11990   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
11991   verifyFormat("int f() {}", Style);
11992   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
11993                "{}",
11994                Style);
11995   verifyFormat("int f()\n"
11996                "{\n"
11997                "  return 0;\n"
11998                "}",
11999                Style);
12000 
12001   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
12002   verifyFormat("class Foo {\n"
12003                "  int f() {}\n"
12004                "};\n",
12005                Style);
12006   verifyFormat("class Foo {\n"
12007                "  int f() { return 0; }\n"
12008                "};\n",
12009                Style);
12010   verifyFormat("class Foo {\n"
12011                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
12012                "  {}\n"
12013                "};\n",
12014                Style);
12015   verifyFormat("class Foo {\n"
12016                "  int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
12017                "  {\n"
12018                "    return 0;\n"
12019                "  }\n"
12020                "};\n",
12021                Style);
12022 
12023   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
12024   verifyFormat("int f() {}", Style);
12025   verifyFormat("int f() { return 0; }", Style);
12026   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
12027                "{}",
12028                Style);
12029   verifyFormat("int aaaaaaaaaaaaaa(int bbbbbbbbbbbbbb)\n"
12030                "{\n"
12031                "  return 0;\n"
12032                "}",
12033                Style);
12034 }
12035 TEST_F(FormatTest, KeepShortFunctionAfterPPElse) {
12036   FormatStyle Style = getLLVMStyle();
12037   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
12038   verifyFormat("#ifdef A\n"
12039                "int f() {}\n"
12040                "#else\n"
12041                "int g() {}\n"
12042                "#endif",
12043                Style);
12044 }
12045 
12046 TEST_F(FormatTest, SplitEmptyClass) {
12047   FormatStyle Style = getLLVMStyle();
12048   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
12049   Style.BraceWrapping.AfterClass = true;
12050   Style.BraceWrapping.SplitEmptyRecord = false;
12051 
12052   verifyFormat("class Foo\n"
12053                "{};",
12054                Style);
12055   verifyFormat("/* something */ class Foo\n"
12056                "{};",
12057                Style);
12058   verifyFormat("template <typename X> class Foo\n"
12059                "{};",
12060                Style);
12061   verifyFormat("class Foo\n"
12062                "{\n"
12063                "  Foo();\n"
12064                "};",
12065                Style);
12066   verifyFormat("typedef class Foo\n"
12067                "{\n"
12068                "} Foo_t;",
12069                Style);
12070 
12071   Style.BraceWrapping.SplitEmptyRecord = true;
12072   Style.BraceWrapping.AfterStruct = true;
12073   verifyFormat("class rep\n"
12074                "{\n"
12075                "};",
12076                Style);
12077   verifyFormat("struct rep\n"
12078                "{\n"
12079                "};",
12080                Style);
12081   verifyFormat("template <typename T> class rep\n"
12082                "{\n"
12083                "};",
12084                Style);
12085   verifyFormat("template <typename T> struct rep\n"
12086                "{\n"
12087                "};",
12088                Style);
12089   verifyFormat("class rep\n"
12090                "{\n"
12091                "  int x;\n"
12092                "};",
12093                Style);
12094   verifyFormat("struct rep\n"
12095                "{\n"
12096                "  int x;\n"
12097                "};",
12098                Style);
12099   verifyFormat("template <typename T> class rep\n"
12100                "{\n"
12101                "  int x;\n"
12102                "};",
12103                Style);
12104   verifyFormat("template <typename T> struct rep\n"
12105                "{\n"
12106                "  int x;\n"
12107                "};",
12108                Style);
12109   verifyFormat("template <typename T> class rep // Foo\n"
12110                "{\n"
12111                "  int x;\n"
12112                "};",
12113                Style);
12114   verifyFormat("template <typename T> struct rep // Bar\n"
12115                "{\n"
12116                "  int x;\n"
12117                "};",
12118                Style);
12119 
12120   verifyFormat("template <typename T> class rep<T>\n"
12121                "{\n"
12122                "  int x;\n"
12123                "};",
12124                Style);
12125 
12126   verifyFormat("template <typename T> class rep<std::complex<T>>\n"
12127                "{\n"
12128                "  int x;\n"
12129                "};",
12130                Style);
12131   verifyFormat("template <typename T> class rep<std::complex<T>>\n"
12132                "{\n"
12133                "};",
12134                Style);
12135 
12136   verifyFormat("#include \"stdint.h\"\n"
12137                "namespace rep {}",
12138                Style);
12139   verifyFormat("#include <stdint.h>\n"
12140                "namespace rep {}",
12141                Style);
12142   verifyFormat("#include <stdint.h>\n"
12143                "namespace rep {}",
12144                "#include <stdint.h>\n"
12145                "namespace rep {\n"
12146                "\n"
12147                "\n"
12148                "}",
12149                Style);
12150 }
12151 
12152 TEST_F(FormatTest, SplitEmptyStruct) {
12153   FormatStyle Style = getLLVMStyle();
12154   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
12155   Style.BraceWrapping.AfterStruct = true;
12156   Style.BraceWrapping.SplitEmptyRecord = false;
12157 
12158   verifyFormat("struct Foo\n"
12159                "{};",
12160                Style);
12161   verifyFormat("/* something */ struct Foo\n"
12162                "{};",
12163                Style);
12164   verifyFormat("template <typename X> struct Foo\n"
12165                "{};",
12166                Style);
12167   verifyFormat("struct Foo\n"
12168                "{\n"
12169                "  Foo();\n"
12170                "};",
12171                Style);
12172   verifyFormat("typedef struct Foo\n"
12173                "{\n"
12174                "} Foo_t;",
12175                Style);
12176   // typedef struct Bar {} Bar_t;
12177 }
12178 
12179 TEST_F(FormatTest, SplitEmptyUnion) {
12180   FormatStyle Style = getLLVMStyle();
12181   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
12182   Style.BraceWrapping.AfterUnion = true;
12183   Style.BraceWrapping.SplitEmptyRecord = false;
12184 
12185   verifyFormat("union Foo\n"
12186                "{};",
12187                Style);
12188   verifyFormat("/* something */ union Foo\n"
12189                "{};",
12190                Style);
12191   verifyFormat("union Foo\n"
12192                "{\n"
12193                "  A,\n"
12194                "};",
12195                Style);
12196   verifyFormat("typedef union Foo\n"
12197                "{\n"
12198                "} Foo_t;",
12199                Style);
12200 }
12201 
12202 TEST_F(FormatTest, SplitEmptyNamespace) {
12203   FormatStyle Style = getLLVMStyle();
12204   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
12205   Style.BraceWrapping.AfterNamespace = true;
12206   Style.BraceWrapping.SplitEmptyNamespace = false;
12207 
12208   verifyFormat("namespace Foo\n"
12209                "{};",
12210                Style);
12211   verifyFormat("/* something */ namespace Foo\n"
12212                "{};",
12213                Style);
12214   verifyFormat("inline namespace Foo\n"
12215                "{};",
12216                Style);
12217   verifyFormat("/* something */ inline namespace Foo\n"
12218                "{};",
12219                Style);
12220   verifyFormat("export namespace Foo\n"
12221                "{};",
12222                Style);
12223   verifyFormat("namespace Foo\n"
12224                "{\n"
12225                "void Bar();\n"
12226                "};",
12227                Style);
12228 }
12229 
12230 TEST_F(FormatTest, NeverMergeShortRecords) {
12231   FormatStyle Style = getLLVMStyle();
12232 
12233   verifyFormat("class Foo {\n"
12234                "  Foo();\n"
12235                "};",
12236                Style);
12237   verifyFormat("typedef class Foo {\n"
12238                "  Foo();\n"
12239                "} Foo_t;",
12240                Style);
12241   verifyFormat("struct Foo {\n"
12242                "  Foo();\n"
12243                "};",
12244                Style);
12245   verifyFormat("typedef struct Foo {\n"
12246                "  Foo();\n"
12247                "} Foo_t;",
12248                Style);
12249   verifyFormat("union Foo {\n"
12250                "  A,\n"
12251                "};",
12252                Style);
12253   verifyFormat("typedef union Foo {\n"
12254                "  A,\n"
12255                "} Foo_t;",
12256                Style);
12257   verifyFormat("namespace Foo {\n"
12258                "void Bar();\n"
12259                "};",
12260                Style);
12261 
12262   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
12263   Style.BraceWrapping.AfterClass = true;
12264   Style.BraceWrapping.AfterStruct = true;
12265   Style.BraceWrapping.AfterUnion = true;
12266   Style.BraceWrapping.AfterNamespace = true;
12267   verifyFormat("class Foo\n"
12268                "{\n"
12269                "  Foo();\n"
12270                "};",
12271                Style);
12272   verifyFormat("typedef class Foo\n"
12273                "{\n"
12274                "  Foo();\n"
12275                "} Foo_t;",
12276                Style);
12277   verifyFormat("struct Foo\n"
12278                "{\n"
12279                "  Foo();\n"
12280                "};",
12281                Style);
12282   verifyFormat("typedef struct Foo\n"
12283                "{\n"
12284                "  Foo();\n"
12285                "} Foo_t;",
12286                Style);
12287   verifyFormat("union Foo\n"
12288                "{\n"
12289                "  A,\n"
12290                "};",
12291                Style);
12292   verifyFormat("typedef union Foo\n"
12293                "{\n"
12294                "  A,\n"
12295                "} Foo_t;",
12296                Style);
12297   verifyFormat("namespace Foo\n"
12298                "{\n"
12299                "void Bar();\n"
12300                "};",
12301                Style);
12302 }
12303 
12304 TEST_F(FormatTest, UnderstandContextOfRecordTypeKeywords) {
12305   // Elaborate type variable declarations.
12306   verifyFormat("struct foo a = {bar};\nint n;");
12307   verifyFormat("class foo a = {bar};\nint n;");
12308   verifyFormat("union foo a = {bar};\nint n;");
12309 
12310   // Elaborate types inside function definitions.
12311   verifyFormat("struct foo f() {}\nint n;");
12312   verifyFormat("class foo f() {}\nint n;");
12313   verifyFormat("union foo f() {}\nint n;");
12314 
12315   // Templates.
12316   verifyFormat("template <class X> void f() {}\nint n;");
12317   verifyFormat("template <struct X> void f() {}\nint n;");
12318   verifyFormat("template <union X> void f() {}\nint n;");
12319 
12320   // Actual definitions...
12321   verifyFormat("struct {\n} n;");
12322   verifyFormat(
12323       "template <template <class T, class Y>, class Z> class X {\n} n;");
12324   verifyFormat("union Z {\n  int n;\n} x;");
12325   verifyFormat("class MACRO Z {\n} n;");
12326   verifyFormat("class MACRO(X) Z {\n} n;");
12327   verifyFormat("class __attribute__(X) Z {\n} n;");
12328   verifyFormat("class __declspec(X) Z {\n} n;");
12329   verifyFormat("class A##B##C {\n} n;");
12330   verifyFormat("class alignas(16) Z {\n} n;");
12331   verifyFormat("class MACRO(X) alignas(16) Z {\n} n;");
12332   verifyFormat("class MACROA MACRO(X) Z {\n} n;");
12333 
12334   // Redefinition from nested context:
12335   verifyFormat("class A::B::C {\n} n;");
12336 
12337   // Template definitions.
12338   verifyFormat(
12339       "template <typename F>\n"
12340       "Matcher(const Matcher<F> &Other,\n"
12341       "        typename enable_if_c<is_base_of<F, T>::value &&\n"
12342       "                             !is_same<F, T>::value>::type * = 0)\n"
12343       "    : Implementation(new ImplicitCastMatcher<F>(Other)) {}");
12344 
12345   // FIXME: This is still incorrectly handled at the formatter side.
12346   verifyFormat("template <> struct X < 15, i<3 && 42 < 50 && 33 < 28> {};");
12347   verifyFormat("int i = SomeFunction(a<b, a> b);");
12348 
12349   // FIXME:
12350   // This now gets parsed incorrectly as class definition.
12351   // verifyFormat("class A<int> f() {\n}\nint n;");
12352 
12353   // Elaborate types where incorrectly parsing the structural element would
12354   // break the indent.
12355   verifyFormat("if (true)\n"
12356                "  class X x;\n"
12357                "else\n"
12358                "  f();\n");
12359 
12360   // This is simply incomplete. Formatting is not important, but must not crash.
12361   verifyFormat("class A:");
12362 }
12363 
12364 TEST_F(FormatTest, DoNotInterfereWithErrorAndWarning) {
12365   EXPECT_EQ("#error Leave     all         white!!!!! space* alone!\n",
12366             format("#error Leave     all         white!!!!! space* alone!\n"));
12367   EXPECT_EQ(
12368       "#warning Leave     all         white!!!!! space* alone!\n",
12369       format("#warning Leave     all         white!!!!! space* alone!\n"));
12370   EXPECT_EQ("#error 1", format("  #  error   1"));
12371   EXPECT_EQ("#warning 1", format("  #  warning 1"));
12372 }
12373 
12374 TEST_F(FormatTest, FormatHashIfExpressions) {
12375   verifyFormat("#if AAAA && BBBB");
12376   verifyFormat("#if (AAAA && BBBB)");
12377   verifyFormat("#elif (AAAA && BBBB)");
12378   // FIXME: Come up with a better indentation for #elif.
12379   verifyFormat(
12380       "#if !defined(AAAAAAA) && (defined CCCCCC || defined DDDDDD) &&  \\\n"
12381       "    defined(BBBBBBBB)\n"
12382       "#elif !defined(AAAAAA) && (defined CCCCC || defined DDDDDD) &&  \\\n"
12383       "    defined(BBBBBBBB)\n"
12384       "#endif",
12385       getLLVMStyleWithColumns(65));
12386 }
12387 
12388 TEST_F(FormatTest, MergeHandlingInTheFaceOfPreprocessorDirectives) {
12389   FormatStyle AllowsMergedIf = getGoogleStyle();
12390   AllowsMergedIf.AllowShortIfStatementsOnASingleLine =
12391       FormatStyle::SIS_WithoutElse;
12392   verifyFormat("void f() { f(); }\n#error E", AllowsMergedIf);
12393   verifyFormat("if (true) return 42;\n#error E", AllowsMergedIf);
12394   verifyFormat("if (true)\n#error E\n  return 42;", AllowsMergedIf);
12395   EXPECT_EQ("if (true) return 42;",
12396             format("if (true)\nreturn 42;", AllowsMergedIf));
12397   FormatStyle ShortMergedIf = AllowsMergedIf;
12398   ShortMergedIf.ColumnLimit = 25;
12399   verifyFormat("#define A \\\n"
12400                "  if (true) return 42;",
12401                ShortMergedIf);
12402   verifyFormat("#define A \\\n"
12403                "  f();    \\\n"
12404                "  if (true)\n"
12405                "#define B",
12406                ShortMergedIf);
12407   verifyFormat("#define A \\\n"
12408                "  f();    \\\n"
12409                "  if (true)\n"
12410                "g();",
12411                ShortMergedIf);
12412   verifyFormat("{\n"
12413                "#ifdef A\n"
12414                "  // Comment\n"
12415                "  if (true) continue;\n"
12416                "#endif\n"
12417                "  // Comment\n"
12418                "  if (true) continue;\n"
12419                "}",
12420                ShortMergedIf);
12421   ShortMergedIf.ColumnLimit = 33;
12422   verifyFormat("#define A \\\n"
12423                "  if constexpr (true) return 42;",
12424                ShortMergedIf);
12425   verifyFormat("#define A \\\n"
12426                "  if CONSTEXPR (true) return 42;",
12427                ShortMergedIf);
12428   ShortMergedIf.ColumnLimit = 29;
12429   verifyFormat("#define A                   \\\n"
12430                "  if (aaaaaaaaaa) return 1; \\\n"
12431                "  return 2;",
12432                ShortMergedIf);
12433   ShortMergedIf.ColumnLimit = 28;
12434   verifyFormat("#define A         \\\n"
12435                "  if (aaaaaaaaaa) \\\n"
12436                "    return 1;     \\\n"
12437                "  return 2;",
12438                ShortMergedIf);
12439   verifyFormat("#define A                \\\n"
12440                "  if constexpr (aaaaaaa) \\\n"
12441                "    return 1;            \\\n"
12442                "  return 2;",
12443                ShortMergedIf);
12444   verifyFormat("#define A                \\\n"
12445                "  if CONSTEXPR (aaaaaaa) \\\n"
12446                "    return 1;            \\\n"
12447                "  return 2;",
12448                ShortMergedIf);
12449 }
12450 
12451 TEST_F(FormatTest, FormatStarDependingOnContext) {
12452   verifyFormat("void f(int *a);");
12453   verifyFormat("void f() { f(fint * b); }");
12454   verifyFormat("class A {\n  void f(int *a);\n};");
12455   verifyFormat("class A {\n  int *a;\n};");
12456   verifyFormat("namespace a {\n"
12457                "namespace b {\n"
12458                "class A {\n"
12459                "  void f() {}\n"
12460                "  int *a;\n"
12461                "};\n"
12462                "} // namespace b\n"
12463                "} // namespace a");
12464 }
12465 
12466 TEST_F(FormatTest, SpecialTokensAtEndOfLine) {
12467   verifyFormat("while");
12468   verifyFormat("operator");
12469 }
12470 
12471 TEST_F(FormatTest, SkipsDeeplyNestedLines) {
12472   // This code would be painfully slow to format if we didn't skip it.
12473   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
12474                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
12475                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
12476                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
12477                    "A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(A(\n"
12478                    "A(1, 1)\n"
12479                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n" // 10x
12480                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
12481                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
12482                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
12483                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
12484                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
12485                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
12486                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
12487                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1)\n"
12488                    ", 1), 1), 1), 1), 1), 1), 1), 1), 1), 1);\n");
12489   // Deeply nested part is untouched, rest is formatted.
12490   EXPECT_EQ(std::string("int i;\n") + Code + "int j;\n",
12491             format(std::string("int    i;\n") + Code + "int    j;\n",
12492                    getLLVMStyle(), SC_ExpectIncomplete));
12493 }
12494 
12495 //===----------------------------------------------------------------------===//
12496 // Objective-C tests.
12497 //===----------------------------------------------------------------------===//
12498 
12499 TEST_F(FormatTest, FormatForObjectiveCMethodDecls) {
12500   verifyFormat("- (void)sendAction:(SEL)aSelector to:(BOOL)anObject;");
12501   EXPECT_EQ("- (NSUInteger)indexOfObject:(id)anObject;",
12502             format("-(NSUInteger)indexOfObject:(id)anObject;"));
12503   EXPECT_EQ("- (NSInteger)Mthod1;", format("-(NSInteger)Mthod1;"));
12504   EXPECT_EQ("+ (id)Mthod2;", format("+(id)Mthod2;"));
12505   EXPECT_EQ("- (NSInteger)Method3:(id)anObject;",
12506             format("-(NSInteger)Method3:(id)anObject;"));
12507   EXPECT_EQ("- (NSInteger)Method4:(id)anObject;",
12508             format("-(NSInteger)Method4:(id)anObject;"));
12509   EXPECT_EQ("- (NSInteger)Method5:(id)anObject:(id)AnotherObject;",
12510             format("-(NSInteger)Method5:(id)anObject:(id)AnotherObject;"));
12511   EXPECT_EQ("- (id)Method6:(id)A:(id)B:(id)C:(id)D;",
12512             format("- (id)Method6:(id)A:(id)B:(id)C:(id)D;"));
12513   EXPECT_EQ("- (void)sendAction:(SEL)aSelector to:(id)anObject "
12514             "forAllCells:(BOOL)flag;",
12515             format("- (void)sendAction:(SEL)aSelector to:(id)anObject "
12516                    "forAllCells:(BOOL)flag;"));
12517 
12518   // Very long objectiveC method declaration.
12519   verifyFormat("- (void)aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
12520                "    (SoooooooooooooooooooooomeType *)bbbbbbbbbb;");
12521   verifyFormat("- (NSUInteger)indexOfObject:(id)anObject\n"
12522                "                    inRange:(NSRange)range\n"
12523                "                   outRange:(NSRange)out_range\n"
12524                "                  outRange1:(NSRange)out_range1\n"
12525                "                  outRange2:(NSRange)out_range2\n"
12526                "                  outRange3:(NSRange)out_range3\n"
12527                "                  outRange4:(NSRange)out_range4\n"
12528                "                  outRange5:(NSRange)out_range5\n"
12529                "                  outRange6:(NSRange)out_range6\n"
12530                "                  outRange7:(NSRange)out_range7\n"
12531                "                  outRange8:(NSRange)out_range8\n"
12532                "                  outRange9:(NSRange)out_range9;");
12533 
12534   // When the function name has to be wrapped.
12535   FormatStyle Style = getLLVMStyle();
12536   // ObjC ignores IndentWrappedFunctionNames when wrapping methods
12537   // and always indents instead.
12538   Style.IndentWrappedFunctionNames = false;
12539   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
12540                "    veryLooooooooooongName:(NSString)aaaaaaaaaaaaaa\n"
12541                "               anotherName:(NSString)bbbbbbbbbbbbbb {\n"
12542                "}",
12543                Style);
12544   Style.IndentWrappedFunctionNames = true;
12545   verifyFormat("- (SomeLooooooooooooooooooooongType *)\n"
12546                "    veryLooooooooooongName:(NSString)cccccccccccccc\n"
12547                "               anotherName:(NSString)dddddddddddddd {\n"
12548                "}",
12549                Style);
12550 
12551   verifyFormat("- (int)sum:(vector<int>)numbers;");
12552   verifyGoogleFormat("- (void)setDelegate:(id<Protocol>)delegate;");
12553   // FIXME: In LLVM style, there should be a space in front of a '<' for ObjC
12554   // protocol lists (but not for template classes):
12555   // verifyFormat("- (void)setDelegate:(id <Protocol>)delegate;");
12556 
12557   verifyFormat("- (int (*)())foo:(int (*)())f;");
12558   verifyGoogleFormat("- (int (*)())foo:(int (*)())foo;");
12559 
12560   // If there's no return type (very rare in practice!), LLVM and Google style
12561   // agree.
12562   verifyFormat("- foo;");
12563   verifyFormat("- foo:(int)f;");
12564   verifyGoogleFormat("- foo:(int)foo;");
12565 }
12566 
12567 TEST_F(FormatTest, BreaksStringLiterals) {
12568   EXPECT_EQ("\"some text \"\n"
12569             "\"other\";",
12570             format("\"some text other\";", getLLVMStyleWithColumns(12)));
12571   EXPECT_EQ("\"some text \"\n"
12572             "\"other\";",
12573             format("\\\n\"some text other\";", getLLVMStyleWithColumns(12)));
12574   EXPECT_EQ(
12575       "#define A  \\\n"
12576       "  \"some \"  \\\n"
12577       "  \"text \"  \\\n"
12578       "  \"other\";",
12579       format("#define A \"some text other\";", getLLVMStyleWithColumns(12)));
12580   EXPECT_EQ(
12581       "#define A  \\\n"
12582       "  \"so \"    \\\n"
12583       "  \"text \"  \\\n"
12584       "  \"other\";",
12585       format("#define A \"so text other\";", getLLVMStyleWithColumns(12)));
12586 
12587   EXPECT_EQ("\"some text\"",
12588             format("\"some text\"", getLLVMStyleWithColumns(1)));
12589   EXPECT_EQ("\"some text\"",
12590             format("\"some text\"", getLLVMStyleWithColumns(11)));
12591   EXPECT_EQ("\"some \"\n"
12592             "\"text\"",
12593             format("\"some text\"", getLLVMStyleWithColumns(10)));
12594   EXPECT_EQ("\"some \"\n"
12595             "\"text\"",
12596             format("\"some text\"", getLLVMStyleWithColumns(7)));
12597   EXPECT_EQ("\"some\"\n"
12598             "\" tex\"\n"
12599             "\"t\"",
12600             format("\"some text\"", getLLVMStyleWithColumns(6)));
12601   EXPECT_EQ("\"some\"\n"
12602             "\" tex\"\n"
12603             "\" and\"",
12604             format("\"some tex and\"", getLLVMStyleWithColumns(6)));
12605   EXPECT_EQ("\"some\"\n"
12606             "\"/tex\"\n"
12607             "\"/and\"",
12608             format("\"some/tex/and\"", getLLVMStyleWithColumns(6)));
12609 
12610   EXPECT_EQ("variable =\n"
12611             "    \"long string \"\n"
12612             "    \"literal\";",
12613             format("variable = \"long string literal\";",
12614                    getLLVMStyleWithColumns(20)));
12615 
12616   EXPECT_EQ("variable = f(\n"
12617             "    \"long string \"\n"
12618             "    \"literal\",\n"
12619             "    short,\n"
12620             "    loooooooooooooooooooong);",
12621             format("variable = f(\"long string literal\", short, "
12622                    "loooooooooooooooooooong);",
12623                    getLLVMStyleWithColumns(20)));
12624 
12625   EXPECT_EQ(
12626       "f(g(\"long string \"\n"
12627       "    \"literal\"),\n"
12628       "  b);",
12629       format("f(g(\"long string literal\"), b);", getLLVMStyleWithColumns(20)));
12630   EXPECT_EQ("f(g(\"long string \"\n"
12631             "    \"literal\",\n"
12632             "    a),\n"
12633             "  b);",
12634             format("f(g(\"long string literal\", a), b);",
12635                    getLLVMStyleWithColumns(20)));
12636   EXPECT_EQ(
12637       "f(\"one two\".split(\n"
12638       "    variable));",
12639       format("f(\"one two\".split(variable));", getLLVMStyleWithColumns(20)));
12640   EXPECT_EQ("f(\"one two three four five six \"\n"
12641             "  \"seven\".split(\n"
12642             "      really_looooong_variable));",
12643             format("f(\"one two three four five six seven\"."
12644                    "split(really_looooong_variable));",
12645                    getLLVMStyleWithColumns(33)));
12646 
12647   EXPECT_EQ("f(\"some \"\n"
12648             "  \"text\",\n"
12649             "  other);",
12650             format("f(\"some text\", other);", getLLVMStyleWithColumns(10)));
12651 
12652   // Only break as a last resort.
12653   verifyFormat(
12654       "aaaaaaaaaaaaaaaaaaaa(\n"
12655       "    aaaaaaaaaaaaaaaaaaaa,\n"
12656       "    aaaaaa(\"aaa aaaaa aaa aaa aaaaa aaa aaaaa aaa aaa aaaaaa\"));");
12657 
12658   EXPECT_EQ("\"splitmea\"\n"
12659             "\"trandomp\"\n"
12660             "\"oint\"",
12661             format("\"splitmeatrandompoint\"", getLLVMStyleWithColumns(10)));
12662 
12663   EXPECT_EQ("\"split/\"\n"
12664             "\"pathat/\"\n"
12665             "\"slashes\"",
12666             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
12667 
12668   EXPECT_EQ("\"split/\"\n"
12669             "\"pathat/\"\n"
12670             "\"slashes\"",
12671             format("\"split/pathat/slashes\"", getLLVMStyleWithColumns(10)));
12672   EXPECT_EQ("\"split at \"\n"
12673             "\"spaces/at/\"\n"
12674             "\"slashes.at.any$\"\n"
12675             "\"non-alphanumeric%\"\n"
12676             "\"1111111111characte\"\n"
12677             "\"rs\"",
12678             format("\"split at "
12679                    "spaces/at/"
12680                    "slashes.at."
12681                    "any$non-"
12682                    "alphanumeric%"
12683                    "1111111111characte"
12684                    "rs\"",
12685                    getLLVMStyleWithColumns(20)));
12686 
12687   // Verify that splitting the strings understands
12688   // Style::AlwaysBreakBeforeMultilineStrings.
12689   EXPECT_EQ("aaaaaaaaaaaa(\n"
12690             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa \"\n"
12691             "    \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\");",
12692             format("aaaaaaaaaaaa(\"aaaaaaaaaaaaaaaaaaaaaaaaaa "
12693                    "aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
12694                    "aaaaaaaaaaaaaaaaaaaaaa\");",
12695                    getGoogleStyle()));
12696   EXPECT_EQ("return \"aaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
12697             "       \"aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaa\";",
12698             format("return \"aaaaaaaaaaaaaaaaaaaaaa "
12699                    "aaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaaaaaaaaaa "
12700                    "aaaaaaaaaaaaaaaaaaaaaa\";",
12701                    getGoogleStyle()));
12702   EXPECT_EQ("llvm::outs() << \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
12703             "                \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
12704             format("llvm::outs() << "
12705                    "\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa aaaaaaaaaaaaaaaaaa"
12706                    "aaaaaaaaaaaaaaaaaaa\";"));
12707   EXPECT_EQ("ffff(\n"
12708             "    {\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa \"\n"
12709             "     \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
12710             format("ffff({\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa "
12711                    "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\"});",
12712                    getGoogleStyle()));
12713 
12714   FormatStyle Style = getLLVMStyleWithColumns(12);
12715   Style.BreakStringLiterals = false;
12716   EXPECT_EQ("\"some text other\";", format("\"some text other\";", Style));
12717 
12718   FormatStyle AlignLeft = getLLVMStyleWithColumns(12);
12719   AlignLeft.AlignEscapedNewlines = FormatStyle::ENAS_Left;
12720   EXPECT_EQ("#define A \\\n"
12721             "  \"some \" \\\n"
12722             "  \"text \" \\\n"
12723             "  \"other\";",
12724             format("#define A \"some text other\";", AlignLeft));
12725 }
12726 
12727 TEST_F(FormatTest, BreaksStringLiteralsAtColumnLimit) {
12728   EXPECT_EQ("C a = \"some more \"\n"
12729             "      \"text\";",
12730             format("C a = \"some more text\";", getLLVMStyleWithColumns(18)));
12731 }
12732 
12733 TEST_F(FormatTest, FullyRemoveEmptyLines) {
12734   FormatStyle NoEmptyLines = getLLVMStyleWithColumns(80);
12735   NoEmptyLines.MaxEmptyLinesToKeep = 0;
12736   EXPECT_EQ("int i = a(b());",
12737             format("int i=a(\n\n b(\n\n\n )\n\n);", NoEmptyLines));
12738 }
12739 
12740 TEST_F(FormatTest, BreaksStringLiteralsWithTabs) {
12741   EXPECT_EQ(
12742       "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
12743       "(\n"
12744       "    \"x\t\");",
12745       format("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
12746              "aaaaaaa("
12747              "\"x\t\");"));
12748 }
12749 
12750 TEST_F(FormatTest, BreaksWideAndNSStringLiterals) {
12751   EXPECT_EQ(
12752       "u8\"utf8 string \"\n"
12753       "u8\"literal\";",
12754       format("u8\"utf8 string literal\";", getGoogleStyleWithColumns(16)));
12755   EXPECT_EQ(
12756       "u\"utf16 string \"\n"
12757       "u\"literal\";",
12758       format("u\"utf16 string literal\";", getGoogleStyleWithColumns(16)));
12759   EXPECT_EQ(
12760       "U\"utf32 string \"\n"
12761       "U\"literal\";",
12762       format("U\"utf32 string literal\";", getGoogleStyleWithColumns(16)));
12763   EXPECT_EQ("L\"wide string \"\n"
12764             "L\"literal\";",
12765             format("L\"wide string literal\";", getGoogleStyleWithColumns(16)));
12766   EXPECT_EQ("@\"NSString \"\n"
12767             "@\"literal\";",
12768             format("@\"NSString literal\";", getGoogleStyleWithColumns(19)));
12769   verifyFormat(R"(NSString *s = @"那那那那";)", getLLVMStyleWithColumns(26));
12770 
12771   // This input makes clang-format try to split the incomplete unicode escape
12772   // sequence, which used to lead to a crasher.
12773   verifyNoCrash(
12774       "aaaaaaaaaaaaaaaaaaaa = L\"\\udff\"'; // aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
12775       getLLVMStyleWithColumns(60));
12776 }
12777 
12778 TEST_F(FormatTest, DoesNotBreakRawStringLiterals) {
12779   FormatStyle Style = getGoogleStyleWithColumns(15);
12780   EXPECT_EQ("R\"x(raw literal)x\";", format("R\"x(raw literal)x\";", Style));
12781   EXPECT_EQ("uR\"x(raw literal)x\";", format("uR\"x(raw literal)x\";", Style));
12782   EXPECT_EQ("LR\"x(raw literal)x\";", format("LR\"x(raw literal)x\";", Style));
12783   EXPECT_EQ("UR\"x(raw literal)x\";", format("UR\"x(raw literal)x\";", Style));
12784   EXPECT_EQ("u8R\"x(raw literal)x\";",
12785             format("u8R\"x(raw literal)x\";", Style));
12786 }
12787 
12788 TEST_F(FormatTest, BreaksStringLiteralsWithin_TMacro) {
12789   FormatStyle Style = getLLVMStyleWithColumns(20);
12790   EXPECT_EQ(
12791       "_T(\"aaaaaaaaaaaaaa\")\n"
12792       "_T(\"aaaaaaaaaaaaaa\")\n"
12793       "_T(\"aaaaaaaaaaaa\")",
12794       format("  _T(\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\")", Style));
12795   EXPECT_EQ("f(x,\n"
12796             "  _T(\"aaaaaaaaaaaa\")\n"
12797             "  _T(\"aaa\"),\n"
12798             "  z);",
12799             format("f(x, _T(\"aaaaaaaaaaaaaaa\"), z);", Style));
12800 
12801   // FIXME: Handle embedded spaces in one iteration.
12802   //  EXPECT_EQ("_T(\"aaaaaaaaaaaaa\")\n"
12803   //            "_T(\"aaaaaaaaaaaaa\")\n"
12804   //            "_T(\"aaaaaaaaaaaaa\")\n"
12805   //            "_T(\"a\")",
12806   //            format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
12807   //                   getLLVMStyleWithColumns(20)));
12808   EXPECT_EQ(
12809       "_T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )",
12810       format("  _T ( \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\" )", Style));
12811   EXPECT_EQ("f(\n"
12812             "#if !TEST\n"
12813             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
12814             "#endif\n"
12815             ");",
12816             format("f(\n"
12817                    "#if !TEST\n"
12818                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\")\n"
12819                    "#endif\n"
12820                    ");"));
12821   EXPECT_EQ("f(\n"
12822             "\n"
12823             "    _T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));",
12824             format("f(\n"
12825                    "\n"
12826                    "_T(\"XXXXXXXXXXXXXXXXXXXXXXXXXXXXXn\"));"));
12827 }
12828 
12829 TEST_F(FormatTest, BreaksStringLiteralOperands) {
12830   // In a function call with two operands, the second can be broken with no line
12831   // break before it.
12832   EXPECT_EQ(
12833       "func(a, \"long long \"\n"
12834       "        \"long long\");",
12835       format("func(a, \"long long long long\");", getLLVMStyleWithColumns(24)));
12836   // In a function call with three operands, the second must be broken with a
12837   // line break before it.
12838   EXPECT_EQ("func(a,\n"
12839             "     \"long long long \"\n"
12840             "     \"long\",\n"
12841             "     c);",
12842             format("func(a, \"long long long long\", c);",
12843                    getLLVMStyleWithColumns(24)));
12844   // In a function call with three operands, the third must be broken with a
12845   // line break before it.
12846   EXPECT_EQ("func(a, b,\n"
12847             "     \"long long long \"\n"
12848             "     \"long\");",
12849             format("func(a, b, \"long long long long\");",
12850                    getLLVMStyleWithColumns(24)));
12851   // In a function call with three operands, both the second and the third must
12852   // be broken with a line break before them.
12853   EXPECT_EQ("func(a,\n"
12854             "     \"long long long \"\n"
12855             "     \"long\",\n"
12856             "     \"long long long \"\n"
12857             "     \"long\");",
12858             format("func(a, \"long long long long\", \"long long long long\");",
12859                    getLLVMStyleWithColumns(24)));
12860   // In a chain of << with two operands, the second can be broken with no line
12861   // break before it.
12862   EXPECT_EQ("a << \"line line \"\n"
12863             "     \"line\";",
12864             format("a << \"line line line\";", getLLVMStyleWithColumns(20)));
12865   // In a chain of << with three operands, the second can be broken with no line
12866   // break before it.
12867   EXPECT_EQ(
12868       "abcde << \"line \"\n"
12869       "         \"line line\"\n"
12870       "      << c;",
12871       format("abcde << \"line line line\" << c;", getLLVMStyleWithColumns(20)));
12872   // In a chain of << with three operands, the third must be broken with a line
12873   // break before it.
12874   EXPECT_EQ(
12875       "a << b\n"
12876       "  << \"line line \"\n"
12877       "     \"line\";",
12878       format("a << b << \"line line line\";", getLLVMStyleWithColumns(20)));
12879   // In a chain of << with three operands, the second can be broken with no line
12880   // break before it and the third must be broken with a line break before it.
12881   EXPECT_EQ("abcd << \"line line \"\n"
12882             "        \"line\"\n"
12883             "     << \"line line \"\n"
12884             "        \"line\";",
12885             format("abcd << \"line line line\" << \"line line line\";",
12886                    getLLVMStyleWithColumns(20)));
12887   // In a chain of binary operators with two operands, the second can be broken
12888   // with no line break before it.
12889   EXPECT_EQ(
12890       "abcd + \"line line \"\n"
12891       "       \"line line\";",
12892       format("abcd + \"line line line line\";", getLLVMStyleWithColumns(20)));
12893   // In a chain of binary operators with three operands, the second must be
12894   // broken with a line break before it.
12895   EXPECT_EQ("abcd +\n"
12896             "    \"line line \"\n"
12897             "    \"line line\" +\n"
12898             "    e;",
12899             format("abcd + \"line line line line\" + e;",
12900                    getLLVMStyleWithColumns(20)));
12901   // In a function call with two operands, with AlignAfterOpenBracket enabled,
12902   // the first must be broken with a line break before it.
12903   FormatStyle Style = getLLVMStyleWithColumns(25);
12904   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
12905   EXPECT_EQ("someFunction(\n"
12906             "    \"long long long \"\n"
12907             "    \"long\",\n"
12908             "    a);",
12909             format("someFunction(\"long long long long\", a);", Style));
12910 }
12911 
12912 TEST_F(FormatTest, DontSplitStringLiteralsWithEscapedNewlines) {
12913   EXPECT_EQ(
12914       "aaaaaaaaaaa = \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
12915       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
12916       "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";",
12917       format("aaaaaaaaaaa  =  \"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
12918              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\\\n"
12919              "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\";"));
12920 }
12921 
12922 TEST_F(FormatTest, CountsCharactersInMultilineRawStringLiterals) {
12923   EXPECT_EQ("f(g(R\"x(raw literal)x\", a), b);",
12924             format("f(g(R\"x(raw literal)x\",   a), b);", getGoogleStyle()));
12925   EXPECT_EQ("fffffffffff(g(R\"x(\n"
12926             "multiline raw string literal xxxxxxxxxxxxxx\n"
12927             ")x\",\n"
12928             "              a),\n"
12929             "            b);",
12930             format("fffffffffff(g(R\"x(\n"
12931                    "multiline raw string literal xxxxxxxxxxxxxx\n"
12932                    ")x\", a), b);",
12933                    getGoogleStyleWithColumns(20)));
12934   EXPECT_EQ("fffffffffff(\n"
12935             "    g(R\"x(qqq\n"
12936             "multiline raw string literal xxxxxxxxxxxxxx\n"
12937             ")x\",\n"
12938             "      a),\n"
12939             "    b);",
12940             format("fffffffffff(g(R\"x(qqq\n"
12941                    "multiline raw string literal xxxxxxxxxxxxxx\n"
12942                    ")x\", a), b);",
12943                    getGoogleStyleWithColumns(20)));
12944 
12945   EXPECT_EQ("fffffffffff(R\"x(\n"
12946             "multiline raw string literal xxxxxxxxxxxxxx\n"
12947             ")x\");",
12948             format("fffffffffff(R\"x(\n"
12949                    "multiline raw string literal xxxxxxxxxxxxxx\n"
12950                    ")x\");",
12951                    getGoogleStyleWithColumns(20)));
12952   EXPECT_EQ("fffffffffff(R\"x(\n"
12953             "multiline raw string literal xxxxxxxxxxxxxx\n"
12954             ")x\" + bbbbbb);",
12955             format("fffffffffff(R\"x(\n"
12956                    "multiline raw string literal xxxxxxxxxxxxxx\n"
12957                    ")x\" +   bbbbbb);",
12958                    getGoogleStyleWithColumns(20)));
12959   EXPECT_EQ("fffffffffff(\n"
12960             "    R\"x(\n"
12961             "multiline raw string literal xxxxxxxxxxxxxx\n"
12962             ")x\" +\n"
12963             "    bbbbbb);",
12964             format("fffffffffff(\n"
12965                    " R\"x(\n"
12966                    "multiline raw string literal xxxxxxxxxxxxxx\n"
12967                    ")x\" + bbbbbb);",
12968                    getGoogleStyleWithColumns(20)));
12969   EXPECT_EQ("fffffffffff(R\"(single line raw string)\" + bbbbbb);",
12970             format("fffffffffff(\n"
12971                    " R\"(single line raw string)\" + bbbbbb);"));
12972 }
12973 
12974 TEST_F(FormatTest, SkipsUnknownStringLiterals) {
12975   verifyFormat("string a = \"unterminated;");
12976   EXPECT_EQ("function(\"unterminated,\n"
12977             "         OtherParameter);",
12978             format("function(  \"unterminated,\n"
12979                    "    OtherParameter);"));
12980 }
12981 
12982 TEST_F(FormatTest, DoesNotTryToParseUDLiteralsInPreCpp11Code) {
12983   FormatStyle Style = getLLVMStyle();
12984   Style.Standard = FormatStyle::LS_Cpp03;
12985   EXPECT_EQ("#define x(_a) printf(\"foo\" _a);",
12986             format("#define x(_a) printf(\"foo\"_a);", Style));
12987 }
12988 
12989 TEST_F(FormatTest, CppLexVersion) {
12990   FormatStyle Style = getLLVMStyle();
12991   // Formatting of x * y differs if x is a type.
12992   verifyFormat("void foo() { MACRO(a * b); }", Style);
12993   verifyFormat("void foo() { MACRO(int *b); }", Style);
12994 
12995   // LLVM style uses latest lexer.
12996   verifyFormat("void foo() { MACRO(char8_t *b); }", Style);
12997   Style.Standard = FormatStyle::LS_Cpp17;
12998   // But in c++17, char8_t isn't a keyword.
12999   verifyFormat("void foo() { MACRO(char8_t * b); }", Style);
13000 }
13001 
13002 TEST_F(FormatTest, UnderstandsCpp1y) { verifyFormat("int bi{1'000'000};"); }
13003 
13004 TEST_F(FormatTest, BreakStringLiteralsBeforeUnbreakableTokenSequence) {
13005   EXPECT_EQ("someFunction(\"aaabbbcccd\"\n"
13006             "             \"ddeeefff\");",
13007             format("someFunction(\"aaabbbcccdddeeefff\");",
13008                    getLLVMStyleWithColumns(25)));
13009   EXPECT_EQ("someFunction1234567890(\n"
13010             "    \"aaabbbcccdddeeefff\");",
13011             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
13012                    getLLVMStyleWithColumns(26)));
13013   EXPECT_EQ("someFunction1234567890(\n"
13014             "    \"aaabbbcccdddeeeff\"\n"
13015             "    \"f\");",
13016             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
13017                    getLLVMStyleWithColumns(25)));
13018   EXPECT_EQ("someFunction1234567890(\n"
13019             "    \"aaabbbcccdddeeeff\"\n"
13020             "    \"f\");",
13021             format("someFunction1234567890(\"aaabbbcccdddeeefff\");",
13022                    getLLVMStyleWithColumns(24)));
13023   EXPECT_EQ("someFunction(\n"
13024             "    \"aaabbbcc ddde \"\n"
13025             "    \"efff\");",
13026             format("someFunction(\"aaabbbcc ddde efff\");",
13027                    getLLVMStyleWithColumns(25)));
13028   EXPECT_EQ("someFunction(\"aaabbbccc \"\n"
13029             "             \"ddeeefff\");",
13030             format("someFunction(\"aaabbbccc ddeeefff\");",
13031                    getLLVMStyleWithColumns(25)));
13032   EXPECT_EQ("someFunction1234567890(\n"
13033             "    \"aaabb \"\n"
13034             "    \"cccdddeeefff\");",
13035             format("someFunction1234567890(\"aaabb cccdddeeefff\");",
13036                    getLLVMStyleWithColumns(25)));
13037   EXPECT_EQ("#define A          \\\n"
13038             "  string s =       \\\n"
13039             "      \"123456789\"  \\\n"
13040             "      \"0\";         \\\n"
13041             "  int i;",
13042             format("#define A string s = \"1234567890\"; int i;",
13043                    getLLVMStyleWithColumns(20)));
13044   EXPECT_EQ("someFunction(\n"
13045             "    \"aaabbbcc \"\n"
13046             "    \"dddeeefff\");",
13047             format("someFunction(\"aaabbbcc dddeeefff\");",
13048                    getLLVMStyleWithColumns(25)));
13049 }
13050 
13051 TEST_F(FormatTest, DoNotBreakStringLiteralsInEscapeSequence) {
13052   EXPECT_EQ("\"\\a\"", format("\"\\a\"", getLLVMStyleWithColumns(3)));
13053   EXPECT_EQ("\"\\\"", format("\"\\\"", getLLVMStyleWithColumns(2)));
13054   EXPECT_EQ("\"test\"\n"
13055             "\"\\n\"",
13056             format("\"test\\n\"", getLLVMStyleWithColumns(7)));
13057   EXPECT_EQ("\"tes\\\\\"\n"
13058             "\"n\"",
13059             format("\"tes\\\\n\"", getLLVMStyleWithColumns(7)));
13060   EXPECT_EQ("\"\\\\\\\\\"\n"
13061             "\"\\n\"",
13062             format("\"\\\\\\\\\\n\"", getLLVMStyleWithColumns(7)));
13063   EXPECT_EQ("\"\\uff01\"", format("\"\\uff01\"", getLLVMStyleWithColumns(7)));
13064   EXPECT_EQ("\"\\uff01\"\n"
13065             "\"test\"",
13066             format("\"\\uff01test\"", getLLVMStyleWithColumns(8)));
13067   EXPECT_EQ("\"\\Uff01ff02\"",
13068             format("\"\\Uff01ff02\"", getLLVMStyleWithColumns(11)));
13069   EXPECT_EQ("\"\\x000000000001\"\n"
13070             "\"next\"",
13071             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(16)));
13072   EXPECT_EQ("\"\\x000000000001next\"",
13073             format("\"\\x000000000001next\"", getLLVMStyleWithColumns(15)));
13074   EXPECT_EQ("\"\\x000000000001\"",
13075             format("\"\\x000000000001\"", getLLVMStyleWithColumns(7)));
13076   EXPECT_EQ("\"test\"\n"
13077             "\"\\000000\"\n"
13078             "\"000001\"",
13079             format("\"test\\000000000001\"", getLLVMStyleWithColumns(9)));
13080   EXPECT_EQ("\"test\\000\"\n"
13081             "\"00000000\"\n"
13082             "\"1\"",
13083             format("\"test\\000000000001\"", getLLVMStyleWithColumns(10)));
13084 }
13085 
13086 TEST_F(FormatTest, DoNotCreateUnreasonableUnwrappedLines) {
13087   verifyFormat("void f() {\n"
13088                "  return g() {}\n"
13089                "  void h() {}");
13090   verifyFormat("int a[] = {void forgot_closing_brace(){f();\n"
13091                "g();\n"
13092                "}");
13093 }
13094 
13095 TEST_F(FormatTest, DoNotPrematurelyEndUnwrappedLineForReturnStatements) {
13096   verifyFormat(
13097       "void f() { return C{param1, param2}.SomeCall(param1, param2); }");
13098 }
13099 
13100 TEST_F(FormatTest, FormatsClosingBracesInEmptyNestedBlocks) {
13101   verifyFormat("class X {\n"
13102                "  void f() {\n"
13103                "  }\n"
13104                "};",
13105                getLLVMStyleWithColumns(12));
13106 }
13107 
13108 TEST_F(FormatTest, ConfigurableIndentWidth) {
13109   FormatStyle EightIndent = getLLVMStyleWithColumns(18);
13110   EightIndent.IndentWidth = 8;
13111   EightIndent.ContinuationIndentWidth = 8;
13112   verifyFormat("void f() {\n"
13113                "        someFunction();\n"
13114                "        if (true) {\n"
13115                "                f();\n"
13116                "        }\n"
13117                "}",
13118                EightIndent);
13119   verifyFormat("class X {\n"
13120                "        void f() {\n"
13121                "        }\n"
13122                "};",
13123                EightIndent);
13124   verifyFormat("int x[] = {\n"
13125                "        call(),\n"
13126                "        call()};",
13127                EightIndent);
13128 }
13129 
13130 TEST_F(FormatTest, ConfigurableFunctionDeclarationIndentAfterType) {
13131   verifyFormat("double\n"
13132                "f();",
13133                getLLVMStyleWithColumns(8));
13134 }
13135 
13136 TEST_F(FormatTest, ConfigurableUseOfTab) {
13137   FormatStyle Tab = getLLVMStyleWithColumns(42);
13138   Tab.IndentWidth = 8;
13139   Tab.UseTab = FormatStyle::UT_Always;
13140   Tab.AlignEscapedNewlines = FormatStyle::ENAS_Left;
13141 
13142   EXPECT_EQ("if (aaaaaaaa && // q\n"
13143             "    bb)\t\t// w\n"
13144             "\t;",
13145             format("if (aaaaaaaa &&// q\n"
13146                    "bb)// w\n"
13147                    ";",
13148                    Tab));
13149   EXPECT_EQ("if (aaa && bbb) // w\n"
13150             "\t;",
13151             format("if(aaa&&bbb)// w\n"
13152                    ";",
13153                    Tab));
13154 
13155   verifyFormat("class X {\n"
13156                "\tvoid f() {\n"
13157                "\t\tsomeFunction(parameter1,\n"
13158                "\t\t\t     parameter2);\n"
13159                "\t}\n"
13160                "};",
13161                Tab);
13162   verifyFormat("#define A                        \\\n"
13163                "\tvoid f() {               \\\n"
13164                "\t\tsomeFunction(    \\\n"
13165                "\t\t    parameter1,  \\\n"
13166                "\t\t    parameter2); \\\n"
13167                "\t}",
13168                Tab);
13169   verifyFormat("int a;\t      // x\n"
13170                "int bbbbbbbb; // x\n",
13171                Tab);
13172 
13173   Tab.TabWidth = 4;
13174   Tab.IndentWidth = 8;
13175   verifyFormat("class TabWidth4Indent8 {\n"
13176                "\t\tvoid f() {\n"
13177                "\t\t\t\tsomeFunction(parameter1,\n"
13178                "\t\t\t\t\t\t\t parameter2);\n"
13179                "\t\t}\n"
13180                "};",
13181                Tab);
13182 
13183   Tab.TabWidth = 4;
13184   Tab.IndentWidth = 4;
13185   verifyFormat("class TabWidth4Indent4 {\n"
13186                "\tvoid f() {\n"
13187                "\t\tsomeFunction(parameter1,\n"
13188                "\t\t\t\t\t parameter2);\n"
13189                "\t}\n"
13190                "};",
13191                Tab);
13192 
13193   Tab.TabWidth = 8;
13194   Tab.IndentWidth = 4;
13195   verifyFormat("class TabWidth8Indent4 {\n"
13196                "    void f() {\n"
13197                "\tsomeFunction(parameter1,\n"
13198                "\t\t     parameter2);\n"
13199                "    }\n"
13200                "};",
13201                Tab);
13202 
13203   Tab.TabWidth = 8;
13204   Tab.IndentWidth = 8;
13205   EXPECT_EQ("/*\n"
13206             "\t      a\t\tcomment\n"
13207             "\t      in multiple lines\n"
13208             "       */",
13209             format("   /*\t \t \n"
13210                    " \t \t a\t\tcomment\t \t\n"
13211                    " \t \t in multiple lines\t\n"
13212                    " \t  */",
13213                    Tab));
13214 
13215   Tab.UseTab = FormatStyle::UT_ForIndentation;
13216   verifyFormat("{\n"
13217                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13218                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13219                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13220                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13221                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13222                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13223                "};",
13224                Tab);
13225   verifyFormat("enum AA {\n"
13226                "\ta1, // Force multiple lines\n"
13227                "\ta2,\n"
13228                "\ta3\n"
13229                "};",
13230                Tab);
13231   EXPECT_EQ("if (aaaaaaaa && // q\n"
13232             "    bb)         // w\n"
13233             "\t;",
13234             format("if (aaaaaaaa &&// q\n"
13235                    "bb)// w\n"
13236                    ";",
13237                    Tab));
13238   verifyFormat("class X {\n"
13239                "\tvoid f() {\n"
13240                "\t\tsomeFunction(parameter1,\n"
13241                "\t\t             parameter2);\n"
13242                "\t}\n"
13243                "};",
13244                Tab);
13245   verifyFormat("{\n"
13246                "\tQ(\n"
13247                "\t    {\n"
13248                "\t\t    int a;\n"
13249                "\t\t    someFunction(aaaaaaaa,\n"
13250                "\t\t                 bbbbbbb);\n"
13251                "\t    },\n"
13252                "\t    p);\n"
13253                "}",
13254                Tab);
13255   EXPECT_EQ("{\n"
13256             "\t/* aaaa\n"
13257             "\t   bbbb */\n"
13258             "}",
13259             format("{\n"
13260                    "/* aaaa\n"
13261                    "   bbbb */\n"
13262                    "}",
13263                    Tab));
13264   EXPECT_EQ("{\n"
13265             "\t/*\n"
13266             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13267             "\t  bbbbbbbbbbbbb\n"
13268             "\t*/\n"
13269             "}",
13270             format("{\n"
13271                    "/*\n"
13272                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
13273                    "*/\n"
13274                    "}",
13275                    Tab));
13276   EXPECT_EQ("{\n"
13277             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13278             "\t// bbbbbbbbbbbbb\n"
13279             "}",
13280             format("{\n"
13281                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
13282                    "}",
13283                    Tab));
13284   EXPECT_EQ("{\n"
13285             "\t/*\n"
13286             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13287             "\t  bbbbbbbbbbbbb\n"
13288             "\t*/\n"
13289             "}",
13290             format("{\n"
13291                    "\t/*\n"
13292                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
13293                    "\t*/\n"
13294                    "}",
13295                    Tab));
13296   EXPECT_EQ("{\n"
13297             "\t/*\n"
13298             "\n"
13299             "\t*/\n"
13300             "}",
13301             format("{\n"
13302                    "\t/*\n"
13303                    "\n"
13304                    "\t*/\n"
13305                    "}",
13306                    Tab));
13307   EXPECT_EQ("{\n"
13308             "\t/*\n"
13309             " asdf\n"
13310             "\t*/\n"
13311             "}",
13312             format("{\n"
13313                    "\t/*\n"
13314                    " asdf\n"
13315                    "\t*/\n"
13316                    "}",
13317                    Tab));
13318 
13319   Tab.UseTab = FormatStyle::UT_Never;
13320   EXPECT_EQ("/*\n"
13321             "              a\t\tcomment\n"
13322             "              in multiple lines\n"
13323             "       */",
13324             format("   /*\t \t \n"
13325                    " \t \t a\t\tcomment\t \t\n"
13326                    " \t \t in multiple lines\t\n"
13327                    " \t  */",
13328                    Tab));
13329   EXPECT_EQ("/* some\n"
13330             "   comment */",
13331             format(" \t \t /* some\n"
13332                    " \t \t    comment */",
13333                    Tab));
13334   EXPECT_EQ("int a; /* some\n"
13335             "   comment */",
13336             format(" \t \t int a; /* some\n"
13337                    " \t \t    comment */",
13338                    Tab));
13339 
13340   EXPECT_EQ("int a; /* some\n"
13341             "comment */",
13342             format(" \t \t int\ta; /* some\n"
13343                    " \t \t    comment */",
13344                    Tab));
13345   EXPECT_EQ("f(\"\t\t\"); /* some\n"
13346             "    comment */",
13347             format(" \t \t f(\"\t\t\"); /* some\n"
13348                    " \t \t    comment */",
13349                    Tab));
13350   EXPECT_EQ("{\n"
13351             "        /*\n"
13352             "         * Comment\n"
13353             "         */\n"
13354             "        int i;\n"
13355             "}",
13356             format("{\n"
13357                    "\t/*\n"
13358                    "\t * Comment\n"
13359                    "\t */\n"
13360                    "\t int i;\n"
13361                    "}",
13362                    Tab));
13363 
13364   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
13365   Tab.TabWidth = 8;
13366   Tab.IndentWidth = 8;
13367   EXPECT_EQ("if (aaaaaaaa && // q\n"
13368             "    bb)         // w\n"
13369             "\t;",
13370             format("if (aaaaaaaa &&// q\n"
13371                    "bb)// w\n"
13372                    ";",
13373                    Tab));
13374   EXPECT_EQ("if (aaa && bbb) // w\n"
13375             "\t;",
13376             format("if(aaa&&bbb)// w\n"
13377                    ";",
13378                    Tab));
13379   verifyFormat("class X {\n"
13380                "\tvoid f() {\n"
13381                "\t\tsomeFunction(parameter1,\n"
13382                "\t\t\t     parameter2);\n"
13383                "\t}\n"
13384                "};",
13385                Tab);
13386   verifyFormat("#define A                        \\\n"
13387                "\tvoid f() {               \\\n"
13388                "\t\tsomeFunction(    \\\n"
13389                "\t\t    parameter1,  \\\n"
13390                "\t\t    parameter2); \\\n"
13391                "\t}",
13392                Tab);
13393   Tab.TabWidth = 4;
13394   Tab.IndentWidth = 8;
13395   verifyFormat("class TabWidth4Indent8 {\n"
13396                "\t\tvoid f() {\n"
13397                "\t\t\t\tsomeFunction(parameter1,\n"
13398                "\t\t\t\t\t\t\t parameter2);\n"
13399                "\t\t}\n"
13400                "};",
13401                Tab);
13402   Tab.TabWidth = 4;
13403   Tab.IndentWidth = 4;
13404   verifyFormat("class TabWidth4Indent4 {\n"
13405                "\tvoid f() {\n"
13406                "\t\tsomeFunction(parameter1,\n"
13407                "\t\t\t\t\t parameter2);\n"
13408                "\t}\n"
13409                "};",
13410                Tab);
13411   Tab.TabWidth = 8;
13412   Tab.IndentWidth = 4;
13413   verifyFormat("class TabWidth8Indent4 {\n"
13414                "    void f() {\n"
13415                "\tsomeFunction(parameter1,\n"
13416                "\t\t     parameter2);\n"
13417                "    }\n"
13418                "};",
13419                Tab);
13420   Tab.TabWidth = 8;
13421   Tab.IndentWidth = 8;
13422   EXPECT_EQ("/*\n"
13423             "\t      a\t\tcomment\n"
13424             "\t      in multiple lines\n"
13425             "       */",
13426             format("   /*\t \t \n"
13427                    " \t \t a\t\tcomment\t \t\n"
13428                    " \t \t in multiple lines\t\n"
13429                    " \t  */",
13430                    Tab));
13431   verifyFormat("{\n"
13432                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13433                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13434                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13435                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13436                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13437                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13438                "};",
13439                Tab);
13440   verifyFormat("enum AA {\n"
13441                "\ta1, // Force multiple lines\n"
13442                "\ta2,\n"
13443                "\ta3\n"
13444                "};",
13445                Tab);
13446   EXPECT_EQ("if (aaaaaaaa && // q\n"
13447             "    bb)         // w\n"
13448             "\t;",
13449             format("if (aaaaaaaa &&// q\n"
13450                    "bb)// w\n"
13451                    ";",
13452                    Tab));
13453   verifyFormat("class X {\n"
13454                "\tvoid f() {\n"
13455                "\t\tsomeFunction(parameter1,\n"
13456                "\t\t\t     parameter2);\n"
13457                "\t}\n"
13458                "};",
13459                Tab);
13460   verifyFormat("{\n"
13461                "\tQ(\n"
13462                "\t    {\n"
13463                "\t\t    int a;\n"
13464                "\t\t    someFunction(aaaaaaaa,\n"
13465                "\t\t\t\t bbbbbbb);\n"
13466                "\t    },\n"
13467                "\t    p);\n"
13468                "}",
13469                Tab);
13470   EXPECT_EQ("{\n"
13471             "\t/* aaaa\n"
13472             "\t   bbbb */\n"
13473             "}",
13474             format("{\n"
13475                    "/* aaaa\n"
13476                    "   bbbb */\n"
13477                    "}",
13478                    Tab));
13479   EXPECT_EQ("{\n"
13480             "\t/*\n"
13481             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13482             "\t  bbbbbbbbbbbbb\n"
13483             "\t*/\n"
13484             "}",
13485             format("{\n"
13486                    "/*\n"
13487                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
13488                    "*/\n"
13489                    "}",
13490                    Tab));
13491   EXPECT_EQ("{\n"
13492             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13493             "\t// bbbbbbbbbbbbb\n"
13494             "}",
13495             format("{\n"
13496                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
13497                    "}",
13498                    Tab));
13499   EXPECT_EQ("{\n"
13500             "\t/*\n"
13501             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13502             "\t  bbbbbbbbbbbbb\n"
13503             "\t*/\n"
13504             "}",
13505             format("{\n"
13506                    "\t/*\n"
13507                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
13508                    "\t*/\n"
13509                    "}",
13510                    Tab));
13511   EXPECT_EQ("{\n"
13512             "\t/*\n"
13513             "\n"
13514             "\t*/\n"
13515             "}",
13516             format("{\n"
13517                    "\t/*\n"
13518                    "\n"
13519                    "\t*/\n"
13520                    "}",
13521                    Tab));
13522   EXPECT_EQ("{\n"
13523             "\t/*\n"
13524             " asdf\n"
13525             "\t*/\n"
13526             "}",
13527             format("{\n"
13528                    "\t/*\n"
13529                    " asdf\n"
13530                    "\t*/\n"
13531                    "}",
13532                    Tab));
13533   EXPECT_EQ("/* some\n"
13534             "   comment */",
13535             format(" \t \t /* some\n"
13536                    " \t \t    comment */",
13537                    Tab));
13538   EXPECT_EQ("int a; /* some\n"
13539             "   comment */",
13540             format(" \t \t int a; /* some\n"
13541                    " \t \t    comment */",
13542                    Tab));
13543   EXPECT_EQ("int a; /* some\n"
13544             "comment */",
13545             format(" \t \t int\ta; /* some\n"
13546                    " \t \t    comment */",
13547                    Tab));
13548   EXPECT_EQ("f(\"\t\t\"); /* some\n"
13549             "    comment */",
13550             format(" \t \t f(\"\t\t\"); /* some\n"
13551                    " \t \t    comment */",
13552                    Tab));
13553   EXPECT_EQ("{\n"
13554             "\t/*\n"
13555             "\t * Comment\n"
13556             "\t */\n"
13557             "\tint i;\n"
13558             "}",
13559             format("{\n"
13560                    "\t/*\n"
13561                    "\t * Comment\n"
13562                    "\t */\n"
13563                    "\t int i;\n"
13564                    "}",
13565                    Tab));
13566   Tab.TabWidth = 2;
13567   Tab.IndentWidth = 2;
13568   EXPECT_EQ("{\n"
13569             "\t/* aaaa\n"
13570             "\t\t bbbb */\n"
13571             "}",
13572             format("{\n"
13573                    "/* aaaa\n"
13574                    "\t bbbb */\n"
13575                    "}",
13576                    Tab));
13577   EXPECT_EQ("{\n"
13578             "\t/*\n"
13579             "\t\taaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13580             "\t\tbbbbbbbbbbbbb\n"
13581             "\t*/\n"
13582             "}",
13583             format("{\n"
13584                    "/*\n"
13585                    "\taaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
13586                    "*/\n"
13587                    "}",
13588                    Tab));
13589   Tab.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
13590   Tab.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
13591   Tab.TabWidth = 4;
13592   Tab.IndentWidth = 4;
13593   verifyFormat("class Assign {\n"
13594                "\tvoid f() {\n"
13595                "\t\tint         x      = 123;\n"
13596                "\t\tint         random = 4;\n"
13597                "\t\tstd::string alphabet =\n"
13598                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
13599                "\t}\n"
13600                "};",
13601                Tab);
13602 
13603   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
13604   Tab.TabWidth = 8;
13605   Tab.IndentWidth = 8;
13606   EXPECT_EQ("if (aaaaaaaa && // q\n"
13607             "    bb)         // w\n"
13608             "\t;",
13609             format("if (aaaaaaaa &&// q\n"
13610                    "bb)// w\n"
13611                    ";",
13612                    Tab));
13613   EXPECT_EQ("if (aaa && bbb) // w\n"
13614             "\t;",
13615             format("if(aaa&&bbb)// w\n"
13616                    ";",
13617                    Tab));
13618   verifyFormat("class X {\n"
13619                "\tvoid f() {\n"
13620                "\t\tsomeFunction(parameter1,\n"
13621                "\t\t             parameter2);\n"
13622                "\t}\n"
13623                "};",
13624                Tab);
13625   verifyFormat("#define A                        \\\n"
13626                "\tvoid f() {               \\\n"
13627                "\t\tsomeFunction(    \\\n"
13628                "\t\t    parameter1,  \\\n"
13629                "\t\t    parameter2); \\\n"
13630                "\t}",
13631                Tab);
13632   Tab.TabWidth = 4;
13633   Tab.IndentWidth = 8;
13634   verifyFormat("class TabWidth4Indent8 {\n"
13635                "\t\tvoid f() {\n"
13636                "\t\t\t\tsomeFunction(parameter1,\n"
13637                "\t\t\t\t             parameter2);\n"
13638                "\t\t}\n"
13639                "};",
13640                Tab);
13641   Tab.TabWidth = 4;
13642   Tab.IndentWidth = 4;
13643   verifyFormat("class TabWidth4Indent4 {\n"
13644                "\tvoid f() {\n"
13645                "\t\tsomeFunction(parameter1,\n"
13646                "\t\t             parameter2);\n"
13647                "\t}\n"
13648                "};",
13649                Tab);
13650   Tab.TabWidth = 8;
13651   Tab.IndentWidth = 4;
13652   verifyFormat("class TabWidth8Indent4 {\n"
13653                "    void f() {\n"
13654                "\tsomeFunction(parameter1,\n"
13655                "\t             parameter2);\n"
13656                "    }\n"
13657                "};",
13658                Tab);
13659   Tab.TabWidth = 8;
13660   Tab.IndentWidth = 8;
13661   EXPECT_EQ("/*\n"
13662             "              a\t\tcomment\n"
13663             "              in multiple lines\n"
13664             "       */",
13665             format("   /*\t \t \n"
13666                    " \t \t a\t\tcomment\t \t\n"
13667                    " \t \t in multiple lines\t\n"
13668                    " \t  */",
13669                    Tab));
13670   verifyFormat("{\n"
13671                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13672                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13673                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13674                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13675                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13676                "\taaaaaaaaaaaaaaaaaaaaaaaaaaaa();\n"
13677                "};",
13678                Tab);
13679   verifyFormat("enum AA {\n"
13680                "\ta1, // Force multiple lines\n"
13681                "\ta2,\n"
13682                "\ta3\n"
13683                "};",
13684                Tab);
13685   EXPECT_EQ("if (aaaaaaaa && // q\n"
13686             "    bb)         // w\n"
13687             "\t;",
13688             format("if (aaaaaaaa &&// q\n"
13689                    "bb)// w\n"
13690                    ";",
13691                    Tab));
13692   verifyFormat("class X {\n"
13693                "\tvoid f() {\n"
13694                "\t\tsomeFunction(parameter1,\n"
13695                "\t\t             parameter2);\n"
13696                "\t}\n"
13697                "};",
13698                Tab);
13699   verifyFormat("{\n"
13700                "\tQ(\n"
13701                "\t    {\n"
13702                "\t\t    int a;\n"
13703                "\t\t    someFunction(aaaaaaaa,\n"
13704                "\t\t                 bbbbbbb);\n"
13705                "\t    },\n"
13706                "\t    p);\n"
13707                "}",
13708                Tab);
13709   EXPECT_EQ("{\n"
13710             "\t/* aaaa\n"
13711             "\t   bbbb */\n"
13712             "}",
13713             format("{\n"
13714                    "/* aaaa\n"
13715                    "   bbbb */\n"
13716                    "}",
13717                    Tab));
13718   EXPECT_EQ("{\n"
13719             "\t/*\n"
13720             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13721             "\t  bbbbbbbbbbbbb\n"
13722             "\t*/\n"
13723             "}",
13724             format("{\n"
13725                    "/*\n"
13726                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
13727                    "*/\n"
13728                    "}",
13729                    Tab));
13730   EXPECT_EQ("{\n"
13731             "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13732             "\t// bbbbbbbbbbbbb\n"
13733             "}",
13734             format("{\n"
13735                    "\t// aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
13736                    "}",
13737                    Tab));
13738   EXPECT_EQ("{\n"
13739             "\t/*\n"
13740             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13741             "\t  bbbbbbbbbbbbb\n"
13742             "\t*/\n"
13743             "}",
13744             format("{\n"
13745                    "\t/*\n"
13746                    "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
13747                    "\t*/\n"
13748                    "}",
13749                    Tab));
13750   EXPECT_EQ("{\n"
13751             "\t/*\n"
13752             "\n"
13753             "\t*/\n"
13754             "}",
13755             format("{\n"
13756                    "\t/*\n"
13757                    "\n"
13758                    "\t*/\n"
13759                    "}",
13760                    Tab));
13761   EXPECT_EQ("{\n"
13762             "\t/*\n"
13763             " asdf\n"
13764             "\t*/\n"
13765             "}",
13766             format("{\n"
13767                    "\t/*\n"
13768                    " asdf\n"
13769                    "\t*/\n"
13770                    "}",
13771                    Tab));
13772   EXPECT_EQ("/* some\n"
13773             "   comment */",
13774             format(" \t \t /* some\n"
13775                    " \t \t    comment */",
13776                    Tab));
13777   EXPECT_EQ("int a; /* some\n"
13778             "   comment */",
13779             format(" \t \t int a; /* some\n"
13780                    " \t \t    comment */",
13781                    Tab));
13782   EXPECT_EQ("int a; /* some\n"
13783             "comment */",
13784             format(" \t \t int\ta; /* some\n"
13785                    " \t \t    comment */",
13786                    Tab));
13787   EXPECT_EQ("f(\"\t\t\"); /* some\n"
13788             "    comment */",
13789             format(" \t \t f(\"\t\t\"); /* some\n"
13790                    " \t \t    comment */",
13791                    Tab));
13792   EXPECT_EQ("{\n"
13793             "\t/*\n"
13794             "\t * Comment\n"
13795             "\t */\n"
13796             "\tint i;\n"
13797             "}",
13798             format("{\n"
13799                    "\t/*\n"
13800                    "\t * Comment\n"
13801                    "\t */\n"
13802                    "\t int i;\n"
13803                    "}",
13804                    Tab));
13805   Tab.TabWidth = 2;
13806   Tab.IndentWidth = 2;
13807   EXPECT_EQ("{\n"
13808             "\t/* aaaa\n"
13809             "\t   bbbb */\n"
13810             "}",
13811             format("{\n"
13812                    "/* aaaa\n"
13813                    "   bbbb */\n"
13814                    "}",
13815                    Tab));
13816   EXPECT_EQ("{\n"
13817             "\t/*\n"
13818             "\t  aaaaaaaaaaaaaaaaaaaaaaaaaa\n"
13819             "\t  bbbbbbbbbbbbb\n"
13820             "\t*/\n"
13821             "}",
13822             format("{\n"
13823                    "/*\n"
13824                    "  aaaaaaaaaaaaaaaaaaaaaaaaaa bbbbbbbbbbbbb\n"
13825                    "*/\n"
13826                    "}",
13827                    Tab));
13828   Tab.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
13829   Tab.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
13830   Tab.TabWidth = 4;
13831   Tab.IndentWidth = 4;
13832   verifyFormat("class Assign {\n"
13833                "\tvoid f() {\n"
13834                "\t\tint         x      = 123;\n"
13835                "\t\tint         random = 4;\n"
13836                "\t\tstd::string alphabet =\n"
13837                "\t\t\t\"abcdefghijklmnopqrstuvwxyz\";\n"
13838                "\t}\n"
13839                "};",
13840                Tab);
13841   Tab.AlignOperands = FormatStyle::OAS_Align;
13842   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb +\n"
13843                "                 cccccccccccccccccccc;",
13844                Tab);
13845   // no alignment
13846   verifyFormat("int aaaaaaaaaa =\n"
13847                "\tbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb;",
13848                Tab);
13849   verifyFormat("return aaaaaaaaaaaaaaaa ? 111111111111111\n"
13850                "       : bbbbbbbbbbbbbb ? 222222222222222\n"
13851                "                        : 333333333333333;",
13852                Tab);
13853   Tab.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
13854   Tab.AlignOperands = FormatStyle::OAS_AlignAfterOperator;
13855   verifyFormat("int aaaaaaaaaa = bbbbbbbbbbbbbbbbbbbb\n"
13856                "               + cccccccccccccccccccc;",
13857                Tab);
13858 }
13859 
13860 TEST_F(FormatTest, ZeroTabWidth) {
13861   FormatStyle Tab = getLLVMStyleWithColumns(42);
13862   Tab.IndentWidth = 8;
13863   Tab.UseTab = FormatStyle::UT_Never;
13864   Tab.TabWidth = 0;
13865   EXPECT_EQ("void a(){\n"
13866             "    // line starts with '\t'\n"
13867             "};",
13868             format("void a(){\n"
13869                    "\t// line starts with '\t'\n"
13870                    "};",
13871                    Tab));
13872 
13873   EXPECT_EQ("void a(){\n"
13874             "    // line starts with '\t'\n"
13875             "};",
13876             format("void a(){\n"
13877                    "\t\t// line starts with '\t'\n"
13878                    "};",
13879                    Tab));
13880 
13881   Tab.UseTab = FormatStyle::UT_ForIndentation;
13882   EXPECT_EQ("void a(){\n"
13883             "    // line starts with '\t'\n"
13884             "};",
13885             format("void a(){\n"
13886                    "\t// line starts with '\t'\n"
13887                    "};",
13888                    Tab));
13889 
13890   EXPECT_EQ("void a(){\n"
13891             "    // line starts with '\t'\n"
13892             "};",
13893             format("void a(){\n"
13894                    "\t\t// line starts with '\t'\n"
13895                    "};",
13896                    Tab));
13897 
13898   Tab.UseTab = FormatStyle::UT_ForContinuationAndIndentation;
13899   EXPECT_EQ("void a(){\n"
13900             "    // line starts with '\t'\n"
13901             "};",
13902             format("void a(){\n"
13903                    "\t// line starts with '\t'\n"
13904                    "};",
13905                    Tab));
13906 
13907   EXPECT_EQ("void a(){\n"
13908             "    // line starts with '\t'\n"
13909             "};",
13910             format("void a(){\n"
13911                    "\t\t// line starts with '\t'\n"
13912                    "};",
13913                    Tab));
13914 
13915   Tab.UseTab = FormatStyle::UT_AlignWithSpaces;
13916   EXPECT_EQ("void a(){\n"
13917             "    // line starts with '\t'\n"
13918             "};",
13919             format("void a(){\n"
13920                    "\t// line starts with '\t'\n"
13921                    "};",
13922                    Tab));
13923 
13924   EXPECT_EQ("void a(){\n"
13925             "    // line starts with '\t'\n"
13926             "};",
13927             format("void a(){\n"
13928                    "\t\t// line starts with '\t'\n"
13929                    "};",
13930                    Tab));
13931 
13932   Tab.UseTab = FormatStyle::UT_Always;
13933   EXPECT_EQ("void a(){\n"
13934             "// line starts with '\t'\n"
13935             "};",
13936             format("void a(){\n"
13937                    "\t// line starts with '\t'\n"
13938                    "};",
13939                    Tab));
13940 
13941   EXPECT_EQ("void a(){\n"
13942             "// line starts with '\t'\n"
13943             "};",
13944             format("void a(){\n"
13945                    "\t\t// line starts with '\t'\n"
13946                    "};",
13947                    Tab));
13948 }
13949 
13950 TEST_F(FormatTest, CalculatesOriginalColumn) {
13951   EXPECT_EQ("\"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
13952             "q\"; /* some\n"
13953             "       comment */",
13954             format("  \"qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
13955                    "q\"; /* some\n"
13956                    "       comment */",
13957                    getLLVMStyle()));
13958   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
13959             "/* some\n"
13960             "   comment */",
13961             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\n"
13962                    " /* some\n"
13963                    "    comment */",
13964                    getLLVMStyle()));
13965   EXPECT_EQ("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
13966             "qqq\n"
13967             "/* some\n"
13968             "   comment */",
13969             format("// qqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
13970                    "qqq\n"
13971                    " /* some\n"
13972                    "    comment */",
13973                    getLLVMStyle()));
13974   EXPECT_EQ("inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
13975             "wwww; /* some\n"
13976             "         comment */",
13977             format("  inttt qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq\\\n"
13978                    "wwww; /* some\n"
13979                    "         comment */",
13980                    getLLVMStyle()));
13981 }
13982 
13983 TEST_F(FormatTest, ConfigurableSpaceBeforeParens) {
13984   FormatStyle NoSpace = getLLVMStyle();
13985   NoSpace.SpaceBeforeParens = FormatStyle::SBPO_Never;
13986 
13987   verifyFormat("while(true)\n"
13988                "  continue;",
13989                NoSpace);
13990   verifyFormat("for(;;)\n"
13991                "  continue;",
13992                NoSpace);
13993   verifyFormat("if(true)\n"
13994                "  f();\n"
13995                "else if(true)\n"
13996                "  f();",
13997                NoSpace);
13998   verifyFormat("do {\n"
13999                "  do_something();\n"
14000                "} while(something());",
14001                NoSpace);
14002   verifyFormat("switch(x) {\n"
14003                "default:\n"
14004                "  break;\n"
14005                "}",
14006                NoSpace);
14007   verifyFormat("auto i = std::make_unique<int>(5);", NoSpace);
14008   verifyFormat("size_t x = sizeof(x);", NoSpace);
14009   verifyFormat("auto f(int x) -> decltype(x);", NoSpace);
14010   verifyFormat("auto f(int x) -> typeof(x);", NoSpace);
14011   verifyFormat("auto f(int x) -> _Atomic(x);", NoSpace);
14012   verifyFormat("auto f(int x) -> __underlying_type(x);", NoSpace);
14013   verifyFormat("int f(T x) noexcept(x.create());", NoSpace);
14014   verifyFormat("alignas(128) char a[128];", NoSpace);
14015   verifyFormat("size_t x = alignof(MyType);", NoSpace);
14016   verifyFormat("static_assert(sizeof(char) == 1, \"Impossible!\");", NoSpace);
14017   verifyFormat("int f() throw(Deprecated);", NoSpace);
14018   verifyFormat("typedef void (*cb)(int);", NoSpace);
14019   verifyFormat("T A::operator()();", NoSpace);
14020   verifyFormat("X A::operator++(T);", NoSpace);
14021   verifyFormat("auto lambda = []() { return 0; };", NoSpace);
14022 
14023   FormatStyle Space = getLLVMStyle();
14024   Space.SpaceBeforeParens = FormatStyle::SBPO_Always;
14025 
14026   verifyFormat("int f ();", Space);
14027   verifyFormat("void f (int a, T b) {\n"
14028                "  while (true)\n"
14029                "    continue;\n"
14030                "}",
14031                Space);
14032   verifyFormat("if (true)\n"
14033                "  f ();\n"
14034                "else if (true)\n"
14035                "  f ();",
14036                Space);
14037   verifyFormat("do {\n"
14038                "  do_something ();\n"
14039                "} while (something ());",
14040                Space);
14041   verifyFormat("switch (x) {\n"
14042                "default:\n"
14043                "  break;\n"
14044                "}",
14045                Space);
14046   verifyFormat("A::A () : a (1) {}", Space);
14047   verifyFormat("void f () __attribute__ ((asdf));", Space);
14048   verifyFormat("*(&a + 1);\n"
14049                "&((&a)[1]);\n"
14050                "a[(b + c) * d];\n"
14051                "(((a + 1) * 2) + 3) * 4;",
14052                Space);
14053   verifyFormat("#define A(x) x", Space);
14054   verifyFormat("#define A (x) x", Space);
14055   verifyFormat("#if defined(x)\n"
14056                "#endif",
14057                Space);
14058   verifyFormat("auto i = std::make_unique<int> (5);", Space);
14059   verifyFormat("size_t x = sizeof (x);", Space);
14060   verifyFormat("auto f (int x) -> decltype (x);", Space);
14061   verifyFormat("auto f (int x) -> typeof (x);", Space);
14062   verifyFormat("auto f (int x) -> _Atomic (x);", Space);
14063   verifyFormat("auto f (int x) -> __underlying_type (x);", Space);
14064   verifyFormat("int f (T x) noexcept (x.create ());", Space);
14065   verifyFormat("alignas (128) char a[128];", Space);
14066   verifyFormat("size_t x = alignof (MyType);", Space);
14067   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");", Space);
14068   verifyFormat("int f () throw (Deprecated);", Space);
14069   verifyFormat("typedef void (*cb) (int);", Space);
14070   verifyFormat("T A::operator() ();", Space);
14071   verifyFormat("X A::operator++ (T);", Space);
14072   verifyFormat("auto lambda = [] () { return 0; };", Space);
14073   verifyFormat("int x = int (y);", Space);
14074 
14075   FormatStyle SomeSpace = getLLVMStyle();
14076   SomeSpace.SpaceBeforeParens = FormatStyle::SBPO_NonEmptyParentheses;
14077 
14078   verifyFormat("[]() -> float {}", SomeSpace);
14079   verifyFormat("[] (auto foo) {}", SomeSpace);
14080   verifyFormat("[foo]() -> int {}", SomeSpace);
14081   verifyFormat("int f();", SomeSpace);
14082   verifyFormat("void f (int a, T b) {\n"
14083                "  while (true)\n"
14084                "    continue;\n"
14085                "}",
14086                SomeSpace);
14087   verifyFormat("if (true)\n"
14088                "  f();\n"
14089                "else if (true)\n"
14090                "  f();",
14091                SomeSpace);
14092   verifyFormat("do {\n"
14093                "  do_something();\n"
14094                "} while (something());",
14095                SomeSpace);
14096   verifyFormat("switch (x) {\n"
14097                "default:\n"
14098                "  break;\n"
14099                "}",
14100                SomeSpace);
14101   verifyFormat("A::A() : a (1) {}", SomeSpace);
14102   verifyFormat("void f() __attribute__ ((asdf));", SomeSpace);
14103   verifyFormat("*(&a + 1);\n"
14104                "&((&a)[1]);\n"
14105                "a[(b + c) * d];\n"
14106                "(((a + 1) * 2) + 3) * 4;",
14107                SomeSpace);
14108   verifyFormat("#define A(x) x", SomeSpace);
14109   verifyFormat("#define A (x) x", SomeSpace);
14110   verifyFormat("#if defined(x)\n"
14111                "#endif",
14112                SomeSpace);
14113   verifyFormat("auto i = std::make_unique<int> (5);", SomeSpace);
14114   verifyFormat("size_t x = sizeof (x);", SomeSpace);
14115   verifyFormat("auto f (int x) -> decltype (x);", SomeSpace);
14116   verifyFormat("auto f (int x) -> typeof (x);", SomeSpace);
14117   verifyFormat("auto f (int x) -> _Atomic (x);", SomeSpace);
14118   verifyFormat("auto f (int x) -> __underlying_type (x);", SomeSpace);
14119   verifyFormat("int f (T x) noexcept (x.create());", SomeSpace);
14120   verifyFormat("alignas (128) char a[128];", SomeSpace);
14121   verifyFormat("size_t x = alignof (MyType);", SomeSpace);
14122   verifyFormat("static_assert (sizeof (char) == 1, \"Impossible!\");",
14123                SomeSpace);
14124   verifyFormat("int f() throw (Deprecated);", SomeSpace);
14125   verifyFormat("typedef void (*cb) (int);", SomeSpace);
14126   verifyFormat("T A::operator()();", SomeSpace);
14127   verifyFormat("X A::operator++ (T);", SomeSpace);
14128   verifyFormat("int x = int (y);", SomeSpace);
14129   verifyFormat("auto lambda = []() { return 0; };", SomeSpace);
14130 }
14131 
14132 TEST_F(FormatTest, SpaceAfterLogicalNot) {
14133   FormatStyle Spaces = getLLVMStyle();
14134   Spaces.SpaceAfterLogicalNot = true;
14135 
14136   verifyFormat("bool x = ! y", Spaces);
14137   verifyFormat("if (! isFailure())", Spaces);
14138   verifyFormat("if (! (a && b))", Spaces);
14139   verifyFormat("\"Error!\"", Spaces);
14140   verifyFormat("! ! x", Spaces);
14141 }
14142 
14143 TEST_F(FormatTest, ConfigurableSpacesInParentheses) {
14144   FormatStyle Spaces = getLLVMStyle();
14145 
14146   Spaces.SpacesInParentheses = true;
14147   verifyFormat("do_something( ::globalVar );", Spaces);
14148   verifyFormat("call( x, y, z );", Spaces);
14149   verifyFormat("call();", Spaces);
14150   verifyFormat("std::function<void( int, int )> callback;", Spaces);
14151   verifyFormat("void inFunction() { std::function<void( int, int )> fct; }",
14152                Spaces);
14153   verifyFormat("while ( (bool)1 )\n"
14154                "  continue;",
14155                Spaces);
14156   verifyFormat("for ( ;; )\n"
14157                "  continue;",
14158                Spaces);
14159   verifyFormat("if ( true )\n"
14160                "  f();\n"
14161                "else if ( true )\n"
14162                "  f();",
14163                Spaces);
14164   verifyFormat("do {\n"
14165                "  do_something( (int)i );\n"
14166                "} while ( something() );",
14167                Spaces);
14168   verifyFormat("switch ( x ) {\n"
14169                "default:\n"
14170                "  break;\n"
14171                "}",
14172                Spaces);
14173 
14174   Spaces.SpacesInParentheses = false;
14175   Spaces.SpacesInCStyleCastParentheses = true;
14176   verifyFormat("Type *A = ( Type * )P;", Spaces);
14177   verifyFormat("Type *A = ( vector<Type *, int *> )P;", Spaces);
14178   verifyFormat("x = ( int32 )y;", Spaces);
14179   verifyFormat("int a = ( int )(2.0f);", Spaces);
14180   verifyFormat("#define AA(X) sizeof((( X * )NULL)->a)", Spaces);
14181   verifyFormat("my_int a = ( my_int )sizeof(int);", Spaces);
14182   verifyFormat("#define x (( int )-1)", Spaces);
14183 
14184   // Run the first set of tests again with:
14185   Spaces.SpacesInParentheses = false;
14186   Spaces.SpaceInEmptyParentheses = true;
14187   Spaces.SpacesInCStyleCastParentheses = true;
14188   verifyFormat("call(x, y, z);", Spaces);
14189   verifyFormat("call( );", Spaces);
14190   verifyFormat("std::function<void(int, int)> callback;", Spaces);
14191   verifyFormat("while (( bool )1)\n"
14192                "  continue;",
14193                Spaces);
14194   verifyFormat("for (;;)\n"
14195                "  continue;",
14196                Spaces);
14197   verifyFormat("if (true)\n"
14198                "  f( );\n"
14199                "else if (true)\n"
14200                "  f( );",
14201                Spaces);
14202   verifyFormat("do {\n"
14203                "  do_something(( int )i);\n"
14204                "} while (something( ));",
14205                Spaces);
14206   verifyFormat("switch (x) {\n"
14207                "default:\n"
14208                "  break;\n"
14209                "}",
14210                Spaces);
14211 
14212   // Run the first set of tests again with:
14213   Spaces.SpaceAfterCStyleCast = true;
14214   verifyFormat("call(x, y, z);", Spaces);
14215   verifyFormat("call( );", Spaces);
14216   verifyFormat("std::function<void(int, int)> callback;", Spaces);
14217   verifyFormat("while (( bool ) 1)\n"
14218                "  continue;",
14219                Spaces);
14220   verifyFormat("for (;;)\n"
14221                "  continue;",
14222                Spaces);
14223   verifyFormat("if (true)\n"
14224                "  f( );\n"
14225                "else if (true)\n"
14226                "  f( );",
14227                Spaces);
14228   verifyFormat("do {\n"
14229                "  do_something(( int ) i);\n"
14230                "} while (something( ));",
14231                Spaces);
14232   verifyFormat("switch (x) {\n"
14233                "default:\n"
14234                "  break;\n"
14235                "}",
14236                Spaces);
14237 
14238   // Run subset of tests again with:
14239   Spaces.SpacesInCStyleCastParentheses = false;
14240   Spaces.SpaceAfterCStyleCast = true;
14241   verifyFormat("while ((bool) 1)\n"
14242                "  continue;",
14243                Spaces);
14244   verifyFormat("do {\n"
14245                "  do_something((int) i);\n"
14246                "} while (something( ));",
14247                Spaces);
14248 
14249   verifyFormat("size_t idx = (size_t) (ptr - ((char *) file));", Spaces);
14250   verifyFormat("size_t idx = (size_t) a;", Spaces);
14251   verifyFormat("size_t idx = (size_t) (a - 1);", Spaces);
14252   verifyFormat("size_t idx = (a->*foo)(a - 1);", Spaces);
14253   verifyFormat("size_t idx = (a->foo)(a - 1);", Spaces);
14254   verifyFormat("size_t idx = (*foo)(a - 1);", Spaces);
14255   verifyFormat("size_t idx = (*(foo))(a - 1);", Spaces);
14256   Spaces.ColumnLimit = 80;
14257   Spaces.IndentWidth = 4;
14258   Spaces.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
14259   verifyFormat("void foo( ) {\n"
14260                "    size_t foo = (*(function))(\n"
14261                "        Foooo, Barrrrr, Foooo, Barrrr, FoooooooooLooooong, "
14262                "BarrrrrrrrrrrrLong,\n"
14263                "        FoooooooooLooooong);\n"
14264                "}",
14265                Spaces);
14266   Spaces.SpaceAfterCStyleCast = false;
14267   verifyFormat("size_t idx = (size_t)(ptr - ((char *)file));", Spaces);
14268   verifyFormat("size_t idx = (size_t)a;", Spaces);
14269   verifyFormat("size_t idx = (size_t)(a - 1);", Spaces);
14270   verifyFormat("size_t idx = (a->*foo)(a - 1);", Spaces);
14271   verifyFormat("size_t idx = (a->foo)(a - 1);", Spaces);
14272   verifyFormat("size_t idx = (*foo)(a - 1);", Spaces);
14273   verifyFormat("size_t idx = (*(foo))(a - 1);", Spaces);
14274 
14275   verifyFormat("void foo( ) {\n"
14276                "    size_t foo = (*(function))(\n"
14277                "        Foooo, Barrrrr, Foooo, Barrrr, FoooooooooLooooong, "
14278                "BarrrrrrrrrrrrLong,\n"
14279                "        FoooooooooLooooong);\n"
14280                "}",
14281                Spaces);
14282 }
14283 
14284 TEST_F(FormatTest, ConfigurableSpacesInSquareBrackets) {
14285   verifyFormat("int a[5];");
14286   verifyFormat("a[3] += 42;");
14287 
14288   FormatStyle Spaces = getLLVMStyle();
14289   Spaces.SpacesInSquareBrackets = true;
14290   // Not lambdas.
14291   verifyFormat("int a[ 5 ];", Spaces);
14292   verifyFormat("a[ 3 ] += 42;", Spaces);
14293   verifyFormat("constexpr char hello[]{\"hello\"};", Spaces);
14294   verifyFormat("double &operator[](int i) { return 0; }\n"
14295                "int i;",
14296                Spaces);
14297   verifyFormat("std::unique_ptr<int[]> foo() {}", Spaces);
14298   verifyFormat("int i = a[ a ][ a ]->f();", Spaces);
14299   verifyFormat("int i = (*b)[ a ]->f();", Spaces);
14300   // Lambdas.
14301   verifyFormat("int c = []() -> int { return 2; }();\n", Spaces);
14302   verifyFormat("return [ i, args... ] {};", Spaces);
14303   verifyFormat("int foo = [ &bar ]() {};", Spaces);
14304   verifyFormat("int foo = [ = ]() {};", Spaces);
14305   verifyFormat("int foo = [ & ]() {};", Spaces);
14306   verifyFormat("int foo = [ =, &bar ]() {};", Spaces);
14307   verifyFormat("int foo = [ &bar, = ]() {};", Spaces);
14308 }
14309 
14310 TEST_F(FormatTest, ConfigurableSpaceBeforeBrackets) {
14311   FormatStyle NoSpaceStyle = getLLVMStyle();
14312   verifyFormat("int a[5];", NoSpaceStyle);
14313   verifyFormat("a[3] += 42;", NoSpaceStyle);
14314 
14315   verifyFormat("int a[1];", NoSpaceStyle);
14316   verifyFormat("int 1 [a];", NoSpaceStyle);
14317   verifyFormat("int a[1][2];", NoSpaceStyle);
14318   verifyFormat("a[7] = 5;", NoSpaceStyle);
14319   verifyFormat("int a = (f())[23];", NoSpaceStyle);
14320   verifyFormat("f([] {})", NoSpaceStyle);
14321 
14322   FormatStyle Space = getLLVMStyle();
14323   Space.SpaceBeforeSquareBrackets = true;
14324   verifyFormat("int c = []() -> int { return 2; }();\n", Space);
14325   verifyFormat("return [i, args...] {};", Space);
14326 
14327   verifyFormat("int a [5];", Space);
14328   verifyFormat("a [3] += 42;", Space);
14329   verifyFormat("constexpr char hello []{\"hello\"};", Space);
14330   verifyFormat("double &operator[](int i) { return 0; }\n"
14331                "int i;",
14332                Space);
14333   verifyFormat("std::unique_ptr<int []> foo() {}", Space);
14334   verifyFormat("int i = a [a][a]->f();", Space);
14335   verifyFormat("int i = (*b) [a]->f();", Space);
14336 
14337   verifyFormat("int a [1];", Space);
14338   verifyFormat("int 1 [a];", Space);
14339   verifyFormat("int a [1][2];", Space);
14340   verifyFormat("a [7] = 5;", Space);
14341   verifyFormat("int a = (f()) [23];", Space);
14342   verifyFormat("f([] {})", Space);
14343 }
14344 
14345 TEST_F(FormatTest, ConfigurableSpaceBeforeAssignmentOperators) {
14346   verifyFormat("int a = 5;");
14347   verifyFormat("a += 42;");
14348   verifyFormat("a or_eq 8;");
14349 
14350   FormatStyle Spaces = getLLVMStyle();
14351   Spaces.SpaceBeforeAssignmentOperators = false;
14352   verifyFormat("int a= 5;", Spaces);
14353   verifyFormat("a+= 42;", Spaces);
14354   verifyFormat("a or_eq 8;", Spaces);
14355 }
14356 
14357 TEST_F(FormatTest, ConfigurableSpaceBeforeColon) {
14358   verifyFormat("class Foo : public Bar {};");
14359   verifyFormat("Foo::Foo() : foo(1) {}");
14360   verifyFormat("for (auto a : b) {\n}");
14361   verifyFormat("int x = a ? b : c;");
14362   verifyFormat("{\n"
14363                "label0:\n"
14364                "  int x = 0;\n"
14365                "}");
14366   verifyFormat("switch (x) {\n"
14367                "case 1:\n"
14368                "default:\n"
14369                "}");
14370   verifyFormat("switch (allBraces) {\n"
14371                "case 1: {\n"
14372                "  break;\n"
14373                "}\n"
14374                "case 2: {\n"
14375                "  [[fallthrough]];\n"
14376                "}\n"
14377                "default: {\n"
14378                "  break;\n"
14379                "}\n"
14380                "}");
14381 
14382   FormatStyle CtorInitializerStyle = getLLVMStyleWithColumns(30);
14383   CtorInitializerStyle.SpaceBeforeCtorInitializerColon = false;
14384   verifyFormat("class Foo : public Bar {};", CtorInitializerStyle);
14385   verifyFormat("Foo::Foo(): foo(1) {}", CtorInitializerStyle);
14386   verifyFormat("for (auto a : b) {\n}", CtorInitializerStyle);
14387   verifyFormat("int x = a ? b : c;", CtorInitializerStyle);
14388   verifyFormat("{\n"
14389                "label1:\n"
14390                "  int x = 0;\n"
14391                "}",
14392                CtorInitializerStyle);
14393   verifyFormat("switch (x) {\n"
14394                "case 1:\n"
14395                "default:\n"
14396                "}",
14397                CtorInitializerStyle);
14398   verifyFormat("switch (allBraces) {\n"
14399                "case 1: {\n"
14400                "  break;\n"
14401                "}\n"
14402                "case 2: {\n"
14403                "  [[fallthrough]];\n"
14404                "}\n"
14405                "default: {\n"
14406                "  break;\n"
14407                "}\n"
14408                "}",
14409                CtorInitializerStyle);
14410   CtorInitializerStyle.BreakConstructorInitializers =
14411       FormatStyle::BCIS_AfterColon;
14412   verifyFormat("Fooooooooooo::Fooooooooooo():\n"
14413                "    aaaaaaaaaaaaaaaa(1),\n"
14414                "    bbbbbbbbbbbbbbbb(2) {}",
14415                CtorInitializerStyle);
14416   CtorInitializerStyle.BreakConstructorInitializers =
14417       FormatStyle::BCIS_BeforeComma;
14418   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
14419                "    : aaaaaaaaaaaaaaaa(1)\n"
14420                "    , bbbbbbbbbbbbbbbb(2) {}",
14421                CtorInitializerStyle);
14422   CtorInitializerStyle.BreakConstructorInitializers =
14423       FormatStyle::BCIS_BeforeColon;
14424   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
14425                "    : aaaaaaaaaaaaaaaa(1),\n"
14426                "      bbbbbbbbbbbbbbbb(2) {}",
14427                CtorInitializerStyle);
14428   CtorInitializerStyle.ConstructorInitializerIndentWidth = 0;
14429   verifyFormat("Fooooooooooo::Fooooooooooo()\n"
14430                ": aaaaaaaaaaaaaaaa(1),\n"
14431                "  bbbbbbbbbbbbbbbb(2) {}",
14432                CtorInitializerStyle);
14433 
14434   FormatStyle InheritanceStyle = getLLVMStyleWithColumns(30);
14435   InheritanceStyle.SpaceBeforeInheritanceColon = false;
14436   verifyFormat("class Foo: public Bar {};", InheritanceStyle);
14437   verifyFormat("Foo::Foo() : foo(1) {}", InheritanceStyle);
14438   verifyFormat("for (auto a : b) {\n}", InheritanceStyle);
14439   verifyFormat("int x = a ? b : c;", InheritanceStyle);
14440   verifyFormat("{\n"
14441                "label2:\n"
14442                "  int x = 0;\n"
14443                "}",
14444                InheritanceStyle);
14445   verifyFormat("switch (x) {\n"
14446                "case 1:\n"
14447                "default:\n"
14448                "}",
14449                InheritanceStyle);
14450   verifyFormat("switch (allBraces) {\n"
14451                "case 1: {\n"
14452                "  break;\n"
14453                "}\n"
14454                "case 2: {\n"
14455                "  [[fallthrough]];\n"
14456                "}\n"
14457                "default: {\n"
14458                "  break;\n"
14459                "}\n"
14460                "}",
14461                InheritanceStyle);
14462   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterComma;
14463   verifyFormat("class Foooooooooooooooooooooo\n"
14464                "    : public aaaaaaaaaaaaaaaaaa,\n"
14465                "      public bbbbbbbbbbbbbbbbbb {\n"
14466                "}",
14467                InheritanceStyle);
14468   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_AfterColon;
14469   verifyFormat("class Foooooooooooooooooooooo:\n"
14470                "    public aaaaaaaaaaaaaaaaaa,\n"
14471                "    public bbbbbbbbbbbbbbbbbb {\n"
14472                "}",
14473                InheritanceStyle);
14474   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeComma;
14475   verifyFormat("class Foooooooooooooooooooooo\n"
14476                "    : public aaaaaaaaaaaaaaaaaa\n"
14477                "    , public bbbbbbbbbbbbbbbbbb {\n"
14478                "}",
14479                InheritanceStyle);
14480   InheritanceStyle.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
14481   verifyFormat("class Foooooooooooooooooooooo\n"
14482                "    : public aaaaaaaaaaaaaaaaaa,\n"
14483                "      public bbbbbbbbbbbbbbbbbb {\n"
14484                "}",
14485                InheritanceStyle);
14486   InheritanceStyle.ConstructorInitializerIndentWidth = 0;
14487   verifyFormat("class Foooooooooooooooooooooo\n"
14488                ": public aaaaaaaaaaaaaaaaaa,\n"
14489                "  public bbbbbbbbbbbbbbbbbb {}",
14490                InheritanceStyle);
14491 
14492   FormatStyle ForLoopStyle = getLLVMStyle();
14493   ForLoopStyle.SpaceBeforeRangeBasedForLoopColon = false;
14494   verifyFormat("class Foo : public Bar {};", ForLoopStyle);
14495   verifyFormat("Foo::Foo() : foo(1) {}", ForLoopStyle);
14496   verifyFormat("for (auto a: b) {\n}", ForLoopStyle);
14497   verifyFormat("int x = a ? b : c;", ForLoopStyle);
14498   verifyFormat("{\n"
14499                "label2:\n"
14500                "  int x = 0;\n"
14501                "}",
14502                ForLoopStyle);
14503   verifyFormat("switch (x) {\n"
14504                "case 1:\n"
14505                "default:\n"
14506                "}",
14507                ForLoopStyle);
14508   verifyFormat("switch (allBraces) {\n"
14509                "case 1: {\n"
14510                "  break;\n"
14511                "}\n"
14512                "case 2: {\n"
14513                "  [[fallthrough]];\n"
14514                "}\n"
14515                "default: {\n"
14516                "  break;\n"
14517                "}\n"
14518                "}",
14519                ForLoopStyle);
14520 
14521   FormatStyle CaseStyle = getLLVMStyle();
14522   CaseStyle.SpaceBeforeCaseColon = true;
14523   verifyFormat("class Foo : public Bar {};", CaseStyle);
14524   verifyFormat("Foo::Foo() : foo(1) {}", CaseStyle);
14525   verifyFormat("for (auto a : b) {\n}", CaseStyle);
14526   verifyFormat("int x = a ? b : c;", CaseStyle);
14527   verifyFormat("switch (x) {\n"
14528                "case 1 :\n"
14529                "default :\n"
14530                "}",
14531                CaseStyle);
14532   verifyFormat("switch (allBraces) {\n"
14533                "case 1 : {\n"
14534                "  break;\n"
14535                "}\n"
14536                "case 2 : {\n"
14537                "  [[fallthrough]];\n"
14538                "}\n"
14539                "default : {\n"
14540                "  break;\n"
14541                "}\n"
14542                "}",
14543                CaseStyle);
14544 
14545   FormatStyle NoSpaceStyle = getLLVMStyle();
14546   EXPECT_EQ(NoSpaceStyle.SpaceBeforeCaseColon, false);
14547   NoSpaceStyle.SpaceBeforeCtorInitializerColon = false;
14548   NoSpaceStyle.SpaceBeforeInheritanceColon = false;
14549   NoSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
14550   verifyFormat("class Foo: public Bar {};", NoSpaceStyle);
14551   verifyFormat("Foo::Foo(): foo(1) {}", NoSpaceStyle);
14552   verifyFormat("for (auto a: b) {\n}", NoSpaceStyle);
14553   verifyFormat("int x = a ? b : c;", NoSpaceStyle);
14554   verifyFormat("{\n"
14555                "label3:\n"
14556                "  int x = 0;\n"
14557                "}",
14558                NoSpaceStyle);
14559   verifyFormat("switch (x) {\n"
14560                "case 1:\n"
14561                "default:\n"
14562                "}",
14563                NoSpaceStyle);
14564   verifyFormat("switch (allBraces) {\n"
14565                "case 1: {\n"
14566                "  break;\n"
14567                "}\n"
14568                "case 2: {\n"
14569                "  [[fallthrough]];\n"
14570                "}\n"
14571                "default: {\n"
14572                "  break;\n"
14573                "}\n"
14574                "}",
14575                NoSpaceStyle);
14576 
14577   FormatStyle InvertedSpaceStyle = getLLVMStyle();
14578   InvertedSpaceStyle.SpaceBeforeCaseColon = true;
14579   InvertedSpaceStyle.SpaceBeforeCtorInitializerColon = false;
14580   InvertedSpaceStyle.SpaceBeforeInheritanceColon = false;
14581   InvertedSpaceStyle.SpaceBeforeRangeBasedForLoopColon = false;
14582   verifyFormat("class Foo: public Bar {};", InvertedSpaceStyle);
14583   verifyFormat("Foo::Foo(): foo(1) {}", InvertedSpaceStyle);
14584   verifyFormat("for (auto a: b) {\n}", InvertedSpaceStyle);
14585   verifyFormat("int x = a ? b : c;", InvertedSpaceStyle);
14586   verifyFormat("{\n"
14587                "label3:\n"
14588                "  int x = 0;\n"
14589                "}",
14590                InvertedSpaceStyle);
14591   verifyFormat("switch (x) {\n"
14592                "case 1 :\n"
14593                "case 2 : {\n"
14594                "  break;\n"
14595                "}\n"
14596                "default :\n"
14597                "  break;\n"
14598                "}",
14599                InvertedSpaceStyle);
14600   verifyFormat("switch (allBraces) {\n"
14601                "case 1 : {\n"
14602                "  break;\n"
14603                "}\n"
14604                "case 2 : {\n"
14605                "  [[fallthrough]];\n"
14606                "}\n"
14607                "default : {\n"
14608                "  break;\n"
14609                "}\n"
14610                "}",
14611                InvertedSpaceStyle);
14612 }
14613 
14614 TEST_F(FormatTest, ConfigurableSpaceAroundPointerQualifiers) {
14615   FormatStyle Style = getLLVMStyle();
14616 
14617   Style.PointerAlignment = FormatStyle::PAS_Left;
14618   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
14619   verifyFormat("void* const* x = NULL;", Style);
14620 
14621 #define verifyQualifierSpaces(Code, Pointers, Qualifiers)                      \
14622   do {                                                                         \
14623     Style.PointerAlignment = FormatStyle::Pointers;                            \
14624     Style.SpaceAroundPointerQualifiers = FormatStyle::Qualifiers;              \
14625     verifyFormat(Code, Style);                                                 \
14626   } while (false)
14627 
14628   verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Default);
14629   verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_Default);
14630   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Default);
14631 
14632   verifyQualifierSpaces("void* const* x = NULL;", PAS_Left, SAPQ_Before);
14633   verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Before);
14634   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Before);
14635 
14636   verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_After);
14637   verifyQualifierSpaces("void *const *x = NULL;", PAS_Right, SAPQ_After);
14638   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_After);
14639 
14640   verifyQualifierSpaces("void* const * x = NULL;", PAS_Left, SAPQ_Both);
14641   verifyQualifierSpaces("void * const *x = NULL;", PAS_Right, SAPQ_Both);
14642   verifyQualifierSpaces("void * const * x = NULL;", PAS_Middle, SAPQ_Both);
14643 
14644   verifyQualifierSpaces("Foo::operator void const*();", PAS_Left, SAPQ_Default);
14645   verifyQualifierSpaces("Foo::operator void const *();", PAS_Right,
14646                         SAPQ_Default);
14647   verifyQualifierSpaces("Foo::operator void const *();", PAS_Middle,
14648                         SAPQ_Default);
14649 
14650   verifyQualifierSpaces("Foo::operator void const*();", PAS_Left, SAPQ_Before);
14651   verifyQualifierSpaces("Foo::operator void const *();", PAS_Right,
14652                         SAPQ_Before);
14653   verifyQualifierSpaces("Foo::operator void const *();", PAS_Middle,
14654                         SAPQ_Before);
14655 
14656   verifyQualifierSpaces("Foo::operator void const *();", PAS_Left, SAPQ_After);
14657   verifyQualifierSpaces("Foo::operator void const *();", PAS_Right, SAPQ_After);
14658   verifyQualifierSpaces("Foo::operator void const *();", PAS_Middle,
14659                         SAPQ_After);
14660 
14661   verifyQualifierSpaces("Foo::operator void const *();", PAS_Left, SAPQ_Both);
14662   verifyQualifierSpaces("Foo::operator void const *();", PAS_Right, SAPQ_Both);
14663   verifyQualifierSpaces("Foo::operator void const *();", PAS_Middle, SAPQ_Both);
14664 
14665 #undef verifyQualifierSpaces
14666 
14667   FormatStyle Spaces = getLLVMStyle();
14668   Spaces.AttributeMacros.push_back("qualified");
14669   Spaces.PointerAlignment = FormatStyle::PAS_Right;
14670   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Default;
14671   verifyFormat("SomeType *volatile *a = NULL;", Spaces);
14672   verifyFormat("SomeType *__attribute__((attr)) *a = NULL;", Spaces);
14673   verifyFormat("std::vector<SomeType *const *> x;", Spaces);
14674   verifyFormat("std::vector<SomeType *qualified *> x;", Spaces);
14675   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
14676   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
14677   verifyFormat("SomeType * volatile *a = NULL;", Spaces);
14678   verifyFormat("SomeType * __attribute__((attr)) *a = NULL;", Spaces);
14679   verifyFormat("std::vector<SomeType * const *> x;", Spaces);
14680   verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
14681   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
14682 
14683   // Check that SAPQ_Before doesn't result in extra spaces for PAS_Left.
14684   Spaces.PointerAlignment = FormatStyle::PAS_Left;
14685   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Before;
14686   verifyFormat("SomeType* volatile* a = NULL;", Spaces);
14687   verifyFormat("SomeType* __attribute__((attr))* a = NULL;", Spaces);
14688   verifyFormat("std::vector<SomeType* const*> x;", Spaces);
14689   verifyFormat("std::vector<SomeType* qualified*> x;", Spaces);
14690   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
14691   // However, setting it to SAPQ_After should add spaces after __attribute, etc.
14692   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
14693   verifyFormat("SomeType* volatile * a = NULL;", Spaces);
14694   verifyFormat("SomeType* __attribute__((attr)) * a = NULL;", Spaces);
14695   verifyFormat("std::vector<SomeType* const *> x;", Spaces);
14696   verifyFormat("std::vector<SomeType* qualified *> x;", Spaces);
14697   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
14698 
14699   // PAS_Middle should not have any noticeable changes even for SAPQ_Both
14700   Spaces.PointerAlignment = FormatStyle::PAS_Middle;
14701   Spaces.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_After;
14702   verifyFormat("SomeType * volatile * a = NULL;", Spaces);
14703   verifyFormat("SomeType * __attribute__((attr)) * a = NULL;", Spaces);
14704   verifyFormat("std::vector<SomeType * const *> x;", Spaces);
14705   verifyFormat("std::vector<SomeType * qualified *> x;", Spaces);
14706   verifyFormat("std::vector<SomeVar * NotAQualifier> x;", Spaces);
14707 }
14708 
14709 TEST_F(FormatTest, AlignConsecutiveMacros) {
14710   FormatStyle Style = getLLVMStyle();
14711   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
14712   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
14713   Style.AlignConsecutiveMacros = FormatStyle::ACS_None;
14714 
14715   verifyFormat("#define a 3\n"
14716                "#define bbbb 4\n"
14717                "#define ccc (5)",
14718                Style);
14719 
14720   verifyFormat("#define f(x) (x * x)\n"
14721                "#define fff(x, y, z) (x * y + z)\n"
14722                "#define ffff(x, y) (x - y)",
14723                Style);
14724 
14725   verifyFormat("#define foo(x, y) (x + y)\n"
14726                "#define bar (5, 6)(2 + 2)",
14727                Style);
14728 
14729   verifyFormat("#define a 3\n"
14730                "#define bbbb 4\n"
14731                "#define ccc (5)\n"
14732                "#define f(x) (x * x)\n"
14733                "#define fff(x, y, z) (x * y + z)\n"
14734                "#define ffff(x, y) (x - y)",
14735                Style);
14736 
14737   Style.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
14738   verifyFormat("#define a    3\n"
14739                "#define bbbb 4\n"
14740                "#define ccc  (5)",
14741                Style);
14742 
14743   verifyFormat("#define f(x)         (x * x)\n"
14744                "#define fff(x, y, z) (x * y + z)\n"
14745                "#define ffff(x, y)   (x - y)",
14746                Style);
14747 
14748   verifyFormat("#define foo(x, y) (x + y)\n"
14749                "#define bar       (5, 6)(2 + 2)",
14750                Style);
14751 
14752   verifyFormat("#define a            3\n"
14753                "#define bbbb         4\n"
14754                "#define ccc          (5)\n"
14755                "#define f(x)         (x * x)\n"
14756                "#define fff(x, y, z) (x * y + z)\n"
14757                "#define ffff(x, y)   (x - y)",
14758                Style);
14759 
14760   verifyFormat("#define a         5\n"
14761                "#define foo(x, y) (x + y)\n"
14762                "#define CCC       (6)\n"
14763                "auto lambda = []() {\n"
14764                "  auto  ii = 0;\n"
14765                "  float j  = 0;\n"
14766                "  return 0;\n"
14767                "};\n"
14768                "int   i  = 0;\n"
14769                "float i2 = 0;\n"
14770                "auto  v  = type{\n"
14771                "    i = 1,   //\n"
14772                "    (i = 2), //\n"
14773                "    i = 3    //\n"
14774                "};",
14775                Style);
14776 
14777   Style.AlignConsecutiveMacros = FormatStyle::ACS_None;
14778   Style.ColumnLimit = 20;
14779 
14780   verifyFormat("#define a          \\\n"
14781                "  \"aabbbbbbbbbbbb\"\n"
14782                "#define D          \\\n"
14783                "  \"aabbbbbbbbbbbb\" \\\n"
14784                "  \"ccddeeeeeeeee\"\n"
14785                "#define B          \\\n"
14786                "  \"QQQQQQQQQQQQQ\"  \\\n"
14787                "  \"FFFFFFFFFFFFF\"  \\\n"
14788                "  \"LLLLLLLL\"\n",
14789                Style);
14790 
14791   Style.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
14792   verifyFormat("#define a          \\\n"
14793                "  \"aabbbbbbbbbbbb\"\n"
14794                "#define D          \\\n"
14795                "  \"aabbbbbbbbbbbb\" \\\n"
14796                "  \"ccddeeeeeeeee\"\n"
14797                "#define B          \\\n"
14798                "  \"QQQQQQQQQQQQQ\"  \\\n"
14799                "  \"FFFFFFFFFFFFF\"  \\\n"
14800                "  \"LLLLLLLL\"\n",
14801                Style);
14802 
14803   // Test across comments
14804   Style.MaxEmptyLinesToKeep = 10;
14805   Style.ReflowComments = false;
14806   Style.AlignConsecutiveMacros = FormatStyle::ACS_AcrossComments;
14807   EXPECT_EQ("#define a    3\n"
14808             "// line comment\n"
14809             "#define bbbb 4\n"
14810             "#define ccc  (5)",
14811             format("#define a 3\n"
14812                    "// line comment\n"
14813                    "#define bbbb 4\n"
14814                    "#define ccc (5)",
14815                    Style));
14816 
14817   EXPECT_EQ("#define a    3\n"
14818             "/* block comment */\n"
14819             "#define bbbb 4\n"
14820             "#define ccc  (5)",
14821             format("#define a  3\n"
14822                    "/* block comment */\n"
14823                    "#define bbbb 4\n"
14824                    "#define ccc (5)",
14825                    Style));
14826 
14827   EXPECT_EQ("#define a    3\n"
14828             "/* multi-line *\n"
14829             " * block comment */\n"
14830             "#define bbbb 4\n"
14831             "#define ccc  (5)",
14832             format("#define a 3\n"
14833                    "/* multi-line *\n"
14834                    " * block comment */\n"
14835                    "#define bbbb 4\n"
14836                    "#define ccc (5)",
14837                    Style));
14838 
14839   EXPECT_EQ("#define a    3\n"
14840             "// multi-line line comment\n"
14841             "//\n"
14842             "#define bbbb 4\n"
14843             "#define ccc  (5)",
14844             format("#define a  3\n"
14845                    "// multi-line line comment\n"
14846                    "//\n"
14847                    "#define bbbb 4\n"
14848                    "#define ccc (5)",
14849                    Style));
14850 
14851   EXPECT_EQ("#define a 3\n"
14852             "// empty lines still break.\n"
14853             "\n"
14854             "#define bbbb 4\n"
14855             "#define ccc  (5)",
14856             format("#define a     3\n"
14857                    "// empty lines still break.\n"
14858                    "\n"
14859                    "#define bbbb     4\n"
14860                    "#define ccc  (5)",
14861                    Style));
14862 
14863   // Test across empty lines
14864   Style.AlignConsecutiveMacros = FormatStyle::ACS_AcrossEmptyLines;
14865   EXPECT_EQ("#define a    3\n"
14866             "\n"
14867             "#define bbbb 4\n"
14868             "#define ccc  (5)",
14869             format("#define a 3\n"
14870                    "\n"
14871                    "#define bbbb 4\n"
14872                    "#define ccc (5)",
14873                    Style));
14874 
14875   EXPECT_EQ("#define a    3\n"
14876             "\n"
14877             "\n"
14878             "\n"
14879             "#define bbbb 4\n"
14880             "#define ccc  (5)",
14881             format("#define a        3\n"
14882                    "\n"
14883                    "\n"
14884                    "\n"
14885                    "#define bbbb 4\n"
14886                    "#define ccc (5)",
14887                    Style));
14888 
14889   EXPECT_EQ("#define a 3\n"
14890             "// comments should break alignment\n"
14891             "//\n"
14892             "#define bbbb 4\n"
14893             "#define ccc  (5)",
14894             format("#define a        3\n"
14895                    "// comments should break alignment\n"
14896                    "//\n"
14897                    "#define bbbb 4\n"
14898                    "#define ccc (5)",
14899                    Style));
14900 
14901   // Test across empty lines and comments
14902   Style.AlignConsecutiveMacros = FormatStyle::ACS_AcrossEmptyLinesAndComments;
14903   verifyFormat("#define a    3\n"
14904                "\n"
14905                "// line comment\n"
14906                "#define bbbb 4\n"
14907                "#define ccc  (5)",
14908                Style);
14909 
14910   EXPECT_EQ("#define a    3\n"
14911             "\n"
14912             "\n"
14913             "/* multi-line *\n"
14914             " * block comment */\n"
14915             "\n"
14916             "\n"
14917             "#define bbbb 4\n"
14918             "#define ccc  (5)",
14919             format("#define a 3\n"
14920                    "\n"
14921                    "\n"
14922                    "/* multi-line *\n"
14923                    " * block comment */\n"
14924                    "\n"
14925                    "\n"
14926                    "#define bbbb 4\n"
14927                    "#define ccc (5)",
14928                    Style));
14929 
14930   EXPECT_EQ("#define a    3\n"
14931             "\n"
14932             "\n"
14933             "/* multi-line *\n"
14934             " * block comment */\n"
14935             "\n"
14936             "\n"
14937             "#define bbbb 4\n"
14938             "#define ccc  (5)",
14939             format("#define a 3\n"
14940                    "\n"
14941                    "\n"
14942                    "/* multi-line *\n"
14943                    " * block comment */\n"
14944                    "\n"
14945                    "\n"
14946                    "#define bbbb 4\n"
14947                    "#define ccc       (5)",
14948                    Style));
14949 }
14950 
14951 TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLines) {
14952   FormatStyle Alignment = getLLVMStyle();
14953   Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
14954   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_AcrossEmptyLines;
14955 
14956   Alignment.MaxEmptyLinesToKeep = 10;
14957   /* Test alignment across empty lines */
14958   EXPECT_EQ("int a           = 5;\n"
14959             "\n"
14960             "int oneTwoThree = 123;",
14961             format("int a       = 5;\n"
14962                    "\n"
14963                    "int oneTwoThree= 123;",
14964                    Alignment));
14965   EXPECT_EQ("int a           = 5;\n"
14966             "int one         = 1;\n"
14967             "\n"
14968             "int oneTwoThree = 123;",
14969             format("int a = 5;\n"
14970                    "int one = 1;\n"
14971                    "\n"
14972                    "int oneTwoThree = 123;",
14973                    Alignment));
14974   EXPECT_EQ("int a           = 5;\n"
14975             "int one         = 1;\n"
14976             "\n"
14977             "int oneTwoThree = 123;\n"
14978             "int oneTwo      = 12;",
14979             format("int a = 5;\n"
14980                    "int one = 1;\n"
14981                    "\n"
14982                    "int oneTwoThree = 123;\n"
14983                    "int oneTwo = 12;",
14984                    Alignment));
14985 
14986   /* Test across comments */
14987   EXPECT_EQ("int a = 5;\n"
14988             "/* block comment */\n"
14989             "int oneTwoThree = 123;",
14990             format("int a = 5;\n"
14991                    "/* block comment */\n"
14992                    "int oneTwoThree=123;",
14993                    Alignment));
14994 
14995   EXPECT_EQ("int a = 5;\n"
14996             "// line comment\n"
14997             "int oneTwoThree = 123;",
14998             format("int a = 5;\n"
14999                    "// line comment\n"
15000                    "int oneTwoThree=123;",
15001                    Alignment));
15002 
15003   /* Test across comments and newlines */
15004   EXPECT_EQ("int a = 5;\n"
15005             "\n"
15006             "/* block comment */\n"
15007             "int oneTwoThree = 123;",
15008             format("int a = 5;\n"
15009                    "\n"
15010                    "/* block comment */\n"
15011                    "int oneTwoThree=123;",
15012                    Alignment));
15013 
15014   EXPECT_EQ("int a = 5;\n"
15015             "\n"
15016             "// line comment\n"
15017             "int oneTwoThree = 123;",
15018             format("int a = 5;\n"
15019                    "\n"
15020                    "// line comment\n"
15021                    "int oneTwoThree=123;",
15022                    Alignment));
15023 }
15024 
15025 TEST_F(FormatTest, AlignConsecutiveDeclarationsAcrossEmptyLinesAndComments) {
15026   FormatStyle Alignment = getLLVMStyle();
15027   Alignment.AlignConsecutiveDeclarations =
15028       FormatStyle::ACS_AcrossEmptyLinesAndComments;
15029   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
15030 
15031   Alignment.MaxEmptyLinesToKeep = 10;
15032   /* Test alignment across empty lines */
15033   EXPECT_EQ("int         a = 5;\n"
15034             "\n"
15035             "float const oneTwoThree = 123;",
15036             format("int a = 5;\n"
15037                    "\n"
15038                    "float const oneTwoThree = 123;",
15039                    Alignment));
15040   EXPECT_EQ("int         a = 5;\n"
15041             "float const one = 1;\n"
15042             "\n"
15043             "int         oneTwoThree = 123;",
15044             format("int a = 5;\n"
15045                    "float const one = 1;\n"
15046                    "\n"
15047                    "int oneTwoThree = 123;",
15048                    Alignment));
15049 
15050   /* Test across comments */
15051   EXPECT_EQ("float const a = 5;\n"
15052             "/* block comment */\n"
15053             "int         oneTwoThree = 123;",
15054             format("float const a = 5;\n"
15055                    "/* block comment */\n"
15056                    "int oneTwoThree=123;",
15057                    Alignment));
15058 
15059   EXPECT_EQ("float const a = 5;\n"
15060             "// line comment\n"
15061             "int         oneTwoThree = 123;",
15062             format("float const a = 5;\n"
15063                    "// line comment\n"
15064                    "int oneTwoThree=123;",
15065                    Alignment));
15066 
15067   /* Test across comments and newlines */
15068   EXPECT_EQ("float const a = 5;\n"
15069             "\n"
15070             "/* block comment */\n"
15071             "int         oneTwoThree = 123;",
15072             format("float const a = 5;\n"
15073                    "\n"
15074                    "/* block comment */\n"
15075                    "int         oneTwoThree=123;",
15076                    Alignment));
15077 
15078   EXPECT_EQ("float const a = 5;\n"
15079             "\n"
15080             "// line comment\n"
15081             "int         oneTwoThree = 123;",
15082             format("float const a = 5;\n"
15083                    "\n"
15084                    "// line comment\n"
15085                    "int oneTwoThree=123;",
15086                    Alignment));
15087 }
15088 
15089 TEST_F(FormatTest, AlignConsecutiveBitFieldsAcrossEmptyLinesAndComments) {
15090   FormatStyle Alignment = getLLVMStyle();
15091   Alignment.AlignConsecutiveBitFields =
15092       FormatStyle::ACS_AcrossEmptyLinesAndComments;
15093 
15094   Alignment.MaxEmptyLinesToKeep = 10;
15095   /* Test alignment across empty lines */
15096   EXPECT_EQ("int a            : 5;\n"
15097             "\n"
15098             "int longbitfield : 6;",
15099             format("int a : 5;\n"
15100                    "\n"
15101                    "int longbitfield : 6;",
15102                    Alignment));
15103   EXPECT_EQ("int a            : 5;\n"
15104             "int one          : 1;\n"
15105             "\n"
15106             "int longbitfield : 6;",
15107             format("int a : 5;\n"
15108                    "int one : 1;\n"
15109                    "\n"
15110                    "int longbitfield : 6;",
15111                    Alignment));
15112 
15113   /* Test across comments */
15114   EXPECT_EQ("int a            : 5;\n"
15115             "/* block comment */\n"
15116             "int longbitfield : 6;",
15117             format("int a : 5;\n"
15118                    "/* block comment */\n"
15119                    "int longbitfield : 6;",
15120                    Alignment));
15121   EXPECT_EQ("int a            : 5;\n"
15122             "int one          : 1;\n"
15123             "// line comment\n"
15124             "int longbitfield : 6;",
15125             format("int a : 5;\n"
15126                    "int one : 1;\n"
15127                    "// line comment\n"
15128                    "int longbitfield : 6;",
15129                    Alignment));
15130 
15131   /* Test across comments and newlines */
15132   EXPECT_EQ("int a            : 5;\n"
15133             "/* block comment */\n"
15134             "\n"
15135             "int longbitfield : 6;",
15136             format("int a : 5;\n"
15137                    "/* block comment */\n"
15138                    "\n"
15139                    "int longbitfield : 6;",
15140                    Alignment));
15141   EXPECT_EQ("int a            : 5;\n"
15142             "int one          : 1;\n"
15143             "\n"
15144             "// line comment\n"
15145             "\n"
15146             "int longbitfield : 6;",
15147             format("int a : 5;\n"
15148                    "int one : 1;\n"
15149                    "\n"
15150                    "// line comment \n"
15151                    "\n"
15152                    "int longbitfield : 6;",
15153                    Alignment));
15154 }
15155 
15156 TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossComments) {
15157   FormatStyle Alignment = getLLVMStyle();
15158   Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
15159   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_AcrossComments;
15160 
15161   Alignment.MaxEmptyLinesToKeep = 10;
15162   /* Test alignment across empty lines */
15163   EXPECT_EQ("int a = 5;\n"
15164             "\n"
15165             "int oneTwoThree = 123;",
15166             format("int a       = 5;\n"
15167                    "\n"
15168                    "int oneTwoThree= 123;",
15169                    Alignment));
15170   EXPECT_EQ("int a   = 5;\n"
15171             "int one = 1;\n"
15172             "\n"
15173             "int oneTwoThree = 123;",
15174             format("int a = 5;\n"
15175                    "int one = 1;\n"
15176                    "\n"
15177                    "int oneTwoThree = 123;",
15178                    Alignment));
15179 
15180   /* Test across comments */
15181   EXPECT_EQ("int a           = 5;\n"
15182             "/* block comment */\n"
15183             "int oneTwoThree = 123;",
15184             format("int a = 5;\n"
15185                    "/* block comment */\n"
15186                    "int oneTwoThree=123;",
15187                    Alignment));
15188 
15189   EXPECT_EQ("int a           = 5;\n"
15190             "// line comment\n"
15191             "int oneTwoThree = 123;",
15192             format("int a = 5;\n"
15193                    "// line comment\n"
15194                    "int oneTwoThree=123;",
15195                    Alignment));
15196 
15197   EXPECT_EQ("int a           = 5;\n"
15198             "/*\n"
15199             " * multi-line block comment\n"
15200             " */\n"
15201             "int oneTwoThree = 123;",
15202             format("int a = 5;\n"
15203                    "/*\n"
15204                    " * multi-line block comment\n"
15205                    " */\n"
15206                    "int oneTwoThree=123;",
15207                    Alignment));
15208 
15209   EXPECT_EQ("int a           = 5;\n"
15210             "//\n"
15211             "// multi-line line comment\n"
15212             "//\n"
15213             "int oneTwoThree = 123;",
15214             format("int a = 5;\n"
15215                    "//\n"
15216                    "// multi-line line comment\n"
15217                    "//\n"
15218                    "int oneTwoThree=123;",
15219                    Alignment));
15220 
15221   /* Test across comments and newlines */
15222   EXPECT_EQ("int a = 5;\n"
15223             "\n"
15224             "/* block comment */\n"
15225             "int oneTwoThree = 123;",
15226             format("int a = 5;\n"
15227                    "\n"
15228                    "/* block comment */\n"
15229                    "int oneTwoThree=123;",
15230                    Alignment));
15231 
15232   EXPECT_EQ("int a = 5;\n"
15233             "\n"
15234             "// line comment\n"
15235             "int oneTwoThree = 123;",
15236             format("int a = 5;\n"
15237                    "\n"
15238                    "// line comment\n"
15239                    "int oneTwoThree=123;",
15240                    Alignment));
15241 }
15242 
15243 TEST_F(FormatTest, AlignConsecutiveAssignmentsAcrossEmptyLinesAndComments) {
15244   FormatStyle Alignment = getLLVMStyle();
15245   Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
15246   Alignment.AlignConsecutiveAssignments =
15247       FormatStyle::ACS_AcrossEmptyLinesAndComments;
15248   verifyFormat("int a           = 5;\n"
15249                "int oneTwoThree = 123;",
15250                Alignment);
15251   verifyFormat("int a           = method();\n"
15252                "int oneTwoThree = 133;",
15253                Alignment);
15254   verifyFormat("a &= 5;\n"
15255                "bcd *= 5;\n"
15256                "ghtyf += 5;\n"
15257                "dvfvdb -= 5;\n"
15258                "a /= 5;\n"
15259                "vdsvsv %= 5;\n"
15260                "sfdbddfbdfbb ^= 5;\n"
15261                "dvsdsv |= 5;\n"
15262                "int dsvvdvsdvvv = 123;",
15263                Alignment);
15264   verifyFormat("int i = 1, j = 10;\n"
15265                "something = 2000;",
15266                Alignment);
15267   verifyFormat("something = 2000;\n"
15268                "int i = 1, j = 10;\n",
15269                Alignment);
15270   verifyFormat("something = 2000;\n"
15271                "another   = 911;\n"
15272                "int i = 1, j = 10;\n"
15273                "oneMore = 1;\n"
15274                "i       = 2;",
15275                Alignment);
15276   verifyFormat("int a   = 5;\n"
15277                "int one = 1;\n"
15278                "method();\n"
15279                "int oneTwoThree = 123;\n"
15280                "int oneTwo      = 12;",
15281                Alignment);
15282   verifyFormat("int oneTwoThree = 123;\n"
15283                "int oneTwo      = 12;\n"
15284                "method();\n",
15285                Alignment);
15286   verifyFormat("int oneTwoThree = 123; // comment\n"
15287                "int oneTwo      = 12;  // comment",
15288                Alignment);
15289 
15290   // Bug 25167
15291   /* Uncomment when fixed
15292     verifyFormat("#if A\n"
15293                  "#else\n"
15294                  "int aaaaaaaa = 12;\n"
15295                  "#endif\n"
15296                  "#if B\n"
15297                  "#else\n"
15298                  "int a = 12;\n"
15299                  "#endif\n",
15300                  Alignment);
15301     verifyFormat("enum foo {\n"
15302                  "#if A\n"
15303                  "#else\n"
15304                  "  aaaaaaaa = 12;\n"
15305                  "#endif\n"
15306                  "#if B\n"
15307                  "#else\n"
15308                  "  a = 12;\n"
15309                  "#endif\n"
15310                  "};\n",
15311                  Alignment);
15312   */
15313 
15314   Alignment.MaxEmptyLinesToKeep = 10;
15315   /* Test alignment across empty lines */
15316   EXPECT_EQ("int a           = 5;\n"
15317             "\n"
15318             "int oneTwoThree = 123;",
15319             format("int a       = 5;\n"
15320                    "\n"
15321                    "int oneTwoThree= 123;",
15322                    Alignment));
15323   EXPECT_EQ("int a           = 5;\n"
15324             "int one         = 1;\n"
15325             "\n"
15326             "int oneTwoThree = 123;",
15327             format("int a = 5;\n"
15328                    "int one = 1;\n"
15329                    "\n"
15330                    "int oneTwoThree = 123;",
15331                    Alignment));
15332   EXPECT_EQ("int a           = 5;\n"
15333             "int one         = 1;\n"
15334             "\n"
15335             "int oneTwoThree = 123;\n"
15336             "int oneTwo      = 12;",
15337             format("int a = 5;\n"
15338                    "int one = 1;\n"
15339                    "\n"
15340                    "int oneTwoThree = 123;\n"
15341                    "int oneTwo = 12;",
15342                    Alignment));
15343 
15344   /* Test across comments */
15345   EXPECT_EQ("int a           = 5;\n"
15346             "/* block comment */\n"
15347             "int oneTwoThree = 123;",
15348             format("int a = 5;\n"
15349                    "/* block comment */\n"
15350                    "int oneTwoThree=123;",
15351                    Alignment));
15352 
15353   EXPECT_EQ("int a           = 5;\n"
15354             "// line comment\n"
15355             "int oneTwoThree = 123;",
15356             format("int a = 5;\n"
15357                    "// line comment\n"
15358                    "int oneTwoThree=123;",
15359                    Alignment));
15360 
15361   /* Test across comments and newlines */
15362   EXPECT_EQ("int a           = 5;\n"
15363             "\n"
15364             "/* block comment */\n"
15365             "int oneTwoThree = 123;",
15366             format("int a = 5;\n"
15367                    "\n"
15368                    "/* block comment */\n"
15369                    "int oneTwoThree=123;",
15370                    Alignment));
15371 
15372   EXPECT_EQ("int a           = 5;\n"
15373             "\n"
15374             "// line comment\n"
15375             "int oneTwoThree = 123;",
15376             format("int a = 5;\n"
15377                    "\n"
15378                    "// line comment\n"
15379                    "int oneTwoThree=123;",
15380                    Alignment));
15381 
15382   EXPECT_EQ("int a           = 5;\n"
15383             "//\n"
15384             "// multi-line line comment\n"
15385             "//\n"
15386             "int oneTwoThree = 123;",
15387             format("int a = 5;\n"
15388                    "//\n"
15389                    "// multi-line line comment\n"
15390                    "//\n"
15391                    "int oneTwoThree=123;",
15392                    Alignment));
15393 
15394   EXPECT_EQ("int a           = 5;\n"
15395             "/*\n"
15396             " *  multi-line block comment\n"
15397             " */\n"
15398             "int oneTwoThree = 123;",
15399             format("int a = 5;\n"
15400                    "/*\n"
15401                    " *  multi-line block comment\n"
15402                    " */\n"
15403                    "int oneTwoThree=123;",
15404                    Alignment));
15405 
15406   EXPECT_EQ("int a           = 5;\n"
15407             "\n"
15408             "/* block comment */\n"
15409             "\n"
15410             "\n"
15411             "\n"
15412             "int oneTwoThree = 123;",
15413             format("int a = 5;\n"
15414                    "\n"
15415                    "/* block comment */\n"
15416                    "\n"
15417                    "\n"
15418                    "\n"
15419                    "int oneTwoThree=123;",
15420                    Alignment));
15421 
15422   EXPECT_EQ("int a           = 5;\n"
15423             "\n"
15424             "// line comment\n"
15425             "\n"
15426             "\n"
15427             "\n"
15428             "int oneTwoThree = 123;",
15429             format("int a = 5;\n"
15430                    "\n"
15431                    "// line comment\n"
15432                    "\n"
15433                    "\n"
15434                    "\n"
15435                    "int oneTwoThree=123;",
15436                    Alignment));
15437 
15438   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
15439   verifyFormat("#define A \\\n"
15440                "  int aaaa       = 12; \\\n"
15441                "  int b          = 23; \\\n"
15442                "  int ccc        = 234; \\\n"
15443                "  int dddddddddd = 2345;",
15444                Alignment);
15445   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
15446   verifyFormat("#define A               \\\n"
15447                "  int aaaa       = 12;  \\\n"
15448                "  int b          = 23;  \\\n"
15449                "  int ccc        = 234; \\\n"
15450                "  int dddddddddd = 2345;",
15451                Alignment);
15452   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
15453   verifyFormat("#define A                                                      "
15454                "                \\\n"
15455                "  int aaaa       = 12;                                         "
15456                "                \\\n"
15457                "  int b          = 23;                                         "
15458                "                \\\n"
15459                "  int ccc        = 234;                                        "
15460                "                \\\n"
15461                "  int dddddddddd = 2345;",
15462                Alignment);
15463   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
15464                "k = 4, int l = 5,\n"
15465                "                  int m = 6) {\n"
15466                "  int j      = 10;\n"
15467                "  otherThing = 1;\n"
15468                "}",
15469                Alignment);
15470   verifyFormat("void SomeFunction(int parameter = 0) {\n"
15471                "  int i   = 1;\n"
15472                "  int j   = 2;\n"
15473                "  int big = 10000;\n"
15474                "}",
15475                Alignment);
15476   verifyFormat("class C {\n"
15477                "public:\n"
15478                "  int i            = 1;\n"
15479                "  virtual void f() = 0;\n"
15480                "};",
15481                Alignment);
15482   verifyFormat("int i = 1;\n"
15483                "if (SomeType t = getSomething()) {\n"
15484                "}\n"
15485                "int j   = 2;\n"
15486                "int big = 10000;",
15487                Alignment);
15488   verifyFormat("int j = 7;\n"
15489                "for (int k = 0; k < N; ++k) {\n"
15490                "}\n"
15491                "int j   = 2;\n"
15492                "int big = 10000;\n"
15493                "}",
15494                Alignment);
15495   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
15496   verifyFormat("int i = 1;\n"
15497                "LooooooooooongType loooooooooooooooooooooongVariable\n"
15498                "    = someLooooooooooooooooongFunction();\n"
15499                "int j = 2;",
15500                Alignment);
15501   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
15502   verifyFormat("int i = 1;\n"
15503                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
15504                "    someLooooooooooooooooongFunction();\n"
15505                "int j = 2;",
15506                Alignment);
15507 
15508   verifyFormat("auto lambda = []() {\n"
15509                "  auto i = 0;\n"
15510                "  return 0;\n"
15511                "};\n"
15512                "int i  = 0;\n"
15513                "auto v = type{\n"
15514                "    i = 1,   //\n"
15515                "    (i = 2), //\n"
15516                "    i = 3    //\n"
15517                "};",
15518                Alignment);
15519 
15520   verifyFormat(
15521       "int i      = 1;\n"
15522       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
15523       "                          loooooooooooooooooooooongParameterB);\n"
15524       "int j      = 2;",
15525       Alignment);
15526 
15527   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
15528                "          typename B   = very_long_type_name_1,\n"
15529                "          typename T_2 = very_long_type_name_2>\n"
15530                "auto foo() {}\n",
15531                Alignment);
15532   verifyFormat("int a, b = 1;\n"
15533                "int c  = 2;\n"
15534                "int dd = 3;\n",
15535                Alignment);
15536   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
15537                "float b[1][] = {{3.f}};\n",
15538                Alignment);
15539   verifyFormat("for (int i = 0; i < 1; i++)\n"
15540                "  int x = 1;\n",
15541                Alignment);
15542   verifyFormat("for (i = 0; i < 1; i++)\n"
15543                "  x = 1;\n"
15544                "y = 1;\n",
15545                Alignment);
15546 
15547   Alignment.ReflowComments = true;
15548   Alignment.ColumnLimit = 50;
15549   EXPECT_EQ("int x   = 0;\n"
15550             "int yy  = 1; /// specificlennospace\n"
15551             "int zzz = 2;\n",
15552             format("int x   = 0;\n"
15553                    "int yy  = 1; ///specificlennospace\n"
15554                    "int zzz = 2;\n",
15555                    Alignment));
15556 }
15557 
15558 TEST_F(FormatTest, AlignConsecutiveAssignments) {
15559   FormatStyle Alignment = getLLVMStyle();
15560   Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
15561   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
15562   verifyFormat("int a = 5;\n"
15563                "int oneTwoThree = 123;",
15564                Alignment);
15565   verifyFormat("int a = 5;\n"
15566                "int oneTwoThree = 123;",
15567                Alignment);
15568 
15569   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
15570   verifyFormat("int a           = 5;\n"
15571                "int oneTwoThree = 123;",
15572                Alignment);
15573   verifyFormat("int a           = method();\n"
15574                "int oneTwoThree = 133;",
15575                Alignment);
15576   verifyFormat("a &= 5;\n"
15577                "bcd *= 5;\n"
15578                "ghtyf += 5;\n"
15579                "dvfvdb -= 5;\n"
15580                "a /= 5;\n"
15581                "vdsvsv %= 5;\n"
15582                "sfdbddfbdfbb ^= 5;\n"
15583                "dvsdsv |= 5;\n"
15584                "int dsvvdvsdvvv = 123;",
15585                Alignment);
15586   verifyFormat("int i = 1, j = 10;\n"
15587                "something = 2000;",
15588                Alignment);
15589   verifyFormat("something = 2000;\n"
15590                "int i = 1, j = 10;\n",
15591                Alignment);
15592   verifyFormat("something = 2000;\n"
15593                "another   = 911;\n"
15594                "int i = 1, j = 10;\n"
15595                "oneMore = 1;\n"
15596                "i       = 2;",
15597                Alignment);
15598   verifyFormat("int a   = 5;\n"
15599                "int one = 1;\n"
15600                "method();\n"
15601                "int oneTwoThree = 123;\n"
15602                "int oneTwo      = 12;",
15603                Alignment);
15604   verifyFormat("int oneTwoThree = 123;\n"
15605                "int oneTwo      = 12;\n"
15606                "method();\n",
15607                Alignment);
15608   verifyFormat("int oneTwoThree = 123; // comment\n"
15609                "int oneTwo      = 12;  // comment",
15610                Alignment);
15611 
15612   // Bug 25167
15613   /* Uncomment when fixed
15614     verifyFormat("#if A\n"
15615                  "#else\n"
15616                  "int aaaaaaaa = 12;\n"
15617                  "#endif\n"
15618                  "#if B\n"
15619                  "#else\n"
15620                  "int a = 12;\n"
15621                  "#endif\n",
15622                  Alignment);
15623     verifyFormat("enum foo {\n"
15624                  "#if A\n"
15625                  "#else\n"
15626                  "  aaaaaaaa = 12;\n"
15627                  "#endif\n"
15628                  "#if B\n"
15629                  "#else\n"
15630                  "  a = 12;\n"
15631                  "#endif\n"
15632                  "};\n",
15633                  Alignment);
15634   */
15635 
15636   EXPECT_EQ("int a = 5;\n"
15637             "\n"
15638             "int oneTwoThree = 123;",
15639             format("int a       = 5;\n"
15640                    "\n"
15641                    "int oneTwoThree= 123;",
15642                    Alignment));
15643   EXPECT_EQ("int a   = 5;\n"
15644             "int one = 1;\n"
15645             "\n"
15646             "int oneTwoThree = 123;",
15647             format("int a = 5;\n"
15648                    "int one = 1;\n"
15649                    "\n"
15650                    "int oneTwoThree = 123;",
15651                    Alignment));
15652   EXPECT_EQ("int a   = 5;\n"
15653             "int one = 1;\n"
15654             "\n"
15655             "int oneTwoThree = 123;\n"
15656             "int oneTwo      = 12;",
15657             format("int a = 5;\n"
15658                    "int one = 1;\n"
15659                    "\n"
15660                    "int oneTwoThree = 123;\n"
15661                    "int oneTwo = 12;",
15662                    Alignment));
15663   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
15664   verifyFormat("#define A \\\n"
15665                "  int aaaa       = 12; \\\n"
15666                "  int b          = 23; \\\n"
15667                "  int ccc        = 234; \\\n"
15668                "  int dddddddddd = 2345;",
15669                Alignment);
15670   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
15671   verifyFormat("#define A               \\\n"
15672                "  int aaaa       = 12;  \\\n"
15673                "  int b          = 23;  \\\n"
15674                "  int ccc        = 234; \\\n"
15675                "  int dddddddddd = 2345;",
15676                Alignment);
15677   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
15678   verifyFormat("#define A                                                      "
15679                "                \\\n"
15680                "  int aaaa       = 12;                                         "
15681                "                \\\n"
15682                "  int b          = 23;                                         "
15683                "                \\\n"
15684                "  int ccc        = 234;                                        "
15685                "                \\\n"
15686                "  int dddddddddd = 2345;",
15687                Alignment);
15688   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
15689                "k = 4, int l = 5,\n"
15690                "                  int m = 6) {\n"
15691                "  int j      = 10;\n"
15692                "  otherThing = 1;\n"
15693                "}",
15694                Alignment);
15695   verifyFormat("void SomeFunction(int parameter = 0) {\n"
15696                "  int i   = 1;\n"
15697                "  int j   = 2;\n"
15698                "  int big = 10000;\n"
15699                "}",
15700                Alignment);
15701   verifyFormat("class C {\n"
15702                "public:\n"
15703                "  int i            = 1;\n"
15704                "  virtual void f() = 0;\n"
15705                "};",
15706                Alignment);
15707   verifyFormat("int i = 1;\n"
15708                "if (SomeType t = getSomething()) {\n"
15709                "}\n"
15710                "int j   = 2;\n"
15711                "int big = 10000;",
15712                Alignment);
15713   verifyFormat("int j = 7;\n"
15714                "for (int k = 0; k < N; ++k) {\n"
15715                "}\n"
15716                "int j   = 2;\n"
15717                "int big = 10000;\n"
15718                "}",
15719                Alignment);
15720   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
15721   verifyFormat("int i = 1;\n"
15722                "LooooooooooongType loooooooooooooooooooooongVariable\n"
15723                "    = someLooooooooooooooooongFunction();\n"
15724                "int j = 2;",
15725                Alignment);
15726   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
15727   verifyFormat("int i = 1;\n"
15728                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
15729                "    someLooooooooooooooooongFunction();\n"
15730                "int j = 2;",
15731                Alignment);
15732 
15733   verifyFormat("auto lambda = []() {\n"
15734                "  auto i = 0;\n"
15735                "  return 0;\n"
15736                "};\n"
15737                "int i  = 0;\n"
15738                "auto v = type{\n"
15739                "    i = 1,   //\n"
15740                "    (i = 2), //\n"
15741                "    i = 3    //\n"
15742                "};",
15743                Alignment);
15744 
15745   verifyFormat(
15746       "int i      = 1;\n"
15747       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
15748       "                          loooooooooooooooooooooongParameterB);\n"
15749       "int j      = 2;",
15750       Alignment);
15751 
15752   verifyFormat("template <typename T, typename T_0 = very_long_type_name_0,\n"
15753                "          typename B   = very_long_type_name_1,\n"
15754                "          typename T_2 = very_long_type_name_2>\n"
15755                "auto foo() {}\n",
15756                Alignment);
15757   verifyFormat("int a, b = 1;\n"
15758                "int c  = 2;\n"
15759                "int dd = 3;\n",
15760                Alignment);
15761   verifyFormat("int aa       = ((1 > 2) ? 3 : 4);\n"
15762                "float b[1][] = {{3.f}};\n",
15763                Alignment);
15764   verifyFormat("for (int i = 0; i < 1; i++)\n"
15765                "  int x = 1;\n",
15766                Alignment);
15767   verifyFormat("for (i = 0; i < 1; i++)\n"
15768                "  x = 1;\n"
15769                "y = 1;\n",
15770                Alignment);
15771 
15772   Alignment.ReflowComments = true;
15773   Alignment.ColumnLimit = 50;
15774   EXPECT_EQ("int x   = 0;\n"
15775             "int yy  = 1; /// specificlennospace\n"
15776             "int zzz = 2;\n",
15777             format("int x   = 0;\n"
15778                    "int yy  = 1; ///specificlennospace\n"
15779                    "int zzz = 2;\n",
15780                    Alignment));
15781 }
15782 
15783 TEST_F(FormatTest, AlignConsecutiveBitFields) {
15784   FormatStyle Alignment = getLLVMStyle();
15785   Alignment.AlignConsecutiveBitFields = FormatStyle::ACS_Consecutive;
15786   verifyFormat("int const a     : 5;\n"
15787                "int oneTwoThree : 23;",
15788                Alignment);
15789 
15790   // Initializers are allowed starting with c++2a
15791   verifyFormat("int const a     : 5 = 1;\n"
15792                "int oneTwoThree : 23 = 0;",
15793                Alignment);
15794 
15795   Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
15796   verifyFormat("int const a           : 5;\n"
15797                "int       oneTwoThree : 23;",
15798                Alignment);
15799 
15800   verifyFormat("int const a           : 5;  // comment\n"
15801                "int       oneTwoThree : 23; // comment",
15802                Alignment);
15803 
15804   verifyFormat("int const a           : 5 = 1;\n"
15805                "int       oneTwoThree : 23 = 0;",
15806                Alignment);
15807 
15808   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
15809   verifyFormat("int const a           : 5  = 1;\n"
15810                "int       oneTwoThree : 23 = 0;",
15811                Alignment);
15812   verifyFormat("int const a           : 5  = {1};\n"
15813                "int       oneTwoThree : 23 = 0;",
15814                Alignment);
15815 
15816   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_None;
15817   verifyFormat("int const a          :5;\n"
15818                "int       oneTwoThree:23;",
15819                Alignment);
15820 
15821   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_Before;
15822   verifyFormat("int const a           :5;\n"
15823                "int       oneTwoThree :23;",
15824                Alignment);
15825 
15826   Alignment.BitFieldColonSpacing = FormatStyle::BFCS_After;
15827   verifyFormat("int const a          : 5;\n"
15828                "int       oneTwoThree: 23;",
15829                Alignment);
15830 
15831   // Known limitations: ':' is only recognized as a bitfield colon when
15832   // followed by a number.
15833   /*
15834   verifyFormat("int oneTwoThree : SOME_CONSTANT;\n"
15835                "int a           : 5;",
15836                Alignment);
15837   */
15838 }
15839 
15840 TEST_F(FormatTest, AlignConsecutiveDeclarations) {
15841   FormatStyle Alignment = getLLVMStyle();
15842   Alignment.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
15843   Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_None;
15844   Alignment.PointerAlignment = FormatStyle::PAS_Right;
15845   verifyFormat("float const a = 5;\n"
15846                "int oneTwoThree = 123;",
15847                Alignment);
15848   verifyFormat("int a = 5;\n"
15849                "float const oneTwoThree = 123;",
15850                Alignment);
15851 
15852   Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
15853   verifyFormat("float const a = 5;\n"
15854                "int         oneTwoThree = 123;",
15855                Alignment);
15856   verifyFormat("int         a = method();\n"
15857                "float const oneTwoThree = 133;",
15858                Alignment);
15859   verifyFormat("int i = 1, j = 10;\n"
15860                "something = 2000;",
15861                Alignment);
15862   verifyFormat("something = 2000;\n"
15863                "int i = 1, j = 10;\n",
15864                Alignment);
15865   verifyFormat("float      something = 2000;\n"
15866                "double     another = 911;\n"
15867                "int        i = 1, j = 10;\n"
15868                "const int *oneMore = 1;\n"
15869                "unsigned   i = 2;",
15870                Alignment);
15871   verifyFormat("float a = 5;\n"
15872                "int   one = 1;\n"
15873                "method();\n"
15874                "const double       oneTwoThree = 123;\n"
15875                "const unsigned int oneTwo = 12;",
15876                Alignment);
15877   verifyFormat("int      oneTwoThree{0}; // comment\n"
15878                "unsigned oneTwo;         // comment",
15879                Alignment);
15880   verifyFormat("unsigned int       *a;\n"
15881                "int                *b;\n"
15882                "unsigned int Const *c;\n"
15883                "unsigned int const *d;\n"
15884                "unsigned int Const &e;\n"
15885                "unsigned int const &f;",
15886                Alignment);
15887   verifyFormat("Const unsigned int *c;\n"
15888                "const unsigned int *d;\n"
15889                "Const unsigned int &e;\n"
15890                "const unsigned int &f;\n"
15891                "const unsigned      g;\n"
15892                "Const unsigned      h;",
15893                Alignment);
15894   EXPECT_EQ("float const a = 5;\n"
15895             "\n"
15896             "int oneTwoThree = 123;",
15897             format("float const   a = 5;\n"
15898                    "\n"
15899                    "int           oneTwoThree= 123;",
15900                    Alignment));
15901   EXPECT_EQ("float a = 5;\n"
15902             "int   one = 1;\n"
15903             "\n"
15904             "unsigned oneTwoThree = 123;",
15905             format("float    a = 5;\n"
15906                    "int      one = 1;\n"
15907                    "\n"
15908                    "unsigned oneTwoThree = 123;",
15909                    Alignment));
15910   EXPECT_EQ("float a = 5;\n"
15911             "int   one = 1;\n"
15912             "\n"
15913             "unsigned oneTwoThree = 123;\n"
15914             "int      oneTwo = 12;",
15915             format("float    a = 5;\n"
15916                    "int one = 1;\n"
15917                    "\n"
15918                    "unsigned oneTwoThree = 123;\n"
15919                    "int oneTwo = 12;",
15920                    Alignment));
15921   // Function prototype alignment
15922   verifyFormat("int    a();\n"
15923                "double b();",
15924                Alignment);
15925   verifyFormat("int    a(int x);\n"
15926                "double b();",
15927                Alignment);
15928   unsigned OldColumnLimit = Alignment.ColumnLimit;
15929   // We need to set ColumnLimit to zero, in order to stress nested alignments,
15930   // otherwise the function parameters will be re-flowed onto a single line.
15931   Alignment.ColumnLimit = 0;
15932   EXPECT_EQ("int    a(int   x,\n"
15933             "         float y);\n"
15934             "double b(int    x,\n"
15935             "         double y);",
15936             format("int a(int x,\n"
15937                    " float y);\n"
15938                    "double b(int x,\n"
15939                    " double y);",
15940                    Alignment));
15941   // This ensures that function parameters of function declarations are
15942   // correctly indented when their owning functions are indented.
15943   // The failure case here is for 'double y' to not be indented enough.
15944   EXPECT_EQ("double a(int x);\n"
15945             "int    b(int    y,\n"
15946             "         double z);",
15947             format("double a(int x);\n"
15948                    "int b(int y,\n"
15949                    " double z);",
15950                    Alignment));
15951   // Set ColumnLimit low so that we induce wrapping immediately after
15952   // the function name and opening paren.
15953   Alignment.ColumnLimit = 13;
15954   verifyFormat("int function(\n"
15955                "    int  x,\n"
15956                "    bool y);",
15957                Alignment);
15958   Alignment.ColumnLimit = OldColumnLimit;
15959   // Ensure function pointers don't screw up recursive alignment
15960   verifyFormat("int    a(int x, void (*fp)(int y));\n"
15961                "double b();",
15962                Alignment);
15963   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
15964   // Ensure recursive alignment is broken by function braces, so that the
15965   // "a = 1" does not align with subsequent assignments inside the function
15966   // body.
15967   verifyFormat("int func(int a = 1) {\n"
15968                "  int b  = 2;\n"
15969                "  int cc = 3;\n"
15970                "}",
15971                Alignment);
15972   verifyFormat("float      something = 2000;\n"
15973                "double     another   = 911;\n"
15974                "int        i = 1, j = 10;\n"
15975                "const int *oneMore = 1;\n"
15976                "unsigned   i       = 2;",
15977                Alignment);
15978   verifyFormat("int      oneTwoThree = {0}; // comment\n"
15979                "unsigned oneTwo      = 0;   // comment",
15980                Alignment);
15981   // Make sure that scope is correctly tracked, in the absence of braces
15982   verifyFormat("for (int i = 0; i < n; i++)\n"
15983                "  j = i;\n"
15984                "double x = 1;\n",
15985                Alignment);
15986   verifyFormat("if (int i = 0)\n"
15987                "  j = i;\n"
15988                "double x = 1;\n",
15989                Alignment);
15990   // Ensure operator[] and operator() are comprehended
15991   verifyFormat("struct test {\n"
15992                "  long long int foo();\n"
15993                "  int           operator[](int a);\n"
15994                "  double        bar();\n"
15995                "};\n",
15996                Alignment);
15997   verifyFormat("struct test {\n"
15998                "  long long int foo();\n"
15999                "  int           operator()(int a);\n"
16000                "  double        bar();\n"
16001                "};\n",
16002                Alignment);
16003 
16004   // PAS_Right
16005   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
16006             "  int const i   = 1;\n"
16007             "  int      *j   = 2;\n"
16008             "  int       big = 10000;\n"
16009             "\n"
16010             "  unsigned oneTwoThree = 123;\n"
16011             "  int      oneTwo      = 12;\n"
16012             "  method();\n"
16013             "  float k  = 2;\n"
16014             "  int   ll = 10000;\n"
16015             "}",
16016             format("void SomeFunction(int parameter= 0) {\n"
16017                    " int const  i= 1;\n"
16018                    "  int *j=2;\n"
16019                    " int big  =  10000;\n"
16020                    "\n"
16021                    "unsigned oneTwoThree  =123;\n"
16022                    "int oneTwo = 12;\n"
16023                    "  method();\n"
16024                    "float k= 2;\n"
16025                    "int ll=10000;\n"
16026                    "}",
16027                    Alignment));
16028   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
16029             "  int const i   = 1;\n"
16030             "  int     **j   = 2, ***k;\n"
16031             "  int      &k   = i;\n"
16032             "  int     &&l   = i + j;\n"
16033             "  int       big = 10000;\n"
16034             "\n"
16035             "  unsigned oneTwoThree = 123;\n"
16036             "  int      oneTwo      = 12;\n"
16037             "  method();\n"
16038             "  float k  = 2;\n"
16039             "  int   ll = 10000;\n"
16040             "}",
16041             format("void SomeFunction(int parameter= 0) {\n"
16042                    " int const  i= 1;\n"
16043                    "  int **j=2,***k;\n"
16044                    "int &k=i;\n"
16045                    "int &&l=i+j;\n"
16046                    " int big  =  10000;\n"
16047                    "\n"
16048                    "unsigned oneTwoThree  =123;\n"
16049                    "int oneTwo = 12;\n"
16050                    "  method();\n"
16051                    "float k= 2;\n"
16052                    "int ll=10000;\n"
16053                    "}",
16054                    Alignment));
16055   // variables are aligned at their name, pointers are at the right most
16056   // position
16057   verifyFormat("int   *a;\n"
16058                "int  **b;\n"
16059                "int ***c;\n"
16060                "int    foobar;\n",
16061                Alignment);
16062 
16063   // PAS_Left
16064   FormatStyle AlignmentLeft = Alignment;
16065   AlignmentLeft.PointerAlignment = FormatStyle::PAS_Left;
16066   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
16067             "  int const i   = 1;\n"
16068             "  int*      j   = 2;\n"
16069             "  int       big = 10000;\n"
16070             "\n"
16071             "  unsigned oneTwoThree = 123;\n"
16072             "  int      oneTwo      = 12;\n"
16073             "  method();\n"
16074             "  float k  = 2;\n"
16075             "  int   ll = 10000;\n"
16076             "}",
16077             format("void SomeFunction(int parameter= 0) {\n"
16078                    " int const  i= 1;\n"
16079                    "  int *j=2;\n"
16080                    " int big  =  10000;\n"
16081                    "\n"
16082                    "unsigned oneTwoThree  =123;\n"
16083                    "int oneTwo = 12;\n"
16084                    "  method();\n"
16085                    "float k= 2;\n"
16086                    "int ll=10000;\n"
16087                    "}",
16088                    AlignmentLeft));
16089   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
16090             "  int const i   = 1;\n"
16091             "  int**     j   = 2;\n"
16092             "  int&      k   = i;\n"
16093             "  int&&     l   = i + j;\n"
16094             "  int       big = 10000;\n"
16095             "\n"
16096             "  unsigned oneTwoThree = 123;\n"
16097             "  int      oneTwo      = 12;\n"
16098             "  method();\n"
16099             "  float k  = 2;\n"
16100             "  int   ll = 10000;\n"
16101             "}",
16102             format("void SomeFunction(int parameter= 0) {\n"
16103                    " int const  i= 1;\n"
16104                    "  int **j=2;\n"
16105                    "int &k=i;\n"
16106                    "int &&l=i+j;\n"
16107                    " int big  =  10000;\n"
16108                    "\n"
16109                    "unsigned oneTwoThree  =123;\n"
16110                    "int oneTwo = 12;\n"
16111                    "  method();\n"
16112                    "float k= 2;\n"
16113                    "int ll=10000;\n"
16114                    "}",
16115                    AlignmentLeft));
16116   // variables are aligned at their name, pointers are at the left most position
16117   verifyFormat("int*   a;\n"
16118                "int**  b;\n"
16119                "int*** c;\n"
16120                "int    foobar;\n",
16121                AlignmentLeft);
16122 
16123   // PAS_Middle
16124   FormatStyle AlignmentMiddle = Alignment;
16125   AlignmentMiddle.PointerAlignment = FormatStyle::PAS_Middle;
16126   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
16127             "  int const i   = 1;\n"
16128             "  int *     j   = 2;\n"
16129             "  int       big = 10000;\n"
16130             "\n"
16131             "  unsigned oneTwoThree = 123;\n"
16132             "  int      oneTwo      = 12;\n"
16133             "  method();\n"
16134             "  float k  = 2;\n"
16135             "  int   ll = 10000;\n"
16136             "}",
16137             format("void SomeFunction(int parameter= 0) {\n"
16138                    " int const  i= 1;\n"
16139                    "  int *j=2;\n"
16140                    " int big  =  10000;\n"
16141                    "\n"
16142                    "unsigned oneTwoThree  =123;\n"
16143                    "int oneTwo = 12;\n"
16144                    "  method();\n"
16145                    "float k= 2;\n"
16146                    "int ll=10000;\n"
16147                    "}",
16148                    AlignmentMiddle));
16149   EXPECT_EQ("void SomeFunction(int parameter = 0) {\n"
16150             "  int const i   = 1;\n"
16151             "  int **    j   = 2, ***k;\n"
16152             "  int &     k   = i;\n"
16153             "  int &&    l   = i + j;\n"
16154             "  int       big = 10000;\n"
16155             "\n"
16156             "  unsigned oneTwoThree = 123;\n"
16157             "  int      oneTwo      = 12;\n"
16158             "  method();\n"
16159             "  float k  = 2;\n"
16160             "  int   ll = 10000;\n"
16161             "}",
16162             format("void SomeFunction(int parameter= 0) {\n"
16163                    " int const  i= 1;\n"
16164                    "  int **j=2,***k;\n"
16165                    "int &k=i;\n"
16166                    "int &&l=i+j;\n"
16167                    " int big  =  10000;\n"
16168                    "\n"
16169                    "unsigned oneTwoThree  =123;\n"
16170                    "int oneTwo = 12;\n"
16171                    "  method();\n"
16172                    "float k= 2;\n"
16173                    "int ll=10000;\n"
16174                    "}",
16175                    AlignmentMiddle));
16176   // variables are aligned at their name, pointers are in the middle
16177   verifyFormat("int *   a;\n"
16178                "int *   b;\n"
16179                "int *** c;\n"
16180                "int     foobar;\n",
16181                AlignmentMiddle);
16182 
16183   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
16184   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_DontAlign;
16185   verifyFormat("#define A \\\n"
16186                "  int       aaaa = 12; \\\n"
16187                "  float     b = 23; \\\n"
16188                "  const int ccc = 234; \\\n"
16189                "  unsigned  dddddddddd = 2345;",
16190                Alignment);
16191   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Left;
16192   verifyFormat("#define A              \\\n"
16193                "  int       aaaa = 12; \\\n"
16194                "  float     b = 23;    \\\n"
16195                "  const int ccc = 234; \\\n"
16196                "  unsigned  dddddddddd = 2345;",
16197                Alignment);
16198   Alignment.AlignEscapedNewlines = FormatStyle::ENAS_Right;
16199   Alignment.ColumnLimit = 30;
16200   verifyFormat("#define A                    \\\n"
16201                "  int       aaaa = 12;       \\\n"
16202                "  float     b = 23;          \\\n"
16203                "  const int ccc = 234;       \\\n"
16204                "  int       dddddddddd = 2345;",
16205                Alignment);
16206   Alignment.ColumnLimit = 80;
16207   verifyFormat("void SomeFunction(int parameter = 1, int i = 2, int j = 3, int "
16208                "k = 4, int l = 5,\n"
16209                "                  int m = 6) {\n"
16210                "  const int j = 10;\n"
16211                "  otherThing = 1;\n"
16212                "}",
16213                Alignment);
16214   verifyFormat("void SomeFunction(int parameter = 0) {\n"
16215                "  int const i = 1;\n"
16216                "  int      *j = 2;\n"
16217                "  int       big = 10000;\n"
16218                "}",
16219                Alignment);
16220   verifyFormat("class C {\n"
16221                "public:\n"
16222                "  int          i = 1;\n"
16223                "  virtual void f() = 0;\n"
16224                "};",
16225                Alignment);
16226   verifyFormat("float i = 1;\n"
16227                "if (SomeType t = getSomething()) {\n"
16228                "}\n"
16229                "const unsigned j = 2;\n"
16230                "int            big = 10000;",
16231                Alignment);
16232   verifyFormat("float j = 7;\n"
16233                "for (int k = 0; k < N; ++k) {\n"
16234                "}\n"
16235                "unsigned j = 2;\n"
16236                "int      big = 10000;\n"
16237                "}",
16238                Alignment);
16239   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
16240   verifyFormat("float              i = 1;\n"
16241                "LooooooooooongType loooooooooooooooooooooongVariable\n"
16242                "    = someLooooooooooooooooongFunction();\n"
16243                "int j = 2;",
16244                Alignment);
16245   Alignment.BreakBeforeBinaryOperators = FormatStyle::BOS_None;
16246   verifyFormat("int                i = 1;\n"
16247                "LooooooooooongType loooooooooooooooooooooongVariable =\n"
16248                "    someLooooooooooooooooongFunction();\n"
16249                "int j = 2;",
16250                Alignment);
16251 
16252   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
16253   verifyFormat("auto lambda = []() {\n"
16254                "  auto  ii = 0;\n"
16255                "  float j  = 0;\n"
16256                "  return 0;\n"
16257                "};\n"
16258                "int   i  = 0;\n"
16259                "float i2 = 0;\n"
16260                "auto  v  = type{\n"
16261                "    i = 1,   //\n"
16262                "    (i = 2), //\n"
16263                "    i = 3    //\n"
16264                "};",
16265                Alignment);
16266   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
16267 
16268   verifyFormat(
16269       "int      i = 1;\n"
16270       "SomeType a = SomeFunction(looooooooooooooooooooooongParameterA,\n"
16271       "                          loooooooooooooooooooooongParameterB);\n"
16272       "int      j = 2;",
16273       Alignment);
16274 
16275   // Test interactions with ColumnLimit and AlignConsecutiveAssignments:
16276   // We expect declarations and assignments to align, as long as it doesn't
16277   // exceed the column limit, starting a new alignment sequence whenever it
16278   // happens.
16279   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
16280   Alignment.ColumnLimit = 30;
16281   verifyFormat("float    ii              = 1;\n"
16282                "unsigned j               = 2;\n"
16283                "int someVerylongVariable = 1;\n"
16284                "AnotherLongType  ll = 123456;\n"
16285                "VeryVeryLongType k  = 2;\n"
16286                "int              myvar = 1;",
16287                Alignment);
16288   Alignment.ColumnLimit = 80;
16289   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
16290 
16291   verifyFormat(
16292       "template <typename LongTemplate, typename VeryLongTemplateTypeName,\n"
16293       "          typename LongType, typename B>\n"
16294       "auto foo() {}\n",
16295       Alignment);
16296   verifyFormat("float a, b = 1;\n"
16297                "int   c = 2;\n"
16298                "int   dd = 3;\n",
16299                Alignment);
16300   verifyFormat("int   aa = ((1 > 2) ? 3 : 4);\n"
16301                "float b[1][] = {{3.f}};\n",
16302                Alignment);
16303   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
16304   verifyFormat("float a, b = 1;\n"
16305                "int   c  = 2;\n"
16306                "int   dd = 3;\n",
16307                Alignment);
16308   verifyFormat("int   aa     = ((1 > 2) ? 3 : 4);\n"
16309                "float b[1][] = {{3.f}};\n",
16310                Alignment);
16311   Alignment.AlignConsecutiveAssignments = FormatStyle::ACS_None;
16312 
16313   Alignment.ColumnLimit = 30;
16314   Alignment.BinPackParameters = false;
16315   verifyFormat("void foo(float     a,\n"
16316                "         float     b,\n"
16317                "         int       c,\n"
16318                "         uint32_t *d) {\n"
16319                "  int   *e = 0;\n"
16320                "  float  f = 0;\n"
16321                "  double g = 0;\n"
16322                "}\n"
16323                "void bar(ino_t     a,\n"
16324                "         int       b,\n"
16325                "         uint32_t *c,\n"
16326                "         bool      d) {}\n",
16327                Alignment);
16328   Alignment.BinPackParameters = true;
16329   Alignment.ColumnLimit = 80;
16330 
16331   // Bug 33507
16332   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
16333   verifyFormat(
16334       "auto found = range::find_if(vsProducts, [&](auto * aProduct) {\n"
16335       "  static const Version verVs2017;\n"
16336       "  return true;\n"
16337       "});\n",
16338       Alignment);
16339   Alignment.PointerAlignment = FormatStyle::PAS_Right;
16340 
16341   // See llvm.org/PR35641
16342   Alignment.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
16343   verifyFormat("int func() { //\n"
16344                "  int      b;\n"
16345                "  unsigned c;\n"
16346                "}",
16347                Alignment);
16348 
16349   // See PR37175
16350   FormatStyle Style = getMozillaStyle();
16351   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
16352   EXPECT_EQ("DECOR1 /**/ int8_t /**/ DECOR2 /**/\n"
16353             "foo(int a);",
16354             format("DECOR1 /**/ int8_t /**/ DECOR2 /**/ foo (int a);", Style));
16355 
16356   Alignment.PointerAlignment = FormatStyle::PAS_Left;
16357   verifyFormat("unsigned int*       a;\n"
16358                "int*                b;\n"
16359                "unsigned int Const* c;\n"
16360                "unsigned int const* d;\n"
16361                "unsigned int Const& e;\n"
16362                "unsigned int const& f;",
16363                Alignment);
16364   verifyFormat("Const unsigned int* c;\n"
16365                "const unsigned int* d;\n"
16366                "Const unsigned int& e;\n"
16367                "const unsigned int& f;\n"
16368                "const unsigned      g;\n"
16369                "Const unsigned      h;",
16370                Alignment);
16371 
16372   Alignment.PointerAlignment = FormatStyle::PAS_Middle;
16373   verifyFormat("unsigned int *       a;\n"
16374                "int *                b;\n"
16375                "unsigned int Const * c;\n"
16376                "unsigned int const * d;\n"
16377                "unsigned int Const & e;\n"
16378                "unsigned int const & f;",
16379                Alignment);
16380   verifyFormat("Const unsigned int * c;\n"
16381                "const unsigned int * d;\n"
16382                "Const unsigned int & e;\n"
16383                "const unsigned int & f;\n"
16384                "const unsigned       g;\n"
16385                "Const unsigned       h;",
16386                Alignment);
16387 }
16388 
16389 TEST_F(FormatTest, AlignWithLineBreaks) {
16390   auto Style = getLLVMStyleWithColumns(120);
16391 
16392   EXPECT_EQ(Style.AlignConsecutiveAssignments, FormatStyle::ACS_None);
16393   EXPECT_EQ(Style.AlignConsecutiveDeclarations, FormatStyle::ACS_None);
16394   verifyFormat("void foo() {\n"
16395                "  int myVar = 5;\n"
16396                "  double x = 3.14;\n"
16397                "  auto str = \"Hello \"\n"
16398                "             \"World\";\n"
16399                "  auto s = \"Hello \"\n"
16400                "           \"Again\";\n"
16401                "}",
16402                Style);
16403 
16404   // clang-format off
16405   verifyFormat("void foo() {\n"
16406                "  const int capacityBefore = Entries.capacity();\n"
16407                "  const auto newEntry = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
16408                "                                            std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
16409                "  const X newEntry2 = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
16410                "                                          std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
16411                "}",
16412                Style);
16413   // clang-format on
16414 
16415   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
16416   verifyFormat("void foo() {\n"
16417                "  int myVar = 5;\n"
16418                "  double x  = 3.14;\n"
16419                "  auto str  = \"Hello \"\n"
16420                "              \"World\";\n"
16421                "  auto s    = \"Hello \"\n"
16422                "              \"Again\";\n"
16423                "}",
16424                Style);
16425 
16426   // clang-format off
16427   verifyFormat("void foo() {\n"
16428                "  const int capacityBefore = Entries.capacity();\n"
16429                "  const auto newEntry      = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
16430                "                                                 std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
16431                "  const X newEntry2        = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
16432                "                                                 std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
16433                "}",
16434                Style);
16435   // clang-format on
16436 
16437   Style.AlignConsecutiveAssignments = FormatStyle::ACS_None;
16438   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
16439   verifyFormat("void foo() {\n"
16440                "  int    myVar = 5;\n"
16441                "  double x = 3.14;\n"
16442                "  auto   str = \"Hello \"\n"
16443                "               \"World\";\n"
16444                "  auto   s = \"Hello \"\n"
16445                "             \"Again\";\n"
16446                "}",
16447                Style);
16448 
16449   // clang-format off
16450   verifyFormat("void foo() {\n"
16451                "  const int  capacityBefore = Entries.capacity();\n"
16452                "  const auto newEntry = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
16453                "                                            std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
16454                "  const X    newEntry2 = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
16455                "                                             std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
16456                "}",
16457                Style);
16458   // clang-format on
16459 
16460   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
16461   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
16462 
16463   verifyFormat("void foo() {\n"
16464                "  int    myVar = 5;\n"
16465                "  double x     = 3.14;\n"
16466                "  auto   str   = \"Hello \"\n"
16467                "                 \"World\";\n"
16468                "  auto   s     = \"Hello \"\n"
16469                "                 \"Again\";\n"
16470                "}",
16471                Style);
16472 
16473   // clang-format off
16474   verifyFormat("void foo() {\n"
16475                "  const int  capacityBefore = Entries.capacity();\n"
16476                "  const auto newEntry       = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
16477                "                                                  std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
16478                "  const X    newEntry2      = Entries.emplaceHint(std::piecewise_construct, std::forward_as_tuple(uniqueId),\n"
16479                "                                                  std::forward_as_tuple(id, uniqueId, name, threadCreation));\n"
16480                "}",
16481                Style);
16482   // clang-format on
16483 
16484   Style = getLLVMStyleWithColumns(120);
16485   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
16486   Style.ContinuationIndentWidth = 4;
16487   Style.IndentWidth = 4;
16488 
16489   // clang-format off
16490   verifyFormat("void SomeFunc() {\n"
16491                "    newWatcher.maxAgeUsec = ToLegacyTimestamp(GetMaxAge(FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec),\n"
16492                "                                                        seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
16493                "    newWatcher.maxAge     = ToLegacyTimestamp(GetMaxAge(FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec),\n"
16494                "                                                        seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
16495                "    newWatcher.max        = ToLegacyTimestamp(GetMaxAge(FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec),\n"
16496                "                                                        seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
16497                "}",
16498                Style);
16499   // clang-format on
16500 
16501   Style.BinPackArguments = false;
16502 
16503   // clang-format off
16504   verifyFormat("void SomeFunc() {\n"
16505                "    newWatcher.maxAgeUsec = ToLegacyTimestamp(GetMaxAge(\n"
16506                "        FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec), seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
16507                "    newWatcher.maxAge     = ToLegacyTimestamp(GetMaxAge(\n"
16508                "        FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec), seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
16509                "    newWatcher.max        = ToLegacyTimestamp(GetMaxAge(\n"
16510                "        FromLegacyTimestamp<milliseconds>(monitorFrequencyUsec), seconds(std::uint64_t(maxSampleAge)), maxKeepSamples));\n"
16511                "}",
16512                Style);
16513   // clang-format on
16514 }
16515 
16516 TEST_F(FormatTest, AlignWithInitializerPeriods) {
16517   auto Style = getLLVMStyleWithColumns(60);
16518 
16519   verifyFormat("void foo1(void) {\n"
16520                "  BYTE p[1] = 1;\n"
16521                "  A B = {.one_foooooooooooooooo = 2,\n"
16522                "         .two_fooooooooooooo = 3,\n"
16523                "         .three_fooooooooooooo = 4};\n"
16524                "  BYTE payload = 2;\n"
16525                "}",
16526                Style);
16527 
16528   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
16529   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_None;
16530   verifyFormat("void foo2(void) {\n"
16531                "  BYTE p[1]    = 1;\n"
16532                "  A B          = {.one_foooooooooooooooo = 2,\n"
16533                "                  .two_fooooooooooooo    = 3,\n"
16534                "                  .three_fooooooooooooo  = 4};\n"
16535                "  BYTE payload = 2;\n"
16536                "}",
16537                Style);
16538 
16539   Style.AlignConsecutiveAssignments = FormatStyle::ACS_None;
16540   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
16541   verifyFormat("void foo3(void) {\n"
16542                "  BYTE p[1] = 1;\n"
16543                "  A    B = {.one_foooooooooooooooo = 2,\n"
16544                "            .two_fooooooooooooo = 3,\n"
16545                "            .three_fooooooooooooo = 4};\n"
16546                "  BYTE payload = 2;\n"
16547                "}",
16548                Style);
16549 
16550   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
16551   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
16552   verifyFormat("void foo4(void) {\n"
16553                "  BYTE p[1]    = 1;\n"
16554                "  A    B       = {.one_foooooooooooooooo = 2,\n"
16555                "                  .two_fooooooooooooo    = 3,\n"
16556                "                  .three_fooooooooooooo  = 4};\n"
16557                "  BYTE payload = 2;\n"
16558                "}",
16559                Style);
16560 }
16561 
16562 TEST_F(FormatTest, LinuxBraceBreaking) {
16563   FormatStyle LinuxBraceStyle = getLLVMStyle();
16564   LinuxBraceStyle.BreakBeforeBraces = FormatStyle::BS_Linux;
16565   verifyFormat("namespace a\n"
16566                "{\n"
16567                "class A\n"
16568                "{\n"
16569                "  void f()\n"
16570                "  {\n"
16571                "    if (true) {\n"
16572                "      a();\n"
16573                "      b();\n"
16574                "    } else {\n"
16575                "      a();\n"
16576                "    }\n"
16577                "  }\n"
16578                "  void g() { return; }\n"
16579                "};\n"
16580                "struct B {\n"
16581                "  int x;\n"
16582                "};\n"
16583                "} // namespace a\n",
16584                LinuxBraceStyle);
16585   verifyFormat("enum X {\n"
16586                "  Y = 0,\n"
16587                "}\n",
16588                LinuxBraceStyle);
16589   verifyFormat("struct S {\n"
16590                "  int Type;\n"
16591                "  union {\n"
16592                "    int x;\n"
16593                "    double y;\n"
16594                "  } Value;\n"
16595                "  class C\n"
16596                "  {\n"
16597                "    MyFavoriteType Value;\n"
16598                "  } Class;\n"
16599                "}\n",
16600                LinuxBraceStyle);
16601 }
16602 
16603 TEST_F(FormatTest, MozillaBraceBreaking) {
16604   FormatStyle MozillaBraceStyle = getLLVMStyle();
16605   MozillaBraceStyle.BreakBeforeBraces = FormatStyle::BS_Mozilla;
16606   MozillaBraceStyle.FixNamespaceComments = false;
16607   verifyFormat("namespace a {\n"
16608                "class A\n"
16609                "{\n"
16610                "  void f()\n"
16611                "  {\n"
16612                "    if (true) {\n"
16613                "      a();\n"
16614                "      b();\n"
16615                "    }\n"
16616                "  }\n"
16617                "  void g() { return; }\n"
16618                "};\n"
16619                "enum E\n"
16620                "{\n"
16621                "  A,\n"
16622                "  // foo\n"
16623                "  B,\n"
16624                "  C\n"
16625                "};\n"
16626                "struct B\n"
16627                "{\n"
16628                "  int x;\n"
16629                "};\n"
16630                "}\n",
16631                MozillaBraceStyle);
16632   verifyFormat("struct S\n"
16633                "{\n"
16634                "  int Type;\n"
16635                "  union\n"
16636                "  {\n"
16637                "    int x;\n"
16638                "    double y;\n"
16639                "  } Value;\n"
16640                "  class C\n"
16641                "  {\n"
16642                "    MyFavoriteType Value;\n"
16643                "  } Class;\n"
16644                "}\n",
16645                MozillaBraceStyle);
16646 }
16647 
16648 TEST_F(FormatTest, StroustrupBraceBreaking) {
16649   FormatStyle StroustrupBraceStyle = getLLVMStyle();
16650   StroustrupBraceStyle.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
16651   verifyFormat("namespace a {\n"
16652                "class A {\n"
16653                "  void f()\n"
16654                "  {\n"
16655                "    if (true) {\n"
16656                "      a();\n"
16657                "      b();\n"
16658                "    }\n"
16659                "  }\n"
16660                "  void g() { return; }\n"
16661                "};\n"
16662                "struct B {\n"
16663                "  int x;\n"
16664                "};\n"
16665                "} // namespace a\n",
16666                StroustrupBraceStyle);
16667 
16668   verifyFormat("void foo()\n"
16669                "{\n"
16670                "  if (a) {\n"
16671                "    a();\n"
16672                "  }\n"
16673                "  else {\n"
16674                "    b();\n"
16675                "  }\n"
16676                "}\n",
16677                StroustrupBraceStyle);
16678 
16679   verifyFormat("#ifdef _DEBUG\n"
16680                "int foo(int i = 0)\n"
16681                "#else\n"
16682                "int foo(int i = 5)\n"
16683                "#endif\n"
16684                "{\n"
16685                "  return i;\n"
16686                "}",
16687                StroustrupBraceStyle);
16688 
16689   verifyFormat("void foo() {}\n"
16690                "void bar()\n"
16691                "#ifdef _DEBUG\n"
16692                "{\n"
16693                "  foo();\n"
16694                "}\n"
16695                "#else\n"
16696                "{\n"
16697                "}\n"
16698                "#endif",
16699                StroustrupBraceStyle);
16700 
16701   verifyFormat("void foobar() { int i = 5; }\n"
16702                "#ifdef _DEBUG\n"
16703                "void bar() {}\n"
16704                "#else\n"
16705                "void bar() { foobar(); }\n"
16706                "#endif",
16707                StroustrupBraceStyle);
16708 }
16709 
16710 TEST_F(FormatTest, AllmanBraceBreaking) {
16711   FormatStyle AllmanBraceStyle = getLLVMStyle();
16712   AllmanBraceStyle.BreakBeforeBraces = FormatStyle::BS_Allman;
16713 
16714   EXPECT_EQ("namespace a\n"
16715             "{\n"
16716             "void f();\n"
16717             "void g();\n"
16718             "} // namespace a\n",
16719             format("namespace a\n"
16720                    "{\n"
16721                    "void f();\n"
16722                    "void g();\n"
16723                    "}\n",
16724                    AllmanBraceStyle));
16725 
16726   verifyFormat("namespace a\n"
16727                "{\n"
16728                "class A\n"
16729                "{\n"
16730                "  void f()\n"
16731                "  {\n"
16732                "    if (true)\n"
16733                "    {\n"
16734                "      a();\n"
16735                "      b();\n"
16736                "    }\n"
16737                "  }\n"
16738                "  void g() { return; }\n"
16739                "};\n"
16740                "struct B\n"
16741                "{\n"
16742                "  int x;\n"
16743                "};\n"
16744                "union C\n"
16745                "{\n"
16746                "};\n"
16747                "} // namespace a",
16748                AllmanBraceStyle);
16749 
16750   verifyFormat("void f()\n"
16751                "{\n"
16752                "  if (true)\n"
16753                "  {\n"
16754                "    a();\n"
16755                "  }\n"
16756                "  else if (false)\n"
16757                "  {\n"
16758                "    b();\n"
16759                "  }\n"
16760                "  else\n"
16761                "  {\n"
16762                "    c();\n"
16763                "  }\n"
16764                "}\n",
16765                AllmanBraceStyle);
16766 
16767   verifyFormat("void f()\n"
16768                "{\n"
16769                "  for (int i = 0; i < 10; ++i)\n"
16770                "  {\n"
16771                "    a();\n"
16772                "  }\n"
16773                "  while (false)\n"
16774                "  {\n"
16775                "    b();\n"
16776                "  }\n"
16777                "  do\n"
16778                "  {\n"
16779                "    c();\n"
16780                "  } while (false)\n"
16781                "}\n",
16782                AllmanBraceStyle);
16783 
16784   verifyFormat("void f(int a)\n"
16785                "{\n"
16786                "  switch (a)\n"
16787                "  {\n"
16788                "  case 0:\n"
16789                "    break;\n"
16790                "  case 1:\n"
16791                "  {\n"
16792                "    break;\n"
16793                "  }\n"
16794                "  case 2:\n"
16795                "  {\n"
16796                "  }\n"
16797                "  break;\n"
16798                "  default:\n"
16799                "    break;\n"
16800                "  }\n"
16801                "}\n",
16802                AllmanBraceStyle);
16803 
16804   verifyFormat("enum X\n"
16805                "{\n"
16806                "  Y = 0,\n"
16807                "}\n",
16808                AllmanBraceStyle);
16809   verifyFormat("enum X\n"
16810                "{\n"
16811                "  Y = 0\n"
16812                "}\n",
16813                AllmanBraceStyle);
16814 
16815   verifyFormat("@interface BSApplicationController ()\n"
16816                "{\n"
16817                "@private\n"
16818                "  id _extraIvar;\n"
16819                "}\n"
16820                "@end\n",
16821                AllmanBraceStyle);
16822 
16823   verifyFormat("#ifdef _DEBUG\n"
16824                "int foo(int i = 0)\n"
16825                "#else\n"
16826                "int foo(int i = 5)\n"
16827                "#endif\n"
16828                "{\n"
16829                "  return i;\n"
16830                "}",
16831                AllmanBraceStyle);
16832 
16833   verifyFormat("void foo() {}\n"
16834                "void bar()\n"
16835                "#ifdef _DEBUG\n"
16836                "{\n"
16837                "  foo();\n"
16838                "}\n"
16839                "#else\n"
16840                "{\n"
16841                "}\n"
16842                "#endif",
16843                AllmanBraceStyle);
16844 
16845   verifyFormat("void foobar() { int i = 5; }\n"
16846                "#ifdef _DEBUG\n"
16847                "void bar() {}\n"
16848                "#else\n"
16849                "void bar() { foobar(); }\n"
16850                "#endif",
16851                AllmanBraceStyle);
16852 
16853   EXPECT_EQ(AllmanBraceStyle.AllowShortLambdasOnASingleLine,
16854             FormatStyle::SLS_All);
16855 
16856   verifyFormat("[](int i) { return i + 2; };\n"
16857                "[](int i, int j)\n"
16858                "{\n"
16859                "  auto x = i + j;\n"
16860                "  auto y = i * j;\n"
16861                "  return x ^ y;\n"
16862                "};\n"
16863                "void foo()\n"
16864                "{\n"
16865                "  auto shortLambda = [](int i) { return i + 2; };\n"
16866                "  auto longLambda = [](int i, int j)\n"
16867                "  {\n"
16868                "    auto x = i + j;\n"
16869                "    auto y = i * j;\n"
16870                "    return x ^ y;\n"
16871                "  };\n"
16872                "}",
16873                AllmanBraceStyle);
16874 
16875   AllmanBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
16876 
16877   verifyFormat("[](int i)\n"
16878                "{\n"
16879                "  return i + 2;\n"
16880                "};\n"
16881                "[](int i, int j)\n"
16882                "{\n"
16883                "  auto x = i + j;\n"
16884                "  auto y = i * j;\n"
16885                "  return x ^ y;\n"
16886                "};\n"
16887                "void foo()\n"
16888                "{\n"
16889                "  auto shortLambda = [](int i)\n"
16890                "  {\n"
16891                "    return i + 2;\n"
16892                "  };\n"
16893                "  auto longLambda = [](int i, int j)\n"
16894                "  {\n"
16895                "    auto x = i + j;\n"
16896                "    auto y = i * j;\n"
16897                "    return x ^ y;\n"
16898                "  };\n"
16899                "}",
16900                AllmanBraceStyle);
16901 
16902   // Reset
16903   AllmanBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_All;
16904 
16905   // This shouldn't affect ObjC blocks..
16906   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
16907                "  // ...\n"
16908                "  int i;\n"
16909                "}];",
16910                AllmanBraceStyle);
16911   verifyFormat("void (^block)(void) = ^{\n"
16912                "  // ...\n"
16913                "  int i;\n"
16914                "};",
16915                AllmanBraceStyle);
16916   // .. or dict literals.
16917   verifyFormat("void f()\n"
16918                "{\n"
16919                "  // ...\n"
16920                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
16921                "}",
16922                AllmanBraceStyle);
16923   verifyFormat("void f()\n"
16924                "{\n"
16925                "  // ...\n"
16926                "  [object someMethod:@{a : @\"b\"}];\n"
16927                "}",
16928                AllmanBraceStyle);
16929   verifyFormat("int f()\n"
16930                "{ // comment\n"
16931                "  return 42;\n"
16932                "}",
16933                AllmanBraceStyle);
16934 
16935   AllmanBraceStyle.ColumnLimit = 19;
16936   verifyFormat("void f() { int i; }", AllmanBraceStyle);
16937   AllmanBraceStyle.ColumnLimit = 18;
16938   verifyFormat("void f()\n"
16939                "{\n"
16940                "  int i;\n"
16941                "}",
16942                AllmanBraceStyle);
16943   AllmanBraceStyle.ColumnLimit = 80;
16944 
16945   FormatStyle BreakBeforeBraceShortIfs = AllmanBraceStyle;
16946   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
16947       FormatStyle::SIS_WithoutElse;
16948   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
16949   verifyFormat("void f(bool b)\n"
16950                "{\n"
16951                "  if (b)\n"
16952                "  {\n"
16953                "    return;\n"
16954                "  }\n"
16955                "}\n",
16956                BreakBeforeBraceShortIfs);
16957   verifyFormat("void f(bool b)\n"
16958                "{\n"
16959                "  if constexpr (b)\n"
16960                "  {\n"
16961                "    return;\n"
16962                "  }\n"
16963                "}\n",
16964                BreakBeforeBraceShortIfs);
16965   verifyFormat("void f(bool b)\n"
16966                "{\n"
16967                "  if CONSTEXPR (b)\n"
16968                "  {\n"
16969                "    return;\n"
16970                "  }\n"
16971                "}\n",
16972                BreakBeforeBraceShortIfs);
16973   verifyFormat("void f(bool b)\n"
16974                "{\n"
16975                "  if (b) return;\n"
16976                "}\n",
16977                BreakBeforeBraceShortIfs);
16978   verifyFormat("void f(bool b)\n"
16979                "{\n"
16980                "  if constexpr (b) return;\n"
16981                "}\n",
16982                BreakBeforeBraceShortIfs);
16983   verifyFormat("void f(bool b)\n"
16984                "{\n"
16985                "  if CONSTEXPR (b) return;\n"
16986                "}\n",
16987                BreakBeforeBraceShortIfs);
16988   verifyFormat("void f(bool b)\n"
16989                "{\n"
16990                "  while (b)\n"
16991                "  {\n"
16992                "    return;\n"
16993                "  }\n"
16994                "}\n",
16995                BreakBeforeBraceShortIfs);
16996 }
16997 
16998 TEST_F(FormatTest, WhitesmithsBraceBreaking) {
16999   FormatStyle WhitesmithsBraceStyle = getLLVMStyle();
17000   WhitesmithsBraceStyle.BreakBeforeBraces = FormatStyle::BS_Whitesmiths;
17001 
17002   // Make a few changes to the style for testing purposes
17003   WhitesmithsBraceStyle.AllowShortFunctionsOnASingleLine =
17004       FormatStyle::SFS_Empty;
17005   WhitesmithsBraceStyle.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
17006   WhitesmithsBraceStyle.ColumnLimit = 0;
17007 
17008   // FIXME: this test case can't decide whether there should be a blank line
17009   // after the ~D() line or not. It adds one if one doesn't exist in the test
17010   // and it removes the line if one exists.
17011   /*
17012   verifyFormat("class A;\n"
17013                "namespace B\n"
17014                "  {\n"
17015                "class C;\n"
17016                "// Comment\n"
17017                "class D\n"
17018                "  {\n"
17019                "public:\n"
17020                "  D();\n"
17021                "  ~D() {}\n"
17022                "private:\n"
17023                "  enum E\n"
17024                "    {\n"
17025                "    F\n"
17026                "    }\n"
17027                "  };\n"
17028                "  } // namespace B\n",
17029                WhitesmithsBraceStyle);
17030   */
17031 
17032   WhitesmithsBraceStyle.NamespaceIndentation = FormatStyle::NI_None;
17033   verifyFormat("namespace a\n"
17034                "  {\n"
17035                "class A\n"
17036                "  {\n"
17037                "  void f()\n"
17038                "    {\n"
17039                "    if (true)\n"
17040                "      {\n"
17041                "      a();\n"
17042                "      b();\n"
17043                "      }\n"
17044                "    }\n"
17045                "  void g()\n"
17046                "    {\n"
17047                "    return;\n"
17048                "    }\n"
17049                "  };\n"
17050                "struct B\n"
17051                "  {\n"
17052                "  int x;\n"
17053                "  };\n"
17054                "  } // namespace a",
17055                WhitesmithsBraceStyle);
17056 
17057   verifyFormat("namespace a\n"
17058                "  {\n"
17059                "namespace b\n"
17060                "  {\n"
17061                "class A\n"
17062                "  {\n"
17063                "  void f()\n"
17064                "    {\n"
17065                "    if (true)\n"
17066                "      {\n"
17067                "      a();\n"
17068                "      b();\n"
17069                "      }\n"
17070                "    }\n"
17071                "  void g()\n"
17072                "    {\n"
17073                "    return;\n"
17074                "    }\n"
17075                "  };\n"
17076                "struct B\n"
17077                "  {\n"
17078                "  int x;\n"
17079                "  };\n"
17080                "  } // namespace b\n"
17081                "  } // namespace a",
17082                WhitesmithsBraceStyle);
17083 
17084   WhitesmithsBraceStyle.NamespaceIndentation = FormatStyle::NI_Inner;
17085   verifyFormat("namespace a\n"
17086                "  {\n"
17087                "namespace b\n"
17088                "  {\n"
17089                "  class A\n"
17090                "    {\n"
17091                "    void f()\n"
17092                "      {\n"
17093                "      if (true)\n"
17094                "        {\n"
17095                "        a();\n"
17096                "        b();\n"
17097                "        }\n"
17098                "      }\n"
17099                "    void g()\n"
17100                "      {\n"
17101                "      return;\n"
17102                "      }\n"
17103                "    };\n"
17104                "  struct B\n"
17105                "    {\n"
17106                "    int x;\n"
17107                "    };\n"
17108                "  } // namespace b\n"
17109                "  } // namespace a",
17110                WhitesmithsBraceStyle);
17111 
17112   WhitesmithsBraceStyle.NamespaceIndentation = FormatStyle::NI_All;
17113   verifyFormat("namespace a\n"
17114                "  {\n"
17115                "  namespace b\n"
17116                "    {\n"
17117                "    class A\n"
17118                "      {\n"
17119                "      void f()\n"
17120                "        {\n"
17121                "        if (true)\n"
17122                "          {\n"
17123                "          a();\n"
17124                "          b();\n"
17125                "          }\n"
17126                "        }\n"
17127                "      void g()\n"
17128                "        {\n"
17129                "        return;\n"
17130                "        }\n"
17131                "      };\n"
17132                "    struct B\n"
17133                "      {\n"
17134                "      int x;\n"
17135                "      };\n"
17136                "    } // namespace b\n"
17137                "  }   // namespace a",
17138                WhitesmithsBraceStyle);
17139 
17140   verifyFormat("void f()\n"
17141                "  {\n"
17142                "  if (true)\n"
17143                "    {\n"
17144                "    a();\n"
17145                "    }\n"
17146                "  else if (false)\n"
17147                "    {\n"
17148                "    b();\n"
17149                "    }\n"
17150                "  else\n"
17151                "    {\n"
17152                "    c();\n"
17153                "    }\n"
17154                "  }\n",
17155                WhitesmithsBraceStyle);
17156 
17157   verifyFormat("void f()\n"
17158                "  {\n"
17159                "  for (int i = 0; i < 10; ++i)\n"
17160                "    {\n"
17161                "    a();\n"
17162                "    }\n"
17163                "  while (false)\n"
17164                "    {\n"
17165                "    b();\n"
17166                "    }\n"
17167                "  do\n"
17168                "    {\n"
17169                "    c();\n"
17170                "    } while (false)\n"
17171                "  }\n",
17172                WhitesmithsBraceStyle);
17173 
17174   WhitesmithsBraceStyle.IndentCaseLabels = true;
17175   verifyFormat("void switchTest1(int a)\n"
17176                "  {\n"
17177                "  switch (a)\n"
17178                "    {\n"
17179                "    case 2:\n"
17180                "      {\n"
17181                "      }\n"
17182                "      break;\n"
17183                "    }\n"
17184                "  }\n",
17185                WhitesmithsBraceStyle);
17186 
17187   verifyFormat("void switchTest2(int a)\n"
17188                "  {\n"
17189                "  switch (a)\n"
17190                "    {\n"
17191                "    case 0:\n"
17192                "      break;\n"
17193                "    case 1:\n"
17194                "      {\n"
17195                "      break;\n"
17196                "      }\n"
17197                "    case 2:\n"
17198                "      {\n"
17199                "      }\n"
17200                "      break;\n"
17201                "    default:\n"
17202                "      break;\n"
17203                "    }\n"
17204                "  }\n",
17205                WhitesmithsBraceStyle);
17206 
17207   verifyFormat("void switchTest3(int a)\n"
17208                "  {\n"
17209                "  switch (a)\n"
17210                "    {\n"
17211                "    case 0:\n"
17212                "      {\n"
17213                "      foo(x);\n"
17214                "      }\n"
17215                "      break;\n"
17216                "    default:\n"
17217                "      {\n"
17218                "      foo(1);\n"
17219                "      }\n"
17220                "      break;\n"
17221                "    }\n"
17222                "  }\n",
17223                WhitesmithsBraceStyle);
17224 
17225   WhitesmithsBraceStyle.IndentCaseLabels = false;
17226 
17227   verifyFormat("void switchTest4(int a)\n"
17228                "  {\n"
17229                "  switch (a)\n"
17230                "    {\n"
17231                "  case 2:\n"
17232                "    {\n"
17233                "    }\n"
17234                "    break;\n"
17235                "    }\n"
17236                "  }\n",
17237                WhitesmithsBraceStyle);
17238 
17239   verifyFormat("void switchTest5(int a)\n"
17240                "  {\n"
17241                "  switch (a)\n"
17242                "    {\n"
17243                "  case 0:\n"
17244                "    break;\n"
17245                "  case 1:\n"
17246                "    {\n"
17247                "    foo();\n"
17248                "    break;\n"
17249                "    }\n"
17250                "  case 2:\n"
17251                "    {\n"
17252                "    }\n"
17253                "    break;\n"
17254                "  default:\n"
17255                "    break;\n"
17256                "    }\n"
17257                "  }\n",
17258                WhitesmithsBraceStyle);
17259 
17260   verifyFormat("void switchTest6(int a)\n"
17261                "  {\n"
17262                "  switch (a)\n"
17263                "    {\n"
17264                "  case 0:\n"
17265                "    {\n"
17266                "    foo(x);\n"
17267                "    }\n"
17268                "    break;\n"
17269                "  default:\n"
17270                "    {\n"
17271                "    foo(1);\n"
17272                "    }\n"
17273                "    break;\n"
17274                "    }\n"
17275                "  }\n",
17276                WhitesmithsBraceStyle);
17277 
17278   verifyFormat("enum X\n"
17279                "  {\n"
17280                "  Y = 0, // testing\n"
17281                "  }\n",
17282                WhitesmithsBraceStyle);
17283 
17284   verifyFormat("enum X\n"
17285                "  {\n"
17286                "  Y = 0\n"
17287                "  }\n",
17288                WhitesmithsBraceStyle);
17289   verifyFormat("enum X\n"
17290                "  {\n"
17291                "  Y = 0,\n"
17292                "  Z = 1\n"
17293                "  };\n",
17294                WhitesmithsBraceStyle);
17295 
17296   verifyFormat("@interface BSApplicationController ()\n"
17297                "  {\n"
17298                "@private\n"
17299                "  id _extraIvar;\n"
17300                "  }\n"
17301                "@end\n",
17302                WhitesmithsBraceStyle);
17303 
17304   verifyFormat("#ifdef _DEBUG\n"
17305                "int foo(int i = 0)\n"
17306                "#else\n"
17307                "int foo(int i = 5)\n"
17308                "#endif\n"
17309                "  {\n"
17310                "  return i;\n"
17311                "  }",
17312                WhitesmithsBraceStyle);
17313 
17314   verifyFormat("void foo() {}\n"
17315                "void bar()\n"
17316                "#ifdef _DEBUG\n"
17317                "  {\n"
17318                "  foo();\n"
17319                "  }\n"
17320                "#else\n"
17321                "  {\n"
17322                "  }\n"
17323                "#endif",
17324                WhitesmithsBraceStyle);
17325 
17326   verifyFormat("void foobar()\n"
17327                "  {\n"
17328                "  int i = 5;\n"
17329                "  }\n"
17330                "#ifdef _DEBUG\n"
17331                "void bar()\n"
17332                "  {\n"
17333                "  }\n"
17334                "#else\n"
17335                "void bar()\n"
17336                "  {\n"
17337                "  foobar();\n"
17338                "  }\n"
17339                "#endif",
17340                WhitesmithsBraceStyle);
17341 
17342   // This shouldn't affect ObjC blocks..
17343   verifyFormat("[self doSomeThingWithACompletionHandler:^{\n"
17344                "  // ...\n"
17345                "  int i;\n"
17346                "}];",
17347                WhitesmithsBraceStyle);
17348   verifyFormat("void (^block)(void) = ^{\n"
17349                "  // ...\n"
17350                "  int i;\n"
17351                "};",
17352                WhitesmithsBraceStyle);
17353   // .. or dict literals.
17354   verifyFormat("void f()\n"
17355                "  {\n"
17356                "  [object someMethod:@{@\"a\" : @\"b\"}];\n"
17357                "  }",
17358                WhitesmithsBraceStyle);
17359 
17360   verifyFormat("int f()\n"
17361                "  { // comment\n"
17362                "  return 42;\n"
17363                "  }",
17364                WhitesmithsBraceStyle);
17365 
17366   FormatStyle BreakBeforeBraceShortIfs = WhitesmithsBraceStyle;
17367   BreakBeforeBraceShortIfs.AllowShortIfStatementsOnASingleLine =
17368       FormatStyle::SIS_OnlyFirstIf;
17369   BreakBeforeBraceShortIfs.AllowShortLoopsOnASingleLine = true;
17370   verifyFormat("void f(bool b)\n"
17371                "  {\n"
17372                "  if (b)\n"
17373                "    {\n"
17374                "    return;\n"
17375                "    }\n"
17376                "  }\n",
17377                BreakBeforeBraceShortIfs);
17378   verifyFormat("void f(bool b)\n"
17379                "  {\n"
17380                "  if (b) return;\n"
17381                "  }\n",
17382                BreakBeforeBraceShortIfs);
17383   verifyFormat("void f(bool b)\n"
17384                "  {\n"
17385                "  while (b)\n"
17386                "    {\n"
17387                "    return;\n"
17388                "    }\n"
17389                "  }\n",
17390                BreakBeforeBraceShortIfs);
17391 }
17392 
17393 TEST_F(FormatTest, GNUBraceBreaking) {
17394   FormatStyle GNUBraceStyle = getLLVMStyle();
17395   GNUBraceStyle.BreakBeforeBraces = FormatStyle::BS_GNU;
17396   verifyFormat("namespace a\n"
17397                "{\n"
17398                "class A\n"
17399                "{\n"
17400                "  void f()\n"
17401                "  {\n"
17402                "    int a;\n"
17403                "    {\n"
17404                "      int b;\n"
17405                "    }\n"
17406                "    if (true)\n"
17407                "      {\n"
17408                "        a();\n"
17409                "        b();\n"
17410                "      }\n"
17411                "  }\n"
17412                "  void g() { return; }\n"
17413                "}\n"
17414                "} // namespace a",
17415                GNUBraceStyle);
17416 
17417   verifyFormat("void f()\n"
17418                "{\n"
17419                "  if (true)\n"
17420                "    {\n"
17421                "      a();\n"
17422                "    }\n"
17423                "  else if (false)\n"
17424                "    {\n"
17425                "      b();\n"
17426                "    }\n"
17427                "  else\n"
17428                "    {\n"
17429                "      c();\n"
17430                "    }\n"
17431                "}\n",
17432                GNUBraceStyle);
17433 
17434   verifyFormat("void f()\n"
17435                "{\n"
17436                "  for (int i = 0; i < 10; ++i)\n"
17437                "    {\n"
17438                "      a();\n"
17439                "    }\n"
17440                "  while (false)\n"
17441                "    {\n"
17442                "      b();\n"
17443                "    }\n"
17444                "  do\n"
17445                "    {\n"
17446                "      c();\n"
17447                "    }\n"
17448                "  while (false);\n"
17449                "}\n",
17450                GNUBraceStyle);
17451 
17452   verifyFormat("void f(int a)\n"
17453                "{\n"
17454                "  switch (a)\n"
17455                "    {\n"
17456                "    case 0:\n"
17457                "      break;\n"
17458                "    case 1:\n"
17459                "      {\n"
17460                "        break;\n"
17461                "      }\n"
17462                "    case 2:\n"
17463                "      {\n"
17464                "      }\n"
17465                "      break;\n"
17466                "    default:\n"
17467                "      break;\n"
17468                "    }\n"
17469                "}\n",
17470                GNUBraceStyle);
17471 
17472   verifyFormat("enum X\n"
17473                "{\n"
17474                "  Y = 0,\n"
17475                "}\n",
17476                GNUBraceStyle);
17477 
17478   verifyFormat("@interface BSApplicationController ()\n"
17479                "{\n"
17480                "@private\n"
17481                "  id _extraIvar;\n"
17482                "}\n"
17483                "@end\n",
17484                GNUBraceStyle);
17485 
17486   verifyFormat("#ifdef _DEBUG\n"
17487                "int foo(int i = 0)\n"
17488                "#else\n"
17489                "int foo(int i = 5)\n"
17490                "#endif\n"
17491                "{\n"
17492                "  return i;\n"
17493                "}",
17494                GNUBraceStyle);
17495 
17496   verifyFormat("void foo() {}\n"
17497                "void bar()\n"
17498                "#ifdef _DEBUG\n"
17499                "{\n"
17500                "  foo();\n"
17501                "}\n"
17502                "#else\n"
17503                "{\n"
17504                "}\n"
17505                "#endif",
17506                GNUBraceStyle);
17507 
17508   verifyFormat("void foobar() { int i = 5; }\n"
17509                "#ifdef _DEBUG\n"
17510                "void bar() {}\n"
17511                "#else\n"
17512                "void bar() { foobar(); }\n"
17513                "#endif",
17514                GNUBraceStyle);
17515 }
17516 
17517 TEST_F(FormatTest, WebKitBraceBreaking) {
17518   FormatStyle WebKitBraceStyle = getLLVMStyle();
17519   WebKitBraceStyle.BreakBeforeBraces = FormatStyle::BS_WebKit;
17520   WebKitBraceStyle.FixNamespaceComments = false;
17521   verifyFormat("namespace a {\n"
17522                "class A {\n"
17523                "  void f()\n"
17524                "  {\n"
17525                "    if (true) {\n"
17526                "      a();\n"
17527                "      b();\n"
17528                "    }\n"
17529                "  }\n"
17530                "  void g() { return; }\n"
17531                "};\n"
17532                "enum E {\n"
17533                "  A,\n"
17534                "  // foo\n"
17535                "  B,\n"
17536                "  C\n"
17537                "};\n"
17538                "struct B {\n"
17539                "  int x;\n"
17540                "};\n"
17541                "}\n",
17542                WebKitBraceStyle);
17543   verifyFormat("struct S {\n"
17544                "  int Type;\n"
17545                "  union {\n"
17546                "    int x;\n"
17547                "    double y;\n"
17548                "  } Value;\n"
17549                "  class C {\n"
17550                "    MyFavoriteType Value;\n"
17551                "  } Class;\n"
17552                "};\n",
17553                WebKitBraceStyle);
17554 }
17555 
17556 TEST_F(FormatTest, CatchExceptionReferenceBinding) {
17557   verifyFormat("void f() {\n"
17558                "  try {\n"
17559                "  } catch (const Exception &e) {\n"
17560                "  }\n"
17561                "}\n",
17562                getLLVMStyle());
17563 }
17564 
17565 TEST_F(FormatTest, CatchAlignArrayOfStructuresRightAlignment) {
17566   auto Style = getLLVMStyle();
17567   Style.AlignArrayOfStructures = FormatStyle::AIAS_Right;
17568   Style.AlignConsecutiveAssignments =
17569       FormatStyle::AlignConsecutiveStyle::ACS_Consecutive;
17570   Style.AlignConsecutiveDeclarations =
17571       FormatStyle::AlignConsecutiveStyle::ACS_Consecutive;
17572   verifyFormat("struct test demo[] = {\n"
17573                "    {56,    23, \"hello\"},\n"
17574                "    {-1, 93463, \"world\"},\n"
17575                "    { 7,     5,    \"!!\"}\n"
17576                "};\n",
17577                Style);
17578 
17579   verifyFormat("struct test demo[] = {\n"
17580                "    {56,    23, \"hello\"}, // first line\n"
17581                "    {-1, 93463, \"world\"}, // second line\n"
17582                "    { 7,     5,    \"!!\"}  // third line\n"
17583                "};\n",
17584                Style);
17585 
17586   verifyFormat("struct test demo[4] = {\n"
17587                "    { 56,    23, 21,       \"oh\"}, // first line\n"
17588                "    { -1, 93463, 22,       \"my\"}, // second line\n"
17589                "    {  7,     5,  1, \"goodness\"}  // third line\n"
17590                "    {234,     5,  1, \"gracious\"}  // fourth line\n"
17591                "};\n",
17592                Style);
17593 
17594   verifyFormat("struct test demo[3] = {\n"
17595                "    {56,    23, \"hello\"},\n"
17596                "    {-1, 93463, \"world\"},\n"
17597                "    { 7,     5,    \"!!\"}\n"
17598                "};\n",
17599                Style);
17600 
17601   verifyFormat("struct test demo[3] = {\n"
17602                "    {int{56},    23, \"hello\"},\n"
17603                "    {int{-1}, 93463, \"world\"},\n"
17604                "    { int{7},     5,    \"!!\"}\n"
17605                "};\n",
17606                Style);
17607 
17608   verifyFormat("struct test demo[] = {\n"
17609                "    {56,    23, \"hello\"},\n"
17610                "    {-1, 93463, \"world\"},\n"
17611                "    { 7,     5,    \"!!\"},\n"
17612                "};\n",
17613                Style);
17614 
17615   verifyFormat("test demo[] = {\n"
17616                "    {56,    23, \"hello\"},\n"
17617                "    {-1, 93463, \"world\"},\n"
17618                "    { 7,     5,    \"!!\"},\n"
17619                "};\n",
17620                Style);
17621 
17622   verifyFormat("demo = std::array<struct test, 3>{\n"
17623                "    test{56,    23, \"hello\"},\n"
17624                "    test{-1, 93463, \"world\"},\n"
17625                "    test{ 7,     5,    \"!!\"},\n"
17626                "};\n",
17627                Style);
17628 
17629   verifyFormat("test demo[] = {\n"
17630                "    {56,    23, \"hello\"},\n"
17631                "#if X\n"
17632                "    {-1, 93463, \"world\"},\n"
17633                "#endif\n"
17634                "    { 7,     5,    \"!!\"}\n"
17635                "};\n",
17636                Style);
17637 
17638   verifyFormat(
17639       "test demo[] = {\n"
17640       "    { 7,    23,\n"
17641       "     \"hello world i am a very long line that really, in any\"\n"
17642       "     \"just world, ought to be split over multiple lines\"},\n"
17643       "    {-1, 93463,                                  \"world\"},\n"
17644       "    {56,     5,                                     \"!!\"}\n"
17645       "};\n",
17646       Style);
17647 
17648   verifyFormat("return GradForUnaryCwise(g, {\n"
17649                "                                {{\"sign\"}, \"Sign\",  "
17650                "  {\"x\", \"dy\"}},\n"
17651                "                                {  {\"dx\"},  \"Mul\", {\"dy\""
17652                ", \"sign\"}},\n"
17653                "});\n",
17654                Style);
17655 
17656   Style.ColumnLimit = 0;
17657   EXPECT_EQ(
17658       "test demo[] = {\n"
17659       "    {56,    23, \"hello world i am a very long line that really, "
17660       "in any just world, ought to be split over multiple lines\"},\n"
17661       "    {-1, 93463,                                                  "
17662       "                                                 \"world\"},\n"
17663       "    { 7,     5,                                                  "
17664       "                                                    \"!!\"},\n"
17665       "};",
17666       format("test demo[] = {{56, 23, \"hello world i am a very long line "
17667              "that really, in any just world, ought to be split over multiple "
17668              "lines\"},{-1, 93463, \"world\"},{7, 5, \"!!\"},};",
17669              Style));
17670 
17671   Style.ColumnLimit = 80;
17672   verifyFormat("test demo[] = {\n"
17673                "    {56,    23, /* a comment */ \"hello\"},\n"
17674                "    {-1, 93463,                 \"world\"},\n"
17675                "    { 7,     5,                    \"!!\"}\n"
17676                "};\n",
17677                Style);
17678 
17679   verifyFormat("test demo[] = {\n"
17680                "    {56,    23,                    \"hello\"},\n"
17681                "    {-1, 93463, \"world\" /* comment here */},\n"
17682                "    { 7,     5,                       \"!!\"}\n"
17683                "};\n",
17684                Style);
17685 
17686   verifyFormat("test demo[] = {\n"
17687                "    {56, /* a comment */ 23, \"hello\"},\n"
17688                "    {-1,              93463, \"world\"},\n"
17689                "    { 7,                  5,    \"!!\"}\n"
17690                "};\n",
17691                Style);
17692 
17693   Style.ColumnLimit = 20;
17694   EXPECT_EQ(
17695       "demo = std::array<\n"
17696       "    struct test, 3>{\n"
17697       "    test{\n"
17698       "         56,    23,\n"
17699       "         \"hello \"\n"
17700       "         \"world i \"\n"
17701       "         \"am a very \"\n"
17702       "         \"long line \"\n"
17703       "         \"that \"\n"
17704       "         \"really, \"\n"
17705       "         \"in any \"\n"
17706       "         \"just \"\n"
17707       "         \"world, \"\n"
17708       "         \"ought to \"\n"
17709       "         \"be split \"\n"
17710       "         \"over \"\n"
17711       "         \"multiple \"\n"
17712       "         \"lines\"},\n"
17713       "    test{-1, 93463,\n"
17714       "         \"world\"},\n"
17715       "    test{ 7,     5,\n"
17716       "         \"!!\"   },\n"
17717       "};",
17718       format("demo = std::array<struct test, 3>{test{56, 23, \"hello world "
17719              "i am a very long line that really, in any just world, ought "
17720              "to be split over multiple lines\"},test{-1, 93463, \"world\"},"
17721              "test{7, 5, \"!!\"},};",
17722              Style));
17723   // This caused a core dump by enabling Alignment in the LLVMStyle globally
17724   Style = getLLVMStyleWithColumns(50);
17725   Style.AlignArrayOfStructures = FormatStyle::AIAS_Right;
17726   verifyFormat("static A x = {\n"
17727                "    {{init1, init2, init3, init4},\n"
17728                "     {init1, init2, init3, init4}}\n"
17729                "};",
17730                Style);
17731   Style.ColumnLimit = 100;
17732   EXPECT_EQ(
17733       "test demo[] = {\n"
17734       "    {56,    23,\n"
17735       "     \"hello world i am a very long line that really, in any just world"
17736       ", ought to be split over \"\n"
17737       "     \"multiple lines\"  },\n"
17738       "    {-1, 93463, \"world\"},\n"
17739       "    { 7,     5,    \"!!\"},\n"
17740       "};",
17741       format("test demo[] = {{56, 23, \"hello world i am a very long line "
17742              "that really, in any just world, ought to be split over multiple "
17743              "lines\"},{-1, 93463, \"world\"},{7, 5, \"!!\"},};",
17744              Style));
17745 
17746   Style = getLLVMStyleWithColumns(50);
17747   Style.AlignArrayOfStructures = FormatStyle::AIAS_Right;
17748   Style.AlignConsecutiveAssignments =
17749       FormatStyle::AlignConsecutiveStyle::ACS_Consecutive;
17750   Style.AlignConsecutiveDeclarations =
17751       FormatStyle::AlignConsecutiveStyle::ACS_Consecutive;
17752   verifyFormat("struct test demo[] = {\n"
17753                "    {56,    23, \"hello\"},\n"
17754                "    {-1, 93463, \"world\"},\n"
17755                "    { 7,     5,    \"!!\"}\n"
17756                "};\n"
17757                "static A x = {\n"
17758                "    {{init1, init2, init3, init4},\n"
17759                "     {init1, init2, init3, init4}}\n"
17760                "};",
17761                Style);
17762   Style.ColumnLimit = 100;
17763   Style.AlignConsecutiveAssignments =
17764       FormatStyle::AlignConsecutiveStyle::ACS_AcrossComments;
17765   Style.AlignConsecutiveDeclarations =
17766       FormatStyle::AlignConsecutiveStyle::ACS_AcrossComments;
17767   verifyFormat("struct test demo[] = {\n"
17768                "    {56,    23, \"hello\"},\n"
17769                "    {-1, 93463, \"world\"},\n"
17770                "    { 7,     5,    \"!!\"}\n"
17771                "};\n"
17772                "struct test demo[4] = {\n"
17773                "    { 56,    23, 21,       \"oh\"}, // first line\n"
17774                "    { -1, 93463, 22,       \"my\"}, // second line\n"
17775                "    {  7,     5,  1, \"goodness\"}  // third line\n"
17776                "    {234,     5,  1, \"gracious\"}  // fourth line\n"
17777                "};\n",
17778                Style);
17779   EXPECT_EQ(
17780       "test demo[] = {\n"
17781       "    {56,\n"
17782       "     \"hello world i am a very long line that really, in any just world"
17783       ", ought to be split over \"\n"
17784       "     \"multiple lines\",    23},\n"
17785       "    {-1,      \"world\", 93463},\n"
17786       "    { 7,         \"!!\",     5},\n"
17787       "};",
17788       format("test demo[] = {{56, \"hello world i am a very long line "
17789              "that really, in any just world, ought to be split over multiple "
17790              "lines\", 23},{-1, \"world\", 93463},{7, \"!!\", 5},};",
17791              Style));
17792 }
17793 
17794 TEST_F(FormatTest, CatchAlignArrayOfStructuresLeftAlignment) {
17795   auto Style = getLLVMStyle();
17796   Style.AlignArrayOfStructures = FormatStyle::AIAS_Left;
17797   verifyFormat("struct test demo[] = {\n"
17798                "    {56, 23,    \"hello\"},\n"
17799                "    {-1, 93463, \"world\"},\n"
17800                "    {7,  5,     \"!!\"   }\n"
17801                "};\n",
17802                Style);
17803 
17804   verifyFormat("struct test demo[] = {\n"
17805                "    {56, 23,    \"hello\"}, // first line\n"
17806                "    {-1, 93463, \"world\"}, // second line\n"
17807                "    {7,  5,     \"!!\"   }  // third line\n"
17808                "};\n",
17809                Style);
17810   verifyFormat("struct test demo[4] = {\n"
17811                "    {56,  23,    21, \"oh\"      }, // first line\n"
17812                "    {-1,  93463, 22, \"my\"      }, // second line\n"
17813                "    {7,   5,     1,  \"goodness\"}  // third line\n"
17814                "    {234, 5,     1,  \"gracious\"}  // fourth line\n"
17815                "};\n",
17816                Style);
17817   verifyFormat("struct test demo[3] = {\n"
17818                "    {56, 23,    \"hello\"},\n"
17819                "    {-1, 93463, \"world\"},\n"
17820                "    {7,  5,     \"!!\"   }\n"
17821                "};\n",
17822                Style);
17823 
17824   verifyFormat("struct test demo[3] = {\n"
17825                "    {int{56}, 23,    \"hello\"},\n"
17826                "    {int{-1}, 93463, \"world\"},\n"
17827                "    {int{7},  5,     \"!!\"   }\n"
17828                "};\n",
17829                Style);
17830   verifyFormat("struct test demo[] = {\n"
17831                "    {56, 23,    \"hello\"},\n"
17832                "    {-1, 93463, \"world\"},\n"
17833                "    {7,  5,     \"!!\"   },\n"
17834                "};\n",
17835                Style);
17836   verifyFormat("test demo[] = {\n"
17837                "    {56, 23,    \"hello\"},\n"
17838                "    {-1, 93463, \"world\"},\n"
17839                "    {7,  5,     \"!!\"   },\n"
17840                "};\n",
17841                Style);
17842   verifyFormat("demo = std::array<struct test, 3>{\n"
17843                "    test{56, 23,    \"hello\"},\n"
17844                "    test{-1, 93463, \"world\"},\n"
17845                "    test{7,  5,     \"!!\"   },\n"
17846                "};\n",
17847                Style);
17848   verifyFormat("test demo[] = {\n"
17849                "    {56, 23,    \"hello\"},\n"
17850                "#if X\n"
17851                "    {-1, 93463, \"world\"},\n"
17852                "#endif\n"
17853                "    {7,  5,     \"!!\"   }\n"
17854                "};\n",
17855                Style);
17856   verifyFormat(
17857       "test demo[] = {\n"
17858       "    {7,  23,\n"
17859       "     \"hello world i am a very long line that really, in any\"\n"
17860       "     \"just world, ought to be split over multiple lines\"},\n"
17861       "    {-1, 93463, \"world\"                                 },\n"
17862       "    {56, 5,     \"!!\"                                    }\n"
17863       "};\n",
17864       Style);
17865 
17866   verifyFormat("return GradForUnaryCwise(g, {\n"
17867                "                                {{\"sign\"}, \"Sign\", {\"x\", "
17868                "\"dy\"}   },\n"
17869                "                                {{\"dx\"},   \"Mul\",  "
17870                "{\"dy\", \"sign\"}},\n"
17871                "});\n",
17872                Style);
17873 
17874   Style.ColumnLimit = 0;
17875   EXPECT_EQ(
17876       "test demo[] = {\n"
17877       "    {56, 23,    \"hello world i am a very long line that really, in any "
17878       "just world, ought to be split over multiple lines\"},\n"
17879       "    {-1, 93463, \"world\"                                               "
17880       "                                                   },\n"
17881       "    {7,  5,     \"!!\"                                                  "
17882       "                                                   },\n"
17883       "};",
17884       format("test demo[] = {{56, 23, \"hello world i am a very long line "
17885              "that really, in any just world, ought to be split over multiple "
17886              "lines\"},{-1, 93463, \"world\"},{7, 5, \"!!\"},};",
17887              Style));
17888 
17889   Style.ColumnLimit = 80;
17890   verifyFormat("test demo[] = {\n"
17891                "    {56, 23,    /* a comment */ \"hello\"},\n"
17892                "    {-1, 93463, \"world\"                },\n"
17893                "    {7,  5,     \"!!\"                   }\n"
17894                "};\n",
17895                Style);
17896 
17897   verifyFormat("test demo[] = {\n"
17898                "    {56, 23,    \"hello\"                   },\n"
17899                "    {-1, 93463, \"world\" /* comment here */},\n"
17900                "    {7,  5,     \"!!\"                      }\n"
17901                "};\n",
17902                Style);
17903 
17904   verifyFormat("test demo[] = {\n"
17905                "    {56, /* a comment */ 23, \"hello\"},\n"
17906                "    {-1, 93463,              \"world\"},\n"
17907                "    {7,  5,                  \"!!\"   }\n"
17908                "};\n",
17909                Style);
17910 
17911   Style.ColumnLimit = 20;
17912   EXPECT_EQ(
17913       "demo = std::array<\n"
17914       "    struct test, 3>{\n"
17915       "    test{\n"
17916       "         56, 23,\n"
17917       "         \"hello \"\n"
17918       "         \"world i \"\n"
17919       "         \"am a very \"\n"
17920       "         \"long line \"\n"
17921       "         \"that \"\n"
17922       "         \"really, \"\n"
17923       "         \"in any \"\n"
17924       "         \"just \"\n"
17925       "         \"world, \"\n"
17926       "         \"ought to \"\n"
17927       "         \"be split \"\n"
17928       "         \"over \"\n"
17929       "         \"multiple \"\n"
17930       "         \"lines\"},\n"
17931       "    test{-1, 93463,\n"
17932       "         \"world\"},\n"
17933       "    test{7,  5,\n"
17934       "         \"!!\"   },\n"
17935       "};",
17936       format("demo = std::array<struct test, 3>{test{56, 23, \"hello world "
17937              "i am a very long line that really, in any just world, ought "
17938              "to be split over multiple lines\"},test{-1, 93463, \"world\"},"
17939              "test{7, 5, \"!!\"},};",
17940              Style));
17941 
17942   // This caused a core dump by enabling Alignment in the LLVMStyle globally
17943   Style = getLLVMStyleWithColumns(50);
17944   Style.AlignArrayOfStructures = FormatStyle::AIAS_Left;
17945   verifyFormat("static A x = {\n"
17946                "    {{init1, init2, init3, init4},\n"
17947                "     {init1, init2, init3, init4}}\n"
17948                "};",
17949                Style);
17950   Style.ColumnLimit = 100;
17951   EXPECT_EQ(
17952       "test demo[] = {\n"
17953       "    {56, 23,\n"
17954       "     \"hello world i am a very long line that really, in any just world"
17955       ", ought to be split over \"\n"
17956       "     \"multiple lines\"  },\n"
17957       "    {-1, 93463, \"world\"},\n"
17958       "    {7,  5,     \"!!\"   },\n"
17959       "};",
17960       format("test demo[] = {{56, 23, \"hello world i am a very long line "
17961              "that really, in any just world, ought to be split over multiple "
17962              "lines\"},{-1, 93463, \"world\"},{7, 5, \"!!\"},};",
17963              Style));
17964 }
17965 
17966 TEST_F(FormatTest, UnderstandsPragmas) {
17967   verifyFormat("#pragma omp reduction(| : var)");
17968   verifyFormat("#pragma omp reduction(+ : var)");
17969 
17970   EXPECT_EQ("#pragma mark Any non-hyphenated or hyphenated string "
17971             "(including parentheses).",
17972             format("#pragma    mark   Any non-hyphenated or hyphenated string "
17973                    "(including parentheses)."));
17974 }
17975 
17976 TEST_F(FormatTest, UnderstandPragmaOption) {
17977   verifyFormat("#pragma option -C -A");
17978 
17979   EXPECT_EQ("#pragma option -C -A", format("#pragma    option   -C   -A"));
17980 }
17981 
17982 TEST_F(FormatTest, OptimizeBreakPenaltyVsExcess) {
17983   FormatStyle Style = getLLVMStyle();
17984   Style.ColumnLimit = 20;
17985 
17986   // See PR41213
17987   EXPECT_EQ("/*\n"
17988             " *\t9012345\n"
17989             " * /8901\n"
17990             " */",
17991             format("/*\n"
17992                    " *\t9012345 /8901\n"
17993                    " */",
17994                    Style));
17995   EXPECT_EQ("/*\n"
17996             " *345678\n"
17997             " *\t/8901\n"
17998             " */",
17999             format("/*\n"
18000                    " *345678\t/8901\n"
18001                    " */",
18002                    Style));
18003 
18004   verifyFormat("int a; // the\n"
18005                "       // comment",
18006                Style);
18007   EXPECT_EQ("int a; /* first line\n"
18008             "        * second\n"
18009             "        * line third\n"
18010             "        * line\n"
18011             "        */",
18012             format("int a; /* first line\n"
18013                    "        * second\n"
18014                    "        * line third\n"
18015                    "        * line\n"
18016                    "        */",
18017                    Style));
18018   EXPECT_EQ("int a; // first line\n"
18019             "       // second\n"
18020             "       // line third\n"
18021             "       // line",
18022             format("int a; // first line\n"
18023                    "       // second line\n"
18024                    "       // third line",
18025                    Style));
18026 
18027   Style.PenaltyExcessCharacter = 90;
18028   verifyFormat("int a; // the comment", Style);
18029   EXPECT_EQ("int a; // the comment\n"
18030             "       // aaa",
18031             format("int a; // the comment aaa", Style));
18032   EXPECT_EQ("int a; /* first line\n"
18033             "        * second line\n"
18034             "        * third line\n"
18035             "        */",
18036             format("int a; /* first line\n"
18037                    "        * second line\n"
18038                    "        * third line\n"
18039                    "        */",
18040                    Style));
18041   EXPECT_EQ("int a; // first line\n"
18042             "       // second line\n"
18043             "       // third line",
18044             format("int a; // first line\n"
18045                    "       // second line\n"
18046                    "       // third line",
18047                    Style));
18048   // FIXME: Investigate why this is not getting the same layout as the test
18049   // above.
18050   EXPECT_EQ("int a; /* first line\n"
18051             "        * second line\n"
18052             "        * third line\n"
18053             "        */",
18054             format("int a; /* first line second line third line"
18055                    "\n*/",
18056                    Style));
18057 
18058   EXPECT_EQ("// foo bar baz bazfoo\n"
18059             "// foo bar foo bar\n",
18060             format("// foo bar baz bazfoo\n"
18061                    "// foo bar foo           bar\n",
18062                    Style));
18063   EXPECT_EQ("// foo bar baz bazfoo\n"
18064             "// foo bar foo bar\n",
18065             format("// foo bar baz      bazfoo\n"
18066                    "// foo            bar foo bar\n",
18067                    Style));
18068 
18069   // FIXME: Optimally, we'd keep bazfoo on the first line and reflow bar to the
18070   // next one.
18071   EXPECT_EQ("// foo bar baz bazfoo\n"
18072             "// bar foo bar\n",
18073             format("// foo bar baz      bazfoo bar\n"
18074                    "// foo            bar\n",
18075                    Style));
18076 
18077   EXPECT_EQ("// foo bar baz bazfoo\n"
18078             "// foo bar baz bazfoo\n"
18079             "// bar foo bar\n",
18080             format("// foo bar baz      bazfoo\n"
18081                    "// foo bar baz      bazfoo bar\n"
18082                    "// foo bar\n",
18083                    Style));
18084 
18085   EXPECT_EQ("// foo bar baz bazfoo\n"
18086             "// foo bar baz bazfoo\n"
18087             "// bar foo bar\n",
18088             format("// foo bar baz      bazfoo\n"
18089                    "// foo bar baz      bazfoo bar\n"
18090                    "// foo           bar\n",
18091                    Style));
18092 
18093   // Make sure we do not keep protruding characters if strict mode reflow is
18094   // cheaper than keeping protruding characters.
18095   Style.ColumnLimit = 21;
18096   EXPECT_EQ(
18097       "// foo foo foo foo\n"
18098       "// foo foo foo foo\n"
18099       "// foo foo foo foo\n",
18100       format("// foo foo foo foo foo foo foo foo foo foo foo foo\n", Style));
18101 
18102   EXPECT_EQ("int a = /* long block\n"
18103             "           comment */\n"
18104             "    42;",
18105             format("int a = /* long block comment */ 42;", Style));
18106 }
18107 
18108 #define EXPECT_ALL_STYLES_EQUAL(Styles)                                        \
18109   for (size_t i = 1; i < Styles.size(); ++i)                                   \
18110   EXPECT_EQ(Styles[0], Styles[i])                                              \
18111       << "Style #" << i << " of " << Styles.size() << " differs from Style #0"
18112 
18113 TEST_F(FormatTest, GetsPredefinedStyleByName) {
18114   SmallVector<FormatStyle, 3> Styles;
18115   Styles.resize(3);
18116 
18117   Styles[0] = getLLVMStyle();
18118   EXPECT_TRUE(getPredefinedStyle("LLVM", FormatStyle::LK_Cpp, &Styles[1]));
18119   EXPECT_TRUE(getPredefinedStyle("lLvM", FormatStyle::LK_Cpp, &Styles[2]));
18120   EXPECT_ALL_STYLES_EQUAL(Styles);
18121 
18122   Styles[0] = getGoogleStyle();
18123   EXPECT_TRUE(getPredefinedStyle("Google", FormatStyle::LK_Cpp, &Styles[1]));
18124   EXPECT_TRUE(getPredefinedStyle("gOOgle", FormatStyle::LK_Cpp, &Styles[2]));
18125   EXPECT_ALL_STYLES_EQUAL(Styles);
18126 
18127   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
18128   EXPECT_TRUE(
18129       getPredefinedStyle("Google", FormatStyle::LK_JavaScript, &Styles[1]));
18130   EXPECT_TRUE(
18131       getPredefinedStyle("gOOgle", FormatStyle::LK_JavaScript, &Styles[2]));
18132   EXPECT_ALL_STYLES_EQUAL(Styles);
18133 
18134   Styles[0] = getChromiumStyle(FormatStyle::LK_Cpp);
18135   EXPECT_TRUE(getPredefinedStyle("Chromium", FormatStyle::LK_Cpp, &Styles[1]));
18136   EXPECT_TRUE(getPredefinedStyle("cHRoMiUM", FormatStyle::LK_Cpp, &Styles[2]));
18137   EXPECT_ALL_STYLES_EQUAL(Styles);
18138 
18139   Styles[0] = getMozillaStyle();
18140   EXPECT_TRUE(getPredefinedStyle("Mozilla", FormatStyle::LK_Cpp, &Styles[1]));
18141   EXPECT_TRUE(getPredefinedStyle("moZILla", FormatStyle::LK_Cpp, &Styles[2]));
18142   EXPECT_ALL_STYLES_EQUAL(Styles);
18143 
18144   Styles[0] = getWebKitStyle();
18145   EXPECT_TRUE(getPredefinedStyle("WebKit", FormatStyle::LK_Cpp, &Styles[1]));
18146   EXPECT_TRUE(getPredefinedStyle("wEbKit", FormatStyle::LK_Cpp, &Styles[2]));
18147   EXPECT_ALL_STYLES_EQUAL(Styles);
18148 
18149   Styles[0] = getGNUStyle();
18150   EXPECT_TRUE(getPredefinedStyle("GNU", FormatStyle::LK_Cpp, &Styles[1]));
18151   EXPECT_TRUE(getPredefinedStyle("gnU", FormatStyle::LK_Cpp, &Styles[2]));
18152   EXPECT_ALL_STYLES_EQUAL(Styles);
18153 
18154   EXPECT_FALSE(getPredefinedStyle("qwerty", FormatStyle::LK_Cpp, &Styles[0]));
18155 }
18156 
18157 TEST_F(FormatTest, GetsCorrectBasedOnStyle) {
18158   SmallVector<FormatStyle, 8> Styles;
18159   Styles.resize(2);
18160 
18161   Styles[0] = getGoogleStyle();
18162   Styles[1] = getLLVMStyle();
18163   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
18164   EXPECT_ALL_STYLES_EQUAL(Styles);
18165 
18166   Styles.resize(5);
18167   Styles[0] = getGoogleStyle(FormatStyle::LK_JavaScript);
18168   Styles[1] = getLLVMStyle();
18169   Styles[1].Language = FormatStyle::LK_JavaScript;
18170   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Styles[1]).value());
18171 
18172   Styles[2] = getLLVMStyle();
18173   Styles[2].Language = FormatStyle::LK_JavaScript;
18174   EXPECT_EQ(0, parseConfiguration("Language: JavaScript\n"
18175                                   "BasedOnStyle: Google",
18176                                   &Styles[2])
18177                    .value());
18178 
18179   Styles[3] = getLLVMStyle();
18180   Styles[3].Language = FormatStyle::LK_JavaScript;
18181   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google\n"
18182                                   "Language: JavaScript",
18183                                   &Styles[3])
18184                    .value());
18185 
18186   Styles[4] = getLLVMStyle();
18187   Styles[4].Language = FormatStyle::LK_JavaScript;
18188   EXPECT_EQ(0, parseConfiguration("---\n"
18189                                   "BasedOnStyle: LLVM\n"
18190                                   "IndentWidth: 123\n"
18191                                   "---\n"
18192                                   "BasedOnStyle: Google\n"
18193                                   "Language: JavaScript",
18194                                   &Styles[4])
18195                    .value());
18196   EXPECT_ALL_STYLES_EQUAL(Styles);
18197 }
18198 
18199 #define CHECK_PARSE_BOOL_FIELD(FIELD, CONFIG_NAME)                             \
18200   Style.FIELD = false;                                                         \
18201   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": true", &Style).value());      \
18202   EXPECT_TRUE(Style.FIELD);                                                    \
18203   EXPECT_EQ(0, parseConfiguration(CONFIG_NAME ": false", &Style).value());     \
18204   EXPECT_FALSE(Style.FIELD);
18205 
18206 #define CHECK_PARSE_BOOL(FIELD) CHECK_PARSE_BOOL_FIELD(FIELD, #FIELD)
18207 
18208 #define CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, CONFIG_NAME)              \
18209   Style.STRUCT.FIELD = false;                                                  \
18210   EXPECT_EQ(0,                                                                 \
18211             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": true", &Style)   \
18212                 .value());                                                     \
18213   EXPECT_TRUE(Style.STRUCT.FIELD);                                             \
18214   EXPECT_EQ(0,                                                                 \
18215             parseConfiguration(#STRUCT ":\n  " CONFIG_NAME ": false", &Style)  \
18216                 .value());                                                     \
18217   EXPECT_FALSE(Style.STRUCT.FIELD);
18218 
18219 #define CHECK_PARSE_NESTED_BOOL(STRUCT, FIELD)                                 \
18220   CHECK_PARSE_NESTED_BOOL_FIELD(STRUCT, FIELD, #FIELD)
18221 
18222 #define CHECK_PARSE(TEXT, FIELD, VALUE)                                        \
18223   EXPECT_NE(VALUE, Style.FIELD) << "Initial value already the same!";          \
18224   EXPECT_EQ(0, parseConfiguration(TEXT, &Style).value());                      \
18225   EXPECT_EQ(VALUE, Style.FIELD) << "Unexpected value after parsing!"
18226 
18227 TEST_F(FormatTest, ParsesConfigurationBools) {
18228   FormatStyle Style = {};
18229   Style.Language = FormatStyle::LK_Cpp;
18230   CHECK_PARSE_BOOL(AlignTrailingComments);
18231   CHECK_PARSE_BOOL(AllowAllArgumentsOnNextLine);
18232   CHECK_PARSE_BOOL(AllowAllParametersOfDeclarationOnNextLine);
18233   CHECK_PARSE_BOOL(AllowShortCaseLabelsOnASingleLine);
18234   CHECK_PARSE_BOOL(AllowShortEnumsOnASingleLine);
18235   CHECK_PARSE_BOOL(AllowShortLoopsOnASingleLine);
18236   CHECK_PARSE_BOOL(BinPackArguments);
18237   CHECK_PARSE_BOOL(BinPackParameters);
18238   CHECK_PARSE_BOOL(BreakAfterJavaFieldAnnotations);
18239   CHECK_PARSE_BOOL(BreakBeforeConceptDeclarations);
18240   CHECK_PARSE_BOOL(BreakBeforeTernaryOperators);
18241   CHECK_PARSE_BOOL(BreakStringLiterals);
18242   CHECK_PARSE_BOOL(CompactNamespaces);
18243   CHECK_PARSE_BOOL(DeriveLineEnding);
18244   CHECK_PARSE_BOOL(DerivePointerAlignment);
18245   CHECK_PARSE_BOOL_FIELD(DerivePointerAlignment, "DerivePointerBinding");
18246   CHECK_PARSE_BOOL(DisableFormat);
18247   CHECK_PARSE_BOOL(IndentAccessModifiers);
18248   CHECK_PARSE_BOOL(IndentCaseLabels);
18249   CHECK_PARSE_BOOL(IndentCaseBlocks);
18250   CHECK_PARSE_BOOL(IndentGotoLabels);
18251   CHECK_PARSE_BOOL(IndentRequires);
18252   CHECK_PARSE_BOOL(IndentWrappedFunctionNames);
18253   CHECK_PARSE_BOOL(KeepEmptyLinesAtTheStartOfBlocks);
18254   CHECK_PARSE_BOOL(ObjCSpaceAfterProperty);
18255   CHECK_PARSE_BOOL(ObjCSpaceBeforeProtocolList);
18256   CHECK_PARSE_BOOL(Cpp11BracedListStyle);
18257   CHECK_PARSE_BOOL(ReflowComments);
18258   CHECK_PARSE_BOOL(SortUsingDeclarations);
18259   CHECK_PARSE_BOOL(SpacesInParentheses);
18260   CHECK_PARSE_BOOL(SpacesInSquareBrackets);
18261   CHECK_PARSE_BOOL(SpacesInConditionalStatement);
18262   CHECK_PARSE_BOOL(SpaceInEmptyBlock);
18263   CHECK_PARSE_BOOL(SpaceInEmptyParentheses);
18264   CHECK_PARSE_BOOL(SpacesInContainerLiterals);
18265   CHECK_PARSE_BOOL(SpacesInCStyleCastParentheses);
18266   CHECK_PARSE_BOOL(SpaceAfterCStyleCast);
18267   CHECK_PARSE_BOOL(SpaceAfterTemplateKeyword);
18268   CHECK_PARSE_BOOL(SpaceAfterLogicalNot);
18269   CHECK_PARSE_BOOL(SpaceBeforeAssignmentOperators);
18270   CHECK_PARSE_BOOL(SpaceBeforeCaseColon);
18271   CHECK_PARSE_BOOL(SpaceBeforeCpp11BracedList);
18272   CHECK_PARSE_BOOL(SpaceBeforeCtorInitializerColon);
18273   CHECK_PARSE_BOOL(SpaceBeforeInheritanceColon);
18274   CHECK_PARSE_BOOL(SpaceBeforeRangeBasedForLoopColon);
18275   CHECK_PARSE_BOOL(SpaceBeforeSquareBrackets);
18276   CHECK_PARSE_BOOL(UseCRLF);
18277 
18278   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterCaseLabel);
18279   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterClass);
18280   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterEnum);
18281   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterFunction);
18282   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterNamespace);
18283   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterObjCDeclaration);
18284   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterStruct);
18285   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterUnion);
18286   CHECK_PARSE_NESTED_BOOL(BraceWrapping, AfterExternBlock);
18287   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeCatch);
18288   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeElse);
18289   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeLambdaBody);
18290   CHECK_PARSE_NESTED_BOOL(BraceWrapping, BeforeWhile);
18291   CHECK_PARSE_NESTED_BOOL(BraceWrapping, IndentBraces);
18292   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyFunction);
18293   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyRecord);
18294   CHECK_PARSE_NESTED_BOOL(BraceWrapping, SplitEmptyNamespace);
18295 }
18296 
18297 #undef CHECK_PARSE_BOOL
18298 
18299 TEST_F(FormatTest, ParsesConfiguration) {
18300   FormatStyle Style = {};
18301   Style.Language = FormatStyle::LK_Cpp;
18302   CHECK_PARSE("AccessModifierOffset: -1234", AccessModifierOffset, -1234);
18303   CHECK_PARSE("ConstructorInitializerIndentWidth: 1234",
18304               ConstructorInitializerIndentWidth, 1234u);
18305   CHECK_PARSE("ObjCBlockIndentWidth: 1234", ObjCBlockIndentWidth, 1234u);
18306   CHECK_PARSE("ColumnLimit: 1234", ColumnLimit, 1234u);
18307   CHECK_PARSE("MaxEmptyLinesToKeep: 1234", MaxEmptyLinesToKeep, 1234u);
18308   CHECK_PARSE("PenaltyBreakAssignment: 1234", PenaltyBreakAssignment, 1234u);
18309   CHECK_PARSE("PenaltyBreakBeforeFirstCallParameter: 1234",
18310               PenaltyBreakBeforeFirstCallParameter, 1234u);
18311   CHECK_PARSE("PenaltyBreakTemplateDeclaration: 1234",
18312               PenaltyBreakTemplateDeclaration, 1234u);
18313   CHECK_PARSE("PenaltyExcessCharacter: 1234", PenaltyExcessCharacter, 1234u);
18314   CHECK_PARSE("PenaltyReturnTypeOnItsOwnLine: 1234",
18315               PenaltyReturnTypeOnItsOwnLine, 1234u);
18316   CHECK_PARSE("SpacesBeforeTrailingComments: 1234",
18317               SpacesBeforeTrailingComments, 1234u);
18318   CHECK_PARSE("IndentWidth: 32", IndentWidth, 32u);
18319   CHECK_PARSE("ContinuationIndentWidth: 11", ContinuationIndentWidth, 11u);
18320   CHECK_PARSE("CommentPragmas: '// abc$'", CommentPragmas, "// abc$");
18321 
18322   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
18323   CHECK_PARSE("AlignConsecutiveAssignments: None", AlignConsecutiveAssignments,
18324               FormatStyle::ACS_None);
18325   CHECK_PARSE("AlignConsecutiveAssignments: Consecutive",
18326               AlignConsecutiveAssignments, FormatStyle::ACS_Consecutive);
18327   CHECK_PARSE("AlignConsecutiveAssignments: AcrossEmptyLines",
18328               AlignConsecutiveAssignments, FormatStyle::ACS_AcrossEmptyLines);
18329   CHECK_PARSE("AlignConsecutiveAssignments: AcrossEmptyLinesAndComments",
18330               AlignConsecutiveAssignments,
18331               FormatStyle::ACS_AcrossEmptyLinesAndComments);
18332   // For backwards compability, false / true should still parse
18333   CHECK_PARSE("AlignConsecutiveAssignments: false", AlignConsecutiveAssignments,
18334               FormatStyle::ACS_None);
18335   CHECK_PARSE("AlignConsecutiveAssignments: true", AlignConsecutiveAssignments,
18336               FormatStyle::ACS_Consecutive);
18337 
18338   Style.AlignConsecutiveBitFields = FormatStyle::ACS_Consecutive;
18339   CHECK_PARSE("AlignConsecutiveBitFields: None", AlignConsecutiveBitFields,
18340               FormatStyle::ACS_None);
18341   CHECK_PARSE("AlignConsecutiveBitFields: Consecutive",
18342               AlignConsecutiveBitFields, FormatStyle::ACS_Consecutive);
18343   CHECK_PARSE("AlignConsecutiveBitFields: AcrossEmptyLines",
18344               AlignConsecutiveBitFields, FormatStyle::ACS_AcrossEmptyLines);
18345   CHECK_PARSE("AlignConsecutiveBitFields: AcrossEmptyLinesAndComments",
18346               AlignConsecutiveBitFields,
18347               FormatStyle::ACS_AcrossEmptyLinesAndComments);
18348   // For backwards compability, false / true should still parse
18349   CHECK_PARSE("AlignConsecutiveBitFields: false", AlignConsecutiveBitFields,
18350               FormatStyle::ACS_None);
18351   CHECK_PARSE("AlignConsecutiveBitFields: true", AlignConsecutiveBitFields,
18352               FormatStyle::ACS_Consecutive);
18353 
18354   Style.AlignConsecutiveMacros = FormatStyle::ACS_Consecutive;
18355   CHECK_PARSE("AlignConsecutiveMacros: None", AlignConsecutiveMacros,
18356               FormatStyle::ACS_None);
18357   CHECK_PARSE("AlignConsecutiveMacros: Consecutive", AlignConsecutiveMacros,
18358               FormatStyle::ACS_Consecutive);
18359   CHECK_PARSE("AlignConsecutiveMacros: AcrossEmptyLines",
18360               AlignConsecutiveMacros, FormatStyle::ACS_AcrossEmptyLines);
18361   CHECK_PARSE("AlignConsecutiveMacros: AcrossEmptyLinesAndComments",
18362               AlignConsecutiveMacros,
18363               FormatStyle::ACS_AcrossEmptyLinesAndComments);
18364   // For backwards compability, false / true should still parse
18365   CHECK_PARSE("AlignConsecutiveMacros: false", AlignConsecutiveMacros,
18366               FormatStyle::ACS_None);
18367   CHECK_PARSE("AlignConsecutiveMacros: true", AlignConsecutiveMacros,
18368               FormatStyle::ACS_Consecutive);
18369 
18370   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
18371   CHECK_PARSE("AlignConsecutiveDeclarations: None",
18372               AlignConsecutiveDeclarations, FormatStyle::ACS_None);
18373   CHECK_PARSE("AlignConsecutiveDeclarations: Consecutive",
18374               AlignConsecutiveDeclarations, FormatStyle::ACS_Consecutive);
18375   CHECK_PARSE("AlignConsecutiveDeclarations: AcrossEmptyLines",
18376               AlignConsecutiveDeclarations, FormatStyle::ACS_AcrossEmptyLines);
18377   CHECK_PARSE("AlignConsecutiveDeclarations: AcrossEmptyLinesAndComments",
18378               AlignConsecutiveDeclarations,
18379               FormatStyle::ACS_AcrossEmptyLinesAndComments);
18380   // For backwards compability, false / true should still parse
18381   CHECK_PARSE("AlignConsecutiveDeclarations: false",
18382               AlignConsecutiveDeclarations, FormatStyle::ACS_None);
18383   CHECK_PARSE("AlignConsecutiveDeclarations: true",
18384               AlignConsecutiveDeclarations, FormatStyle::ACS_Consecutive);
18385 
18386   Style.PointerAlignment = FormatStyle::PAS_Middle;
18387   CHECK_PARSE("PointerAlignment: Left", PointerAlignment,
18388               FormatStyle::PAS_Left);
18389   CHECK_PARSE("PointerAlignment: Right", PointerAlignment,
18390               FormatStyle::PAS_Right);
18391   CHECK_PARSE("PointerAlignment: Middle", PointerAlignment,
18392               FormatStyle::PAS_Middle);
18393   Style.ReferenceAlignment = FormatStyle::RAS_Middle;
18394   CHECK_PARSE("ReferenceAlignment: Pointer", ReferenceAlignment,
18395               FormatStyle::RAS_Pointer);
18396   CHECK_PARSE("ReferenceAlignment: Left", ReferenceAlignment,
18397               FormatStyle::RAS_Left);
18398   CHECK_PARSE("ReferenceAlignment: Right", ReferenceAlignment,
18399               FormatStyle::RAS_Right);
18400   CHECK_PARSE("ReferenceAlignment: Middle", ReferenceAlignment,
18401               FormatStyle::RAS_Middle);
18402   // For backward compatibility:
18403   CHECK_PARSE("PointerBindsToType: Left", PointerAlignment,
18404               FormatStyle::PAS_Left);
18405   CHECK_PARSE("PointerBindsToType: Right", PointerAlignment,
18406               FormatStyle::PAS_Right);
18407   CHECK_PARSE("PointerBindsToType: Middle", PointerAlignment,
18408               FormatStyle::PAS_Middle);
18409 
18410   Style.Standard = FormatStyle::LS_Auto;
18411   CHECK_PARSE("Standard: c++03", Standard, FormatStyle::LS_Cpp03);
18412   CHECK_PARSE("Standard: c++11", Standard, FormatStyle::LS_Cpp11);
18413   CHECK_PARSE("Standard: c++14", Standard, FormatStyle::LS_Cpp14);
18414   CHECK_PARSE("Standard: c++17", Standard, FormatStyle::LS_Cpp17);
18415   CHECK_PARSE("Standard: c++20", Standard, FormatStyle::LS_Cpp20);
18416   CHECK_PARSE("Standard: Auto", Standard, FormatStyle::LS_Auto);
18417   CHECK_PARSE("Standard: Latest", Standard, FormatStyle::LS_Latest);
18418   // Legacy aliases:
18419   CHECK_PARSE("Standard: Cpp03", Standard, FormatStyle::LS_Cpp03);
18420   CHECK_PARSE("Standard: Cpp11", Standard, FormatStyle::LS_Latest);
18421   CHECK_PARSE("Standard: C++03", Standard, FormatStyle::LS_Cpp03);
18422   CHECK_PARSE("Standard: C++11", Standard, FormatStyle::LS_Cpp11);
18423 
18424   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
18425   CHECK_PARSE("BreakBeforeBinaryOperators: NonAssignment",
18426               BreakBeforeBinaryOperators, FormatStyle::BOS_NonAssignment);
18427   CHECK_PARSE("BreakBeforeBinaryOperators: None", BreakBeforeBinaryOperators,
18428               FormatStyle::BOS_None);
18429   CHECK_PARSE("BreakBeforeBinaryOperators: All", BreakBeforeBinaryOperators,
18430               FormatStyle::BOS_All);
18431   // For backward compatibility:
18432   CHECK_PARSE("BreakBeforeBinaryOperators: false", BreakBeforeBinaryOperators,
18433               FormatStyle::BOS_None);
18434   CHECK_PARSE("BreakBeforeBinaryOperators: true", BreakBeforeBinaryOperators,
18435               FormatStyle::BOS_All);
18436 
18437   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
18438   CHECK_PARSE("BreakConstructorInitializers: BeforeComma",
18439               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
18440   CHECK_PARSE("BreakConstructorInitializers: AfterColon",
18441               BreakConstructorInitializers, FormatStyle::BCIS_AfterColon);
18442   CHECK_PARSE("BreakConstructorInitializers: BeforeColon",
18443               BreakConstructorInitializers, FormatStyle::BCIS_BeforeColon);
18444   // For backward compatibility:
18445   CHECK_PARSE("BreakConstructorInitializersBeforeComma: true",
18446               BreakConstructorInitializers, FormatStyle::BCIS_BeforeComma);
18447 
18448   Style.BreakInheritanceList = FormatStyle::BILS_BeforeColon;
18449   CHECK_PARSE("BreakInheritanceList: AfterComma", BreakInheritanceList,
18450               FormatStyle::BILS_AfterComma);
18451   CHECK_PARSE("BreakInheritanceList: BeforeComma", BreakInheritanceList,
18452               FormatStyle::BILS_BeforeComma);
18453   CHECK_PARSE("BreakInheritanceList: AfterColon", BreakInheritanceList,
18454               FormatStyle::BILS_AfterColon);
18455   CHECK_PARSE("BreakInheritanceList: BeforeColon", BreakInheritanceList,
18456               FormatStyle::BILS_BeforeColon);
18457   // For backward compatibility:
18458   CHECK_PARSE("BreakBeforeInheritanceComma: true", BreakInheritanceList,
18459               FormatStyle::BILS_BeforeComma);
18460 
18461   Style.PackConstructorInitializers = FormatStyle::PCIS_BinPack;
18462   CHECK_PARSE("PackConstructorInitializers: Never", PackConstructorInitializers,
18463               FormatStyle::PCIS_Never);
18464   CHECK_PARSE("PackConstructorInitializers: BinPack",
18465               PackConstructorInitializers, FormatStyle::PCIS_BinPack);
18466   CHECK_PARSE("PackConstructorInitializers: CurrentLine",
18467               PackConstructorInitializers, FormatStyle::PCIS_CurrentLine);
18468   CHECK_PARSE("PackConstructorInitializers: NextLine",
18469               PackConstructorInitializers, FormatStyle::PCIS_NextLine);
18470 
18471   Style.EmptyLineBeforeAccessModifier = FormatStyle::ELBAMS_LogicalBlock;
18472   CHECK_PARSE("EmptyLineBeforeAccessModifier: Never",
18473               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Never);
18474   CHECK_PARSE("EmptyLineBeforeAccessModifier: Leave",
18475               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Leave);
18476   CHECK_PARSE("EmptyLineBeforeAccessModifier: LogicalBlock",
18477               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_LogicalBlock);
18478   CHECK_PARSE("EmptyLineBeforeAccessModifier: Always",
18479               EmptyLineBeforeAccessModifier, FormatStyle::ELBAMS_Always);
18480 
18481   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
18482   CHECK_PARSE("AlignAfterOpenBracket: Align", AlignAfterOpenBracket,
18483               FormatStyle::BAS_Align);
18484   CHECK_PARSE("AlignAfterOpenBracket: DontAlign", AlignAfterOpenBracket,
18485               FormatStyle::BAS_DontAlign);
18486   CHECK_PARSE("AlignAfterOpenBracket: AlwaysBreak", AlignAfterOpenBracket,
18487               FormatStyle::BAS_AlwaysBreak);
18488   // For backward compatibility:
18489   CHECK_PARSE("AlignAfterOpenBracket: false", AlignAfterOpenBracket,
18490               FormatStyle::BAS_DontAlign);
18491   CHECK_PARSE("AlignAfterOpenBracket: true", AlignAfterOpenBracket,
18492               FormatStyle::BAS_Align);
18493 
18494   Style.AlignEscapedNewlines = FormatStyle::ENAS_Left;
18495   CHECK_PARSE("AlignEscapedNewlines: DontAlign", AlignEscapedNewlines,
18496               FormatStyle::ENAS_DontAlign);
18497   CHECK_PARSE("AlignEscapedNewlines: Left", AlignEscapedNewlines,
18498               FormatStyle::ENAS_Left);
18499   CHECK_PARSE("AlignEscapedNewlines: Right", AlignEscapedNewlines,
18500               FormatStyle::ENAS_Right);
18501   // For backward compatibility:
18502   CHECK_PARSE("AlignEscapedNewlinesLeft: true", AlignEscapedNewlines,
18503               FormatStyle::ENAS_Left);
18504   CHECK_PARSE("AlignEscapedNewlinesLeft: false", AlignEscapedNewlines,
18505               FormatStyle::ENAS_Right);
18506 
18507   Style.AlignOperands = FormatStyle::OAS_Align;
18508   CHECK_PARSE("AlignOperands: DontAlign", AlignOperands,
18509               FormatStyle::OAS_DontAlign);
18510   CHECK_PARSE("AlignOperands: Align", AlignOperands, FormatStyle::OAS_Align);
18511   CHECK_PARSE("AlignOperands: AlignAfterOperator", AlignOperands,
18512               FormatStyle::OAS_AlignAfterOperator);
18513   // For backward compatibility:
18514   CHECK_PARSE("AlignOperands: false", AlignOperands,
18515               FormatStyle::OAS_DontAlign);
18516   CHECK_PARSE("AlignOperands: true", AlignOperands, FormatStyle::OAS_Align);
18517 
18518   Style.UseTab = FormatStyle::UT_ForIndentation;
18519   CHECK_PARSE("UseTab: Never", UseTab, FormatStyle::UT_Never);
18520   CHECK_PARSE("UseTab: ForIndentation", UseTab, FormatStyle::UT_ForIndentation);
18521   CHECK_PARSE("UseTab: Always", UseTab, FormatStyle::UT_Always);
18522   CHECK_PARSE("UseTab: ForContinuationAndIndentation", UseTab,
18523               FormatStyle::UT_ForContinuationAndIndentation);
18524   CHECK_PARSE("UseTab: AlignWithSpaces", UseTab,
18525               FormatStyle::UT_AlignWithSpaces);
18526   // For backward compatibility:
18527   CHECK_PARSE("UseTab: false", UseTab, FormatStyle::UT_Never);
18528   CHECK_PARSE("UseTab: true", UseTab, FormatStyle::UT_Always);
18529 
18530   Style.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Empty;
18531   CHECK_PARSE("AllowShortBlocksOnASingleLine: Never",
18532               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
18533   CHECK_PARSE("AllowShortBlocksOnASingleLine: Empty",
18534               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Empty);
18535   CHECK_PARSE("AllowShortBlocksOnASingleLine: Always",
18536               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
18537   // For backward compatibility:
18538   CHECK_PARSE("AllowShortBlocksOnASingleLine: false",
18539               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Never);
18540   CHECK_PARSE("AllowShortBlocksOnASingleLine: true",
18541               AllowShortBlocksOnASingleLine, FormatStyle::SBS_Always);
18542 
18543   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
18544   CHECK_PARSE("AllowShortFunctionsOnASingleLine: None",
18545               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
18546   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Inline",
18547               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Inline);
18548   CHECK_PARSE("AllowShortFunctionsOnASingleLine: Empty",
18549               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_Empty);
18550   CHECK_PARSE("AllowShortFunctionsOnASingleLine: All",
18551               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
18552   // For backward compatibility:
18553   CHECK_PARSE("AllowShortFunctionsOnASingleLine: false",
18554               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_None);
18555   CHECK_PARSE("AllowShortFunctionsOnASingleLine: true",
18556               AllowShortFunctionsOnASingleLine, FormatStyle::SFS_All);
18557 
18558   Style.SpaceAroundPointerQualifiers = FormatStyle::SAPQ_Both;
18559   CHECK_PARSE("SpaceAroundPointerQualifiers: Default",
18560               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Default);
18561   CHECK_PARSE("SpaceAroundPointerQualifiers: Before",
18562               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Before);
18563   CHECK_PARSE("SpaceAroundPointerQualifiers: After",
18564               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_After);
18565   CHECK_PARSE("SpaceAroundPointerQualifiers: Both",
18566               SpaceAroundPointerQualifiers, FormatStyle::SAPQ_Both);
18567 
18568   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
18569   CHECK_PARSE("SpaceBeforeParens: Never", SpaceBeforeParens,
18570               FormatStyle::SBPO_Never);
18571   CHECK_PARSE("SpaceBeforeParens: Always", SpaceBeforeParens,
18572               FormatStyle::SBPO_Always);
18573   CHECK_PARSE("SpaceBeforeParens: ControlStatements", SpaceBeforeParens,
18574               FormatStyle::SBPO_ControlStatements);
18575   CHECK_PARSE("SpaceBeforeParens: ControlStatementsExceptControlMacros",
18576               SpaceBeforeParens,
18577               FormatStyle::SBPO_ControlStatementsExceptControlMacros);
18578   CHECK_PARSE("SpaceBeforeParens: NonEmptyParentheses", SpaceBeforeParens,
18579               FormatStyle::SBPO_NonEmptyParentheses);
18580   // For backward compatibility:
18581   CHECK_PARSE("SpaceAfterControlStatementKeyword: false", SpaceBeforeParens,
18582               FormatStyle::SBPO_Never);
18583   CHECK_PARSE("SpaceAfterControlStatementKeyword: true", SpaceBeforeParens,
18584               FormatStyle::SBPO_ControlStatements);
18585   CHECK_PARSE("SpaceBeforeParens: ControlStatementsExceptForEachMacros",
18586               SpaceBeforeParens,
18587               FormatStyle::SBPO_ControlStatementsExceptControlMacros);
18588 
18589   Style.ColumnLimit = 123;
18590   FormatStyle BaseStyle = getLLVMStyle();
18591   CHECK_PARSE("BasedOnStyle: LLVM", ColumnLimit, BaseStyle.ColumnLimit);
18592   CHECK_PARSE("BasedOnStyle: LLVM\nColumnLimit: 1234", ColumnLimit, 1234u);
18593 
18594   Style.BreakBeforeBraces = FormatStyle::BS_Stroustrup;
18595   CHECK_PARSE("BreakBeforeBraces: Attach", BreakBeforeBraces,
18596               FormatStyle::BS_Attach);
18597   CHECK_PARSE("BreakBeforeBraces: Linux", BreakBeforeBraces,
18598               FormatStyle::BS_Linux);
18599   CHECK_PARSE("BreakBeforeBraces: Mozilla", BreakBeforeBraces,
18600               FormatStyle::BS_Mozilla);
18601   CHECK_PARSE("BreakBeforeBraces: Stroustrup", BreakBeforeBraces,
18602               FormatStyle::BS_Stroustrup);
18603   CHECK_PARSE("BreakBeforeBraces: Allman", BreakBeforeBraces,
18604               FormatStyle::BS_Allman);
18605   CHECK_PARSE("BreakBeforeBraces: Whitesmiths", BreakBeforeBraces,
18606               FormatStyle::BS_Whitesmiths);
18607   CHECK_PARSE("BreakBeforeBraces: GNU", BreakBeforeBraces, FormatStyle::BS_GNU);
18608   CHECK_PARSE("BreakBeforeBraces: WebKit", BreakBeforeBraces,
18609               FormatStyle::BS_WebKit);
18610   CHECK_PARSE("BreakBeforeBraces: Custom", BreakBeforeBraces,
18611               FormatStyle::BS_Custom);
18612 
18613   Style.BraceWrapping.AfterControlStatement = FormatStyle::BWACS_Never;
18614   CHECK_PARSE("BraceWrapping:\n"
18615               "  AfterControlStatement: MultiLine",
18616               BraceWrapping.AfterControlStatement,
18617               FormatStyle::BWACS_MultiLine);
18618   CHECK_PARSE("BraceWrapping:\n"
18619               "  AfterControlStatement: Always",
18620               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
18621   CHECK_PARSE("BraceWrapping:\n"
18622               "  AfterControlStatement: Never",
18623               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
18624   // For backward compatibility:
18625   CHECK_PARSE("BraceWrapping:\n"
18626               "  AfterControlStatement: true",
18627               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Always);
18628   CHECK_PARSE("BraceWrapping:\n"
18629               "  AfterControlStatement: false",
18630               BraceWrapping.AfterControlStatement, FormatStyle::BWACS_Never);
18631 
18632   Style.AlwaysBreakAfterReturnType = FormatStyle::RTBS_All;
18633   CHECK_PARSE("AlwaysBreakAfterReturnType: None", AlwaysBreakAfterReturnType,
18634               FormatStyle::RTBS_None);
18635   CHECK_PARSE("AlwaysBreakAfterReturnType: All", AlwaysBreakAfterReturnType,
18636               FormatStyle::RTBS_All);
18637   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevel",
18638               AlwaysBreakAfterReturnType, FormatStyle::RTBS_TopLevel);
18639   CHECK_PARSE("AlwaysBreakAfterReturnType: AllDefinitions",
18640               AlwaysBreakAfterReturnType, FormatStyle::RTBS_AllDefinitions);
18641   CHECK_PARSE("AlwaysBreakAfterReturnType: TopLevelDefinitions",
18642               AlwaysBreakAfterReturnType,
18643               FormatStyle::RTBS_TopLevelDefinitions);
18644 
18645   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
18646   CHECK_PARSE("AlwaysBreakTemplateDeclarations: No",
18647               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_No);
18648   CHECK_PARSE("AlwaysBreakTemplateDeclarations: MultiLine",
18649               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
18650   CHECK_PARSE("AlwaysBreakTemplateDeclarations: Yes",
18651               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
18652   CHECK_PARSE("AlwaysBreakTemplateDeclarations: false",
18653               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_MultiLine);
18654   CHECK_PARSE("AlwaysBreakTemplateDeclarations: true",
18655               AlwaysBreakTemplateDeclarations, FormatStyle::BTDS_Yes);
18656 
18657   Style.AlwaysBreakAfterDefinitionReturnType = FormatStyle::DRTBS_All;
18658   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: None",
18659               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_None);
18660   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: All",
18661               AlwaysBreakAfterDefinitionReturnType, FormatStyle::DRTBS_All);
18662   CHECK_PARSE("AlwaysBreakAfterDefinitionReturnType: TopLevel",
18663               AlwaysBreakAfterDefinitionReturnType,
18664               FormatStyle::DRTBS_TopLevel);
18665 
18666   Style.NamespaceIndentation = FormatStyle::NI_All;
18667   CHECK_PARSE("NamespaceIndentation: None", NamespaceIndentation,
18668               FormatStyle::NI_None);
18669   CHECK_PARSE("NamespaceIndentation: Inner", NamespaceIndentation,
18670               FormatStyle::NI_Inner);
18671   CHECK_PARSE("NamespaceIndentation: All", NamespaceIndentation,
18672               FormatStyle::NI_All);
18673 
18674   Style.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_OnlyFirstIf;
18675   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Never",
18676               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
18677   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: WithoutElse",
18678               AllowShortIfStatementsOnASingleLine,
18679               FormatStyle::SIS_WithoutElse);
18680   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: OnlyFirstIf",
18681               AllowShortIfStatementsOnASingleLine,
18682               FormatStyle::SIS_OnlyFirstIf);
18683   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: AllIfsAndElse",
18684               AllowShortIfStatementsOnASingleLine,
18685               FormatStyle::SIS_AllIfsAndElse);
18686   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: Always",
18687               AllowShortIfStatementsOnASingleLine,
18688               FormatStyle::SIS_OnlyFirstIf);
18689   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: false",
18690               AllowShortIfStatementsOnASingleLine, FormatStyle::SIS_Never);
18691   CHECK_PARSE("AllowShortIfStatementsOnASingleLine: true",
18692               AllowShortIfStatementsOnASingleLine,
18693               FormatStyle::SIS_WithoutElse);
18694 
18695   Style.IndentExternBlock = FormatStyle::IEBS_NoIndent;
18696   CHECK_PARSE("IndentExternBlock: AfterExternBlock", IndentExternBlock,
18697               FormatStyle::IEBS_AfterExternBlock);
18698   CHECK_PARSE("IndentExternBlock: Indent", IndentExternBlock,
18699               FormatStyle::IEBS_Indent);
18700   CHECK_PARSE("IndentExternBlock: NoIndent", IndentExternBlock,
18701               FormatStyle::IEBS_NoIndent);
18702   CHECK_PARSE("IndentExternBlock: true", IndentExternBlock,
18703               FormatStyle::IEBS_Indent);
18704   CHECK_PARSE("IndentExternBlock: false", IndentExternBlock,
18705               FormatStyle::IEBS_NoIndent);
18706 
18707   Style.BitFieldColonSpacing = FormatStyle::BFCS_None;
18708   CHECK_PARSE("BitFieldColonSpacing: Both", BitFieldColonSpacing,
18709               FormatStyle::BFCS_Both);
18710   CHECK_PARSE("BitFieldColonSpacing: None", BitFieldColonSpacing,
18711               FormatStyle::BFCS_None);
18712   CHECK_PARSE("BitFieldColonSpacing: Before", BitFieldColonSpacing,
18713               FormatStyle::BFCS_Before);
18714   CHECK_PARSE("BitFieldColonSpacing: After", BitFieldColonSpacing,
18715               FormatStyle::BFCS_After);
18716 
18717   Style.SortJavaStaticImport = FormatStyle::SJSIO_Before;
18718   CHECK_PARSE("SortJavaStaticImport: After", SortJavaStaticImport,
18719               FormatStyle::SJSIO_After);
18720   CHECK_PARSE("SortJavaStaticImport: Before", SortJavaStaticImport,
18721               FormatStyle::SJSIO_Before);
18722 
18723   // FIXME: This is required because parsing a configuration simply overwrites
18724   // the first N elements of the list instead of resetting it.
18725   Style.ForEachMacros.clear();
18726   std::vector<std::string> BoostForeach;
18727   BoostForeach.push_back("BOOST_FOREACH");
18728   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH]", ForEachMacros, BoostForeach);
18729   std::vector<std::string> BoostAndQForeach;
18730   BoostAndQForeach.push_back("BOOST_FOREACH");
18731   BoostAndQForeach.push_back("Q_FOREACH");
18732   CHECK_PARSE("ForEachMacros: [BOOST_FOREACH, Q_FOREACH]", ForEachMacros,
18733               BoostAndQForeach);
18734 
18735   Style.IfMacros.clear();
18736   std::vector<std::string> CustomIfs;
18737   CustomIfs.push_back("MYIF");
18738   CHECK_PARSE("IfMacros: [MYIF]", IfMacros, CustomIfs);
18739 
18740   Style.AttributeMacros.clear();
18741   CHECK_PARSE("BasedOnStyle: LLVM", AttributeMacros,
18742               std::vector<std::string>{"__capability"});
18743   CHECK_PARSE("AttributeMacros: [attr1, attr2]", AttributeMacros,
18744               std::vector<std::string>({"attr1", "attr2"}));
18745 
18746   Style.StatementAttributeLikeMacros.clear();
18747   CHECK_PARSE("StatementAttributeLikeMacros: [emit,Q_EMIT]",
18748               StatementAttributeLikeMacros,
18749               std::vector<std::string>({"emit", "Q_EMIT"}));
18750 
18751   Style.StatementMacros.clear();
18752   CHECK_PARSE("StatementMacros: [QUNUSED]", StatementMacros,
18753               std::vector<std::string>{"QUNUSED"});
18754   CHECK_PARSE("StatementMacros: [QUNUSED, QT_REQUIRE_VERSION]", StatementMacros,
18755               std::vector<std::string>({"QUNUSED", "QT_REQUIRE_VERSION"}));
18756 
18757   Style.NamespaceMacros.clear();
18758   CHECK_PARSE("NamespaceMacros: [TESTSUITE]", NamespaceMacros,
18759               std::vector<std::string>{"TESTSUITE"});
18760   CHECK_PARSE("NamespaceMacros: [TESTSUITE, SUITE]", NamespaceMacros,
18761               std::vector<std::string>({"TESTSUITE", "SUITE"}));
18762 
18763   Style.WhitespaceSensitiveMacros.clear();
18764   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE]",
18765               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
18766   CHECK_PARSE("WhitespaceSensitiveMacros: [STRINGIZE, ASSERT]",
18767               WhitespaceSensitiveMacros,
18768               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
18769   Style.WhitespaceSensitiveMacros.clear();
18770   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE']",
18771               WhitespaceSensitiveMacros, std::vector<std::string>{"STRINGIZE"});
18772   CHECK_PARSE("WhitespaceSensitiveMacros: ['STRINGIZE', 'ASSERT']",
18773               WhitespaceSensitiveMacros,
18774               std::vector<std::string>({"STRINGIZE", "ASSERT"}));
18775 
18776   Style.IncludeStyle.IncludeCategories.clear();
18777   std::vector<tooling::IncludeStyle::IncludeCategory> ExpectedCategories = {
18778       {"abc/.*", 2, 0, false}, {".*", 1, 0, true}};
18779   CHECK_PARSE("IncludeCategories:\n"
18780               "  - Regex: abc/.*\n"
18781               "    Priority: 2\n"
18782               "  - Regex: .*\n"
18783               "    Priority: 1\n"
18784               "    CaseSensitive: true\n",
18785               IncludeStyle.IncludeCategories, ExpectedCategories);
18786   CHECK_PARSE("IncludeIsMainRegex: 'abc$'", IncludeStyle.IncludeIsMainRegex,
18787               "abc$");
18788   CHECK_PARSE("IncludeIsMainSourceRegex: 'abc$'",
18789               IncludeStyle.IncludeIsMainSourceRegex, "abc$");
18790 
18791   Style.SortIncludes = FormatStyle::SI_Never;
18792   CHECK_PARSE("SortIncludes: true", SortIncludes,
18793               FormatStyle::SI_CaseSensitive);
18794   CHECK_PARSE("SortIncludes: false", SortIncludes, FormatStyle::SI_Never);
18795   CHECK_PARSE("SortIncludes: CaseInsensitive", SortIncludes,
18796               FormatStyle::SI_CaseInsensitive);
18797   CHECK_PARSE("SortIncludes: CaseSensitive", SortIncludes,
18798               FormatStyle::SI_CaseSensitive);
18799   CHECK_PARSE("SortIncludes: Never", SortIncludes, FormatStyle::SI_Never);
18800 
18801   Style.RawStringFormats.clear();
18802   std::vector<FormatStyle::RawStringFormat> ExpectedRawStringFormats = {
18803       {
18804           FormatStyle::LK_TextProto,
18805           {"pb", "proto"},
18806           {"PARSE_TEXT_PROTO"},
18807           /*CanonicalDelimiter=*/"",
18808           "llvm",
18809       },
18810       {
18811           FormatStyle::LK_Cpp,
18812           {"cc", "cpp"},
18813           {"C_CODEBLOCK", "CPPEVAL"},
18814           /*CanonicalDelimiter=*/"cc",
18815           /*BasedOnStyle=*/"",
18816       },
18817   };
18818 
18819   CHECK_PARSE("RawStringFormats:\n"
18820               "  - Language: TextProto\n"
18821               "    Delimiters:\n"
18822               "      - 'pb'\n"
18823               "      - 'proto'\n"
18824               "    EnclosingFunctions:\n"
18825               "      - 'PARSE_TEXT_PROTO'\n"
18826               "    BasedOnStyle: llvm\n"
18827               "  - Language: Cpp\n"
18828               "    Delimiters:\n"
18829               "      - 'cc'\n"
18830               "      - 'cpp'\n"
18831               "    EnclosingFunctions:\n"
18832               "      - 'C_CODEBLOCK'\n"
18833               "      - 'CPPEVAL'\n"
18834               "    CanonicalDelimiter: 'cc'",
18835               RawStringFormats, ExpectedRawStringFormats);
18836 
18837   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
18838               "  Minimum: 0\n"
18839               "  Maximum: 0",
18840               SpacesInLineCommentPrefix.Minimum, 0u);
18841   EXPECT_EQ(Style.SpacesInLineCommentPrefix.Maximum, 0u);
18842   Style.SpacesInLineCommentPrefix.Minimum = 1;
18843   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
18844               "  Minimum: 2",
18845               SpacesInLineCommentPrefix.Minimum, 0u);
18846   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
18847               "  Maximum: -1",
18848               SpacesInLineCommentPrefix.Maximum, -1u);
18849   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
18850               "  Minimum: 2",
18851               SpacesInLineCommentPrefix.Minimum, 2u);
18852   CHECK_PARSE("SpacesInLineCommentPrefix:\n"
18853               "  Maximum: 1",
18854               SpacesInLineCommentPrefix.Maximum, 1u);
18855   EXPECT_EQ(Style.SpacesInLineCommentPrefix.Minimum, 1u);
18856 
18857   Style.SpacesInAngles = FormatStyle::SIAS_Always;
18858   CHECK_PARSE("SpacesInAngles: Never", SpacesInAngles, FormatStyle::SIAS_Never);
18859   CHECK_PARSE("SpacesInAngles: Always", SpacesInAngles,
18860               FormatStyle::SIAS_Always);
18861   CHECK_PARSE("SpacesInAngles: Leave", SpacesInAngles, FormatStyle::SIAS_Leave);
18862   // For backward compatibility:
18863   CHECK_PARSE("SpacesInAngles: false", SpacesInAngles, FormatStyle::SIAS_Never);
18864   CHECK_PARSE("SpacesInAngles: true", SpacesInAngles, FormatStyle::SIAS_Always);
18865 }
18866 
18867 TEST_F(FormatTest, ParsesConfigurationWithLanguages) {
18868   FormatStyle Style = {};
18869   Style.Language = FormatStyle::LK_Cpp;
18870   CHECK_PARSE("Language: Cpp\n"
18871               "IndentWidth: 12",
18872               IndentWidth, 12u);
18873   EXPECT_EQ(parseConfiguration("Language: JavaScript\n"
18874                                "IndentWidth: 34",
18875                                &Style),
18876             ParseError::Unsuitable);
18877   FormatStyle BinPackedTCS = {};
18878   BinPackedTCS.Language = FormatStyle::LK_JavaScript;
18879   EXPECT_EQ(parseConfiguration("BinPackArguments: true\n"
18880                                "InsertTrailingCommas: Wrapped",
18881                                &BinPackedTCS),
18882             ParseError::BinPackTrailingCommaConflict);
18883   EXPECT_EQ(12u, Style.IndentWidth);
18884   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
18885   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
18886 
18887   Style.Language = FormatStyle::LK_JavaScript;
18888   CHECK_PARSE("Language: JavaScript\n"
18889               "IndentWidth: 12",
18890               IndentWidth, 12u);
18891   CHECK_PARSE("IndentWidth: 23", IndentWidth, 23u);
18892   EXPECT_EQ(parseConfiguration("Language: Cpp\n"
18893                                "IndentWidth: 34",
18894                                &Style),
18895             ParseError::Unsuitable);
18896   EXPECT_EQ(23u, Style.IndentWidth);
18897   CHECK_PARSE("IndentWidth: 56", IndentWidth, 56u);
18898   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
18899 
18900   CHECK_PARSE("BasedOnStyle: LLVM\n"
18901               "IndentWidth: 67",
18902               IndentWidth, 67u);
18903 
18904   CHECK_PARSE("---\n"
18905               "Language: JavaScript\n"
18906               "IndentWidth: 12\n"
18907               "---\n"
18908               "Language: Cpp\n"
18909               "IndentWidth: 34\n"
18910               "...\n",
18911               IndentWidth, 12u);
18912 
18913   Style.Language = FormatStyle::LK_Cpp;
18914   CHECK_PARSE("---\n"
18915               "Language: JavaScript\n"
18916               "IndentWidth: 12\n"
18917               "---\n"
18918               "Language: Cpp\n"
18919               "IndentWidth: 34\n"
18920               "...\n",
18921               IndentWidth, 34u);
18922   CHECK_PARSE("---\n"
18923               "IndentWidth: 78\n"
18924               "---\n"
18925               "Language: JavaScript\n"
18926               "IndentWidth: 56\n"
18927               "...\n",
18928               IndentWidth, 78u);
18929 
18930   Style.ColumnLimit = 123;
18931   Style.IndentWidth = 234;
18932   Style.BreakBeforeBraces = FormatStyle::BS_Linux;
18933   Style.TabWidth = 345;
18934   EXPECT_FALSE(parseConfiguration("---\n"
18935                                   "IndentWidth: 456\n"
18936                                   "BreakBeforeBraces: Allman\n"
18937                                   "---\n"
18938                                   "Language: JavaScript\n"
18939                                   "IndentWidth: 111\n"
18940                                   "TabWidth: 111\n"
18941                                   "---\n"
18942                                   "Language: Cpp\n"
18943                                   "BreakBeforeBraces: Stroustrup\n"
18944                                   "TabWidth: 789\n"
18945                                   "...\n",
18946                                   &Style));
18947   EXPECT_EQ(123u, Style.ColumnLimit);
18948   EXPECT_EQ(456u, Style.IndentWidth);
18949   EXPECT_EQ(FormatStyle::BS_Stroustrup, Style.BreakBeforeBraces);
18950   EXPECT_EQ(789u, Style.TabWidth);
18951 
18952   EXPECT_EQ(parseConfiguration("---\n"
18953                                "Language: JavaScript\n"
18954                                "IndentWidth: 56\n"
18955                                "---\n"
18956                                "IndentWidth: 78\n"
18957                                "...\n",
18958                                &Style),
18959             ParseError::Error);
18960   EXPECT_EQ(parseConfiguration("---\n"
18961                                "Language: JavaScript\n"
18962                                "IndentWidth: 56\n"
18963                                "---\n"
18964                                "Language: JavaScript\n"
18965                                "IndentWidth: 78\n"
18966                                "...\n",
18967                                &Style),
18968             ParseError::Error);
18969 
18970   EXPECT_EQ(FormatStyle::LK_Cpp, Style.Language);
18971 }
18972 
18973 #undef CHECK_PARSE
18974 
18975 TEST_F(FormatTest, UsesLanguageForBasedOnStyle) {
18976   FormatStyle Style = {};
18977   Style.Language = FormatStyle::LK_JavaScript;
18978   Style.BreakBeforeTernaryOperators = true;
18979   EXPECT_EQ(0, parseConfiguration("BasedOnStyle: Google", &Style).value());
18980   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
18981 
18982   Style.BreakBeforeTernaryOperators = true;
18983   EXPECT_EQ(0, parseConfiguration("---\n"
18984                                   "BasedOnStyle: Google\n"
18985                                   "---\n"
18986                                   "Language: JavaScript\n"
18987                                   "IndentWidth: 76\n"
18988                                   "...\n",
18989                                   &Style)
18990                    .value());
18991   EXPECT_FALSE(Style.BreakBeforeTernaryOperators);
18992   EXPECT_EQ(76u, Style.IndentWidth);
18993   EXPECT_EQ(FormatStyle::LK_JavaScript, Style.Language);
18994 }
18995 
18996 TEST_F(FormatTest, ConfigurationRoundTripTest) {
18997   FormatStyle Style = getLLVMStyle();
18998   std::string YAML = configurationAsText(Style);
18999   FormatStyle ParsedStyle = {};
19000   ParsedStyle.Language = FormatStyle::LK_Cpp;
19001   EXPECT_EQ(0, parseConfiguration(YAML, &ParsedStyle).value());
19002   EXPECT_EQ(Style, ParsedStyle);
19003 }
19004 
19005 TEST_F(FormatTest, WorksFor8bitEncodings) {
19006   EXPECT_EQ("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 \"\n"
19007             "\"\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \"\n"
19008             "\"\xe7\xe8\xec\xed\xfe\xfe \"\n"
19009             "\"\xef\xee\xf0\xf3...\"",
19010             format("\"\xce\xe4\xed\xe0\xe6\xe4\xfb \xe2 "
19011                    "\xf1\xf2\xf3\xe4\xb8\xed\xf3\xfe \xe7\xe8\xec\xed\xfe\xfe "
19012                    "\xef\xee\xf0\xf3...\"",
19013                    getLLVMStyleWithColumns(12)));
19014 }
19015 
19016 TEST_F(FormatTest, HandlesUTF8BOM) {
19017   EXPECT_EQ("\xef\xbb\xbf", format("\xef\xbb\xbf"));
19018   EXPECT_EQ("\xef\xbb\xbf#include <iostream>",
19019             format("\xef\xbb\xbf#include <iostream>"));
19020   EXPECT_EQ("\xef\xbb\xbf\n#include <iostream>",
19021             format("\xef\xbb\xbf\n#include <iostream>"));
19022 }
19023 
19024 // FIXME: Encode Cyrillic and CJK characters below to appease MS compilers.
19025 #if !defined(_MSC_VER)
19026 
19027 TEST_F(FormatTest, CountsUTF8CharactersProperly) {
19028   verifyFormat("\"Однажды в студёную зимнюю пору...\"",
19029                getLLVMStyleWithColumns(35));
19030   verifyFormat("\"一 二 三 四 五 六 七 八 九 十\"",
19031                getLLVMStyleWithColumns(31));
19032   verifyFormat("// Однажды в студёную зимнюю пору...",
19033                getLLVMStyleWithColumns(36));
19034   verifyFormat("// 一 二 三 四 五 六 七 八 九 十", getLLVMStyleWithColumns(32));
19035   verifyFormat("/* Однажды в студёную зимнюю пору... */",
19036                getLLVMStyleWithColumns(39));
19037   verifyFormat("/* 一 二 三 四 五 六 七 八 九 十 */",
19038                getLLVMStyleWithColumns(35));
19039 }
19040 
19041 TEST_F(FormatTest, SplitsUTF8Strings) {
19042   // Non-printable characters' width is currently considered to be the length in
19043   // bytes in UTF8. The characters can be displayed in very different manner
19044   // (zero-width, single width with a substitution glyph, expanded to their code
19045   // (e.g. "<8d>"), so there's no single correct way to handle them.
19046   EXPECT_EQ("\"aaaaÄ\"\n"
19047             "\"\xc2\x8d\";",
19048             format("\"aaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
19049   EXPECT_EQ("\"aaaaaaaÄ\"\n"
19050             "\"\xc2\x8d\";",
19051             format("\"aaaaaaaÄ\xc2\x8d\";", getLLVMStyleWithColumns(10)));
19052   EXPECT_EQ("\"Однажды, в \"\n"
19053             "\"студёную \"\n"
19054             "\"зимнюю \"\n"
19055             "\"пору,\"",
19056             format("\"Однажды, в студёную зимнюю пору,\"",
19057                    getLLVMStyleWithColumns(13)));
19058   EXPECT_EQ(
19059       "\"一 二 三 \"\n"
19060       "\"四 五六 \"\n"
19061       "\"七 八 九 \"\n"
19062       "\"十\"",
19063       format("\"一 二 三 四 五六 七 八 九 十\"", getLLVMStyleWithColumns(11)));
19064   EXPECT_EQ("\"一\t\"\n"
19065             "\"二 \t\"\n"
19066             "\"三 四 \"\n"
19067             "\"五\t\"\n"
19068             "\"六 \t\"\n"
19069             "\"七 \"\n"
19070             "\"八九十\tqq\"",
19071             format("\"一\t二 \t三 四 五\t六 \t七 八九十\tqq\"",
19072                    getLLVMStyleWithColumns(11)));
19073 
19074   // UTF8 character in an escape sequence.
19075   EXPECT_EQ("\"aaaaaa\"\n"
19076             "\"\\\xC2\x8D\"",
19077             format("\"aaaaaa\\\xC2\x8D\"", getLLVMStyleWithColumns(10)));
19078 }
19079 
19080 TEST_F(FormatTest, HandlesDoubleWidthCharsInMultiLineStrings) {
19081   EXPECT_EQ("const char *sssss =\n"
19082             "    \"一二三四五六七八\\\n"
19083             " 九 十\";",
19084             format("const char *sssss = \"一二三四五六七八\\\n"
19085                    " 九 十\";",
19086                    getLLVMStyleWithColumns(30)));
19087 }
19088 
19089 TEST_F(FormatTest, SplitsUTF8LineComments) {
19090   EXPECT_EQ("// aaaaÄ\xc2\x8d",
19091             format("// aaaaÄ\xc2\x8d", getLLVMStyleWithColumns(10)));
19092   EXPECT_EQ("// Я из лесу\n"
19093             "// вышел; был\n"
19094             "// сильный\n"
19095             "// мороз.",
19096             format("// Я из лесу вышел; был сильный мороз.",
19097                    getLLVMStyleWithColumns(13)));
19098   EXPECT_EQ("// 一二三\n"
19099             "// 四五六七\n"
19100             "// 八  九\n"
19101             "// 十",
19102             format("// 一二三 四五六七 八  九 十", getLLVMStyleWithColumns(9)));
19103 }
19104 
19105 TEST_F(FormatTest, SplitsUTF8BlockComments) {
19106   EXPECT_EQ("/* Гляжу,\n"
19107             " * поднимается\n"
19108             " * медленно в\n"
19109             " * гору\n"
19110             " * Лошадка,\n"
19111             " * везущая\n"
19112             " * хворосту\n"
19113             " * воз. */",
19114             format("/* Гляжу, поднимается медленно в гору\n"
19115                    " * Лошадка, везущая хворосту воз. */",
19116                    getLLVMStyleWithColumns(13)));
19117   EXPECT_EQ(
19118       "/* 一二三\n"
19119       " * 四五六七\n"
19120       " * 八  九\n"
19121       " * 十  */",
19122       format("/* 一二三 四五六七 八  九 十  */", getLLVMStyleWithColumns(9)));
19123   EXPECT_EQ("/* �������� ��������\n"
19124             " * ��������\n"
19125             " * ������-�� */",
19126             format("/* �������� �������� �������� ������-�� */", getLLVMStyleWithColumns(12)));
19127 }
19128 
19129 #endif // _MSC_VER
19130 
19131 TEST_F(FormatTest, ConstructorInitializerIndentWidth) {
19132   FormatStyle Style = getLLVMStyle();
19133 
19134   Style.ConstructorInitializerIndentWidth = 4;
19135   verifyFormat(
19136       "SomeClass::Constructor()\n"
19137       "    : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
19138       "      aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
19139       Style);
19140 
19141   Style.ConstructorInitializerIndentWidth = 2;
19142   verifyFormat(
19143       "SomeClass::Constructor()\n"
19144       "  : aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
19145       "    aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
19146       Style);
19147 
19148   Style.ConstructorInitializerIndentWidth = 0;
19149   verifyFormat(
19150       "SomeClass::Constructor()\n"
19151       ": aaaaaaaaaaaaa(aaaaaaaaaaaaaa), aaaaaaaaaaaaa(aaaaaaaaaaaaaa),\n"
19152       "  aaaaaaaaaaaaa(aaaaaaaaaaaaaa) {}",
19153       Style);
19154   Style.AlignAfterOpenBracket = FormatStyle::BAS_AlwaysBreak;
19155   verifyFormat(
19156       "SomeLongTemplateVariableName<\n"
19157       "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa>",
19158       Style);
19159   verifyFormat("bool smaller = 1 < "
19160                "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb(\n"
19161                "                       "
19162                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);",
19163                Style);
19164 
19165   Style.BreakConstructorInitializers = FormatStyle::BCIS_AfterColon;
19166   verifyFormat("SomeClass::Constructor() :\n"
19167                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa),\n"
19168                "aaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaa) {}",
19169                Style);
19170 }
19171 
19172 TEST_F(FormatTest, BreakConstructorInitializersBeforeComma) {
19173   FormatStyle Style = getLLVMStyle();
19174   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeComma;
19175   Style.ConstructorInitializerIndentWidth = 4;
19176   verifyFormat("SomeClass::Constructor()\n"
19177                "    : a(a)\n"
19178                "    , b(b)\n"
19179                "    , c(c) {}",
19180                Style);
19181   verifyFormat("SomeClass::Constructor()\n"
19182                "    : a(a) {}",
19183                Style);
19184 
19185   Style.ColumnLimit = 0;
19186   verifyFormat("SomeClass::Constructor()\n"
19187                "    : a(a) {}",
19188                Style);
19189   verifyFormat("SomeClass::Constructor() noexcept\n"
19190                "    : a(a) {}",
19191                Style);
19192   verifyFormat("SomeClass::Constructor()\n"
19193                "    : a(a)\n"
19194                "    , b(b)\n"
19195                "    , c(c) {}",
19196                Style);
19197   verifyFormat("SomeClass::Constructor()\n"
19198                "    : a(a) {\n"
19199                "  foo();\n"
19200                "  bar();\n"
19201                "}",
19202                Style);
19203 
19204   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
19205   verifyFormat("SomeClass::Constructor()\n"
19206                "    : a(a)\n"
19207                "    , b(b)\n"
19208                "    , c(c) {\n}",
19209                Style);
19210   verifyFormat("SomeClass::Constructor()\n"
19211                "    : a(a) {\n}",
19212                Style);
19213 
19214   Style.ColumnLimit = 80;
19215   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
19216   Style.ConstructorInitializerIndentWidth = 2;
19217   verifyFormat("SomeClass::Constructor()\n"
19218                "  : a(a)\n"
19219                "  , b(b)\n"
19220                "  , c(c) {}",
19221                Style);
19222 
19223   Style.ConstructorInitializerIndentWidth = 0;
19224   verifyFormat("SomeClass::Constructor()\n"
19225                ": a(a)\n"
19226                ", b(b)\n"
19227                ", c(c) {}",
19228                Style);
19229 
19230   Style.PackConstructorInitializers = FormatStyle::PCIS_NextLine;
19231   Style.ConstructorInitializerIndentWidth = 4;
19232   verifyFormat("SomeClass::Constructor() : aaaaaaaa(aaaaaaaa) {}", Style);
19233   verifyFormat(
19234       "SomeClass::Constructor() : aaaaa(aaaaa), aaaaa(aaaaa), aaaaa(aaaaa)\n",
19235       Style);
19236   verifyFormat(
19237       "SomeClass::Constructor()\n"
19238       "    : aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa), aaaaaaaa(aaaaaaaa) {}",
19239       Style);
19240   Style.ConstructorInitializerIndentWidth = 4;
19241   Style.ColumnLimit = 60;
19242   verifyFormat("SomeClass::Constructor()\n"
19243                "    : aaaaaaaa(aaaaaaaa)\n"
19244                "    , aaaaaaaa(aaaaaaaa)\n"
19245                "    , aaaaaaaa(aaaaaaaa) {}",
19246                Style);
19247 }
19248 
19249 TEST_F(FormatTest, Destructors) {
19250   verifyFormat("void F(int &i) { i.~int(); }");
19251   verifyFormat("void F(int &i) { i->~int(); }");
19252 }
19253 
19254 TEST_F(FormatTest, FormatsWithWebKitStyle) {
19255   FormatStyle Style = getWebKitStyle();
19256 
19257   // Don't indent in outer namespaces.
19258   verifyFormat("namespace outer {\n"
19259                "int i;\n"
19260                "namespace inner {\n"
19261                "    int i;\n"
19262                "} // namespace inner\n"
19263                "} // namespace outer\n"
19264                "namespace other_outer {\n"
19265                "int i;\n"
19266                "}",
19267                Style);
19268 
19269   // Don't indent case labels.
19270   verifyFormat("switch (variable) {\n"
19271                "case 1:\n"
19272                "case 2:\n"
19273                "    doSomething();\n"
19274                "    break;\n"
19275                "default:\n"
19276                "    ++variable;\n"
19277                "}",
19278                Style);
19279 
19280   // Wrap before binary operators.
19281   EXPECT_EQ("void f()\n"
19282             "{\n"
19283             "    if (aaaaaaaaaaaaaaaa\n"
19284             "        && bbbbbbbbbbbbbbbbbbbbbbbb\n"
19285             "        && (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
19286             "        return;\n"
19287             "}",
19288             format("void f() {\n"
19289                    "if (aaaaaaaaaaaaaaaa\n"
19290                    "&& bbbbbbbbbbbbbbbbbbbbbbbb\n"
19291                    "&& (cccccccccccccccccccccccccc || dddddddddddddddddddd))\n"
19292                    "return;\n"
19293                    "}",
19294                    Style));
19295 
19296   // Allow functions on a single line.
19297   verifyFormat("void f() { return; }", Style);
19298 
19299   // Allow empty blocks on a single line and insert a space in empty blocks.
19300   EXPECT_EQ("void f() { }", format("void f() {}", Style));
19301   EXPECT_EQ("while (true) { }", format("while (true) {}", Style));
19302   // However, don't merge non-empty short loops.
19303   EXPECT_EQ("while (true) {\n"
19304             "    continue;\n"
19305             "}",
19306             format("while (true) { continue; }", Style));
19307 
19308   // Constructor initializers are formatted one per line with the "," on the
19309   // new line.
19310   verifyFormat("Constructor()\n"
19311                "    : aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
19312                "    , aaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaa, // break\n"
19313                "          aaaaaaaaaaaaaa)\n"
19314                "    , aaaaaaaaaaaaaaaaaaaaaaa()\n"
19315                "{\n"
19316                "}",
19317                Style);
19318   verifyFormat("SomeClass::Constructor()\n"
19319                "    : a(a)\n"
19320                "{\n"
19321                "}",
19322                Style);
19323   EXPECT_EQ("SomeClass::Constructor()\n"
19324             "    : a(a)\n"
19325             "{\n"
19326             "}",
19327             format("SomeClass::Constructor():a(a){}", Style));
19328   verifyFormat("SomeClass::Constructor()\n"
19329                "    : a(a)\n"
19330                "    , b(b)\n"
19331                "    , c(c)\n"
19332                "{\n"
19333                "}",
19334                Style);
19335   verifyFormat("SomeClass::Constructor()\n"
19336                "    : a(a)\n"
19337                "{\n"
19338                "    foo();\n"
19339                "    bar();\n"
19340                "}",
19341                Style);
19342 
19343   // Access specifiers should be aligned left.
19344   verifyFormat("class C {\n"
19345                "public:\n"
19346                "    int i;\n"
19347                "};",
19348                Style);
19349 
19350   // Do not align comments.
19351   verifyFormat("int a; // Do not\n"
19352                "double b; // align comments.",
19353                Style);
19354 
19355   // Do not align operands.
19356   EXPECT_EQ("ASSERT(aaaa\n"
19357             "    || bbbb);",
19358             format("ASSERT ( aaaa\n||bbbb);", Style));
19359 
19360   // Accept input's line breaks.
19361   EXPECT_EQ("if (aaaaaaaaaaaaaaa\n"
19362             "    || bbbbbbbbbbbbbbb) {\n"
19363             "    i++;\n"
19364             "}",
19365             format("if (aaaaaaaaaaaaaaa\n"
19366                    "|| bbbbbbbbbbbbbbb) { i++; }",
19367                    Style));
19368   EXPECT_EQ("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) {\n"
19369             "    i++;\n"
19370             "}",
19371             format("if (aaaaaaaaaaaaaaa || bbbbbbbbbbbbbbb) { i++; }", Style));
19372 
19373   // Don't automatically break all macro definitions (llvm.org/PR17842).
19374   verifyFormat("#define aNumber 10", Style);
19375   // However, generally keep the line breaks that the user authored.
19376   EXPECT_EQ("#define aNumber \\\n"
19377             "    10",
19378             format("#define aNumber \\\n"
19379                    " 10",
19380                    Style));
19381 
19382   // Keep empty and one-element array literals on a single line.
19383   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[]\n"
19384             "                                  copyItems:YES];",
19385             format("NSArray*a=[[NSArray alloc] initWithArray:@[]\n"
19386                    "copyItems:YES];",
19387                    Style));
19388   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\" ]\n"
19389             "                                  copyItems:YES];",
19390             format("NSArray*a=[[NSArray alloc]initWithArray:@[ @\"a\" ]\n"
19391                    "             copyItems:YES];",
19392                    Style));
19393   // FIXME: This does not seem right, there should be more indentation before
19394   // the array literal's entries. Nested blocks have the same problem.
19395   EXPECT_EQ("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
19396             "    @\"a\",\n"
19397             "    @\"a\"\n"
19398             "]\n"
19399             "                                  copyItems:YES];",
19400             format("NSArray* a = [[NSArray alloc] initWithArray:@[\n"
19401                    "     @\"a\",\n"
19402                    "     @\"a\"\n"
19403                    "     ]\n"
19404                    "       copyItems:YES];",
19405                    Style));
19406   EXPECT_EQ(
19407       "NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
19408       "                                  copyItems:YES];",
19409       format("NSArray* a = [[NSArray alloc] initWithArray:@[ @\"a\", @\"a\" ]\n"
19410              "   copyItems:YES];",
19411              Style));
19412 
19413   verifyFormat("[self.a b:c c:d];", Style);
19414   EXPECT_EQ("[self.a b:c\n"
19415             "        c:d];",
19416             format("[self.a b:c\n"
19417                    "c:d];",
19418                    Style));
19419 }
19420 
19421 TEST_F(FormatTest, FormatsLambdas) {
19422   verifyFormat("int c = [b]() mutable { return [&b] { return b++; }(); }();\n");
19423   verifyFormat(
19424       "int c = [b]() mutable noexcept { return [&b] { return b++; }(); }();\n");
19425   verifyFormat("int c = [&] { [=] { return b++; }(); }();\n");
19426   verifyFormat("int c = [&, &a, a] { [=, c, &d] { return b++; }(); }();\n");
19427   verifyFormat("int c = [&a, &a, a] { [=, a, b, &c] { return b++; }(); }();\n");
19428   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] { return b++; }(); }}\n");
19429   verifyFormat("auto c = {[&a, &a, a] { [=, a, b, &c] {}(); }}\n");
19430   verifyFormat("auto c = [a = [b = 42] {}] {};\n");
19431   verifyFormat("auto c = [a = &i + 10, b = [] {}] {};\n");
19432   verifyFormat("int x = f(*+[] {});");
19433   verifyFormat("void f() {\n"
19434                "  other(x.begin(), x.end(), [&](int, int) { return 1; });\n"
19435                "}\n");
19436   verifyFormat("void f() {\n"
19437                "  other(x.begin(), //\n"
19438                "        x.end(),   //\n"
19439                "        [&](int, int) { return 1; });\n"
19440                "}\n");
19441   verifyFormat("void f() {\n"
19442                "  other.other.other.other.other(\n"
19443                "      x.begin(), x.end(),\n"
19444                "      [something, rather](int, int, int, int, int, int, int) { "
19445                "return 1; });\n"
19446                "}\n");
19447   verifyFormat(
19448       "void f() {\n"
19449       "  other.other.other.other.other(\n"
19450       "      x.begin(), x.end(),\n"
19451       "      [something, rather](int, int, int, int, int, int, int) {\n"
19452       "        //\n"
19453       "      });\n"
19454       "}\n");
19455   verifyFormat("SomeFunction([]() { // A cool function...\n"
19456                "  return 43;\n"
19457                "});");
19458   EXPECT_EQ("SomeFunction([]() {\n"
19459             "#define A a\n"
19460             "  return 43;\n"
19461             "});",
19462             format("SomeFunction([](){\n"
19463                    "#define A a\n"
19464                    "return 43;\n"
19465                    "});"));
19466   verifyFormat("void f() {\n"
19467                "  SomeFunction([](decltype(x), A *a) {});\n"
19468                "  SomeFunction([](typeof(x), A *a) {});\n"
19469                "  SomeFunction([](_Atomic(x), A *a) {});\n"
19470                "  SomeFunction([](__underlying_type(x), A *a) {});\n"
19471                "}");
19472   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
19473                "    [](const aaaaaaaaaa &a) { return a; });");
19474   verifyFormat("string abc = SomeFunction(aaaaaaaaaaaaa, aaaaa, []() {\n"
19475                "  SomeOtherFunctioooooooooooooooooooooooooon();\n"
19476                "});");
19477   verifyFormat("Constructor()\n"
19478                "    : Field([] { // comment\n"
19479                "        int i;\n"
19480                "      }) {}");
19481   verifyFormat("auto my_lambda = [](const string &some_parameter) {\n"
19482                "  return some_parameter.size();\n"
19483                "};");
19484   verifyFormat("std::function<std::string(const std::string &)> my_lambda =\n"
19485                "    [](const string &s) { return s; };");
19486   verifyFormat("int i = aaaaaa ? 1 //\n"
19487                "               : [] {\n"
19488                "                   return 2; //\n"
19489                "                 }();");
19490   verifyFormat("llvm::errs() << \"number of twos is \"\n"
19491                "             << std::count_if(v.begin(), v.end(), [](int x) {\n"
19492                "                  return x == 2; // force break\n"
19493                "                });");
19494   verifyFormat("return aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
19495                "    [=](int iiiiiiiiiiii) {\n"
19496                "      return aaaaaaaaaaaaaaaaaaaaaaa !=\n"
19497                "             aaaaaaaaaaaaaaaaaaaaaaa;\n"
19498                "    });",
19499                getLLVMStyleWithColumns(60));
19500 
19501   verifyFormat("SomeFunction({[&] {\n"
19502                "                // comment\n"
19503                "              },\n"
19504                "              [&] {\n"
19505                "                // comment\n"
19506                "              }});");
19507   verifyFormat("SomeFunction({[&] {\n"
19508                "  // comment\n"
19509                "}});");
19510   verifyFormat(
19511       "virtual aaaaaaaaaaaaaaaa(\n"
19512       "    std::function<bool()> bbbbbbbbbbbb = [&]() { return true; },\n"
19513       "    aaaaa aaaaaaaaa);");
19514 
19515   // Lambdas with return types.
19516   verifyFormat("int c = []() -> int { return 2; }();\n");
19517   verifyFormat("int c = []() -> int * { return 2; }();\n");
19518   verifyFormat("int c = []() -> vector<int> { return {2}; }();\n");
19519   verifyFormat("Foo([]() -> std::vector<int> { return {2}; }());");
19520   verifyGoogleFormat("auto a = [&b, c](D* d) -> D* {};");
19521   verifyGoogleFormat("auto a = [&b, c](D* d) -> pair<D*, D*> {};");
19522   verifyGoogleFormat("auto a = [&b, c](D* d) -> D& {};");
19523   verifyGoogleFormat("auto a = [&b, c](D* d) -> const D* {};");
19524   verifyFormat("[a, a]() -> a<1> {};");
19525   verifyFormat("[]() -> foo<5 + 2> { return {}; };");
19526   verifyFormat("[]() -> foo<5 - 2> { return {}; };");
19527   verifyFormat("[]() -> foo<5 / 2> { return {}; };");
19528   verifyFormat("[]() -> foo<5 * 2> { return {}; };");
19529   verifyFormat("[]() -> foo<5 % 2> { return {}; };");
19530   verifyFormat("[]() -> foo<5 << 2> { return {}; };");
19531   verifyFormat("[]() -> foo<!5> { return {}; };");
19532   verifyFormat("[]() -> foo<~5> { return {}; };");
19533   verifyFormat("[]() -> foo<5 | 2> { return {}; };");
19534   verifyFormat("[]() -> foo<5 || 2> { return {}; };");
19535   verifyFormat("[]() -> foo<5 & 2> { return {}; };");
19536   verifyFormat("[]() -> foo<5 && 2> { return {}; };");
19537   verifyFormat("[]() -> foo<5 == 2> { return {}; };");
19538   verifyFormat("[]() -> foo<5 != 2> { return {}; };");
19539   verifyFormat("[]() -> foo<5 >= 2> { return {}; };");
19540   verifyFormat("[]() -> foo<5 <= 2> { return {}; };");
19541   verifyFormat("[]() -> foo<5 < 2> { return {}; };");
19542   verifyFormat("[]() -> foo<2 ? 1 : 0> { return {}; };");
19543   verifyFormat("namespace bar {\n"
19544                "// broken:\n"
19545                "auto foo{[]() -> foo<5 + 2> { return {}; }};\n"
19546                "} // namespace bar");
19547   verifyFormat("namespace bar {\n"
19548                "// broken:\n"
19549                "auto foo{[]() -> foo<5 - 2> { return {}; }};\n"
19550                "} // namespace bar");
19551   verifyFormat("namespace bar {\n"
19552                "// broken:\n"
19553                "auto foo{[]() -> foo<5 / 2> { return {}; }};\n"
19554                "} // namespace bar");
19555   verifyFormat("namespace bar {\n"
19556                "// broken:\n"
19557                "auto foo{[]() -> foo<5 * 2> { return {}; }};\n"
19558                "} // namespace bar");
19559   verifyFormat("namespace bar {\n"
19560                "// broken:\n"
19561                "auto foo{[]() -> foo<5 % 2> { return {}; }};\n"
19562                "} // namespace bar");
19563   verifyFormat("namespace bar {\n"
19564                "// broken:\n"
19565                "auto foo{[]() -> foo<5 << 2> { return {}; }};\n"
19566                "} // namespace bar");
19567   verifyFormat("namespace bar {\n"
19568                "// broken:\n"
19569                "auto foo{[]() -> foo<!5> { return {}; }};\n"
19570                "} // namespace bar");
19571   verifyFormat("namespace bar {\n"
19572                "// broken:\n"
19573                "auto foo{[]() -> foo<~5> { return {}; }};\n"
19574                "} // namespace bar");
19575   verifyFormat("namespace bar {\n"
19576                "// broken:\n"
19577                "auto foo{[]() -> foo<5 | 2> { return {}; }};\n"
19578                "} // namespace bar");
19579   verifyFormat("namespace bar {\n"
19580                "// broken:\n"
19581                "auto foo{[]() -> foo<5 || 2> { return {}; }};\n"
19582                "} // namespace bar");
19583   verifyFormat("namespace bar {\n"
19584                "// broken:\n"
19585                "auto foo{[]() -> foo<5 & 2> { return {}; }};\n"
19586                "} // namespace bar");
19587   verifyFormat("namespace bar {\n"
19588                "// broken:\n"
19589                "auto foo{[]() -> foo<5 && 2> { return {}; }};\n"
19590                "} // namespace bar");
19591   verifyFormat("namespace bar {\n"
19592                "// broken:\n"
19593                "auto foo{[]() -> foo<5 == 2> { return {}; }};\n"
19594                "} // namespace bar");
19595   verifyFormat("namespace bar {\n"
19596                "// broken:\n"
19597                "auto foo{[]() -> foo<5 != 2> { return {}; }};\n"
19598                "} // namespace bar");
19599   verifyFormat("namespace bar {\n"
19600                "// broken:\n"
19601                "auto foo{[]() -> foo<5 >= 2> { return {}; }};\n"
19602                "} // namespace bar");
19603   verifyFormat("namespace bar {\n"
19604                "// broken:\n"
19605                "auto foo{[]() -> foo<5 <= 2> { return {}; }};\n"
19606                "} // namespace bar");
19607   verifyFormat("namespace bar {\n"
19608                "// broken:\n"
19609                "auto foo{[]() -> foo<5 < 2> { return {}; }};\n"
19610                "} // namespace bar");
19611   verifyFormat("namespace bar {\n"
19612                "// broken:\n"
19613                "auto foo{[]() -> foo<2 ? 1 : 0> { return {}; }};\n"
19614                "} // namespace bar");
19615   verifyFormat("[]() -> a<1> {};");
19616   verifyFormat("[]() -> a<1> { ; };");
19617   verifyFormat("[]() -> a<1> { ; }();");
19618   verifyFormat("[a, a]() -> a<true> {};");
19619   verifyFormat("[]() -> a<true> {};");
19620   verifyFormat("[]() -> a<true> { ; };");
19621   verifyFormat("[]() -> a<true> { ; }();");
19622   verifyFormat("[a, a]() -> a<false> {};");
19623   verifyFormat("[]() -> a<false> {};");
19624   verifyFormat("[]() -> a<false> { ; };");
19625   verifyFormat("[]() -> a<false> { ; }();");
19626   verifyFormat("auto foo{[]() -> foo<false> { ; }};");
19627   verifyFormat("namespace bar {\n"
19628                "auto foo{[]() -> foo<false> { ; }};\n"
19629                "} // namespace bar");
19630   verifyFormat("auto aaaaaaaa = [](int i, // break for some reason\n"
19631                "                   int j) -> int {\n"
19632                "  return ffffffffffffffffffffffffffffffffffffffffffff(i * j);\n"
19633                "};");
19634   verifyFormat(
19635       "aaaaaaaaaaaaaaaaaaaaaa(\n"
19636       "    [](aaaaaaaaaaaaaaaaaaaaaaaaaaa &aaa) -> aaaaaaaaaaaaaaaa {\n"
19637       "      return aaaaaaaaaaaaaaaaa;\n"
19638       "    });",
19639       getLLVMStyleWithColumns(70));
19640   verifyFormat("[]() //\n"
19641                "    -> int {\n"
19642                "  return 1; //\n"
19643                "};");
19644   verifyFormat("[]() -> Void<T...> {};");
19645   verifyFormat("[a, b]() -> Tuple<T...> { return {}; };");
19646 
19647   // Lambdas with explicit template argument lists.
19648   verifyFormat(
19649       "auto L = []<template <typename> class T, class U>(T<U> &&a) {};\n");
19650 
19651   // Multiple lambdas in the same parentheses change indentation rules. These
19652   // lambdas are forced to start on new lines.
19653   verifyFormat("SomeFunction(\n"
19654                "    []() {\n"
19655                "      //\n"
19656                "    },\n"
19657                "    []() {\n"
19658                "      //\n"
19659                "    });");
19660 
19661   // A lambda passed as arg0 is always pushed to the next line.
19662   verifyFormat("SomeFunction(\n"
19663                "    [this] {\n"
19664                "      //\n"
19665                "    },\n"
19666                "    1);\n");
19667 
19668   // A multi-line lambda passed as arg1 forces arg0 to be pushed out, just like
19669   // the arg0 case above.
19670   auto Style = getGoogleStyle();
19671   Style.BinPackArguments = false;
19672   verifyFormat("SomeFunction(\n"
19673                "    a,\n"
19674                "    [this] {\n"
19675                "      //\n"
19676                "    },\n"
19677                "    b);\n",
19678                Style);
19679   verifyFormat("SomeFunction(\n"
19680                "    a,\n"
19681                "    [this] {\n"
19682                "      //\n"
19683                "    },\n"
19684                "    b);\n");
19685 
19686   // A lambda with a very long line forces arg0 to be pushed out irrespective of
19687   // the BinPackArguments value (as long as the code is wide enough).
19688   verifyFormat(
19689       "something->SomeFunction(\n"
19690       "    a,\n"
19691       "    [this] {\n"
19692       "      "
19693       "D0000000000000000000000000000000000000000000000000000000000001();\n"
19694       "    },\n"
19695       "    b);\n");
19696 
19697   // A multi-line lambda is pulled up as long as the introducer fits on the
19698   // previous line and there are no further args.
19699   verifyFormat("function(1, [this, that] {\n"
19700                "  //\n"
19701                "});\n");
19702   verifyFormat("function([this, that] {\n"
19703                "  //\n"
19704                "});\n");
19705   // FIXME: this format is not ideal and we should consider forcing the first
19706   // arg onto its own line.
19707   verifyFormat("function(a, b, c, //\n"
19708                "         d, [this, that] {\n"
19709                "           //\n"
19710                "         });\n");
19711 
19712   // Multiple lambdas are treated correctly even when there is a short arg0.
19713   verifyFormat("SomeFunction(\n"
19714                "    1,\n"
19715                "    [this] {\n"
19716                "      //\n"
19717                "    },\n"
19718                "    [this] {\n"
19719                "      //\n"
19720                "    },\n"
19721                "    1);\n");
19722 
19723   // More complex introducers.
19724   verifyFormat("return [i, args...] {};");
19725 
19726   // Not lambdas.
19727   verifyFormat("constexpr char hello[]{\"hello\"};");
19728   verifyFormat("double &operator[](int i) { return 0; }\n"
19729                "int i;");
19730   verifyFormat("std::unique_ptr<int[]> foo() {}");
19731   verifyFormat("int i = a[a][a]->f();");
19732   verifyFormat("int i = (*b)[a]->f();");
19733 
19734   // Other corner cases.
19735   verifyFormat("void f() {\n"
19736                "  bar([]() {} // Did not respect SpacesBeforeTrailingComments\n"
19737                "  );\n"
19738                "}");
19739 
19740   // Lambdas created through weird macros.
19741   verifyFormat("void f() {\n"
19742                "  MACRO((const AA &a) { return 1; });\n"
19743                "  MACRO((AA &a) { return 1; });\n"
19744                "}");
19745 
19746   verifyFormat("if (blah_blah(whatever, whatever, [] {\n"
19747                "      doo_dah();\n"
19748                "      doo_dah();\n"
19749                "    })) {\n"
19750                "}");
19751   verifyFormat("if constexpr (blah_blah(whatever, whatever, [] {\n"
19752                "                doo_dah();\n"
19753                "                doo_dah();\n"
19754                "              })) {\n"
19755                "}");
19756   verifyFormat("if CONSTEXPR (blah_blah(whatever, whatever, [] {\n"
19757                "                doo_dah();\n"
19758                "                doo_dah();\n"
19759                "              })) {\n"
19760                "}");
19761   verifyFormat("auto lambda = []() {\n"
19762                "  int a = 2\n"
19763                "#if A\n"
19764                "          + 2\n"
19765                "#endif\n"
19766                "      ;\n"
19767                "};");
19768 
19769   // Lambdas with complex multiline introducers.
19770   verifyFormat(
19771       "aaaaaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
19772       "    [aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa]()\n"
19773       "        -> ::std::unordered_set<\n"
19774       "            aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa> {\n"
19775       "      //\n"
19776       "    });");
19777 
19778   FormatStyle DoNotMerge = getLLVMStyle();
19779   DoNotMerge.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
19780   verifyFormat("auto c = []() {\n"
19781                "  return b;\n"
19782                "};",
19783                "auto c = []() { return b; };", DoNotMerge);
19784   verifyFormat("auto c = []() {\n"
19785                "};",
19786                " auto c = []() {};", DoNotMerge);
19787 
19788   FormatStyle MergeEmptyOnly = getLLVMStyle();
19789   MergeEmptyOnly.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
19790   verifyFormat("auto c = []() {\n"
19791                "  return b;\n"
19792                "};",
19793                "auto c = []() {\n"
19794                "  return b;\n"
19795                " };",
19796                MergeEmptyOnly);
19797   verifyFormat("auto c = []() {};",
19798                "auto c = []() {\n"
19799                "};",
19800                MergeEmptyOnly);
19801 
19802   FormatStyle MergeInline = getLLVMStyle();
19803   MergeInline.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
19804   verifyFormat("auto c = []() {\n"
19805                "  return b;\n"
19806                "};",
19807                "auto c = []() { return b; };", MergeInline);
19808   verifyFormat("function([]() { return b; })", "function([]() { return b; })",
19809                MergeInline);
19810   verifyFormat("function([]() { return b; }, a)",
19811                "function([]() { return b; }, a)", MergeInline);
19812   verifyFormat("function(a, []() { return b; })",
19813                "function(a, []() { return b; })", MergeInline);
19814 
19815   // Check option "BraceWrapping.BeforeLambdaBody" and different state of
19816   // AllowShortLambdasOnASingleLine
19817   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
19818   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
19819   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
19820   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
19821       FormatStyle::ShortLambdaStyle::SLS_None;
19822   verifyFormat("FctWithOneNestedLambdaInline_SLS_None(\n"
19823                "    []()\n"
19824                "    {\n"
19825                "      return 17;\n"
19826                "    });",
19827                LLVMWithBeforeLambdaBody);
19828   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_None(\n"
19829                "    []()\n"
19830                "    {\n"
19831                "    });",
19832                LLVMWithBeforeLambdaBody);
19833   verifyFormat("auto fct_SLS_None = []()\n"
19834                "{\n"
19835                "  return 17;\n"
19836                "};",
19837                LLVMWithBeforeLambdaBody);
19838   verifyFormat("TwoNestedLambdas_SLS_None(\n"
19839                "    []()\n"
19840                "    {\n"
19841                "      return Call(\n"
19842                "          []()\n"
19843                "          {\n"
19844                "            return 17;\n"
19845                "          });\n"
19846                "    });",
19847                LLVMWithBeforeLambdaBody);
19848   verifyFormat("void Fct() {\n"
19849                "  return {[]()\n"
19850                "          {\n"
19851                "            return 17;\n"
19852                "          }};\n"
19853                "}",
19854                LLVMWithBeforeLambdaBody);
19855 
19856   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
19857       FormatStyle::ShortLambdaStyle::SLS_Empty;
19858   verifyFormat("FctWithOneNestedLambdaInline_SLS_Empty(\n"
19859                "    []()\n"
19860                "    {\n"
19861                "      return 17;\n"
19862                "    });",
19863                LLVMWithBeforeLambdaBody);
19864   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Empty([]() {});",
19865                LLVMWithBeforeLambdaBody);
19866   verifyFormat("FctWithOneNestedLambdaEmptyInsideAVeryVeryVeryVeryVeryVeryVeryL"
19867                "ongFunctionName_SLS_Empty(\n"
19868                "    []() {});",
19869                LLVMWithBeforeLambdaBody);
19870   verifyFormat("FctWithMultipleParams_SLS_Empty(A, B,\n"
19871                "                                []()\n"
19872                "                                {\n"
19873                "                                  return 17;\n"
19874                "                                });",
19875                LLVMWithBeforeLambdaBody);
19876   verifyFormat("auto fct_SLS_Empty = []()\n"
19877                "{\n"
19878                "  return 17;\n"
19879                "};",
19880                LLVMWithBeforeLambdaBody);
19881   verifyFormat("TwoNestedLambdas_SLS_Empty(\n"
19882                "    []()\n"
19883                "    {\n"
19884                "      return Call([]() {});\n"
19885                "    });",
19886                LLVMWithBeforeLambdaBody);
19887   verifyFormat("TwoNestedLambdas_SLS_Empty(A,\n"
19888                "                           []()\n"
19889                "                           {\n"
19890                "                             return Call([]() {});\n"
19891                "                           });",
19892                LLVMWithBeforeLambdaBody);
19893   verifyFormat(
19894       "FctWithLongLineInLambda_SLS_Empty(\n"
19895       "    []()\n"
19896       "    {\n"
19897       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
19898       "                               AndShouldNotBeConsiderAsInline,\n"
19899       "                               LambdaBodyMustBeBreak);\n"
19900       "    });",
19901       LLVMWithBeforeLambdaBody);
19902 
19903   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
19904       FormatStyle::ShortLambdaStyle::SLS_Inline;
19905   verifyFormat("FctWithOneNestedLambdaInline_SLS_Inline([]() { return 17; });",
19906                LLVMWithBeforeLambdaBody);
19907   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_Inline([]() {});",
19908                LLVMWithBeforeLambdaBody);
19909   verifyFormat("auto fct_SLS_Inline = []()\n"
19910                "{\n"
19911                "  return 17;\n"
19912                "};",
19913                LLVMWithBeforeLambdaBody);
19914   verifyFormat("TwoNestedLambdas_SLS_Inline([]() { return Call([]() { return "
19915                "17; }); });",
19916                LLVMWithBeforeLambdaBody);
19917   verifyFormat(
19918       "FctWithLongLineInLambda_SLS_Inline(\n"
19919       "    []()\n"
19920       "    {\n"
19921       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
19922       "                               AndShouldNotBeConsiderAsInline,\n"
19923       "                               LambdaBodyMustBeBreak);\n"
19924       "    });",
19925       LLVMWithBeforeLambdaBody);
19926   verifyFormat("FctWithMultipleParams_SLS_Inline("
19927                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
19928                "                                 []() { return 17; });",
19929                LLVMWithBeforeLambdaBody);
19930   verifyFormat(
19931       "FctWithMultipleParams_SLS_Inline(FirstParam, []() { return 17; });",
19932       LLVMWithBeforeLambdaBody);
19933 
19934   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
19935       FormatStyle::ShortLambdaStyle::SLS_All;
19936   verifyFormat("FctWithOneNestedLambdaInline_SLS_All([]() { return 17; });",
19937                LLVMWithBeforeLambdaBody);
19938   verifyFormat("FctWithOneNestedLambdaEmpty_SLS_All([]() {});",
19939                LLVMWithBeforeLambdaBody);
19940   verifyFormat("auto fct_SLS_All = []() { return 17; };",
19941                LLVMWithBeforeLambdaBody);
19942   verifyFormat("FctWithOneParam_SLS_All(\n"
19943                "    []()\n"
19944                "    {\n"
19945                "      // A cool function...\n"
19946                "      return 43;\n"
19947                "    });",
19948                LLVMWithBeforeLambdaBody);
19949   verifyFormat("FctWithMultipleParams_SLS_All("
19950                "VeryLongParameterThatShouldAskToBeOnMultiLine,\n"
19951                "                              []() { return 17; });",
19952                LLVMWithBeforeLambdaBody);
19953   verifyFormat("FctWithMultipleParams_SLS_All(A, []() { return 17; });",
19954                LLVMWithBeforeLambdaBody);
19955   verifyFormat("FctWithMultipleParams_SLS_All(A, B, []() { return 17; });",
19956                LLVMWithBeforeLambdaBody);
19957   verifyFormat(
19958       "FctWithLongLineInLambda_SLS_All(\n"
19959       "    []()\n"
19960       "    {\n"
19961       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
19962       "                               AndShouldNotBeConsiderAsInline,\n"
19963       "                               LambdaBodyMustBeBreak);\n"
19964       "    });",
19965       LLVMWithBeforeLambdaBody);
19966   verifyFormat(
19967       "auto fct_SLS_All = []()\n"
19968       "{\n"
19969       "  return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
19970       "                           AndShouldNotBeConsiderAsInline,\n"
19971       "                           LambdaBodyMustBeBreak);\n"
19972       "};",
19973       LLVMWithBeforeLambdaBody);
19974   LLVMWithBeforeLambdaBody.BinPackParameters = false;
19975   verifyFormat("FctAllOnSameLine_SLS_All([]() { return S; }, Fst, Second);",
19976                LLVMWithBeforeLambdaBody);
19977   verifyFormat(
19978       "FctWithLongLineInLambda_SLS_All([]() { return SomeValueNotSoLong; },\n"
19979       "                                FirstParam,\n"
19980       "                                SecondParam,\n"
19981       "                                ThirdParam,\n"
19982       "                                FourthParam);",
19983       LLVMWithBeforeLambdaBody);
19984   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
19985                "    []() { return "
19986                "SomeValueVeryVeryVeryVeryVeryVeryVeryVeryVeryLong; },\n"
19987                "    FirstParam,\n"
19988                "    SecondParam,\n"
19989                "    ThirdParam,\n"
19990                "    FourthParam);",
19991                LLVMWithBeforeLambdaBody);
19992   verifyFormat(
19993       "FctWithLongLineInLambda_SLS_All(FirstParam,\n"
19994       "                                SecondParam,\n"
19995       "                                ThirdParam,\n"
19996       "                                FourthParam,\n"
19997       "                                []() { return SomeValueNotSoLong; });",
19998       LLVMWithBeforeLambdaBody);
19999   verifyFormat("FctWithLongLineInLambda_SLS_All(\n"
20000                "    []()\n"
20001                "    {\n"
20002                "      return "
20003                "HereAVeryLongLineThatWillBeFormattedOnMultipleLineAndShouldNotB"
20004                "eConsiderAsInline;\n"
20005                "    });",
20006                LLVMWithBeforeLambdaBody);
20007   verifyFormat(
20008       "FctWithLongLineInLambda_SLS_All(\n"
20009       "    []()\n"
20010       "    {\n"
20011       "      return HereAVeryLongLine(ThatWillBeFormatted, OnMultipleLine,\n"
20012       "                               AndShouldNotBeConsiderAsInline,\n"
20013       "                               LambdaBodyMustBeBreak);\n"
20014       "    });",
20015       LLVMWithBeforeLambdaBody);
20016   verifyFormat("FctWithTwoParams_SLS_All(\n"
20017                "    []()\n"
20018                "    {\n"
20019                "      // A cool function...\n"
20020                "      return 43;\n"
20021                "    },\n"
20022                "    87);",
20023                LLVMWithBeforeLambdaBody);
20024   verifyFormat("FctWithTwoParams_SLS_All([]() { return 43; }, 87);",
20025                LLVMWithBeforeLambdaBody);
20026   verifyFormat("FctWithOneNestedLambdas_SLS_All([]() { return 17; });",
20027                LLVMWithBeforeLambdaBody);
20028   verifyFormat(
20029       "TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; }); });",
20030       LLVMWithBeforeLambdaBody);
20031   verifyFormat("TwoNestedLambdas_SLS_All([]() { return Call([]() { return 17; "
20032                "}); }, x);",
20033                LLVMWithBeforeLambdaBody);
20034   verifyFormat("TwoNestedLambdas_SLS_All(\n"
20035                "    []()\n"
20036                "    {\n"
20037                "      // A cool function...\n"
20038                "      return Call([]() { return 17; });\n"
20039                "    });",
20040                LLVMWithBeforeLambdaBody);
20041   verifyFormat("TwoNestedLambdas_SLS_All(\n"
20042                "    []()\n"
20043                "    {\n"
20044                "      return Call(\n"
20045                "          []()\n"
20046                "          {\n"
20047                "            // A cool function...\n"
20048                "            return 17;\n"
20049                "          });\n"
20050                "    });",
20051                LLVMWithBeforeLambdaBody);
20052 
20053   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
20054       FormatStyle::ShortLambdaStyle::SLS_None;
20055 
20056   verifyFormat("auto select = [this]() -> const Library::Object *\n"
20057                "{\n"
20058                "  return MyAssignment::SelectFromList(this);\n"
20059                "};\n",
20060                LLVMWithBeforeLambdaBody);
20061 
20062   verifyFormat("auto select = [this]() -> const Library::Object &\n"
20063                "{\n"
20064                "  return MyAssignment::SelectFromList(this);\n"
20065                "};\n",
20066                LLVMWithBeforeLambdaBody);
20067 
20068   verifyFormat("auto select = [this]() -> std::unique_ptr<Object>\n"
20069                "{\n"
20070                "  return MyAssignment::SelectFromList(this);\n"
20071                "};\n",
20072                LLVMWithBeforeLambdaBody);
20073 
20074   verifyFormat("namespace test {\n"
20075                "class Test {\n"
20076                "public:\n"
20077                "  Test() = default;\n"
20078                "};\n"
20079                "} // namespace test",
20080                LLVMWithBeforeLambdaBody);
20081 
20082   // Lambdas with different indentation styles.
20083   Style = getLLVMStyleWithColumns(100);
20084   EXPECT_EQ("SomeResult doSomething(SomeObject promise) {\n"
20085             "  return promise.then(\n"
20086             "      [this, &someVariable, someObject = "
20087             "std::mv(s)](std::vector<int> evaluated) mutable {\n"
20088             "        return someObject.startAsyncAction().then(\n"
20089             "            [this, &someVariable](AsyncActionResult result) "
20090             "mutable { result.processMore(); });\n"
20091             "      });\n"
20092             "}\n",
20093             format("SomeResult doSomething(SomeObject promise) {\n"
20094                    "  return promise.then([this, &someVariable, someObject = "
20095                    "std::mv(s)](std::vector<int> evaluated) mutable {\n"
20096                    "    return someObject.startAsyncAction().then([this, "
20097                    "&someVariable](AsyncActionResult result) mutable {\n"
20098                    "      result.processMore();\n"
20099                    "    });\n"
20100                    "  });\n"
20101                    "}\n",
20102                    Style));
20103   Style.LambdaBodyIndentation = FormatStyle::LBI_OuterScope;
20104   verifyFormat("test() {\n"
20105                "  ([]() -> {\n"
20106                "    int b = 32;\n"
20107                "    return 3;\n"
20108                "  }).foo();\n"
20109                "}",
20110                Style);
20111   verifyFormat("test() {\n"
20112                "  []() -> {\n"
20113                "    int b = 32;\n"
20114                "    return 3;\n"
20115                "  }\n"
20116                "}",
20117                Style);
20118   verifyFormat("std::sort(v.begin(), v.end(),\n"
20119                "          [](const auto &someLongArgumentName, const auto "
20120                "&someOtherLongArgumentName) {\n"
20121                "  return someLongArgumentName.someMemberVariable < "
20122                "someOtherLongArgumentName.someMemberVariable;\n"
20123                "});",
20124                Style);
20125   verifyFormat("test() {\n"
20126                "  (\n"
20127                "      []() -> {\n"
20128                "        int b = 32;\n"
20129                "        return 3;\n"
20130                "      },\n"
20131                "      foo, bar)\n"
20132                "      .foo();\n"
20133                "}",
20134                Style);
20135   verifyFormat("test() {\n"
20136                "  ([]() -> {\n"
20137                "    int b = 32;\n"
20138                "    return 3;\n"
20139                "  })\n"
20140                "      .foo()\n"
20141                "      .bar();\n"
20142                "}",
20143                Style);
20144   EXPECT_EQ("SomeResult doSomething(SomeObject promise) {\n"
20145             "  return promise.then(\n"
20146             "      [this, &someVariable, someObject = "
20147             "std::mv(s)](std::vector<int> evaluated) mutable {\n"
20148             "    return someObject.startAsyncAction().then(\n"
20149             "        [this, &someVariable](AsyncActionResult result) mutable { "
20150             "result.processMore(); });\n"
20151             "  });\n"
20152             "}\n",
20153             format("SomeResult doSomething(SomeObject promise) {\n"
20154                    "  return promise.then([this, &someVariable, someObject = "
20155                    "std::mv(s)](std::vector<int> evaluated) mutable {\n"
20156                    "    return someObject.startAsyncAction().then([this, "
20157                    "&someVariable](AsyncActionResult result) mutable {\n"
20158                    "      result.processMore();\n"
20159                    "    });\n"
20160                    "  });\n"
20161                    "}\n",
20162                    Style));
20163   EXPECT_EQ("SomeResult doSomething(SomeObject promise) {\n"
20164             "  return promise.then([this, &someVariable] {\n"
20165             "    return someObject.startAsyncAction().then(\n"
20166             "        [this, &someVariable](AsyncActionResult result) mutable { "
20167             "result.processMore(); });\n"
20168             "  });\n"
20169             "}\n",
20170             format("SomeResult doSomething(SomeObject promise) {\n"
20171                    "  return promise.then([this, &someVariable] {\n"
20172                    "    return someObject.startAsyncAction().then([this, "
20173                    "&someVariable](AsyncActionResult result) mutable {\n"
20174                    "      result.processMore();\n"
20175                    "    });\n"
20176                    "  });\n"
20177                    "}\n",
20178                    Style));
20179   Style = getGoogleStyle();
20180   Style.LambdaBodyIndentation = FormatStyle::LBI_OuterScope;
20181   EXPECT_EQ("#define A                                       \\\n"
20182             "  [] {                                          \\\n"
20183             "    xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx(        \\\n"
20184             "        xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); \\\n"
20185             "      }",
20186             format("#define A [] { xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx( \\\n"
20187                    "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx); }",
20188                    Style));
20189   // TODO: The current formatting has a minor issue that's not worth fixing
20190   // right now whereby the closing brace is indented relative to the signature
20191   // instead of being aligned. This only happens with macros.
20192 }
20193 
20194 TEST_F(FormatTest, LambdaWithLineComments) {
20195   FormatStyle LLVMWithBeforeLambdaBody = getLLVMStyle();
20196   LLVMWithBeforeLambdaBody.BreakBeforeBraces = FormatStyle::BS_Custom;
20197   LLVMWithBeforeLambdaBody.BraceWrapping.BeforeLambdaBody = true;
20198   LLVMWithBeforeLambdaBody.AllowShortLambdasOnASingleLine =
20199       FormatStyle::ShortLambdaStyle::SLS_All;
20200 
20201   verifyFormat("auto k = []() { return; }", LLVMWithBeforeLambdaBody);
20202   verifyFormat("auto k = []() // comment\n"
20203                "{ return; }",
20204                LLVMWithBeforeLambdaBody);
20205   verifyFormat("auto k = []() /* comment */ { return; }",
20206                LLVMWithBeforeLambdaBody);
20207   verifyFormat("auto k = []() /* comment */ /* comment */ { return; }",
20208                LLVMWithBeforeLambdaBody);
20209   verifyFormat("auto k = []() // X\n"
20210                "{ return; }",
20211                LLVMWithBeforeLambdaBody);
20212   verifyFormat(
20213       "auto k = []() // XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"
20214       "{ return; }",
20215       LLVMWithBeforeLambdaBody);
20216 }
20217 
20218 TEST_F(FormatTest, EmptyLinesInLambdas) {
20219   verifyFormat("auto lambda = []() {\n"
20220                "  x(); //\n"
20221                "};",
20222                "auto lambda = []() {\n"
20223                "\n"
20224                "  x(); //\n"
20225                "\n"
20226                "};");
20227 }
20228 
20229 TEST_F(FormatTest, FormatsBlocks) {
20230   FormatStyle ShortBlocks = getLLVMStyle();
20231   ShortBlocks.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
20232   verifyFormat("int (^Block)(int, int);", ShortBlocks);
20233   verifyFormat("int (^Block1)(int, int) = ^(int i, int j)", ShortBlocks);
20234   verifyFormat("void (^block)(int) = ^(id test) { int i; };", ShortBlocks);
20235   verifyFormat("void (^block)(int) = ^(int test) { int i; };", ShortBlocks);
20236   verifyFormat("void (^block)(int) = ^id(int test) { int i; };", ShortBlocks);
20237   verifyFormat("void (^block)(int) = ^int(int test) { int i; };", ShortBlocks);
20238 
20239   verifyFormat("foo(^{ bar(); });", ShortBlocks);
20240   verifyFormat("foo(a, ^{ bar(); });", ShortBlocks);
20241   verifyFormat("{ void (^block)(Object *x); }", ShortBlocks);
20242 
20243   verifyFormat("[operation setCompletionBlock:^{\n"
20244                "  [self onOperationDone];\n"
20245                "}];");
20246   verifyFormat("int i = {[operation setCompletionBlock:^{\n"
20247                "  [self onOperationDone];\n"
20248                "}]};");
20249   verifyFormat("[operation setCompletionBlock:^(int *i) {\n"
20250                "  f();\n"
20251                "}];");
20252   verifyFormat("int a = [operation block:^int(int *i) {\n"
20253                "  return 1;\n"
20254                "}];");
20255   verifyFormat("[myObject doSomethingWith:arg1\n"
20256                "                      aaa:^int(int *a) {\n"
20257                "                        return 1;\n"
20258                "                      }\n"
20259                "                      bbb:f(a * bbbbbbbb)];");
20260 
20261   verifyFormat("[operation setCompletionBlock:^{\n"
20262                "  [self.delegate newDataAvailable];\n"
20263                "}];",
20264                getLLVMStyleWithColumns(60));
20265   verifyFormat("dispatch_async(_fileIOQueue, ^{\n"
20266                "  NSString *path = [self sessionFilePath];\n"
20267                "  if (path) {\n"
20268                "    // ...\n"
20269                "  }\n"
20270                "});");
20271   verifyFormat("[[SessionService sharedService]\n"
20272                "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
20273                "      if (window) {\n"
20274                "        [self windowDidLoad:window];\n"
20275                "      } else {\n"
20276                "        [self errorLoadingWindow];\n"
20277                "      }\n"
20278                "    }];");
20279   verifyFormat("void (^largeBlock)(void) = ^{\n"
20280                "  // ...\n"
20281                "};\n",
20282                getLLVMStyleWithColumns(40));
20283   verifyFormat("[[SessionService sharedService]\n"
20284                "    loadWindowWithCompletionBlock: //\n"
20285                "        ^(SessionWindow *window) {\n"
20286                "          if (window) {\n"
20287                "            [self windowDidLoad:window];\n"
20288                "          } else {\n"
20289                "            [self errorLoadingWindow];\n"
20290                "          }\n"
20291                "        }];",
20292                getLLVMStyleWithColumns(60));
20293   verifyFormat("[myObject doSomethingWith:arg1\n"
20294                "    firstBlock:^(Foo *a) {\n"
20295                "      // ...\n"
20296                "      int i;\n"
20297                "    }\n"
20298                "    secondBlock:^(Bar *b) {\n"
20299                "      // ...\n"
20300                "      int i;\n"
20301                "    }\n"
20302                "    thirdBlock:^Foo(Bar *b) {\n"
20303                "      // ...\n"
20304                "      int i;\n"
20305                "    }];");
20306   verifyFormat("[myObject doSomethingWith:arg1\n"
20307                "               firstBlock:-1\n"
20308                "              secondBlock:^(Bar *b) {\n"
20309                "                // ...\n"
20310                "                int i;\n"
20311                "              }];");
20312 
20313   verifyFormat("f(^{\n"
20314                "  @autoreleasepool {\n"
20315                "    if (a) {\n"
20316                "      g();\n"
20317                "    }\n"
20318                "  }\n"
20319                "});");
20320   verifyFormat("Block b = ^int *(A *a, B *b) {}");
20321   verifyFormat("BOOL (^aaa)(void) = ^BOOL {\n"
20322                "};");
20323 
20324   FormatStyle FourIndent = getLLVMStyle();
20325   FourIndent.ObjCBlockIndentWidth = 4;
20326   verifyFormat("[operation setCompletionBlock:^{\n"
20327                "    [self onOperationDone];\n"
20328                "}];",
20329                FourIndent);
20330 }
20331 
20332 TEST_F(FormatTest, FormatsBlocksWithZeroColumnWidth) {
20333   FormatStyle ZeroColumn = getLLVMStyle();
20334   ZeroColumn.ColumnLimit = 0;
20335 
20336   verifyFormat("[[SessionService sharedService] "
20337                "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
20338                "  if (window) {\n"
20339                "    [self windowDidLoad:window];\n"
20340                "  } else {\n"
20341                "    [self errorLoadingWindow];\n"
20342                "  }\n"
20343                "}];",
20344                ZeroColumn);
20345   EXPECT_EQ("[[SessionService sharedService]\n"
20346             "    loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
20347             "      if (window) {\n"
20348             "        [self windowDidLoad:window];\n"
20349             "      } else {\n"
20350             "        [self errorLoadingWindow];\n"
20351             "      }\n"
20352             "    }];",
20353             format("[[SessionService sharedService]\n"
20354                    "loadWindowWithCompletionBlock:^(SessionWindow *window) {\n"
20355                    "                if (window) {\n"
20356                    "    [self windowDidLoad:window];\n"
20357                    "  } else {\n"
20358                    "    [self errorLoadingWindow];\n"
20359                    "  }\n"
20360                    "}];",
20361                    ZeroColumn));
20362   verifyFormat("[myObject doSomethingWith:arg1\n"
20363                "    firstBlock:^(Foo *a) {\n"
20364                "      // ...\n"
20365                "      int i;\n"
20366                "    }\n"
20367                "    secondBlock:^(Bar *b) {\n"
20368                "      // ...\n"
20369                "      int i;\n"
20370                "    }\n"
20371                "    thirdBlock:^Foo(Bar *b) {\n"
20372                "      // ...\n"
20373                "      int i;\n"
20374                "    }];",
20375                ZeroColumn);
20376   verifyFormat("f(^{\n"
20377                "  @autoreleasepool {\n"
20378                "    if (a) {\n"
20379                "      g();\n"
20380                "    }\n"
20381                "  }\n"
20382                "});",
20383                ZeroColumn);
20384   verifyFormat("void (^largeBlock)(void) = ^{\n"
20385                "  // ...\n"
20386                "};",
20387                ZeroColumn);
20388 
20389   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Always;
20390   EXPECT_EQ("void (^largeBlock)(void) = ^{ int i; };",
20391             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
20392   ZeroColumn.AllowShortBlocksOnASingleLine = FormatStyle::SBS_Never;
20393   EXPECT_EQ("void (^largeBlock)(void) = ^{\n"
20394             "  int i;\n"
20395             "};",
20396             format("void   (^largeBlock)(void) = ^{ int   i; };", ZeroColumn));
20397 }
20398 
20399 TEST_F(FormatTest, SupportsCRLF) {
20400   EXPECT_EQ("int a;\r\n"
20401             "int b;\r\n"
20402             "int c;\r\n",
20403             format("int a;\r\n"
20404                    "  int b;\r\n"
20405                    "    int c;\r\n",
20406                    getLLVMStyle()));
20407   EXPECT_EQ("int a;\r\n"
20408             "int b;\r\n"
20409             "int c;\r\n",
20410             format("int a;\r\n"
20411                    "  int b;\n"
20412                    "    int c;\r\n",
20413                    getLLVMStyle()));
20414   EXPECT_EQ("int a;\n"
20415             "int b;\n"
20416             "int c;\n",
20417             format("int a;\r\n"
20418                    "  int b;\n"
20419                    "    int c;\n",
20420                    getLLVMStyle()));
20421   EXPECT_EQ("\"aaaaaaa \"\r\n"
20422             "\"bbbbbbb\";\r\n",
20423             format("\"aaaaaaa bbbbbbb\";\r\n", getLLVMStyleWithColumns(10)));
20424   EXPECT_EQ("#define A \\\r\n"
20425             "  b;      \\\r\n"
20426             "  c;      \\\r\n"
20427             "  d;\r\n",
20428             format("#define A \\\r\n"
20429                    "  b; \\\r\n"
20430                    "  c; d; \r\n",
20431                    getGoogleStyle()));
20432 
20433   EXPECT_EQ("/*\r\n"
20434             "multi line block comments\r\n"
20435             "should not introduce\r\n"
20436             "an extra carriage return\r\n"
20437             "*/\r\n",
20438             format("/*\r\n"
20439                    "multi line block comments\r\n"
20440                    "should not introduce\r\n"
20441                    "an extra carriage return\r\n"
20442                    "*/\r\n"));
20443   EXPECT_EQ("/*\r\n"
20444             "\r\n"
20445             "*/",
20446             format("/*\r\n"
20447                    "    \r\r\r\n"
20448                    "*/"));
20449 
20450   FormatStyle style = getLLVMStyle();
20451 
20452   style.DeriveLineEnding = true;
20453   style.UseCRLF = false;
20454   EXPECT_EQ("union FooBarBazQux {\n"
20455             "  int foo;\n"
20456             "  int bar;\n"
20457             "  int baz;\n"
20458             "};",
20459             format("union FooBarBazQux {\r\n"
20460                    "  int foo;\n"
20461                    "  int bar;\r\n"
20462                    "  int baz;\n"
20463                    "};",
20464                    style));
20465   style.UseCRLF = true;
20466   EXPECT_EQ("union FooBarBazQux {\r\n"
20467             "  int foo;\r\n"
20468             "  int bar;\r\n"
20469             "  int baz;\r\n"
20470             "};",
20471             format("union FooBarBazQux {\r\n"
20472                    "  int foo;\n"
20473                    "  int bar;\r\n"
20474                    "  int baz;\n"
20475                    "};",
20476                    style));
20477 
20478   style.DeriveLineEnding = false;
20479   style.UseCRLF = false;
20480   EXPECT_EQ("union FooBarBazQux {\n"
20481             "  int foo;\n"
20482             "  int bar;\n"
20483             "  int baz;\n"
20484             "  int qux;\n"
20485             "};",
20486             format("union FooBarBazQux {\r\n"
20487                    "  int foo;\n"
20488                    "  int bar;\r\n"
20489                    "  int baz;\n"
20490                    "  int qux;\r\n"
20491                    "};",
20492                    style));
20493   style.UseCRLF = true;
20494   EXPECT_EQ("union FooBarBazQux {\r\n"
20495             "  int foo;\r\n"
20496             "  int bar;\r\n"
20497             "  int baz;\r\n"
20498             "  int qux;\r\n"
20499             "};",
20500             format("union FooBarBazQux {\r\n"
20501                    "  int foo;\n"
20502                    "  int bar;\r\n"
20503                    "  int baz;\n"
20504                    "  int qux;\n"
20505                    "};",
20506                    style));
20507 
20508   style.DeriveLineEnding = true;
20509   style.UseCRLF = false;
20510   EXPECT_EQ("union FooBarBazQux {\r\n"
20511             "  int foo;\r\n"
20512             "  int bar;\r\n"
20513             "  int baz;\r\n"
20514             "  int qux;\r\n"
20515             "};",
20516             format("union FooBarBazQux {\r\n"
20517                    "  int foo;\n"
20518                    "  int bar;\r\n"
20519                    "  int baz;\n"
20520                    "  int qux;\r\n"
20521                    "};",
20522                    style));
20523   style.UseCRLF = true;
20524   EXPECT_EQ("union FooBarBazQux {\n"
20525             "  int foo;\n"
20526             "  int bar;\n"
20527             "  int baz;\n"
20528             "  int qux;\n"
20529             "};",
20530             format("union FooBarBazQux {\r\n"
20531                    "  int foo;\n"
20532                    "  int bar;\r\n"
20533                    "  int baz;\n"
20534                    "  int qux;\n"
20535                    "};",
20536                    style));
20537 }
20538 
20539 TEST_F(FormatTest, MunchSemicolonAfterBlocks) {
20540   verifyFormat("MY_CLASS(C) {\n"
20541                "  int i;\n"
20542                "  int j;\n"
20543                "};");
20544 }
20545 
20546 TEST_F(FormatTest, ConfigurableContinuationIndentWidth) {
20547   FormatStyle TwoIndent = getLLVMStyleWithColumns(15);
20548   TwoIndent.ContinuationIndentWidth = 2;
20549 
20550   EXPECT_EQ("int i =\n"
20551             "  longFunction(\n"
20552             "    arg);",
20553             format("int i = longFunction(arg);", TwoIndent));
20554 
20555   FormatStyle SixIndent = getLLVMStyleWithColumns(20);
20556   SixIndent.ContinuationIndentWidth = 6;
20557 
20558   EXPECT_EQ("int i =\n"
20559             "      longFunction(\n"
20560             "            arg);",
20561             format("int i = longFunction(arg);", SixIndent));
20562 }
20563 
20564 TEST_F(FormatTest, WrappedClosingParenthesisIndent) {
20565   FormatStyle Style = getLLVMStyle();
20566   verifyFormat("int Foo::getter(\n"
20567                "    //\n"
20568                ") const {\n"
20569                "  return foo;\n"
20570                "}",
20571                Style);
20572   verifyFormat("void Foo::setter(\n"
20573                "    //\n"
20574                ") {\n"
20575                "  foo = 1;\n"
20576                "}",
20577                Style);
20578 }
20579 
20580 TEST_F(FormatTest, SpacesInAngles) {
20581   FormatStyle Spaces = getLLVMStyle();
20582   Spaces.SpacesInAngles = FormatStyle::SIAS_Always;
20583 
20584   verifyFormat("vector< ::std::string > x1;", Spaces);
20585   verifyFormat("Foo< int, Bar > x2;", Spaces);
20586   verifyFormat("Foo< ::int, ::Bar > x3;", Spaces);
20587 
20588   verifyFormat("static_cast< int >(arg);", Spaces);
20589   verifyFormat("template < typename T0, typename T1 > void f() {}", Spaces);
20590   verifyFormat("f< int, float >();", Spaces);
20591   verifyFormat("template <> g() {}", Spaces);
20592   verifyFormat("template < std::vector< int > > f() {}", Spaces);
20593   verifyFormat("std::function< void(int, int) > fct;", Spaces);
20594   verifyFormat("void inFunction() { std::function< void(int, int) > fct; }",
20595                Spaces);
20596 
20597   Spaces.Standard = FormatStyle::LS_Cpp03;
20598   Spaces.SpacesInAngles = FormatStyle::SIAS_Always;
20599   verifyFormat("A< A< int > >();", Spaces);
20600 
20601   Spaces.SpacesInAngles = FormatStyle::SIAS_Never;
20602   verifyFormat("A<A<int> >();", Spaces);
20603 
20604   Spaces.SpacesInAngles = FormatStyle::SIAS_Leave;
20605   verifyFormat("vector< ::std::string> x4;", "vector<::std::string> x4;",
20606                Spaces);
20607   verifyFormat("vector< ::std::string > x4;", "vector<::std::string > x4;",
20608                Spaces);
20609 
20610   verifyFormat("A<A<int> >();", Spaces);
20611   verifyFormat("A<A<int> >();", "A<A<int>>();", Spaces);
20612   verifyFormat("A< A< int > >();", Spaces);
20613 
20614   Spaces.Standard = FormatStyle::LS_Cpp11;
20615   Spaces.SpacesInAngles = FormatStyle::SIAS_Always;
20616   verifyFormat("A< A< int > >();", Spaces);
20617 
20618   Spaces.SpacesInAngles = FormatStyle::SIAS_Never;
20619   verifyFormat("vector<::std::string> x4;", Spaces);
20620   verifyFormat("vector<int> x5;", Spaces);
20621   verifyFormat("Foo<int, Bar> x6;", Spaces);
20622   verifyFormat("Foo<::int, ::Bar> x7;", Spaces);
20623 
20624   verifyFormat("A<A<int>>();", Spaces);
20625 
20626   Spaces.SpacesInAngles = FormatStyle::SIAS_Leave;
20627   verifyFormat("vector<::std::string> x4;", Spaces);
20628   verifyFormat("vector< ::std::string > x4;", Spaces);
20629   verifyFormat("vector<int> x5;", Spaces);
20630   verifyFormat("vector< int > x5;", Spaces);
20631   verifyFormat("Foo<int, Bar> x6;", Spaces);
20632   verifyFormat("Foo< int, Bar > x6;", Spaces);
20633   verifyFormat("Foo<::int, ::Bar> x7;", Spaces);
20634   verifyFormat("Foo< ::int, ::Bar > x7;", Spaces);
20635 
20636   verifyFormat("A<A<int>>();", Spaces);
20637   verifyFormat("A< A< int > >();", Spaces);
20638   verifyFormat("A<A<int > >();", Spaces);
20639   verifyFormat("A< A< int>>();", Spaces);
20640 }
20641 
20642 TEST_F(FormatTest, SpaceAfterTemplateKeyword) {
20643   FormatStyle Style = getLLVMStyle();
20644   Style.SpaceAfterTemplateKeyword = false;
20645   verifyFormat("template<int> void foo();", Style);
20646 }
20647 
20648 TEST_F(FormatTest, TripleAngleBrackets) {
20649   verifyFormat("f<<<1, 1>>>();");
20650   verifyFormat("f<<<1, 1, 1, s>>>();");
20651   verifyFormat("f<<<a, b, c, d>>>();");
20652   EXPECT_EQ("f<<<1, 1>>>();", format("f <<< 1, 1 >>> ();"));
20653   verifyFormat("f<param><<<1, 1>>>();");
20654   verifyFormat("f<1><<<1, 1>>>();");
20655   EXPECT_EQ("f<param><<<1, 1>>>();", format("f< param > <<< 1, 1 >>> ();"));
20656   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
20657                "aaaaaaaaaaa<<<\n    1, 1>>>();");
20658   verifyFormat("aaaaaaaaaaaaaaa<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaa>\n"
20659                "    <<<aaaaaaaaa, aaaaaaaaaa, aaaaaaaaaaaaaaaaaa>>>();");
20660 }
20661 
20662 TEST_F(FormatTest, MergeLessLessAtEnd) {
20663   verifyFormat("<<");
20664   EXPECT_EQ("< < <", format("\\\n<<<"));
20665   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
20666                "aaallvm::outs() <<");
20667   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
20668                "aaaallvm::outs()\n    <<");
20669 }
20670 
20671 TEST_F(FormatTest, HandleUnbalancedImplicitBracesAcrossPPBranches) {
20672   std::string code = "#if A\n"
20673                      "#if B\n"
20674                      "a.\n"
20675                      "#endif\n"
20676                      "    a = 1;\n"
20677                      "#else\n"
20678                      "#endif\n"
20679                      "#if C\n"
20680                      "#else\n"
20681                      "#endif\n";
20682   EXPECT_EQ(code, format(code));
20683 }
20684 
20685 TEST_F(FormatTest, HandleConflictMarkers) {
20686   // Git/SVN conflict markers.
20687   EXPECT_EQ("int a;\n"
20688             "void f() {\n"
20689             "  callme(some(parameter1,\n"
20690             "<<<<<<< text by the vcs\n"
20691             "              parameter2),\n"
20692             "||||||| text by the vcs\n"
20693             "              parameter2),\n"
20694             "         parameter3,\n"
20695             "======= text by the vcs\n"
20696             "              parameter2, parameter3),\n"
20697             ">>>>>>> text by the vcs\n"
20698             "         otherparameter);\n",
20699             format("int a;\n"
20700                    "void f() {\n"
20701                    "  callme(some(parameter1,\n"
20702                    "<<<<<<< text by the vcs\n"
20703                    "  parameter2),\n"
20704                    "||||||| text by the vcs\n"
20705                    "  parameter2),\n"
20706                    "  parameter3,\n"
20707                    "======= text by the vcs\n"
20708                    "  parameter2,\n"
20709                    "  parameter3),\n"
20710                    ">>>>>>> text by the vcs\n"
20711                    "  otherparameter);\n"));
20712 
20713   // Perforce markers.
20714   EXPECT_EQ("void f() {\n"
20715             "  function(\n"
20716             ">>>> text by the vcs\n"
20717             "      parameter,\n"
20718             "==== text by the vcs\n"
20719             "      parameter,\n"
20720             "==== text by the vcs\n"
20721             "      parameter,\n"
20722             "<<<< text by the vcs\n"
20723             "      parameter);\n",
20724             format("void f() {\n"
20725                    "  function(\n"
20726                    ">>>> text by the vcs\n"
20727                    "  parameter,\n"
20728                    "==== text by the vcs\n"
20729                    "  parameter,\n"
20730                    "==== text by the vcs\n"
20731                    "  parameter,\n"
20732                    "<<<< text by the vcs\n"
20733                    "  parameter);\n"));
20734 
20735   EXPECT_EQ("<<<<<<<\n"
20736             "|||||||\n"
20737             "=======\n"
20738             ">>>>>>>",
20739             format("<<<<<<<\n"
20740                    "|||||||\n"
20741                    "=======\n"
20742                    ">>>>>>>"));
20743 
20744   EXPECT_EQ("<<<<<<<\n"
20745             "|||||||\n"
20746             "int i;\n"
20747             "=======\n"
20748             ">>>>>>>",
20749             format("<<<<<<<\n"
20750                    "|||||||\n"
20751                    "int i;\n"
20752                    "=======\n"
20753                    ">>>>>>>"));
20754 
20755   // FIXME: Handle parsing of macros around conflict markers correctly:
20756   EXPECT_EQ("#define Macro \\\n"
20757             "<<<<<<<\n"
20758             "Something \\\n"
20759             "|||||||\n"
20760             "Else \\\n"
20761             "=======\n"
20762             "Other \\\n"
20763             ">>>>>>>\n"
20764             "    End int i;\n",
20765             format("#define Macro \\\n"
20766                    "<<<<<<<\n"
20767                    "  Something \\\n"
20768                    "|||||||\n"
20769                    "  Else \\\n"
20770                    "=======\n"
20771                    "  Other \\\n"
20772                    ">>>>>>>\n"
20773                    "  End\n"
20774                    "int i;\n"));
20775 }
20776 
20777 TEST_F(FormatTest, DisableRegions) {
20778   EXPECT_EQ("int i;\n"
20779             "// clang-format off\n"
20780             "  int j;\n"
20781             "// clang-format on\n"
20782             "int k;",
20783             format(" int  i;\n"
20784                    "   // clang-format off\n"
20785                    "  int j;\n"
20786                    " // clang-format on\n"
20787                    "   int   k;"));
20788   EXPECT_EQ("int i;\n"
20789             "/* clang-format off */\n"
20790             "  int j;\n"
20791             "/* clang-format on */\n"
20792             "int k;",
20793             format(" int  i;\n"
20794                    "   /* clang-format off */\n"
20795                    "  int j;\n"
20796                    " /* clang-format on */\n"
20797                    "   int   k;"));
20798 
20799   // Don't reflow comments within disabled regions.
20800   EXPECT_EQ("// clang-format off\n"
20801             "// long long long long long long line\n"
20802             "/* clang-format on */\n"
20803             "/* long long long\n"
20804             " * long long long\n"
20805             " * line */\n"
20806             "int i;\n"
20807             "/* clang-format off */\n"
20808             "/* long long long long long long line */\n",
20809             format("// clang-format off\n"
20810                    "// long long long long long long line\n"
20811                    "/* clang-format on */\n"
20812                    "/* long long long long long long line */\n"
20813                    "int i;\n"
20814                    "/* clang-format off */\n"
20815                    "/* long long long long long long line */\n",
20816                    getLLVMStyleWithColumns(20)));
20817 }
20818 
20819 TEST_F(FormatTest, DoNotCrashOnInvalidInput) {
20820   format("? ) =");
20821   verifyNoCrash("#define a\\\n /**/}");
20822 }
20823 
20824 TEST_F(FormatTest, FormatsTableGenCode) {
20825   FormatStyle Style = getLLVMStyle();
20826   Style.Language = FormatStyle::LK_TableGen;
20827   verifyFormat("include \"a.td\"\ninclude \"b.td\"", Style);
20828 }
20829 
20830 TEST_F(FormatTest, ArrayOfTemplates) {
20831   EXPECT_EQ("auto a = new unique_ptr<int>[10];",
20832             format("auto a = new unique_ptr<int > [ 10];"));
20833 
20834   FormatStyle Spaces = getLLVMStyle();
20835   Spaces.SpacesInSquareBrackets = true;
20836   EXPECT_EQ("auto a = new unique_ptr<int>[ 10 ];",
20837             format("auto a = new unique_ptr<int > [10];", Spaces));
20838 }
20839 
20840 TEST_F(FormatTest, ArrayAsTemplateType) {
20841   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[10]>;",
20842             format("auto a = unique_ptr < Foo < Bar>[ 10]> ;"));
20843 
20844   FormatStyle Spaces = getLLVMStyle();
20845   Spaces.SpacesInSquareBrackets = true;
20846   EXPECT_EQ("auto a = unique_ptr<Foo<Bar>[ 10 ]>;",
20847             format("auto a = unique_ptr < Foo < Bar>[10]> ;", Spaces));
20848 }
20849 
20850 TEST_F(FormatTest, NoSpaceAfterSuper) { verifyFormat("__super::FooBar();"); }
20851 
20852 TEST(FormatStyle, GetStyleWithEmptyFileName) {
20853   llvm::vfs::InMemoryFileSystem FS;
20854   auto Style1 = getStyle("file", "", "Google", "", &FS);
20855   ASSERT_TRUE((bool)Style1);
20856   ASSERT_EQ(*Style1, getGoogleStyle());
20857 }
20858 
20859 TEST(FormatStyle, GetStyleOfFile) {
20860   llvm::vfs::InMemoryFileSystem FS;
20861   // Test 1: format file in the same directory.
20862   ASSERT_TRUE(
20863       FS.addFile("/a/.clang-format", 0,
20864                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM")));
20865   ASSERT_TRUE(
20866       FS.addFile("/a/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
20867   auto Style1 = getStyle("file", "/a/.clang-format", "Google", "", &FS);
20868   ASSERT_TRUE((bool)Style1);
20869   ASSERT_EQ(*Style1, getLLVMStyle());
20870 
20871   // Test 2.1: fallback to default.
20872   ASSERT_TRUE(
20873       FS.addFile("/b/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
20874   auto Style2 = getStyle("file", "/b/test.cpp", "Mozilla", "", &FS);
20875   ASSERT_TRUE((bool)Style2);
20876   ASSERT_EQ(*Style2, getMozillaStyle());
20877 
20878   // Test 2.2: no format on 'none' fallback style.
20879   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
20880   ASSERT_TRUE((bool)Style2);
20881   ASSERT_EQ(*Style2, getNoStyle());
20882 
20883   // Test 2.3: format if config is found with no based style while fallback is
20884   // 'none'.
20885   ASSERT_TRUE(FS.addFile("/b/.clang-format", 0,
20886                          llvm::MemoryBuffer::getMemBuffer("IndentWidth: 2")));
20887   Style2 = getStyle("file", "/b/test.cpp", "none", "", &FS);
20888   ASSERT_TRUE((bool)Style2);
20889   ASSERT_EQ(*Style2, getLLVMStyle());
20890 
20891   // Test 2.4: format if yaml with no based style, while fallback is 'none'.
20892   Style2 = getStyle("{}", "a.h", "none", "", &FS);
20893   ASSERT_TRUE((bool)Style2);
20894   ASSERT_EQ(*Style2, getLLVMStyle());
20895 
20896   // Test 3: format file in parent directory.
20897   ASSERT_TRUE(
20898       FS.addFile("/c/.clang-format", 0,
20899                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google")));
20900   ASSERT_TRUE(FS.addFile("/c/sub/sub/sub/test.cpp", 0,
20901                          llvm::MemoryBuffer::getMemBuffer("int i;")));
20902   auto Style3 = getStyle("file", "/c/sub/sub/sub/test.cpp", "LLVM", "", &FS);
20903   ASSERT_TRUE((bool)Style3);
20904   ASSERT_EQ(*Style3, getGoogleStyle());
20905 
20906   // Test 4: error on invalid fallback style
20907   auto Style4 = getStyle("file", "a.h", "KungFu", "", &FS);
20908   ASSERT_FALSE((bool)Style4);
20909   llvm::consumeError(Style4.takeError());
20910 
20911   // Test 5: error on invalid yaml on command line
20912   auto Style5 = getStyle("{invalid_key=invalid_value}", "a.h", "LLVM", "", &FS);
20913   ASSERT_FALSE((bool)Style5);
20914   llvm::consumeError(Style5.takeError());
20915 
20916   // Test 6: error on invalid style
20917   auto Style6 = getStyle("KungFu", "a.h", "LLVM", "", &FS);
20918   ASSERT_FALSE((bool)Style6);
20919   llvm::consumeError(Style6.takeError());
20920 
20921   // Test 7: found config file, error on parsing it
20922   ASSERT_TRUE(
20923       FS.addFile("/d/.clang-format", 0,
20924                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: LLVM\n"
20925                                                   "InvalidKey: InvalidValue")));
20926   ASSERT_TRUE(
20927       FS.addFile("/d/test.cpp", 0, llvm::MemoryBuffer::getMemBuffer("int i;")));
20928   auto Style7a = getStyle("file", "/d/.clang-format", "LLVM", "", &FS);
20929   ASSERT_FALSE((bool)Style7a);
20930   llvm::consumeError(Style7a.takeError());
20931 
20932   auto Style7b = getStyle("file", "/d/.clang-format", "LLVM", "", &FS, true);
20933   ASSERT_TRUE((bool)Style7b);
20934 
20935   // Test 8: inferred per-language defaults apply.
20936   auto StyleTd = getStyle("file", "x.td", "llvm", "", &FS);
20937   ASSERT_TRUE((bool)StyleTd);
20938   ASSERT_EQ(*StyleTd, getLLVMStyle(FormatStyle::LK_TableGen));
20939 
20940   // Test 9.1: overwriting a file style, when parent no file exists with no
20941   // fallback style
20942   ASSERT_TRUE(FS.addFile(
20943       "/e/sub/.clang-format", 0,
20944       llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: InheritParentConfig\n"
20945                                        "ColumnLimit: 20")));
20946   ASSERT_TRUE(FS.addFile("/e/sub/code.cpp", 0,
20947                          llvm::MemoryBuffer::getMemBuffer("int i;")));
20948   auto Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
20949   ASSERT_TRUE(static_cast<bool>(Style9));
20950   ASSERT_EQ(*Style9, [] {
20951     auto Style = getNoStyle();
20952     Style.ColumnLimit = 20;
20953     return Style;
20954   }());
20955 
20956   // Test 9.2: with LLVM fallback style
20957   Style9 = getStyle("file", "/e/sub/code.cpp", "LLVM", "", &FS);
20958   ASSERT_TRUE(static_cast<bool>(Style9));
20959   ASSERT_EQ(*Style9, [] {
20960     auto Style = getLLVMStyle();
20961     Style.ColumnLimit = 20;
20962     return Style;
20963   }());
20964 
20965   // Test 9.3: with a parent file
20966   ASSERT_TRUE(
20967       FS.addFile("/e/.clang-format", 0,
20968                  llvm::MemoryBuffer::getMemBuffer("BasedOnStyle: Google\n"
20969                                                   "UseTab: Always")));
20970   Style9 = getStyle("file", "/e/sub/code.cpp", "none", "", &FS);
20971   ASSERT_TRUE(static_cast<bool>(Style9));
20972   ASSERT_EQ(*Style9, [] {
20973     auto Style = getGoogleStyle();
20974     Style.ColumnLimit = 20;
20975     Style.UseTab = FormatStyle::UT_Always;
20976     return Style;
20977   }());
20978 
20979   // Test 9.4: propagate more than one level
20980   ASSERT_TRUE(FS.addFile("/e/sub/sub/code.cpp", 0,
20981                          llvm::MemoryBuffer::getMemBuffer("int i;")));
20982   ASSERT_TRUE(FS.addFile("/e/sub/sub/.clang-format", 0,
20983                          llvm::MemoryBuffer::getMemBuffer(
20984                              "BasedOnStyle: InheritParentConfig\n"
20985                              "WhitespaceSensitiveMacros: ['FOO', 'BAR']")));
20986   std::vector<std::string> NonDefaultWhiteSpaceMacros{"FOO", "BAR"};
20987 
20988   const auto SubSubStyle = [&NonDefaultWhiteSpaceMacros] {
20989     auto Style = getGoogleStyle();
20990     Style.ColumnLimit = 20;
20991     Style.UseTab = FormatStyle::UT_Always;
20992     Style.WhitespaceSensitiveMacros = NonDefaultWhiteSpaceMacros;
20993     return Style;
20994   }();
20995 
20996   ASSERT_NE(Style9->WhitespaceSensitiveMacros, NonDefaultWhiteSpaceMacros);
20997   Style9 = getStyle("file", "/e/sub/sub/code.cpp", "none", "", &FS);
20998   ASSERT_TRUE(static_cast<bool>(Style9));
20999   ASSERT_EQ(*Style9, SubSubStyle);
21000 
21001   // Test 9.5: use InheritParentConfig as style name
21002   Style9 =
21003       getStyle("inheritparentconfig", "/e/sub/sub/code.cpp", "none", "", &FS);
21004   ASSERT_TRUE(static_cast<bool>(Style9));
21005   ASSERT_EQ(*Style9, SubSubStyle);
21006 
21007   // Test 9.6: use command line style with inheritance
21008   Style9 = getStyle("{BasedOnStyle: InheritParentConfig}", "/e/sub/code.cpp",
21009                     "none", "", &FS);
21010   ASSERT_TRUE(static_cast<bool>(Style9));
21011   ASSERT_EQ(*Style9, SubSubStyle);
21012 
21013   // Test 9.7: use command line style with inheritance and own config
21014   Style9 = getStyle("{BasedOnStyle: InheritParentConfig, "
21015                     "WhitespaceSensitiveMacros: ['FOO', 'BAR']}",
21016                     "/e/sub/code.cpp", "none", "", &FS);
21017   ASSERT_TRUE(static_cast<bool>(Style9));
21018   ASSERT_EQ(*Style9, SubSubStyle);
21019 
21020   // Test 9.8: use inheritance from a file without BasedOnStyle
21021   ASSERT_TRUE(FS.addFile("/e/withoutbase/.clang-format", 0,
21022                          llvm::MemoryBuffer::getMemBuffer("ColumnLimit: 123")));
21023   ASSERT_TRUE(
21024       FS.addFile("/e/withoutbase/sub/.clang-format", 0,
21025                  llvm::MemoryBuffer::getMemBuffer(
21026                      "BasedOnStyle: InheritParentConfig\nIndentWidth: 7")));
21027   // Make sure we do not use the fallback style
21028   Style9 = getStyle("file", "/e/withoutbase/code.cpp", "google", "", &FS);
21029   ASSERT_TRUE(static_cast<bool>(Style9));
21030   ASSERT_EQ(*Style9, [] {
21031     auto Style = getLLVMStyle();
21032     Style.ColumnLimit = 123;
21033     return Style;
21034   }());
21035 
21036   Style9 = getStyle("file", "/e/withoutbase/sub/code.cpp", "google", "", &FS);
21037   ASSERT_TRUE(static_cast<bool>(Style9));
21038   ASSERT_EQ(*Style9, [] {
21039     auto Style = getLLVMStyle();
21040     Style.ColumnLimit = 123;
21041     Style.IndentWidth = 7;
21042     return Style;
21043   }());
21044 }
21045 
21046 TEST_F(ReplacementTest, FormatCodeAfterReplacements) {
21047   // Column limit is 20.
21048   std::string Code = "Type *a =\n"
21049                      "    new Type();\n"
21050                      "g(iiiii, 0, jjjjj,\n"
21051                      "  0, kkkkk, 0, mm);\n"
21052                      "int  bad     = format   ;";
21053   std::string Expected = "auto a = new Type();\n"
21054                          "g(iiiii, nullptr,\n"
21055                          "  jjjjj, nullptr,\n"
21056                          "  kkkkk, nullptr,\n"
21057                          "  mm);\n"
21058                          "int  bad     = format   ;";
21059   FileID ID = Context.createInMemoryFile("format.cpp", Code);
21060   tooling::Replacements Replaces = toReplacements(
21061       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 6,
21062                             "auto "),
21063        tooling::Replacement(Context.Sources, Context.getLocation(ID, 3, 10), 1,
21064                             "nullptr"),
21065        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 3), 1,
21066                             "nullptr"),
21067        tooling::Replacement(Context.Sources, Context.getLocation(ID, 4, 13), 1,
21068                             "nullptr")});
21069 
21070   format::FormatStyle Style = format::getLLVMStyle();
21071   Style.ColumnLimit = 20; // Set column limit to 20 to increase readibility.
21072   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
21073   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
21074       << llvm::toString(FormattedReplaces.takeError()) << "\n";
21075   auto Result = applyAllReplacements(Code, *FormattedReplaces);
21076   EXPECT_TRUE(static_cast<bool>(Result));
21077   EXPECT_EQ(Expected, *Result);
21078 }
21079 
21080 TEST_F(ReplacementTest, SortIncludesAfterReplacement) {
21081   std::string Code = "#include \"a.h\"\n"
21082                      "#include \"c.h\"\n"
21083                      "\n"
21084                      "int main() {\n"
21085                      "  return 0;\n"
21086                      "}";
21087   std::string Expected = "#include \"a.h\"\n"
21088                          "#include \"b.h\"\n"
21089                          "#include \"c.h\"\n"
21090                          "\n"
21091                          "int main() {\n"
21092                          "  return 0;\n"
21093                          "}";
21094   FileID ID = Context.createInMemoryFile("fix.cpp", Code);
21095   tooling::Replacements Replaces = toReplacements(
21096       {tooling::Replacement(Context.Sources, Context.getLocation(ID, 1, 1), 0,
21097                             "#include \"b.h\"\n")});
21098 
21099   format::FormatStyle Style = format::getLLVMStyle();
21100   Style.SortIncludes = FormatStyle::SI_CaseSensitive;
21101   auto FormattedReplaces = formatReplacements(Code, Replaces, Style);
21102   EXPECT_TRUE(static_cast<bool>(FormattedReplaces))
21103       << llvm::toString(FormattedReplaces.takeError()) << "\n";
21104   auto Result = applyAllReplacements(Code, *FormattedReplaces);
21105   EXPECT_TRUE(static_cast<bool>(Result));
21106   EXPECT_EQ(Expected, *Result);
21107 }
21108 
21109 TEST_F(FormatTest, FormatSortsUsingDeclarations) {
21110   EXPECT_EQ("using std::cin;\n"
21111             "using std::cout;",
21112             format("using std::cout;\n"
21113                    "using std::cin;",
21114                    getGoogleStyle()));
21115 }
21116 
21117 TEST_F(FormatTest, UTF8CharacterLiteralCpp03) {
21118   format::FormatStyle Style = format::getLLVMStyle();
21119   Style.Standard = FormatStyle::LS_Cpp03;
21120   // cpp03 recognize this string as identifier u8 and literal character 'a'
21121   EXPECT_EQ("auto c = u8 'a';", format("auto c = u8'a';", Style));
21122 }
21123 
21124 TEST_F(FormatTest, UTF8CharacterLiteralCpp11) {
21125   // u8'a' is a C++17 feature, utf8 literal character, LS_Cpp11 covers
21126   // all modes, including C++11, C++14 and C++17
21127   EXPECT_EQ("auto c = u8'a';", format("auto c = u8'a';"));
21128 }
21129 
21130 TEST_F(FormatTest, DoNotFormatLikelyXml) {
21131   EXPECT_EQ("<!-- ;> -->", format("<!-- ;> -->", getGoogleStyle()));
21132   EXPECT_EQ(" <!-- >; -->", format(" <!-- >; -->", getGoogleStyle()));
21133 }
21134 
21135 TEST_F(FormatTest, StructuredBindings) {
21136   // Structured bindings is a C++17 feature.
21137   // all modes, including C++11, C++14 and C++17
21138   verifyFormat("auto [a, b] = f();");
21139   EXPECT_EQ("auto [a, b] = f();", format("auto[a, b] = f();"));
21140   EXPECT_EQ("const auto [a, b] = f();", format("const   auto[a, b] = f();"));
21141   EXPECT_EQ("auto const [a, b] = f();", format("auto  const[a, b] = f();"));
21142   EXPECT_EQ("auto const volatile [a, b] = f();",
21143             format("auto  const   volatile[a, b] = f();"));
21144   EXPECT_EQ("auto [a, b, c] = f();", format("auto   [  a  ,  b,c   ] = f();"));
21145   EXPECT_EQ("auto &[a, b, c] = f();",
21146             format("auto   &[  a  ,  b,c   ] = f();"));
21147   EXPECT_EQ("auto &&[a, b, c] = f();",
21148             format("auto   &&[  a  ,  b,c   ] = f();"));
21149   EXPECT_EQ("auto const &[a, b] = f();", format("auto  const&[a, b] = f();"));
21150   EXPECT_EQ("auto const volatile &&[a, b] = f();",
21151             format("auto  const  volatile  &&[a, b] = f();"));
21152   EXPECT_EQ("auto const &&[a, b] = f();",
21153             format("auto  const   &&  [a, b] = f();"));
21154   EXPECT_EQ("const auto &[a, b] = f();",
21155             format("const  auto  &  [a, b] = f();"));
21156   EXPECT_EQ("const auto volatile &&[a, b] = f();",
21157             format("const  auto   volatile  &&[a, b] = f();"));
21158   EXPECT_EQ("volatile const auto &&[a, b] = f();",
21159             format("volatile  const  auto   &&[a, b] = f();"));
21160   EXPECT_EQ("const auto &&[a, b] = f();",
21161             format("const  auto  &&  [a, b] = f();"));
21162 
21163   // Make sure we don't mistake structured bindings for lambdas.
21164   FormatStyle PointerMiddle = getLLVMStyle();
21165   PointerMiddle.PointerAlignment = FormatStyle::PAS_Middle;
21166   verifyFormat("auto [a1, b]{A * i};", getGoogleStyle());
21167   verifyFormat("auto [a2, b]{A * i};", getLLVMStyle());
21168   verifyFormat("auto [a3, b]{A * i};", PointerMiddle);
21169   verifyFormat("auto const [a1, b]{A * i};", getGoogleStyle());
21170   verifyFormat("auto const [a2, b]{A * i};", getLLVMStyle());
21171   verifyFormat("auto const [a3, b]{A * i};", PointerMiddle);
21172   verifyFormat("auto const& [a1, b]{A * i};", getGoogleStyle());
21173   verifyFormat("auto const &[a2, b]{A * i};", getLLVMStyle());
21174   verifyFormat("auto const & [a3, b]{A * i};", PointerMiddle);
21175   verifyFormat("auto const&& [a1, b]{A * i};", getGoogleStyle());
21176   verifyFormat("auto const &&[a2, b]{A * i};", getLLVMStyle());
21177   verifyFormat("auto const && [a3, b]{A * i};", PointerMiddle);
21178 
21179   EXPECT_EQ("for (const auto &&[a, b] : some_range) {\n}",
21180             format("for (const auto   &&   [a, b] : some_range) {\n}"));
21181   EXPECT_EQ("for (const auto &[a, b] : some_range) {\n}",
21182             format("for (const auto   &   [a, b] : some_range) {\n}"));
21183   EXPECT_EQ("for (const auto [a, b] : some_range) {\n}",
21184             format("for (const auto[a, b] : some_range) {\n}"));
21185   EXPECT_EQ("auto [x, y](expr);", format("auto[x,y]  (expr);"));
21186   EXPECT_EQ("auto &[x, y](expr);", format("auto  &  [x,y]  (expr);"));
21187   EXPECT_EQ("auto &&[x, y](expr);", format("auto  &&  [x,y]  (expr);"));
21188   EXPECT_EQ("auto const &[x, y](expr);",
21189             format("auto  const  &  [x,y]  (expr);"));
21190   EXPECT_EQ("auto const &&[x, y](expr);",
21191             format("auto  const  &&  [x,y]  (expr);"));
21192   EXPECT_EQ("auto [x, y]{expr};", format("auto[x,y]     {expr};"));
21193   EXPECT_EQ("auto const &[x, y]{expr};",
21194             format("auto  const  &  [x,y]  {expr};"));
21195   EXPECT_EQ("auto const &&[x, y]{expr};",
21196             format("auto  const  &&  [x,y]  {expr};"));
21197 
21198   format::FormatStyle Spaces = format::getLLVMStyle();
21199   Spaces.SpacesInSquareBrackets = true;
21200   verifyFormat("auto [ a, b ] = f();", Spaces);
21201   verifyFormat("auto &&[ a, b ] = f();", Spaces);
21202   verifyFormat("auto &[ a, b ] = f();", Spaces);
21203   verifyFormat("auto const &&[ a, b ] = f();", Spaces);
21204   verifyFormat("auto const &[ a, b ] = f();", Spaces);
21205 }
21206 
21207 TEST_F(FormatTest, FileAndCode) {
21208   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.cc", ""));
21209   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.m", ""));
21210   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.mm", ""));
21211   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", ""));
21212   EXPECT_EQ(FormatStyle::LK_ObjC,
21213             guessLanguage("foo.h", "@interface Foo\n@end\n"));
21214   EXPECT_EQ(
21215       FormatStyle::LK_ObjC,
21216       guessLanguage("foo.h", "#define TRY(x, y) @try { x; } @finally { y; }"));
21217   EXPECT_EQ(FormatStyle::LK_ObjC,
21218             guessLanguage("foo.h", "#define AVAIL(x) @available(x, *))"));
21219   EXPECT_EQ(FormatStyle::LK_ObjC, guessLanguage("foo.h", "@class Foo;"));
21220   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo", ""));
21221   EXPECT_EQ(FormatStyle::LK_ObjC,
21222             guessLanguage("foo", "@interface Foo\n@end\n"));
21223   EXPECT_EQ(FormatStyle::LK_ObjC,
21224             guessLanguage("foo.h", "int DoStuff(CGRect rect);\n"));
21225   EXPECT_EQ(
21226       FormatStyle::LK_ObjC,
21227       guessLanguage("foo.h",
21228                     "#define MY_POINT_MAKE(x, y) CGPointMake((x), (y));\n"));
21229   EXPECT_EQ(
21230       FormatStyle::LK_Cpp,
21231       guessLanguage("foo.h", "#define FOO(...) auto bar = [] __VA_ARGS__;"));
21232 }
21233 
21234 TEST_F(FormatTest, GuessLanguageWithCpp11AttributeSpecifiers) {
21235   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[noreturn]];"));
21236   EXPECT_EQ(FormatStyle::LK_ObjC,
21237             guessLanguage("foo.h", "array[[calculator getIndex]];"));
21238   EXPECT_EQ(FormatStyle::LK_Cpp,
21239             guessLanguage("foo.h", "[[noreturn, deprecated(\"so sorry\")]];"));
21240   EXPECT_EQ(
21241       FormatStyle::LK_Cpp,
21242       guessLanguage("foo.h", "[[noreturn, deprecated(\"gone, sorry\")]];"));
21243   EXPECT_EQ(FormatStyle::LK_ObjC,
21244             guessLanguage("foo.h", "[[noreturn foo] bar];"));
21245   EXPECT_EQ(FormatStyle::LK_Cpp,
21246             guessLanguage("foo.h", "[[clang::fallthrough]];"));
21247   EXPECT_EQ(FormatStyle::LK_ObjC,
21248             guessLanguage("foo.h", "[[clang:fallthrough] foo];"));
21249   EXPECT_EQ(FormatStyle::LK_Cpp,
21250             guessLanguage("foo.h", "[[gsl::suppress(\"type\")]];"));
21251   EXPECT_EQ(FormatStyle::LK_Cpp,
21252             guessLanguage("foo.h", "[[using clang: fallthrough]];"));
21253   EXPECT_EQ(FormatStyle::LK_ObjC,
21254             guessLanguage("foo.h", "[[abusing clang:fallthrough] bar];"));
21255   EXPECT_EQ(FormatStyle::LK_Cpp,
21256             guessLanguage("foo.h", "[[using gsl: suppress(\"type\")]];"));
21257   EXPECT_EQ(
21258       FormatStyle::LK_Cpp,
21259       guessLanguage("foo.h", "for (auto &&[endpoint, stream] : streams_)"));
21260   EXPECT_EQ(
21261       FormatStyle::LK_Cpp,
21262       guessLanguage("foo.h",
21263                     "[[clang::callable_when(\"unconsumed\", \"unknown\")]]"));
21264   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "[[foo::bar, ...]]"));
21265 }
21266 
21267 TEST_F(FormatTest, GuessLanguageWithCaret) {
21268   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^);"));
21269   EXPECT_EQ(FormatStyle::LK_Cpp, guessLanguage("foo.h", "FOO(^, Bar);"));
21270   EXPECT_EQ(FormatStyle::LK_ObjC,
21271             guessLanguage("foo.h", "int(^)(char, float);"));
21272   EXPECT_EQ(FormatStyle::LK_ObjC,
21273             guessLanguage("foo.h", "int(^foo)(char, float);"));
21274   EXPECT_EQ(FormatStyle::LK_ObjC,
21275             guessLanguage("foo.h", "int(^foo[10])(char, float);"));
21276   EXPECT_EQ(FormatStyle::LK_ObjC,
21277             guessLanguage("foo.h", "int(^foo[kNumEntries])(char, float);"));
21278   EXPECT_EQ(
21279       FormatStyle::LK_ObjC,
21280       guessLanguage("foo.h", "int(^foo[(kNumEntries + 10)])(char, float);"));
21281 }
21282 
21283 TEST_F(FormatTest, GuessLanguageWithPragmas) {
21284   EXPECT_EQ(FormatStyle::LK_Cpp,
21285             guessLanguage("foo.h", "__pragma(warning(disable:))"));
21286   EXPECT_EQ(FormatStyle::LK_Cpp,
21287             guessLanguage("foo.h", "#pragma(warning(disable:))"));
21288   EXPECT_EQ(FormatStyle::LK_Cpp,
21289             guessLanguage("foo.h", "_Pragma(warning(disable:))"));
21290 }
21291 
21292 TEST_F(FormatTest, FormatsInlineAsmSymbolicNames) {
21293   // ASM symbolic names are identifiers that must be surrounded by [] without
21294   // space in between:
21295   // https://gcc.gnu.org/onlinedocs/gcc/Extended-Asm.html#InputOperands
21296 
21297   // Example from https://bugs.llvm.org/show_bug.cgi?id=45108.
21298   verifyFormat(R"(//
21299 asm volatile("mrs %x[result], FPCR" : [result] "=r"(result));
21300 )");
21301 
21302   // A list of several ASM symbolic names.
21303   verifyFormat(R"(asm("mov %[e], %[d]" : [d] "=rm"(d), [e] "rm"(*e));)");
21304 
21305   // ASM symbolic names in inline ASM with inputs and outputs.
21306   verifyFormat(R"(//
21307 asm("cmoveq %1, %2, %[result]"
21308     : [result] "=r"(result)
21309     : "r"(test), "r"(new), "[result]"(old));
21310 )");
21311 
21312   // ASM symbolic names in inline ASM with no outputs.
21313   verifyFormat(R"(asm("mov %[e], %[d]" : : [d] "=rm"(d), [e] "rm"(*e));)");
21314 }
21315 
21316 TEST_F(FormatTest, GuessedLanguageWithInlineAsmClobbers) {
21317   EXPECT_EQ(FormatStyle::LK_Cpp,
21318             guessLanguage("foo.h", "void f() {\n"
21319                                    "  asm (\"mov %[e], %[d]\"\n"
21320                                    "     : [d] \"=rm\" (d)\n"
21321                                    "       [e] \"rm\" (*e));\n"
21322                                    "}"));
21323   EXPECT_EQ(FormatStyle::LK_Cpp,
21324             guessLanguage("foo.h", "void f() {\n"
21325                                    "  _asm (\"mov %[e], %[d]\"\n"
21326                                    "     : [d] \"=rm\" (d)\n"
21327                                    "       [e] \"rm\" (*e));\n"
21328                                    "}"));
21329   EXPECT_EQ(FormatStyle::LK_Cpp,
21330             guessLanguage("foo.h", "void f() {\n"
21331                                    "  __asm (\"mov %[e], %[d]\"\n"
21332                                    "     : [d] \"=rm\" (d)\n"
21333                                    "       [e] \"rm\" (*e));\n"
21334                                    "}"));
21335   EXPECT_EQ(FormatStyle::LK_Cpp,
21336             guessLanguage("foo.h", "void f() {\n"
21337                                    "  __asm__ (\"mov %[e], %[d]\"\n"
21338                                    "     : [d] \"=rm\" (d)\n"
21339                                    "       [e] \"rm\" (*e));\n"
21340                                    "}"));
21341   EXPECT_EQ(FormatStyle::LK_Cpp,
21342             guessLanguage("foo.h", "void f() {\n"
21343                                    "  asm (\"mov %[e], %[d]\"\n"
21344                                    "     : [d] \"=rm\" (d),\n"
21345                                    "       [e] \"rm\" (*e));\n"
21346                                    "}"));
21347   EXPECT_EQ(FormatStyle::LK_Cpp,
21348             guessLanguage("foo.h", "void f() {\n"
21349                                    "  asm volatile (\"mov %[e], %[d]\"\n"
21350                                    "     : [d] \"=rm\" (d)\n"
21351                                    "       [e] \"rm\" (*e));\n"
21352                                    "}"));
21353 }
21354 
21355 TEST_F(FormatTest, GuessLanguageWithChildLines) {
21356   EXPECT_EQ(FormatStyle::LK_Cpp,
21357             guessLanguage("foo.h", "#define FOO ({ std::string s; })"));
21358   EXPECT_EQ(FormatStyle::LK_ObjC,
21359             guessLanguage("foo.h", "#define FOO ({ NSString *s; })"));
21360   EXPECT_EQ(
21361       FormatStyle::LK_Cpp,
21362       guessLanguage("foo.h", "#define FOO ({ foo(); ({ std::string s; }) })"));
21363   EXPECT_EQ(
21364       FormatStyle::LK_ObjC,
21365       guessLanguage("foo.h", "#define FOO ({ foo(); ({ NSString *s; }) })"));
21366 }
21367 
21368 TEST_F(FormatTest, TypenameMacros) {
21369   std::vector<std::string> TypenameMacros = {"STACK_OF", "LIST", "TAILQ_ENTRY"};
21370 
21371   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=30353
21372   FormatStyle Google = getGoogleStyleWithColumns(0);
21373   Google.TypenameMacros = TypenameMacros;
21374   verifyFormat("struct foo {\n"
21375                "  int bar;\n"
21376                "  TAILQ_ENTRY(a) bleh;\n"
21377                "};",
21378                Google);
21379 
21380   FormatStyle Macros = getLLVMStyle();
21381   Macros.TypenameMacros = TypenameMacros;
21382 
21383   verifyFormat("STACK_OF(int) a;", Macros);
21384   verifyFormat("STACK_OF(int) *a;", Macros);
21385   verifyFormat("STACK_OF(int const *) *a;", Macros);
21386   verifyFormat("STACK_OF(int *const) *a;", Macros);
21387   verifyFormat("STACK_OF(int, string) a;", Macros);
21388   verifyFormat("STACK_OF(LIST(int)) a;", Macros);
21389   verifyFormat("STACK_OF(LIST(int)) a, b;", Macros);
21390   verifyFormat("for (LIST(int) *a = NULL; a;) {\n}", Macros);
21391   verifyFormat("STACK_OF(int) f(LIST(int) *arg);", Macros);
21392   verifyFormat("vector<LIST(uint64_t) *attr> x;", Macros);
21393   verifyFormat("vector<LIST(uint64_t) *const> f(LIST(uint64_t) *arg);", Macros);
21394 
21395   Macros.PointerAlignment = FormatStyle::PAS_Left;
21396   verifyFormat("STACK_OF(int)* a;", Macros);
21397   verifyFormat("STACK_OF(int*)* a;", Macros);
21398   verifyFormat("x = (STACK_OF(uint64_t))*a;", Macros);
21399   verifyFormat("x = (STACK_OF(uint64_t))&a;", Macros);
21400   verifyFormat("vector<STACK_OF(uint64_t)* attr> x;", Macros);
21401 }
21402 
21403 TEST_F(FormatTest, AtomicQualifier) {
21404   // Check that we treate _Atomic as a type and not a function call
21405   FormatStyle Google = getGoogleStyleWithColumns(0);
21406   verifyFormat("struct foo {\n"
21407                "  int a1;\n"
21408                "  _Atomic(a) a2;\n"
21409                "  _Atomic(_Atomic(int) *const) a3;\n"
21410                "};",
21411                Google);
21412   verifyFormat("_Atomic(uint64_t) a;");
21413   verifyFormat("_Atomic(uint64_t) *a;");
21414   verifyFormat("_Atomic(uint64_t const *) *a;");
21415   verifyFormat("_Atomic(uint64_t *const) *a;");
21416   verifyFormat("_Atomic(const uint64_t *) *a;");
21417   verifyFormat("_Atomic(uint64_t) a;");
21418   verifyFormat("_Atomic(_Atomic(uint64_t)) a;");
21419   verifyFormat("_Atomic(_Atomic(uint64_t)) a, b;");
21420   verifyFormat("for (_Atomic(uint64_t) *a = NULL; a;) {\n}");
21421   verifyFormat("_Atomic(uint64_t) f(_Atomic(uint64_t) *arg);");
21422 
21423   verifyFormat("_Atomic(uint64_t) *s(InitValue);");
21424   verifyFormat("_Atomic(uint64_t) *s{InitValue};");
21425   FormatStyle Style = getLLVMStyle();
21426   Style.PointerAlignment = FormatStyle::PAS_Left;
21427   verifyFormat("_Atomic(uint64_t)* s(InitValue);", Style);
21428   verifyFormat("_Atomic(uint64_t)* s{InitValue};", Style);
21429   verifyFormat("_Atomic(int)* a;", Style);
21430   verifyFormat("_Atomic(int*)* a;", Style);
21431   verifyFormat("vector<_Atomic(uint64_t)* attr> x;", Style);
21432 
21433   Style.SpacesInCStyleCastParentheses = true;
21434   Style.SpacesInParentheses = false;
21435   verifyFormat("x = ( _Atomic(uint64_t) )*a;", Style);
21436   Style.SpacesInCStyleCastParentheses = false;
21437   Style.SpacesInParentheses = true;
21438   verifyFormat("x = (_Atomic( uint64_t ))*a;", Style);
21439   verifyFormat("x = (_Atomic( uint64_t ))&a;", Style);
21440 }
21441 
21442 TEST_F(FormatTest, AmbersandInLamda) {
21443   // Test case reported in https://bugs.llvm.org/show_bug.cgi?id=41899
21444   FormatStyle AlignStyle = getLLVMStyle();
21445   AlignStyle.PointerAlignment = FormatStyle::PAS_Left;
21446   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
21447   AlignStyle.PointerAlignment = FormatStyle::PAS_Right;
21448   verifyFormat("auto lambda = [&a = a]() { a = 2; };", AlignStyle);
21449 }
21450 
21451 TEST_F(FormatTest, SpacesInConditionalStatement) {
21452   FormatStyle Spaces = getLLVMStyle();
21453   Spaces.IfMacros.clear();
21454   Spaces.IfMacros.push_back("MYIF");
21455   Spaces.SpacesInConditionalStatement = true;
21456   verifyFormat("for ( int i = 0; i; i++ )\n  continue;", Spaces);
21457   verifyFormat("if ( !a )\n  return;", Spaces);
21458   verifyFormat("if ( a )\n  return;", Spaces);
21459   verifyFormat("if constexpr ( a )\n  return;", Spaces);
21460   verifyFormat("MYIF ( a )\n  return;", Spaces);
21461   verifyFormat("MYIF ( a )\n  return;\nelse MYIF ( b )\n  return;", Spaces);
21462   verifyFormat("MYIF ( a )\n  return;\nelse\n  return;", Spaces);
21463   verifyFormat("switch ( a )\ncase 1:\n  return;", Spaces);
21464   verifyFormat("while ( a )\n  return;", Spaces);
21465   verifyFormat("while ( (a && b) )\n  return;", Spaces);
21466   verifyFormat("do {\n} while ( 1 != 0 );", Spaces);
21467   verifyFormat("try {\n} catch ( const std::exception & ) {\n}", Spaces);
21468   // Check that space on the left of "::" is inserted as expected at beginning
21469   // of condition.
21470   verifyFormat("while ( ::func() )\n  return;", Spaces);
21471 
21472   // Check impact of ControlStatementsExceptControlMacros is honored.
21473   Spaces.SpaceBeforeParens =
21474       FormatStyle::SBPO_ControlStatementsExceptControlMacros;
21475   verifyFormat("MYIF( a )\n  return;", Spaces);
21476   verifyFormat("MYIF( a )\n  return;\nelse MYIF( b )\n  return;", Spaces);
21477   verifyFormat("MYIF( a )\n  return;\nelse\n  return;", Spaces);
21478 }
21479 
21480 TEST_F(FormatTest, AlternativeOperators) {
21481   // Test case for ensuring alternate operators are not
21482   // combined with their right most neighbour.
21483   verifyFormat("int a and b;");
21484   verifyFormat("int a and_eq b;");
21485   verifyFormat("int a bitand b;");
21486   verifyFormat("int a bitor b;");
21487   verifyFormat("int a compl b;");
21488   verifyFormat("int a not b;");
21489   verifyFormat("int a not_eq b;");
21490   verifyFormat("int a or b;");
21491   verifyFormat("int a xor b;");
21492   verifyFormat("int a xor_eq b;");
21493   verifyFormat("return this not_eq bitand other;");
21494   verifyFormat("bool operator not_eq(const X bitand other)");
21495 
21496   verifyFormat("int a and 5;");
21497   verifyFormat("int a and_eq 5;");
21498   verifyFormat("int a bitand 5;");
21499   verifyFormat("int a bitor 5;");
21500   verifyFormat("int a compl 5;");
21501   verifyFormat("int a not 5;");
21502   verifyFormat("int a not_eq 5;");
21503   verifyFormat("int a or 5;");
21504   verifyFormat("int a xor 5;");
21505   verifyFormat("int a xor_eq 5;");
21506 
21507   verifyFormat("int a compl(5);");
21508   verifyFormat("int a not(5);");
21509 
21510   /* FIXME handle alternate tokens
21511    * https://en.cppreference.com/w/cpp/language/operator_alternative
21512   // alternative tokens
21513   verifyFormat("compl foo();");     //  ~foo();
21514   verifyFormat("foo() <%%>;");      // foo();
21515   verifyFormat("void foo() <%%>;"); // void foo(){}
21516   verifyFormat("int a <:1:>;");     // int a[1];[
21517   verifyFormat("%:define ABC abc"); // #define ABC abc
21518   verifyFormat("%:%:");             // ##
21519   */
21520 }
21521 
21522 TEST_F(FormatTest, STLWhileNotDefineChed) {
21523   verifyFormat("#if defined(while)\n"
21524                "#define while EMIT WARNING C4005\n"
21525                "#endif // while");
21526 }
21527 
21528 TEST_F(FormatTest, OperatorSpacing) {
21529   FormatStyle Style = getLLVMStyle();
21530   Style.PointerAlignment = FormatStyle::PAS_Right;
21531   verifyFormat("Foo::operator*();", Style);
21532   verifyFormat("Foo::operator void *();", Style);
21533   verifyFormat("Foo::operator void **();", Style);
21534   verifyFormat("Foo::operator void *&();", Style);
21535   verifyFormat("Foo::operator void *&&();", Style);
21536   verifyFormat("Foo::operator void const *();", Style);
21537   verifyFormat("Foo::operator void const **();", Style);
21538   verifyFormat("Foo::operator void const *&();", Style);
21539   verifyFormat("Foo::operator void const *&&();", Style);
21540   verifyFormat("Foo::operator()(void *);", Style);
21541   verifyFormat("Foo::operator*(void *);", Style);
21542   verifyFormat("Foo::operator*();", Style);
21543   verifyFormat("Foo::operator**();", Style);
21544   verifyFormat("Foo::operator&();", Style);
21545   verifyFormat("Foo::operator<int> *();", Style);
21546   verifyFormat("Foo::operator<Foo> *();", Style);
21547   verifyFormat("Foo::operator<int> **();", Style);
21548   verifyFormat("Foo::operator<Foo> **();", Style);
21549   verifyFormat("Foo::operator<int> &();", Style);
21550   verifyFormat("Foo::operator<Foo> &();", Style);
21551   verifyFormat("Foo::operator<int> &&();", Style);
21552   verifyFormat("Foo::operator<Foo> &&();", Style);
21553   verifyFormat("Foo::operator<int> *&();", Style);
21554   verifyFormat("Foo::operator<Foo> *&();", Style);
21555   verifyFormat("Foo::operator<int> *&&();", Style);
21556   verifyFormat("Foo::operator<Foo> *&&();", Style);
21557   verifyFormat("operator*(int (*)(), class Foo);", Style);
21558 
21559   verifyFormat("Foo::operator&();", Style);
21560   verifyFormat("Foo::operator void &();", Style);
21561   verifyFormat("Foo::operator void const &();", Style);
21562   verifyFormat("Foo::operator()(void &);", Style);
21563   verifyFormat("Foo::operator&(void &);", Style);
21564   verifyFormat("Foo::operator&();", Style);
21565   verifyFormat("operator&(int (&)(), class Foo);", Style);
21566 
21567   verifyFormat("Foo::operator&&();", Style);
21568   verifyFormat("Foo::operator**();", Style);
21569   verifyFormat("Foo::operator void &&();", Style);
21570   verifyFormat("Foo::operator void const &&();", Style);
21571   verifyFormat("Foo::operator()(void &&);", Style);
21572   verifyFormat("Foo::operator&&(void &&);", Style);
21573   verifyFormat("Foo::operator&&();", Style);
21574   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
21575   verifyFormat("operator const nsTArrayRight<E> &()", Style);
21576   verifyFormat("[[nodiscard]] operator const nsTArrayRight<E, Allocator> &()",
21577                Style);
21578   verifyFormat("operator void **()", Style);
21579   verifyFormat("operator const FooRight<Object> &()", Style);
21580   verifyFormat("operator const FooRight<Object> *()", Style);
21581   verifyFormat("operator const FooRight<Object> **()", Style);
21582   verifyFormat("operator const FooRight<Object> *&()", Style);
21583   verifyFormat("operator const FooRight<Object> *&&()", Style);
21584 
21585   Style.PointerAlignment = FormatStyle::PAS_Left;
21586   verifyFormat("Foo::operator*();", Style);
21587   verifyFormat("Foo::operator**();", Style);
21588   verifyFormat("Foo::operator void*();", Style);
21589   verifyFormat("Foo::operator void**();", Style);
21590   verifyFormat("Foo::operator void*&();", Style);
21591   verifyFormat("Foo::operator void*&&();", Style);
21592   verifyFormat("Foo::operator void const*();", Style);
21593   verifyFormat("Foo::operator void const**();", Style);
21594   verifyFormat("Foo::operator void const*&();", Style);
21595   verifyFormat("Foo::operator void const*&&();", Style);
21596   verifyFormat("Foo::operator/*comment*/ void*();", Style);
21597   verifyFormat("Foo::operator/*a*/ const /*b*/ void*();", Style);
21598   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void*();", Style);
21599   verifyFormat("Foo::operator()(void*);", Style);
21600   verifyFormat("Foo::operator*(void*);", Style);
21601   verifyFormat("Foo::operator*();", Style);
21602   verifyFormat("Foo::operator<int>*();", Style);
21603   verifyFormat("Foo::operator<Foo>*();", Style);
21604   verifyFormat("Foo::operator<int>**();", Style);
21605   verifyFormat("Foo::operator<Foo>**();", Style);
21606   verifyFormat("Foo::operator<Foo>*&();", Style);
21607   verifyFormat("Foo::operator<int>&();", Style);
21608   verifyFormat("Foo::operator<Foo>&();", Style);
21609   verifyFormat("Foo::operator<int>&&();", Style);
21610   verifyFormat("Foo::operator<Foo>&&();", Style);
21611   verifyFormat("Foo::operator<int>*&();", Style);
21612   verifyFormat("Foo::operator<Foo>*&();", Style);
21613   verifyFormat("operator*(int (*)(), class Foo);", Style);
21614 
21615   verifyFormat("Foo::operator&();", Style);
21616   verifyFormat("Foo::operator void&();", Style);
21617   verifyFormat("Foo::operator void const&();", Style);
21618   verifyFormat("Foo::operator/*comment*/ void&();", Style);
21619   verifyFormat("Foo::operator/*a*/ const /*b*/ void&();", Style);
21620   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&();", Style);
21621   verifyFormat("Foo::operator()(void&);", Style);
21622   verifyFormat("Foo::operator&(void&);", Style);
21623   verifyFormat("Foo::operator&();", Style);
21624   verifyFormat("operator&(int (&)(), class Foo);", Style);
21625 
21626   verifyFormat("Foo::operator&&();", Style);
21627   verifyFormat("Foo::operator void&&();", Style);
21628   verifyFormat("Foo::operator void const&&();", Style);
21629   verifyFormat("Foo::operator/*comment*/ void&&();", Style);
21630   verifyFormat("Foo::operator/*a*/ const /*b*/ void&&();", Style);
21631   verifyFormat("Foo::operator/*a*/ volatile /*b*/ void&&();", Style);
21632   verifyFormat("Foo::operator()(void&&);", Style);
21633   verifyFormat("Foo::operator&&(void&&);", Style);
21634   verifyFormat("Foo::operator&&();", Style);
21635   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
21636   verifyFormat("operator const nsTArrayLeft<E>&()", Style);
21637   verifyFormat("[[nodiscard]] operator const nsTArrayLeft<E, Allocator>&()",
21638                Style);
21639   verifyFormat("operator void**()", Style);
21640   verifyFormat("operator const FooLeft<Object>&()", Style);
21641   verifyFormat("operator const FooLeft<Object>*()", Style);
21642   verifyFormat("operator const FooLeft<Object>**()", Style);
21643   verifyFormat("operator const FooLeft<Object>*&()", Style);
21644   verifyFormat("operator const FooLeft<Object>*&&()", Style);
21645 
21646   // PR45107
21647   verifyFormat("operator Vector<String>&();", Style);
21648   verifyFormat("operator const Vector<String>&();", Style);
21649   verifyFormat("operator foo::Bar*();", Style);
21650   verifyFormat("operator const Foo<X>::Bar<Y>*();", Style);
21651   verifyFormat("operator/*a*/ const /*b*/ Foo /*c*/<X> /*d*/ ::Bar<Y>*();",
21652                Style);
21653 
21654   Style.PointerAlignment = FormatStyle::PAS_Middle;
21655   verifyFormat("Foo::operator*();", Style);
21656   verifyFormat("Foo::operator void *();", Style);
21657   verifyFormat("Foo::operator()(void *);", Style);
21658   verifyFormat("Foo::operator*(void *);", Style);
21659   verifyFormat("Foo::operator*();", Style);
21660   verifyFormat("operator*(int (*)(), class Foo);", Style);
21661 
21662   verifyFormat("Foo::operator&();", Style);
21663   verifyFormat("Foo::operator void &();", Style);
21664   verifyFormat("Foo::operator void const &();", Style);
21665   verifyFormat("Foo::operator()(void &);", Style);
21666   verifyFormat("Foo::operator&(void &);", Style);
21667   verifyFormat("Foo::operator&();", Style);
21668   verifyFormat("operator&(int (&)(), class Foo);", Style);
21669 
21670   verifyFormat("Foo::operator&&();", Style);
21671   verifyFormat("Foo::operator void &&();", Style);
21672   verifyFormat("Foo::operator void const &&();", Style);
21673   verifyFormat("Foo::operator()(void &&);", Style);
21674   verifyFormat("Foo::operator&&(void &&);", Style);
21675   verifyFormat("Foo::operator&&();", Style);
21676   verifyFormat("operator&&(int(&&)(), class Foo);", Style);
21677 }
21678 
21679 TEST_F(FormatTest, OperatorPassedAsAFunctionPtr) {
21680   FormatStyle Style = getLLVMStyle();
21681   // PR46157
21682   verifyFormat("foo(operator+, -42);", Style);
21683   verifyFormat("foo(operator++, -42);", Style);
21684   verifyFormat("foo(operator--, -42);", Style);
21685   verifyFormat("foo(-42, operator--);", Style);
21686   verifyFormat("foo(-42, operator, );", Style);
21687   verifyFormat("foo(operator, , -42);", Style);
21688 }
21689 
21690 TEST_F(FormatTest, WhitespaceSensitiveMacros) {
21691   FormatStyle Style = getLLVMStyle();
21692   Style.WhitespaceSensitiveMacros.push_back("FOO");
21693 
21694   // Don't use the helpers here, since 'mess up' will change the whitespace
21695   // and these are all whitespace sensitive by definition
21696   EXPECT_EQ("FOO(String-ized&Messy+But(: :Still)=Intentional);",
21697             format("FOO(String-ized&Messy+But(: :Still)=Intentional);", Style));
21698   EXPECT_EQ(
21699       "FOO(String-ized&Messy+But\\(: :Still)=Intentional);",
21700       format("FOO(String-ized&Messy+But\\(: :Still)=Intentional);", Style));
21701   EXPECT_EQ("FOO(String-ized&Messy+But,: :Still=Intentional);",
21702             format("FOO(String-ized&Messy+But,: :Still=Intentional);", Style));
21703   EXPECT_EQ("FOO(String-ized&Messy+But,: :\n"
21704             "       Still=Intentional);",
21705             format("FOO(String-ized&Messy+But,: :\n"
21706                    "       Still=Intentional);",
21707                    Style));
21708   Style.AlignConsecutiveAssignments = FormatStyle::ACS_Consecutive;
21709   EXPECT_EQ("FOO(String-ized=&Messy+But,: :\n"
21710             "       Still=Intentional);",
21711             format("FOO(String-ized=&Messy+But,: :\n"
21712                    "       Still=Intentional);",
21713                    Style));
21714 
21715   Style.ColumnLimit = 21;
21716   EXPECT_EQ("FOO(String-ized&Messy+But: :Still=Intentional);",
21717             format("FOO(String-ized&Messy+But: :Still=Intentional);", Style));
21718 }
21719 
21720 TEST_F(FormatTest, VeryLongNamespaceCommentSplit) {
21721   // These tests are not in NamespaceFixer because that doesn't
21722   // test its interaction with line wrapping
21723   FormatStyle Style = getLLVMStyle();
21724   Style.ColumnLimit = 80;
21725   verifyFormat("namespace {\n"
21726                "int i;\n"
21727                "int j;\n"
21728                "} // namespace",
21729                Style);
21730 
21731   verifyFormat("namespace AAA {\n"
21732                "int i;\n"
21733                "int j;\n"
21734                "} // namespace AAA",
21735                Style);
21736 
21737   EXPECT_EQ("namespace Averyveryveryverylongnamespace {\n"
21738             "int i;\n"
21739             "int j;\n"
21740             "} // namespace Averyveryveryverylongnamespace",
21741             format("namespace Averyveryveryverylongnamespace {\n"
21742                    "int i;\n"
21743                    "int j;\n"
21744                    "}",
21745                    Style));
21746 
21747   EXPECT_EQ(
21748       "namespace "
21749       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
21750       "    went::mad::now {\n"
21751       "int i;\n"
21752       "int j;\n"
21753       "} // namespace\n"
21754       "  // "
21755       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
21756       "went::mad::now",
21757       format("namespace "
21758              "would::it::save::you::a::lot::of::time::if_::i::"
21759              "just::gave::up::and_::went::mad::now {\n"
21760              "int i;\n"
21761              "int j;\n"
21762              "}",
21763              Style));
21764 
21765   // This used to duplicate the comment again and again on subsequent runs
21766   EXPECT_EQ(
21767       "namespace "
21768       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::\n"
21769       "    went::mad::now {\n"
21770       "int i;\n"
21771       "int j;\n"
21772       "} // namespace\n"
21773       "  // "
21774       "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::and_::"
21775       "went::mad::now",
21776       format("namespace "
21777              "would::it::save::you::a::lot::of::time::if_::i::"
21778              "just::gave::up::and_::went::mad::now {\n"
21779              "int i;\n"
21780              "int j;\n"
21781              "} // namespace\n"
21782              "  // "
21783              "would::it::save::you::a::lot::of::time::if_::i::just::gave::up::"
21784              "and_::went::mad::now",
21785              Style));
21786 }
21787 
21788 TEST_F(FormatTest, LikelyUnlikely) {
21789   FormatStyle Style = getLLVMStyle();
21790 
21791   verifyFormat("if (argc > 5) [[unlikely]] {\n"
21792                "  return 29;\n"
21793                "}",
21794                Style);
21795 
21796   verifyFormat("if (argc > 5) [[likely]] {\n"
21797                "  return 29;\n"
21798                "}",
21799                Style);
21800 
21801   verifyFormat("if (argc > 5) [[unlikely]] {\n"
21802                "  return 29;\n"
21803                "} else [[likely]] {\n"
21804                "  return 42;\n"
21805                "}\n",
21806                Style);
21807 
21808   verifyFormat("if (argc > 5) [[unlikely]] {\n"
21809                "  return 29;\n"
21810                "} else if (argc > 10) [[likely]] {\n"
21811                "  return 99;\n"
21812                "} else {\n"
21813                "  return 42;\n"
21814                "}\n",
21815                Style);
21816 
21817   verifyFormat("if (argc > 5) [[gnu::unused]] {\n"
21818                "  return 29;\n"
21819                "}",
21820                Style);
21821 }
21822 
21823 TEST_F(FormatTest, PenaltyIndentedWhitespace) {
21824   verifyFormat("Constructor()\n"
21825                "    : aaaaaa(aaaaaa), aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
21826                "                          aaaa(aaaaaaaaaaaaaaaaaa, "
21827                "aaaaaaaaaaaaaaaaaat))");
21828   verifyFormat("Constructor()\n"
21829                "    : aaaaaaaaaaaaa(aaaaaa), "
21830                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa)");
21831 
21832   FormatStyle StyleWithWhitespacePenalty = getLLVMStyle();
21833   StyleWithWhitespacePenalty.PenaltyIndentedWhitespace = 5;
21834   verifyFormat("Constructor()\n"
21835                "    : aaaaaa(aaaaaa),\n"
21836                "      aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
21837                "          aaaa(aaaaaaaaaaaaaaaaaa, aaaaaaaaaaaaaaaaaat))",
21838                StyleWithWhitespacePenalty);
21839   verifyFormat("Constructor()\n"
21840                "    : aaaaaaaaaaaaa(aaaaaa), "
21841                "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaaaaa)",
21842                StyleWithWhitespacePenalty);
21843 }
21844 
21845 TEST_F(FormatTest, LLVMDefaultStyle) {
21846   FormatStyle Style = getLLVMStyle();
21847   verifyFormat("extern \"C\" {\n"
21848                "int foo();\n"
21849                "}",
21850                Style);
21851 }
21852 TEST_F(FormatTest, GNUDefaultStyle) {
21853   FormatStyle Style = getGNUStyle();
21854   verifyFormat("extern \"C\"\n"
21855                "{\n"
21856                "  int foo ();\n"
21857                "}",
21858                Style);
21859 }
21860 TEST_F(FormatTest, MozillaDefaultStyle) {
21861   FormatStyle Style = getMozillaStyle();
21862   verifyFormat("extern \"C\"\n"
21863                "{\n"
21864                "  int foo();\n"
21865                "}",
21866                Style);
21867 }
21868 TEST_F(FormatTest, GoogleDefaultStyle) {
21869   FormatStyle Style = getGoogleStyle();
21870   verifyFormat("extern \"C\" {\n"
21871                "int foo();\n"
21872                "}",
21873                Style);
21874 }
21875 TEST_F(FormatTest, ChromiumDefaultStyle) {
21876   FormatStyle Style = getChromiumStyle(FormatStyle::LanguageKind::LK_Cpp);
21877   verifyFormat("extern \"C\" {\n"
21878                "int foo();\n"
21879                "}",
21880                Style);
21881 }
21882 TEST_F(FormatTest, MicrosoftDefaultStyle) {
21883   FormatStyle Style = getMicrosoftStyle(FormatStyle::LanguageKind::LK_Cpp);
21884   verifyFormat("extern \"C\"\n"
21885                "{\n"
21886                "    int foo();\n"
21887                "}",
21888                Style);
21889 }
21890 TEST_F(FormatTest, WebKitDefaultStyle) {
21891   FormatStyle Style = getWebKitStyle();
21892   verifyFormat("extern \"C\" {\n"
21893                "int foo();\n"
21894                "}",
21895                Style);
21896 }
21897 
21898 TEST_F(FormatTest, ConceptsAndRequires) {
21899   FormatStyle Style = getLLVMStyle();
21900   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
21901 
21902   verifyFormat("template <typename T>\n"
21903                "concept Hashable = requires(T a) {\n"
21904                "  { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
21905                "};",
21906                Style);
21907   verifyFormat("template <typename T>\n"
21908                "concept EqualityComparable = requires(T a, T b) {\n"
21909                "  { a == b } -> bool;\n"
21910                "};",
21911                Style);
21912   verifyFormat("template <typename T>\n"
21913                "concept EqualityComparable = requires(T a, T b) {\n"
21914                "  { a == b } -> bool;\n"
21915                "  { a != b } -> bool;\n"
21916                "};",
21917                Style);
21918   verifyFormat("template <typename T>\n"
21919                "concept EqualityComparable = requires(T a, T b) {\n"
21920                "  { a == b } -> bool;\n"
21921                "  { a != b } -> bool;\n"
21922                "};",
21923                Style);
21924 
21925   verifyFormat("template <typename It>\n"
21926                "requires Iterator<It>\n"
21927                "void sort(It begin, It end) {\n"
21928                "  //....\n"
21929                "}",
21930                Style);
21931 
21932   verifyFormat("template <typename T>\n"
21933                "concept Large = sizeof(T) > 10;",
21934                Style);
21935 
21936   verifyFormat("template <typename T, typename U>\n"
21937                "concept FooableWith = requires(T t, U u) {\n"
21938                "  typename T::foo_type;\n"
21939                "  { t.foo(u) } -> typename T::foo_type;\n"
21940                "  t++;\n"
21941                "};\n"
21942                "void doFoo(FooableWith<int> auto t) {\n"
21943                "  t.foo(3);\n"
21944                "}",
21945                Style);
21946   verifyFormat("template <typename T>\n"
21947                "concept Context = sizeof(T) == 1;",
21948                Style);
21949   verifyFormat("template <typename T>\n"
21950                "concept Context = is_specialization_of_v<context, T>;",
21951                Style);
21952   verifyFormat("template <typename T>\n"
21953                "concept Node = std::is_object_v<T>;",
21954                Style);
21955   verifyFormat("template <typename T>\n"
21956                "concept Tree = true;",
21957                Style);
21958 
21959   verifyFormat("template <typename T> int g(T i) requires Concept1<I> {\n"
21960                "  //...\n"
21961                "}",
21962                Style);
21963 
21964   verifyFormat(
21965       "template <typename T> int g(T i) requires Concept1<I> && Concept2<I> {\n"
21966       "  //...\n"
21967       "}",
21968       Style);
21969 
21970   verifyFormat(
21971       "template <typename T> int g(T i) requires Concept1<I> || Concept2<I> {\n"
21972       "  //...\n"
21973       "}",
21974       Style);
21975 
21976   verifyFormat("template <typename T>\n"
21977                "veryveryvery_long_return_type g(T i) requires Concept1<I> || "
21978                "Concept2<I> {\n"
21979                "  //...\n"
21980                "}",
21981                Style);
21982 
21983   verifyFormat("template <typename T>\n"
21984                "veryveryvery_long_return_type g(T i) requires Concept1<I> && "
21985                "Concept2<I> {\n"
21986                "  //...\n"
21987                "}",
21988                Style);
21989 
21990   verifyFormat(
21991       "template <typename T>\n"
21992       "veryveryvery_long_return_type g(T i) requires Concept1 && Concept2 {\n"
21993       "  //...\n"
21994       "}",
21995       Style);
21996 
21997   verifyFormat(
21998       "template <typename T>\n"
21999       "veryveryvery_long_return_type g(T i) requires Concept1 || Concept2 {\n"
22000       "  //...\n"
22001       "}",
22002       Style);
22003 
22004   verifyFormat("template <typename It>\n"
22005                "requires Foo<It>() && Bar<It> {\n"
22006                "  //....\n"
22007                "}",
22008                Style);
22009 
22010   verifyFormat("template <typename It>\n"
22011                "requires Foo<Bar<It>>() && Bar<Foo<It, It>> {\n"
22012                "  //....\n"
22013                "}",
22014                Style);
22015 
22016   verifyFormat("template <typename It>\n"
22017                "requires Foo<Bar<It, It>>() && Bar<Foo<It, It>> {\n"
22018                "  //....\n"
22019                "}",
22020                Style);
22021 
22022   verifyFormat(
22023       "template <typename It>\n"
22024       "requires Foo<Bar<It>, Baz<It>>() && Bar<Foo<It>, Baz<It, It>> {\n"
22025       "  //....\n"
22026       "}",
22027       Style);
22028 
22029   Style.IndentRequires = true;
22030   verifyFormat("template <typename It>\n"
22031                "  requires Iterator<It>\n"
22032                "void sort(It begin, It end) {\n"
22033                "  //....\n"
22034                "}",
22035                Style);
22036   verifyFormat("template <std::size index_>\n"
22037                "  requires(index_ < sizeof...(Children_))\n"
22038                "Tree auto &child() {\n"
22039                "  // ...\n"
22040                "}",
22041                Style);
22042 
22043   Style.SpaceBeforeParens = FormatStyle::SBPO_Always;
22044   verifyFormat("template <typename T>\n"
22045                "concept Hashable = requires (T a) {\n"
22046                "  { std::hash<T>{}(a) } -> std::convertible_to<std::size_t>;\n"
22047                "};",
22048                Style);
22049 
22050   verifyFormat("template <class T = void>\n"
22051                "  requires EqualityComparable<T> || Same<T, void>\n"
22052                "struct equal_to;",
22053                Style);
22054 
22055   verifyFormat("template <class T>\n"
22056                "  requires requires {\n"
22057                "    T{};\n"
22058                "    T (int);\n"
22059                "  }\n",
22060                Style);
22061 
22062   Style.ColumnLimit = 78;
22063   verifyFormat("template <typename T>\n"
22064                "concept Context = Traits<typename T::traits_type> and\n"
22065                "    Interface<typename T::interface_type> and\n"
22066                "    Request<typename T::request_type> and\n"
22067                "    Response<typename T::response_type> and\n"
22068                "    ContextExtension<typename T::extension_type> and\n"
22069                "    ::std::is_copy_constructable<T> and "
22070                "::std::is_move_constructable<T> and\n"
22071                "    requires (T c) {\n"
22072                "  { c.response; } -> Response;\n"
22073                "} and requires (T c) {\n"
22074                "  { c.request; } -> Request;\n"
22075                "}\n",
22076                Style);
22077 
22078   verifyFormat("template <typename T>\n"
22079                "concept Context = Traits<typename T::traits_type> or\n"
22080                "    Interface<typename T::interface_type> or\n"
22081                "    Request<typename T::request_type> or\n"
22082                "    Response<typename T::response_type> or\n"
22083                "    ContextExtension<typename T::extension_type> or\n"
22084                "    ::std::is_copy_constructable<T> or "
22085                "::std::is_move_constructable<T> or\n"
22086                "    requires (T c) {\n"
22087                "  { c.response; } -> Response;\n"
22088                "} or requires (T c) {\n"
22089                "  { c.request; } -> Request;\n"
22090                "}\n",
22091                Style);
22092 
22093   verifyFormat("template <typename T>\n"
22094                "concept Context = Traits<typename T::traits_type> &&\n"
22095                "    Interface<typename T::interface_type> &&\n"
22096                "    Request<typename T::request_type> &&\n"
22097                "    Response<typename T::response_type> &&\n"
22098                "    ContextExtension<typename T::extension_type> &&\n"
22099                "    ::std::is_copy_constructable<T> && "
22100                "::std::is_move_constructable<T> &&\n"
22101                "    requires (T c) {\n"
22102                "  { c.response; } -> Response;\n"
22103                "} && requires (T c) {\n"
22104                "  { c.request; } -> Request;\n"
22105                "}\n",
22106                Style);
22107 
22108   verifyFormat("template <typename T>\nconcept someConcept = Constraint1<T> && "
22109                "Constraint2<T>;");
22110 
22111   Style.BreakBeforeBraces = FormatStyle::BS_Custom;
22112   Style.BraceWrapping.AfterFunction = true;
22113   Style.BraceWrapping.AfterClass = true;
22114   Style.AlwaysBreakTemplateDeclarations = FormatStyle::BTDS_Yes;
22115   Style.BreakConstructorInitializers = FormatStyle::BCIS_BeforeColon;
22116   verifyFormat("void Foo () requires (std::copyable<T>)\n"
22117                "{\n"
22118                "  return\n"
22119                "}\n",
22120                Style);
22121 
22122   verifyFormat("void Foo () requires std::copyable<T>\n"
22123                "{\n"
22124                "  return\n"
22125                "}\n",
22126                Style);
22127 
22128   verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
22129                "  requires (std::invocable<F, std::invoke_result_t<Args>...>)\n"
22130                "struct constant;",
22131                Style);
22132 
22133   verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
22134                "  requires std::invocable<F, std::invoke_result_t<Args>...>\n"
22135                "struct constant;",
22136                Style);
22137 
22138   verifyFormat("template <class T>\n"
22139                "class plane_with_very_very_very_long_name\n"
22140                "{\n"
22141                "  constexpr plane_with_very_very_very_long_name () requires "
22142                "std::copyable<T>\n"
22143                "      : plane_with_very_very_very_long_name (1)\n"
22144                "  {\n"
22145                "  }\n"
22146                "}\n",
22147                Style);
22148 
22149   verifyFormat("template <class T>\n"
22150                "class plane_with_long_name\n"
22151                "{\n"
22152                "  constexpr plane_with_long_name () requires std::copyable<T>\n"
22153                "      : plane_with_long_name (1)\n"
22154                "  {\n"
22155                "  }\n"
22156                "}\n",
22157                Style);
22158 
22159   Style.BreakBeforeConceptDeclarations = false;
22160   verifyFormat("template <typename T> concept Tree = true;", Style);
22161 
22162   Style.IndentRequires = false;
22163   verifyFormat("template <std::semiregular F, std::semiregular... Args>\n"
22164                "requires (std::invocable<F, std::invoke_result_t<Args>...>) "
22165                "struct constant;",
22166                Style);
22167 }
22168 
22169 TEST_F(FormatTest, StatementAttributeLikeMacros) {
22170   FormatStyle Style = getLLVMStyle();
22171   StringRef Source = "void Foo::slot() {\n"
22172                      "  unsigned char MyChar = 'x';\n"
22173                      "  emit signal(MyChar);\n"
22174                      "  Q_EMIT signal(MyChar);\n"
22175                      "}";
22176 
22177   EXPECT_EQ(Source, format(Source, Style));
22178 
22179   Style.AlignConsecutiveDeclarations = FormatStyle::ACS_Consecutive;
22180   EXPECT_EQ("void Foo::slot() {\n"
22181             "  unsigned char MyChar = 'x';\n"
22182             "  emit          signal(MyChar);\n"
22183             "  Q_EMIT signal(MyChar);\n"
22184             "}",
22185             format(Source, Style));
22186 
22187   Style.StatementAttributeLikeMacros.push_back("emit");
22188   EXPECT_EQ(Source, format(Source, Style));
22189 
22190   Style.StatementAttributeLikeMacros = {};
22191   EXPECT_EQ("void Foo::slot() {\n"
22192             "  unsigned char MyChar = 'x';\n"
22193             "  emit          signal(MyChar);\n"
22194             "  Q_EMIT        signal(MyChar);\n"
22195             "}",
22196             format(Source, Style));
22197 }
22198 
22199 TEST_F(FormatTest, IndentAccessModifiers) {
22200   FormatStyle Style = getLLVMStyle();
22201   Style.IndentAccessModifiers = true;
22202   // Members are *two* levels below the record;
22203   // Style.IndentWidth == 2, thus yielding a 4 spaces wide indentation.
22204   verifyFormat("class C {\n"
22205                "    int i;\n"
22206                "};\n",
22207                Style);
22208   verifyFormat("union C {\n"
22209                "    int i;\n"
22210                "    unsigned u;\n"
22211                "};\n",
22212                Style);
22213   // Access modifiers should be indented one level below the record.
22214   verifyFormat("class C {\n"
22215                "  public:\n"
22216                "    int i;\n"
22217                "};\n",
22218                Style);
22219   verifyFormat("struct S {\n"
22220                "  private:\n"
22221                "    class C {\n"
22222                "        int j;\n"
22223                "\n"
22224                "      public:\n"
22225                "        C();\n"
22226                "    };\n"
22227                "\n"
22228                "  public:\n"
22229                "    int i;\n"
22230                "};\n",
22231                Style);
22232   // Enumerations are not records and should be unaffected.
22233   Style.AllowShortEnumsOnASingleLine = false;
22234   verifyFormat("enum class E {\n"
22235                "  A,\n"
22236                "  B\n"
22237                "};\n",
22238                Style);
22239   // Test with a different indentation width;
22240   // also proves that the result is Style.AccessModifierOffset agnostic.
22241   Style.IndentWidth = 3;
22242   verifyFormat("class C {\n"
22243                "   public:\n"
22244                "      int i;\n"
22245                "};\n",
22246                Style);
22247 }
22248 
22249 TEST_F(FormatTest, LimitlessStringsAndComments) {
22250   auto Style = getLLVMStyleWithColumns(0);
22251   constexpr StringRef Code =
22252       "/**\n"
22253       " * This is a multiline comment with quite some long lines, at least for "
22254       "the LLVM Style.\n"
22255       " * We will redo this with strings and line comments. Just to  check if "
22256       "everything is working.\n"
22257       " */\n"
22258       "bool foo() {\n"
22259       "  /* Single line multi line comment. */\n"
22260       "  const std::string String = \"This is a multiline string with quite "
22261       "some long lines, at least for the LLVM Style.\"\n"
22262       "                             \"We already did it with multi line "
22263       "comments, and we will do it with line comments. Just to check if "
22264       "everything is working.\";\n"
22265       "  // This is a line comment (block) with quite some long lines, at "
22266       "least for the LLVM Style.\n"
22267       "  // We already did this with multi line comments and strings. Just to "
22268       "check if everything is working.\n"
22269       "  const std::string SmallString = \"Hello World\";\n"
22270       "  // Small line comment\n"
22271       "  return String.size() > SmallString.size();\n"
22272       "}";
22273   EXPECT_EQ(Code, format(Code, Style));
22274 }
22275 } // namespace
22276 } // namespace format
22277 } // namespace clang
22278